PyTorch(torch)

用张量和自动求导构建、训练神经网络。安装包和导入名均为 torch。

安装与导入

python -m pip install torch numpy

上面是通用安装方式;使用 NVIDIA GPU 时,按官方安装选择器选择匹配环境的命令。

import torch
from torch import nn

本页小节共用这些导入;标注“接训练示例”的代码需要先运行训练小节。

常用用法

张量、形状与设备

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = torch.arange(6, dtype=torch.float32).reshape(2, 3).to(device)
print(x.shape, x.dtype, x.device)
print(x.mean(dim=0))           # 对第 0 维聚合
print(x.unsqueeze(0).shape)    # (1, 2, 3)
print(x.transpose(0, 1).shape) # (3, 2)
array = x.detach().cpu().numpy()

模型参数与参与同一次运算的数据需要位于兼容的设备上。

自动求导

x = torch.tensor([2., 3.], requires_grad=True)
loss = (x ** 2).sum()
loss.backward()
print(x.grad)  # tensor([4., 6.])

梯度默认累加。训练时通常每个 batch 更新前调用 optimizer.zero_grad();见自动求导机制。

一个最小训练流程

下面用二维坐标的和是否大于零做二分类,数据在本地生成。

from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(42)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = torch.randn(128, 2)
y = (x.sum(dim=1) > 0).long()
loader = DataLoader(TensorDataset(x, y), batch_size=16, shuffle=True)

model = nn.Sequential(nn.Linear(2, 16), nn.ReLU(), nn.Linear(16, 2)).to(device)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

for epoch in range(5):
    model.train()
    total_loss = 0.0
    for xb, yb in loader:
        xb, yb = xb.to(device), yb.to(device)
        optimizer.zero_grad(set_to_none=True)
        logits = model(xb)
        loss = loss_fn(logits, yb)
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * xb.size(0)
    print(epoch, total_loss / len(loader.dataset))

CrossEntropyLoss 接收原始 logits;本例标签为形状 (batch,) 的整数类别,无需先做 softmax。

推理

接训练示例:

model.eval()
with torch.inference_mode():
    logits = model(torch.tensor([[0.2, 0.8]], device=device))
    probabilities = logits.softmax(dim=-1)
    predicted = logits.argmax(dim=-1)
print(predicted.cpu().tolist())

eval() 切换 Dropout 等层的行为;inference_mode() 关闭推理中的梯度记录,两者用途不同。见推理模式。

保存与恢复参数

接训练示例;恢复时需使用相同的模型结构。

torch.save(model.state_dict(), "model.pt")
restored = nn.Sequential(nn.Linear(2, 16), nn.ReLU(), nn.Linear(16, 2))
state = torch.load("model.pt", map_location="cpu", weights_only=True)
restored.load_state_dict(state)
restored.eval()

如果要继续训练,还应保存优化器状态和训练进度,见保存与加载。

进阶与不常用用法

冻结参数与裁剪梯度

迁移学习时可冻结一部分网络。下面使用独立的小模型:

backbone = nn.Linear(4, 8)
head = nn.Linear(8, 2)
backbone.requires_grad_(False)
frozen_model = nn.Sequential(backbone, nn.ReLU(), head)
head_optimizer = torch.optim.Adam(head.parameters(), lr=1e-3)
head_loss = nn.CrossEntropyLoss()(frozen_model(torch.randn(3, 4)), torch.tensor([0, 1, 0]))
head_optimizer.zero_grad(set_to_none=True)
head_loss.backward()
nn.utils.clip_grad_norm_(head.parameters(), max_norm=1.0)
head_optimizer.step()

冻结梯度不等于切换 eval();含 BatchNorm 等层时,是否更新运行统计要另行控制。

CUDA 混合精度

接常用部分的训练示例,将内层 batch 循环替换为下面的写法;仅在 CUDA 可用时运行。

scaler = torch.amp.GradScaler("cuda")
model.train()
for xb, yb in loader:
    xb, yb = xb.to("cuda"), yb.to("cuda")
    optimizer.zero_grad(set_to_none=True)
    with torch.autocast(device_type="cuda", dtype=torch.float16):
        loss = loss_fn(model(xb), yb)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

模型应已在 CUDA 上。若同时裁剪梯度,先 scaler.unscale_(optimizer),再裁剪;见混合精度文档。

易错点

  • detach() 切断求导关系,不会自动复制数据;需要独立数据时再 .clone()。
  • view() 对内存布局有要求,转置后重排可先考虑 reshape()。
  • 推理不需要梯度时,别只写 model.eval()。
  • Windows 下给 DataLoader 设置 num_workers > 0 时,将执行入口放在 if __name__ == "__main__": 中。

官方文档

应用于项目

手写数字识别 从 NumPy 核心实现到 PyTorch 对照,按六阶段组织手写数字识别的模块、知识与实践。