PyTorch深度学习实战

PyTorch 简介

PyTorch是由Facebook AI Research开发的深度学习框架，以其动态计算图和简洁的Python接口而闻名。

PyTorch 核心优势

动态计算图：支持实时修改网络结构
Pythonic接口：与NumPy无缝衔接
自动求导：简化反向传播实现
GPU加速：支持CUDA
丰富的生态：TorchVision、TorchText、TorchAudio

张量操作

张量是PyTorch的基本数据结构，类似于NumPy的数组，但可以在GPU上运行。

import torch
import numpy as np

# 创建张量
x = torch.tensor([1, 2, 3])
y = torch.zeros(3, 4)
z = torch.ones(2, 3, 4)
rand_tensor = torch.randn(3, 3)

# 张量运算
a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])
c = a + b
d = torch.matmul(rand_tensor, rand_tensor)

# 形状操作
reshaped = rand_tensor.view(9)
transposed = rand_tensor.t()

# 与NumPy转换
np_array = rand_tensor.numpy()
torch_tensor = torch.from_numpy(np_array)

# GPU支持
if torch.cuda.is_available():
    device = torch.device("cuda")
    gpu_tensor = rand_tensor.to(device)

自动求导

PyTorch的自动求导机制可以自动计算张量的梯度。

import torch

x = torch.tensor(2.0, requires_grad=True)
y = x ** 2 + 3 * x + 1

y.backward()

print(x.grad)

神经网络搭建

使用PyTorch可以轻松搭建各种神经网络模型。

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

模型训练

完整的模型训练流程包括数据准备、模型初始化、损失函数、优化器和训练循环。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 准备数据
X_train = torch.randn(1000, 10)
y_train = torch.randint(0, 10, (1000,))
dataset = TensorDataset(X_train, y_train)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# 初始化模型、损失函数和优化器
model = SimpleNet(input_size=10, hidden_size=64, output_size=10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练循环
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    
    for inputs, labels in dataloader:
        optimizer.zero_grad()
        
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item() * inputs.size(0)
    
    epoch_loss = running_loss / len(dataloader.dataset)
    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}')

# 模型保存与加载
torch.save(model.state_dict(), 'model.pth')
model.load_state_dict(torch.load('model.pth'))

预训练模型

PyTorch提供了丰富的预训练模型，可以用于迁移学习。

import torch
import torchvision.models as models
from torchvision import transforms
from PIL import Image

# 加载预训练模型
resnet = models.resnet50(pretrained=True)
resnet.eval()

# 图像预处理
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

# 图像分类
image = Image.open('image.jpg').convert('RGB')
input_tensor = transform(image).unsqueeze(0)

with torch.no_grad():
    output = resnet(input_tensor)
    _, predicted = torch.max(output, 1)

print(f'预测类别: {predicted.item()}')

总结

PyTorch是一个功能强大且易于使用的深度学习框架，其动态计算图和Pythonic接口使它成为研究和生产中的首选框架。掌握PyTorch对于从事机器学习和深度学习工作至关重要。