PyTorch 学习笔记

1.1 Tensor（张量）#

• 核心数据结构：类似于 NumPy 的 ndarray，但支持 GPU 加速和自动求导。

• 创建方式：

  1
  import torch
  2
  
  3
  # 从 Python 列表或 NumPy 数组创建
  4
  x = torch.tensor([1, 2, 3])
  5
  
  6
  # 创建特定值的张量
  7
  a = torch.zeros((2, 3))
  8
  b = torch.ones((2, 3))
  9
  c = torch.rand((2, 3))
  10
  d = torch.randn((2, 3))
  11
  
  12
  # 创建序列
  13
  r1 = torch.arange(0, 10, 2)
  14
  r2 = torch.linspace(0, 1, 5)
  15
  
  16
  # 创建单位矩阵
  17
  i = torch.eye(3)

  展开收起

• 属性：

  1
  x.dtype
  2
  x.shape
  3
  x.size()
  4
  x.device
  5
  x.requires_grad

• 操作：

  • 索引与切片：与 NumPy 类似。

  • 视图 (View) 与 复制 (Copy)：

    1
    y = x.view(-1)          # 返回一个新视图，共享底层数据（要求内存连续）
    2
    z = x.reshape(-1)       # 更灵活的形状变换，可能返回视图或副本
    3
    x_copy = x.clone()      # 返回数据的副本

  • 数学运算：

    1
    s = torch.sum(x)
    2
    m = torch.mean(x.float())
    3
    mx = torch.max(x)
    4
    e = torch.exp(x.float())
    5
    lg = torch.log(x.float())

  • 广播 (Broadcasting)：自动扩展张量以进行运算。

  • 类型转换：

    1
    xf = x.float()
    2
    xl = x.long()
    3
    x2 = x.to(dtype=torch.float32)

  • 设备转移：

    1
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    2
    x_gpu = x.to(device)
    3
    x_cpu = x_gpu.cpu()

1.2 自动求导（Autograd）#

• 核心机制：PyTorch 能自动计算张量的梯度。

• 关键属性：

  1
  import torch
  2
  
  3
  # requires_grad: 设置张量需要计算梯度（通常对模型参数设置）
  4
  w = torch.randn(10, requires_grad=True)
  5
  
  6
  # grad: 存储计算得到的梯度
  7
  w.grad
  8
  
  9
  # grad_fn: 指向创建该张量的 Function 对象，用于构建计算图
  10
  y = w * 2
  11
  y.grad_fn

• 基本流程：

  1
  import torch
  2
  
  3
  x = torch.randn(10)
  4
  w = torch.randn(10, requires_grad=True)
  5
  b = torch.randn(1, requires_grad=True)
  6
  
  7
  y = (x * w).sum() + b
  8
  loss = y
  9
  
  10
  loss.backward()
  11
  
  12
  with torch.no_grad():
  13
      w -= 0.01 * w.grad
  14
      b -= 0.01 * b.grad
  15
  
  16
  w.grad.zero_()
  17
  b.grad.zero_()

  展开收起

• 停止梯度：

  1
  import torch
  2
  
  3
  x = torch.randn(3, requires_grad=True)
  4
  
  5
  with torch.no_grad():
  6
      y = x * 2
  7
  
  8
  z = x.detach()
  9
  x.requires_grad_(False)

2.1 定义网络#

• 常见写法：

  1
  import torch
  2
  import torch.nn as nn
  3
  
  4
  class MyModel(nn.Module):
  5
      def __init__(self):
  6
          super().__init__()
  7
          self.net = nn.Sequential(
  8
              nn.Linear(10, 32),
  9
              nn.ReLU(),
  10
              nn.Linear(32, 10),
  11
          )
  12
  
  13
      def forward(self, x):
  14
          return self.net(x)

• 常用层：

  1
  import torch.nn as nn
  2
  
  3
  nn.Linear
  4
  nn.Conv2d
  5
  nn.MaxPool2d
  6
  nn.AvgPool2d
  7
  nn.BatchNorm1d
  8
  nn.BatchNorm2d
  9
  nn.BatchNorm3d
  10
  nn.Dropout
  11
  nn.Embedding
  12
  nn.LSTM
  13
  nn.GRU

• 激活函数：

  1
  import torch.nn as nn
  2
  
  3
  nn.ReLU
  4
  nn.Sigmoid
  5
  nn.Tanh
  6
  nn.Softmax

