PyTorch 教程
PyTorch 是一个广泛使用的深度学习框架，支持自动求导并提供了灵活的 GPU 加速功能。它的易用性和动态计算图机制使得它在学术研究和工业界中都得到了广泛的使用。本文将带你从基础开始学习 PyTorch，逐步构建神经网络并训练模型。
1. 安装 PyTorch
你可以通过以下命令安装 PyTorch：
bash
pip install torch torchvision安装时可以根据你的环境选择安装是否支持 CUDA（用于 GPU 加速）。详细的安装选项可以参考 PyTorch 官方安装页面。
2. 张量（Tensor）
张量（Tensor） 是 PyTorch 的核心数据结构，类似于 NumPy 中的 ndarray，但具有 GPU 加速的能力。
2.1 创建张量
你可以通过多种方式创建张量：
python
import torch
# 创建一个空张量
x = torch.empty(2, 3)
print(x)
# 使用随机数填充张量
x = torch.rand(2, 3)
print(x)
# 创建全0张量
x = torch.zeros(2, 3)
print(x)
# 创建全1张量
x = torch.ones(2, 3)
print(x)
# 创建自定义数据的张量
x = torch.tensor([2.0, 3.5, 4.0])
print(x)2.2 张量的属性
python
x = torch.rand(2, 3)
print(x.size()) # 张量的大小
print(x.dtype) # 张量的数据类型
print(x.device) # 张量的设备（CPU or GPU）2.3 张量的基本操作
python
# 张量加法
y = torch.rand(2, 3)
print(x + y)
# 改变形状
z = torch.randn(4, 4)
z_reshaped = z.view(2, 8) # 改变为 2x8 张量
print(z_reshaped)
# 张量转 NumPy 数组
x_np = x.numpy()
print(x_np)
# NumPy 转张量
import numpy as np
n = np.array([1, 2, 3])
x_torch = torch.from_numpy(n)
print(x_torch)2.4 在 GPU 上使用张量
如果你有 GPU，可以将张量移动到 GPU 上进行计算：
python
# 检查是否有可用的 GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
# 将张量移到 GPU
x = torch.rand(2, 3)
x = x.to(device)
print(x)3. 自动求导
PyTorch 提供了强大的自动求导功能，通过 autograd 模块可以轻松地计算梯度，支持构建神经网络中的反向传播过程。
3.1 创建带梯度的张量
python
# 创建一个带有梯度的张量
x = torch.ones(2, 2, requires_grad=True)
print(x)3.2 执行张量的计算
python
y = x + 2
z = y * y * 3
out = z.mean()
print(out)
# 反向传播计算梯度
out.backward()
# x的梯度
print(x.grad)4. 构建神经网络
在 PyTorch 中，神经网络通过 torch.nn 模块来构建。最常用的方式是继承 nn.Module 类，并定义自己的前向传播函数。
4.1 定义一个简单的神经网络
python
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(28 * 28, 128)
self.fc2 = nn.Linear(128, 64)
self.fc3 = nn.Linear(64, 10)
def forward(self, x):
x = x.view(-1, 28 * 28) # 将输入平铺成一维
x = F.relu(self.fc1(x)) # ReLU 激活函数
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
# 创建网络实例
net = Net()
print(net)4.2 损失函数和优化器
PyTorch 提供了多种损失函数和优化器，用于训练神经网络。
python
import torch.optim as optim
# 定义损失函数
criterion = nn.CrossEntropyLoss()
# 定义优化器
optimizer = optim.SGD(net.parameters(), lr=0.01)5. 训练模型
我们将使用 PyTorch 的 torchvision 数据集来加载 MNIST 数据集，并训练一个简单的分类模型。
5.1 加载数据集
python
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
# 定义数据预处理
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
# 下载并加载 MNIST 数据集
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform, download=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)5.2 训练循环
python
# 训练神经网络
for epoch in range(2): # 训练2个轮次
running_loss = 0.0
for inputs, labels in train_loader:
# 将数据移动到 GPU
inputs, labels = inputs.to(device), labels.to(device)
# 梯度清零
optimizer.zero_grad()
# 前向传播
outputs = net(inputs)
loss = criterion(outputs, labels)
# 反向传播和优化
loss.backward()
optimizer.step()
# 记录损失
running_loss += loss.item()
print(f'Epoch {epoch + 1}, Loss: {running_loss / len(train_loader)}')5.3 测试模型
python
# 测试模型准确率
correct = 0
total = 0
with torch.no_grad(): # 测试时不需要反向传播
for inputs, labels in test_loader:
inputs, labels = inputs.to(device), labels.to(device)
outputs = net(inputs)
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print(f'Accuracy: {100 * correct / total}%')6. 保存和加载模型
训练完成后，你可以保存模型的参数，并在之后重新加载。
python
# 保存模型
torch.save(net.state_dict(), 'mnist_net.pth')
# 加载模型
net = Net()
net.load_state_dict(torch.load('mnist_net.pth'))
net.eval() # 将模型切换为评估模式7. 完整示例
以下是一个包含加载数据、定义模型、训练和测试的完整 PyTorch 示例：
python
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
# 定义神经网络
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(28 * 28, 128)
self.fc2 = nn.Linear(128, 64)
self.fc3 = nn.Linear(64, 10)
def forward(self, x):
x = x.view(-1, 28 * 28)
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = self.fc3(x)
return x
# 设置设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 加载 MNIST 数据集
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform, download=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
# 创建网络和优化器
net = Net().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
# 训练网络
for epoch in range(2):
running_loss = 0.0
for inputs, labels in train_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
print(f'Epoch {epoch+1}, Loss: {running_loss/len(train_loader)}')
# 测试网络
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in test_loader:
inputs, labels = inputs.to(device), labels.to(device)
outputs = net(inputs)
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print(f'Accuracy: {100 * correct / total}%')8. 总结
通过本教程，我们了解了 PyTorch 的基础知识，包括张量操作、自动求导、神经网络的构建、训练和测试等内容。PyTorch 的灵活性和易用性使得它非常适合研究和实际项目。希望这个教程能帮助你快速上手 PyTorch，并应用于你的深度学习项目。