• 容器：

  1
  import torch.nn as nn
  2
  
  3
  nn.Sequential
  4
  nn.ModuleList
  5
  nn.ModuleDict

2.2 损失函数（Loss Functions）#

• 常用损失：

  1
  import torch.nn as nn
  2
  
  3
  nn.MSELoss                 # 回归
  4
  nn.CrossEntropyLoss        # 分类（输入 logits，内部会做 Softmax）
  5
  nn.BCELoss                 # 二元交叉熵（输入概率）
  6
  nn.BCEWithLogitsLoss       # Sigmoid + BCELoss，数值更稳定
  7
  nn.NLLLoss                 # 负对数似然（常与 LogSoftmax 配合）

• 使用：

  1
  loss = criterion(predicted_output, true_target)

2.3 优化器（Optimizers）#

• 作用：根据计算出的梯度更新模型参数。

• 常用优化器：

  1
  import torch
  2
  
  3
  torch.optim.SGD
  4
  torch.optim.Adam
  5
  torch.optim.RMSprop

• 基本使用流程：

  1
  optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
  2
  loss = criterion(outputs, labels)
  3
  
  4
  optimizer.zero_grad()
  5
  loss.backward()
  6
  optimizer.step()

3.1 Dataset#

• 抽象基类：

  1
  from torch.utils.data import Dataset

• 自定义数据集：

  1
  from torch.utils.data import Dataset
  2
  
  3
  class MyCustomDataset(Dataset):
  4
      def __len__(self):
  5
          return 0
  6
  
  7
      def __getitem__(self, idx):
  8
          return None

• 内置数据集：torchvision.datasets.MNIST/CIFAR10/ImageFolder 等。

  1
  import torchvision
  2
  
  3
  torchvision.datasets.MNIST
  4
  torchvision.datasets.CIFAR10
  5
  torchvision.datasets.ImageFolder

3.2 DataLoader#

• 作用：将数据集封装成可迭代对象，支持批量加载、打乱、多进程加载。

  1
  from torch.utils.data import DataLoader
  2
  
  3
  DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4)

• 使用：

1
dataset = MyCustomDataset(...)
2
dataloader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4)
3

4
for batch_data, batch_labels in dataloader:
5
    # 训练/验证逻辑
6
    pass

4.1 基本训练循环#

1
model.train()  # 设置为训练模式（影响 Dropout, BatchNorm 等层）
2
for epoch in range(num_epochs):
3
    for inputs, labels in train_loader:
4
        inputs, labels = inputs.to(device), labels.to(device)
5

6
        optimizer.zero_grad()  # 1. 清空梯度
7
        outputs = model(inputs)  # 2. 前向传播
8
        loss = criterion(outputs, labels)  # 3. 计算损失
9
        loss.backward()  # 4. 反向传播
10
        optimizer.step()  # 5. 更新参数
11

12
        # 可选：记录损失、准确率等

4.2 验证/测试循环#

1
model.eval()  # 设置为评估模式（关闭 Dropout, 固定 BatchNorm 统计量）
2
with torch.no_grad():  # 关闭梯度计算，节省内存和计算
3
    for inputs, labels in val_loader:
4
        inputs, labels = inputs.to(device), labels.to(device)
5
        outputs = model(inputs)
6
        loss = criterion(outputs, labels)
7
        # 计算准确率或其他指标
8
        # 记录验证损失和指标

7.1 TorchScript（模型部署）#

• 将 PyTorch 模型转换为可序列化的、独立于 Python 的中间表示，便于在 C++ 环境或生产环境中部署。

• 常用方式：

  1
  import torch
  2
  
  3
  torch.jit.trace(model, example_input)
  4
  torch.jit.script(model)

7.2 分布式训练#

• 常用方式：

  1
  import torch
  2
  
  3
  torch.nn.DataParallel
  4
  torch.nn.parallel.DistributedDataParallel

7.3 混合精度训练（AMP）#

• 常用工具：

  1
  import torch
  2
  
  3
  torch.cuda.amp.autocast
  4
  torch.cuda.amp.GradScaler

7.4 可视化与调试#

• TensorBoard：

  1
  from torch.utils.tensorboard import SummaryWriter

• 打印模型结构：

  1
  print(model)

• 结构摘要（需安装第三方包）：

  1
  summary(model, input_size)