PyTorch笔记 on 知识仓库

PyTorch 概述与安装

Mon, 01 Jan 0001 00:00:00 +0000

PyTorch 概述与安装#

什么是 PyTorch？#

PyTorch 是一个基于 Python 的开源深度学习框架，由 Facebook 的 AI 研究团队开发。它提供了灵活、动态的计算图，使得研究和实验变得更加容易。

核心特点#

动态计算图：与 TensorFlow 的静态图不同，PyTorch 使用动态计算图，可以在运行时修改网络结构
Pythonic：完全基于 Python，与 Python 生态系统无缝集成
易于调试：使用标准的 Python 调试工具即可调试
GPU 加速：原生支持 CUDA，可以轻松利用 GPU 加速计算
活跃的社区：拥有庞大的用户社区和丰富的资源

PyTorch vs TensorFlow#

特性	PyTorch	TensorFlow
计算图	动态	静态（2.x 也支持动态）
学习曲线	较平缓	较陡峭
研究友好度	高	中
生产部署	良好	优秀
社区规模	大	非常大

动态图 vs 静态图#

动态图（Dynamic Graph）：

在运行时动态构建计算图
每次执行操作时，计算图都会更新
调试和修改模型更加容易
PyTorch 使用动态图

静态图（Static Graph）：

在开始执行之前构建完成，不会改变
可以进行更多优化，执行效率可能更高
TensorFlow 最初使用静态图，但后来也支持动态图

安装 PyTorch#

使用 pip 安装#

CPU 版本#

pip install torch torchvision torchaudio

GPU 版本（CUDA 11.8）#

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

GPU 版本（CUDA 12.1）#

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

使用 conda 安装#

# CPU 版本
conda install pytorch torchvision torchaudio cpuonly -c pytorch

# GPU 版本（CUDA 11.8）
conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia

# GPU 版本（CUDA 12.1）
conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia

验证安装#

import torch

# 检查 PyTorch 版本
print(f"PyTorch 版本: {torch.__version__}")

# 检查 CUDA 是否可用
print(f"CUDA 可用: {torch.cuda.is_available()}")

# 如果 CUDA 可用，显示 GPU 信息
if torch.cuda.is_available():
 print(f"CUDA 版本: {torch.version.cuda}")
 print(f"GPU 数量: {torch.cuda.device_count()}")
 print(f"GPU 名称: {torch.cuda.get_device_name(0)}")

PyTorch 架构总览#

PyTorch 采用模块化设计，由多个相互协作的核心组件构成。理解这些组件的作用和相互关系，是掌握 PyTorch 的关键。

张量基础

Mon, 01 Jan 0001 00:00:00 +0000

张量基础#

张量（Tensor）是 PyTorch 中最基本的数据结构，类似于 NumPy 的数组，但可以在 GPU 上运行。理解张量是学习 PyTorch 的第一步。

什么是张量？#

张量是一个多维数组：

0维张量：标量（scalar）
1维张量：向量（vector）
2维张量：矩阵（matrix）
3维及以上：高阶张量

创建张量#

从 Python 列表创建#

import torch

# 创建一维张量
x = torch.tensor([1, 2, 3, 4])
print(x)

# 创建二维张量（矩阵）
y = torch.tensor([[1, 2], [3, 4]])
print(y)

# 创建三维张量
z = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(z)

使用构造函数创建#

# 创建全零张量
zeros = torch.zeros(3, 4)
print(zeros)

# 创建全一张量
ones = torch.ones(2, 3)
print(ones)

# 创建随机张量
rand = torch.rand(3, 3) # 均匀分布 [0, 1)
print(rand)

# 创建正态分布随机张量
randn = torch.randn(3, 3) # 标准正态分布
print(randn)

# 创建指定范围的张量
arange = torch.arange(0, 10, 2) # [0, 10)，步长为 2
print(arange)

# 创建线性空间
linspace = torch.linspace(0, 1, 5) # [0, 1] 之间 5 个等间距点
print(linspace)

从 NumPy 数组创建#

import numpy as np

# 从 NumPy 数组创建
numpy_array = np.array([1, 2, 3])
tensor_from_numpy = torch.from_numpy(numpy_array)
print(tensor_from_numpy)

# 转换回 NumPy（仅限 CPU 张量）
numpy_from_tensor = tensor_from_numpy.numpy()
print(numpy_from_tensor)

重要提示：torch.from_numpy() 和 .numpy() 创建的张量和 NumPy 数组共享内存，修改一个会影响另一个：

自动微分（Autograd）

Mon, 01 Jan 0001 00:00:00 +0000

自动微分（Autograd）#

自动微分是 PyTorch 的核心特性之一，它能够自动计算梯度，这是训练神经网络的基础。理解自动微分机制对于掌握 PyTorch 至关重要。

在深度学习中，自动求导主要用于两个方面：

在训练神经网络时计算梯度
进行反向传播算法的实现

自动微分基于链式法则（Chain Rule），复合函数 $y = f(g(x))$ 的导数为：

$$ \frac{dy}{dx} = \frac{dy}{dg} \cdot \frac{dg}{dx} $$

在深度学习中，模型由多层复合而成，自动求导沿计算图从输出到输入逐层应用链式法则，高效计算梯度。

核心机制#

前向传播：执行操作时构建有向无环图（DAG），叶子节点为输入张量，根节点为输出
记录操作：每个张量的 grad_fn 指向创建它时对应的运算信息，形成计算历史链
反向传播：调用 backward() 时，从根到叶遍历图，按链式法则累积梯度，记入.grad中
动态图：每次迭代重新构建有向无环图，支持 Python 控制流（if/for）

基本使用#

启用梯度追踪#

import torch

# 创建需要梯度的张量
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
print(f"requires_grad: {x.requires_grad}")

# 进行计算
y = x ** 2
z = y.sum()

# 反向传播
z.backward()

# 查看梯度
print(f"x.grad: {x.grad}") # [2., 4., 6.]

requires_grad 参数#

# 创建时指定
x = torch.tensor([1.0, 2.0], requires_grad=True)

# 后续修改
x.requires_grad_(True)
x.requires_grad_(False)

# 使用 detach() 分离
y = x.detach() # y 不追踪梯度

计算图#

PyTorch 使用动态计算图来追踪操作：

数据加载

Mon, 01 Jan 0001 00:00:00 +0000

数据加载#

数据是深度学习的核心。PyTorch 提供了强大的数据加载和预处理工具，帮助我们高效地处理各种类型的数据。

Dataset 和 DataLoader#

在 PyTorch 中，处理和加载数据是深度学习训练过程中的关键步骤。PyTorch 提供了强大的工具，包括 torch.utils.data.Dataset 和 torch.utils.data.DataLoader，帮助我们管理数据集、批量加载和数据增强等任务。

Dataset 基类#

Dataset 是一个抽象类，所有自定义数据集都应该继承它。我们需要实现以下两个方法：

__getitem__(idx)：通过索引返回一个样本
__len__()：返回数据集中的样本数量

from torch.utils.data import Dataset

class CustomDataset(Dataset):
 def __init__(self, data, labels):
 """
 初始化数据集
 data: 输入特征
 labels: 目标标签
 """
 self.data = data
 self.labels = labels
 
 def __len__(self):
 """返回数据集的大小"""
 return len(self.data)
 
 def __getitem__(self, idx):
 """返回指定索引的数据"""
 sample = self.data[idx]
 label = self.labels[idx]
 return sample, label

# 示例数据
X_data = [[1, 2], [3, 4], [5, 6], [7, 8]] # 输入特征
Y_data = [1, 0, 1, 0] # 目标标签

# 创建数据集实例
dataset = CustomDataset(X_data, Y_data)
print(f"数据集大小: {len(dataset)}")

完整示例#

import torch
from torch.utils.data import Dataset, DataLoader
import numpy as np

class MyDataset(Dataset):
 def __init__(self, data, labels, transform=None):
 self.data = data
 self.labels = labels
 self.transform = transform
 
 def __len__(self):
 return len(self.data)
 
 def __getitem__(self, idx):
 sample = self.data[idx]
 label = self.labels[idx]
 
 # 转换为张量
 sample = torch.FloatTensor(sample)
 label = torch.LongTensor([label])[0]
 
 # 应用变换
 if self.transform:
 sample = self.transform(sample)
 
 return sample, label

# 创建数据集
data = np.random.randn(1000, 784)
labels = np.random.randint(0, 10, 1000)
dataset = MyDataset(data, labels)

# 创建 DataLoader
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# 使用
for batch_data, batch_labels in dataloader:
 print(batch_data.shape) # (32, 784)
 print(batch_labels.shape) # (32,)
 break

DataLoader 参数#

DataLoader 是 PyTorch 提供的一个重要工具，用于从 Dataset 中按批次（batch）加载数据。DataLoader 允许我们批量读取数据并进行多线程加载，从而提高训练效率。

训练流程

Mon, 01 Jan 0001 00:00:00 +0000

训练流程#

训练神经网络是深度学习的核心环节。本章将详细介绍 PyTorch 中完整的训练流程，包括前向传播、反向传播、优化器使用等。

基本训练循环#

最简单的训练循环#

import torch
import torch.nn as nn
import torch.optim as optim

# 1. 准备数据
# ... (假设已有 dataloader)

# 2. 定义模型
model = nn.Linear(10, 1)

# 3. 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 4. 训练循环
model.train() # 设置为训练模式
for epoch in range(num_epochs):
 for batch_data, batch_labels in dataloader:
 # 前向传播
 outputs = model(batch_data)
 loss = criterion(outputs, batch_labels)
 
 # 反向传播
 optimizer.zero_grad() # 清零梯度
 loss.backward() # 计算梯度
 optimizer.step() # 更新参数
 
 # 打印损失
 if (epoch + 1) % 10 == 0:
 print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

完整的训练和验证流程#

def train_model(model, train_loader, val_loader, num_epochs, device):
 # 定义损失函数和优化器
 criterion = nn.CrossEntropyLoss()
 optimizer = optim.Adam(model.parameters(), lr=0.001)
 
 # 记录训练历史
 train_losses = []
 val_losses = []
 train_accs = []
 val_accs = []
 
 for epoch in range(num_epochs):
 # ========== 训练阶段 ==========
 model.train()
 train_loss = 0.0
 train_correct = 0
 train_total = 0
 
 for batch_data, batch_labels in train_loader:
 # 移到设备
 batch_data = batch_data.to(device)
 batch_labels = batch_labels.to(device)
 
 # 前向传播
 outputs = model(batch_data)
 loss = criterion(outputs, batch_labels)
 
 # 反向传播
 optimizer.zero_grad()
 loss.backward()
 optimizer.step()
 
 # 统计
 train_loss += loss.item()
 _, predicted = torch.max(outputs.data, 1)
 train_total += batch_labels.size(0)
 train_correct += (predicted == batch_labels).sum().item()
 
 # 计算平均损失和准确率
 avg_train_loss = train_loss / len(train_loader)
 train_acc = 100 * train_correct / train_total
 
 # ========== 验证阶段 ==========
 model.eval()
 val_loss = 0.0
 val_correct = 0
 val_total = 0
 
 with torch.no_grad(): # 验证时不需要计算梯度
 for batch_data, batch_labels in val_loader:
 batch_data = batch_data.to(device)
 batch_labels = batch_labels.to(device)
 
 outputs = model(batch_data)
 loss = criterion(outputs, batch_labels)
 
 val_loss += loss.item()
 _, predicted = torch.max(outputs.data, 1)
 val_total += batch_labels.size(0)
 val_correct += (predicted == batch_labels).sum().item()
 
 avg_val_loss = val_loss / len(val_loader)
 val_acc = 100 * val_correct / val_total
 
 # 记录历史
 train_losses.append(avg_train_loss)
 val_losses.append(avg_val_loss)
 train_accs.append(train_acc)
 val_accs.append(val_acc)
 
 # 打印进度
 print(f'Epoch [{epoch+1}/{num_epochs}]')
 print(f'Train Loss: {avg_train_loss:.4f}, Train Acc: {train_acc:.2f}%')
 print(f'Val Loss: {avg_val_loss:.4f}, Val Acc: {val_acc:.2f}%')
 print('-' * 50)
 
 return {
 'train_losses': train_losses,
 'val_losses': val_losses,
 'train_accs': train_accs,
 'val_accs': val_accs
 }

优化器使用#

常用优化器#

# SGD
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=1e-4)

# Adam
optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999), weight_decay=1e-4)

# AdamW
optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=1e-4)

# RMSprop
optimizer = optim.RMSprop(model.parameters(), lr=0.01, alpha=0.99)

# Adagrad
optimizer = optim.Adagrad(model.parameters(), lr=0.01)

学习率调度器#

# StepLR：每 step_size 个 epoch 将学习率乘以 gamma
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

# ExponentialLR：每个 epoch 将学习率乘以 gamma
scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.95)

# CosineAnnealingLR：余弦退火
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100)

# ReduceLROnPlateau：当指标停止改善时降低学习率
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
 optimizer, mode='min', factor=0.5, patience=5
)

# 在训练循环中使用
for epoch in range(num_epochs):
 # ... 训练代码 ...
 
 # 更新学习率
 scheduler.step() # 对于 StepLR, ExponentialLR, CosineAnnealingLR
 # 或
 scheduler.step(val_loss) # 对于 ReduceLROnPlateau

不同参数组使用不同学习率#

optimizer = optim.SGD([
 {'params': model.features.parameters(), 'lr': 0.001}, # 预训练层
 {'params': model.classifier.parameters(), 'lr': 0.01} # 新层
], lr=0.001, momentum=0.9)

梯度裁剪#

# 梯度裁剪：防止梯度爆炸
max_norm = 1.0
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm)

# 在训练循环中
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm)
optimizer.step()

早停（Early Stopping）#

class EarlyStopping:
 def __init__(self, patience=7, min_delta=0, restore_best_weights=True):
 self.patience = patience
 self.min_delta = min_delta
 self.restore_best_weights = restore_best_weights
 self.best_loss = None
 self.counter = 0
 self.best_weights = None
 
 def __call__(self, val_loss, model):
 if self.best_loss is None:
 self.best_loss = val_loss
 self.save_checkpoint(model)
 elif val_loss < self.best_loss - self.min_delta:
 self.best_loss = val_loss
 self.counter = 0
 self.save_checkpoint(model)
 else:
 self.counter += 1
 
 if self.counter >= self.patience:
 if self.restore_best_weights:
 model.load_state_dict(self.best_weights)
 return True
 return False
 
 def save_checkpoint(self, model):
 self.best_weights = model.state_dict().copy()

# 使用
early_stopping = EarlyStopping(patience=10)
for epoch in range(num_epochs):
 # ... 训练和验证 ...
 if early_stopping(val_loss, model):
 print("Early stopping triggered")
 break

混合精度训练#

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

for epoch in range(num_epochs):
 for batch_data, batch_labels in train_loader:
 optimizer.zero_grad()
 
 # 使用混合精度
 with autocast():
 outputs = model(batch_data)
 loss = criterion(outputs, batch_labels)
 
 # 缩放损失并反向传播
 scaler.scale(loss).backward()
 scaler.step(optimizer)
 scaler.update()

分布式训练#

DataParallel（单机多GPU）#

if torch.cuda.device_count() > 1:
 model = nn.DataParallel(model)

model = model.to(device)

DistributedDataParallel（多机多GPU，推荐）#

import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

# 初始化进程组
dist.init_process_group(backend='nccl')

# 创建模型
model = DDP(model, device_ids=[local_rank])

# 使用 DistributedSampler
from torch.utils.data.distributed import DistributedSampler
sampler = DistributedSampler(dataset)
dataloader = DataLoader(dataset, batch_size=32, sampler=sampler)

训练技巧#

1. 学习率预热（Warmup）#

from torch.optim.lr_scheduler import LambdaLR

def warmup_lambda(epoch):
 if epoch < 5:
 return epoch / 5
 return 1.0

scheduler = LambdaLR(optimizer, lr_lambda=warmup_lambda)

2. 梯度累积#

accumulation_steps = 4
optimizer.zero_grad()

for i, (data, labels) in enumerate(dataloader):
 outputs = model(data)
 loss = criterion(outputs, labels) / accumulation_steps
 loss.backward()
 
 if (i + 1) % accumulation_steps == 0:
 optimizer.step()
 optimizer.zero_grad()

3. 模型检查点#

def save_checkpoint(model, optimizer, epoch, loss, filepath):
 checkpoint = {
 'epoch': epoch,
 'model_state_dict': model.state_dict(),
 'optimizer_state_dict': optimizer.state_dict(),
 'loss': loss,
 }
 torch.save(checkpoint, filepath)

def load_checkpoint(model, optimizer, filepath):
 checkpoint = torch.load(filepath)
 model.load_state_dict(checkpoint['model_state_dict'])
 optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
 epoch = checkpoint['epoch']
 loss = checkpoint['loss']
 return epoch, loss

4. 训练监控#

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('runs/experiment_1')

for epoch in range(num_epochs):
 # ... 训练 ...
 writer.add_scalar('Loss/Train', train_loss, epoch)
 writer.add_scalar('Loss/Val', val_loss, epoch)
 writer.add_scalar('Accuracy/Train', train_acc, epoch)
 writer.add_scalar('Accuracy/Val', val_acc, epoch)
 writer.add_scalar('Learning_Rate', optimizer.param_groups[0]['lr'], epoch)

writer.close()

完整训练模板#

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

def train(model, train_loader, val_loader, config):
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 model = model.to(device)
 
 criterion = nn.CrossEntropyLoss()
 optimizer = optim.Adam(model.parameters(), lr=config['lr'])
 scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
 
 writer = SummaryWriter(config['log_dir'])
 best_val_acc = 0.0
 
 for epoch in range(config['num_epochs']):
 # 训练
 model.train()
 train_loss = 0.0
 train_correct = 0
 train_total = 0
 
 for data, labels in train_loader:
 data, labels = data.to(device), labels.to(device)
 
 optimizer.zero_grad()
 outputs = model(data)
 loss = criterion(outputs, labels)
 loss.backward()
 optimizer.step()
 
 train_loss += loss.item()
 _, predicted = torch.max(outputs.data, 1)
 train_total += labels.size(0)
 train_correct += (predicted == labels).sum().item()
 
 # 验证
 model.eval()
 val_loss = 0.0
 val_correct = 0
 val_total = 0
 
 with torch.no_grad():
 for data, labels in val_loader:
 data, labels = data.to(device), labels.to(device)
 outputs = model(data)
 loss = criterion(outputs, labels)
 
 val_loss += loss.item()
 _, predicted = torch.max(outputs.data, 1)
 val_total += labels.size(0)
 val_correct += (predicted == labels).sum().item()
 
 # 记录
 train_acc = 100 * train_correct / train_total
 val_acc = 100 * val_correct / val_total
 
 writer.add_scalar('Loss/Train', train_loss / len(train_loader), epoch)
 writer.add_scalar('Loss/Val', val_loss / len(val_loader), epoch)
 writer.add_scalar('Accuracy/Train', train_acc, epoch)
 writer.add_scalar('Accuracy/Val', val_acc, epoch)
 
 scheduler.step()
 
 # 保存最佳模型
 if val_acc > best_val_acc:
 best_val_acc = val_acc
 torch.save(model.state_dict(), config['save_path'])
 
 print(f'Epoch [{epoch+1}/{config["num_epochs"]}]')
 print(f'Train Acc: {train_acc:.2f}%, Val Acc: {val_acc:.2f}%')
 
 writer.close()
 return model

常见问题#

1. 过拟合#

# 解决方案：
# - 增加 Dropout
# - 使用数据增强
# - 增加权重衰减（weight_decay）
# - 使用早停

2. 训练不收敛#

# 解决方案：
# - 检查学习率（可能太大或太小）
# - 检查数据预处理
# - 检查损失函数
# - 使用梯度裁剪

3. 内存不足#

# 解决方案：
# - 减小 batch_size
# - 使用梯度累积
# - 使用混合精度训练
# - 减少模型大小

练习#

实现一个完整的训练循环，包括训练和验证
使用学习率调度器优化训练过程
实现早停机制
使用 TensorBoard 可视化训练过程

模型保存与加载

Mon, 01 Jan 0001 00:00:00 +0000

模型保存与加载#

保存和加载模型是深度学习工作流中的重要环节。本章将介绍 PyTorch 中各种模型保存和加载的方法。

基本保存和加载#

保存和加载整个模型#

import torch

# 保存整个模型
torch.save(model, 'model.pth')

# 加载整个模型
model = torch.load('model.pth')
model.eval()

优点：简单直接
缺点：

常用层和函数

Mon, 01 Jan 0001 00:00:00 +0000

常用层和函数#

PyTorch 提供了丰富的神经网络层和工具函数。本章将介绍常用的层类型和函数，帮助你更好地构建模型。

卷积层#

卷积层模块速查#

模块	说明
`nn.Conv1d`	一维卷积层，用于序列数据
`nn.Conv2d`	二维卷积层，用于图像处理
`nn.Conv3d`	三维卷积层，用于视频或3D数据
`nn.ConvTranspose1d`	一维转置卷积（反卷积），用于上采样
`nn.ConvTranspose2d`	二维转置卷积，用于生成模型和上采样
`nn.ConvTranspose3d`	三维转置卷积
`nn.Unfold`	将滑动窗口展开为矩阵
`nn.Fold`	将展开的矩阵折叠回特征图

示例#

import torch
import torch.nn as nn

# Conv1d
conv1d = nn.Conv1d(16, 32, kernel_size=3, stride=1, padding=1)
x = torch.randn(32, 16, 100) # (batch, channels, length)
out = conv1d(x) # (32, 32, 100)

# Conv2d 基础用法
conv2d = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
x = torch.randn(32, 3, 32, 32)
out = conv2d(x) # (32, 64, 32, 32)

# Conv3d
conv3d = nn.Conv3d(1, 32, kernel_size=3)
out = conv3d(torch.randn(32, 1, 16, 16, 16))

# 转置卷积（上采样）
transpose_conv = nn.ConvTranspose2d(64, 32, kernel_size=2, stride=2)
out = transpose_conv(torch.randn(32, 64, 16, 16)) # (32, 32, 32, 32)

# Unfold：将滑动窗口展开为矩阵
unfold = nn.Unfold(kernel_size=3, padding=1)
x = torch.randn(32, 64, 32, 32)
out = unfold(x) # (32, 64*3*3, 32*32)

池化层#

池化层模块速查#

模块	说明
`nn.MaxPool1d`	一维最大池化
`nn.MaxPool2d`	二维最大池化
`nn.MaxPool3d`	三维最大池化
`nn.AvgPool1d`	一维平均池化
`nn.AvgPool2d`	二维平均池化
`nn.AvgPool3d`	三维平均池化
`nn.AdaptiveMaxPool1d`	一维自适应最大池化，输出固定大小
`nn.AdaptiveMaxPool2d`	二维自适应最大池化
`nn.AdaptiveMaxPool3d`	三维自适应最大池化
`nn.AdaptiveAvgPool1d`	一维自适应平均池化
`nn.AdaptiveAvgPool2d`	二维自适应平均池化（全局平均池化）
`nn.AdaptiveAvgPool3d`	三维自适应平均池化
`nn.MaxUnpool1d/2d/3d`	最大池化的逆操作
`nn.FractionalMaxPool2d`	分数最大池化，使用随机步长
`nn.LPPool1d/2d`	Lp 范数池化

示例#

import torch
import torch.nn as nn

# MaxPool1d（1d 典型）
maxpool1d = nn.MaxPool1d(kernel_size=2, stride=2)
x = torch.randn(32, 64, 100)
out = maxpool1d(x) # (32, 64, 50)

# MaxPool2d、AvgPool2d
maxpool = nn.MaxPool2d(kernel_size=2, stride=2)
avgpool = nn.AvgPool2d(kernel_size=2, stride=2)
x = torch.randn(32, 64, 32, 32)
out = maxpool(x) # (32, 64, 16, 16)
out = avgpool(x) # (32, 64, 16, 16)

# 全局平均池化
global_avg = nn.AdaptiveAvgPool2d((1, 1))
out = global_avg(x) # (32, 64, 1, 1)

归一化层#

归一化层模块速查#

模块	说明
`nn.BatchNorm1d`	一维批归一化，用于全连接层
`nn.BatchNorm2d`	二维批归一化，用于卷积层
`nn.BatchNorm3d`	三维批归一化
`nn.GroupNorm`	组归一化
`nn.LayerNorm`	层归一化
`nn.InstanceNorm1d/2d/3d`	实例归一化，常用于风格迁移
`nn.LocalResponseNorm`	局部响应归一化（LRN），常用于 AlexNet

示例#

import torch
import torch.nn as nn

# BatchNorm2d
bn = nn.BatchNorm2d(64)
x = torch.randn(32, 64, 32, 32)
out = bn(x)

# LayerNorm
ln = nn.LayerNorm(128)
x = torch.randn(32, 128)
out = ln(x)

# GroupNorm
gn = nn.GroupNorm(8, 64)
x = torch.randn(32, 64, 32, 32)
out = gn(x)

# InstanceNorm2d
in_norm = nn.InstanceNorm2d(64)
out = in_norm(x)

# LocalResponseNorm（LRN）
lrn = nn.LocalResponseNorm(size=5)
out = lrn(x)

激活函数#

非线性激活函数速查#

模块	说明	公式
`nn.ReLU`	修正线性单元	$\text{ReLU}(x) = \max(0, x)$
`nn.LeakyReLU`	泄漏 ReLU	$\text{LeakyReLU}(x) = \max(0, x) + \alpha \min(0, x)$
`nn.PReLU`	参数化 ReLU，斜率可学习	$\text{PReLU}(x) = \max(0, x) + a \min(0, x)$
`nn.RReLU`	随机 ReLU，训练时随机选择斜率	-
`nn.Sigmoid`	Sigmoid 函数	$\text{Sigmoid}(x) = \frac{1}{1 + \exp(-x)}$
`nn.Tanh`	双曲正切函数	$\text{Tanh}(x) = \frac{\exp(x) - \exp(-x)}{\exp(x) + \exp(-x)}$
`nn.GELU`	高斯误差线性单元	$\text{GELU}(x) = x \times \Phi(x)$
`nn.SiLU`	Sigmoid 线性单元（Swish）	$\text{SiLU}(x) = x \times \text{sigmoid}(x)$
`nn.ELU`	指数线性单元	$\text{ELU}(x) = \max(0, x) + \min(0, \alpha \times (\exp(x) - 1))$
`nn.CELU`	连续可微的 ELU	-
`nn.SELU`	缩放指数线性单元	-
`nn.ReLU6`	ReLU6	$\text{ReLU6}(x) = \min(\max(0, x), 6)$
`nn.Hardswish`	Hardswish 激活函数	-
`nn.Hardsigmoid`	Hard sigmoid 激活函数	-
`nn.Hardtanh`	Hard tanh 激活函数	-
`nn.Softmax`	Softmax 函数	$\text{Softmax}(x_i) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}$
`nn.LogSoftmax`	对数 Softmax	$\text{LogSoftmax}(x_i) = \log\left(\frac{\exp(x_i)}{\sum_j \exp(x_j)}\right)$
`nn.Softmin`	Softmin 函数（Softmax 的负值版本）	-
`nn.Softmax2d`	对每个空间位置应用 Softmax	-
`nn.Softsign`	Softsign 函数	$\text{Softsign}(x) = \frac{x}{1 + \\|x\\|}$
`nn.Tanhshrink`	Tanhshrink 函数	$\text{Tanhshrink}(x) = x - \tanh(x)$
`nn.Threshold`	阈值激活函数	-

示例#

import torch
import torch.nn as nn

x = torch.randn(32, 128)

# ReLU、LeakyReLU
relu = nn.ReLU()
out = relu(x)
leaky_relu = nn.LeakyReLU(negative_slope=0.01)
out = leaky_relu(x)

# Sigmoid、Tanh、GELU
out = nn.Sigmoid()(x)
out = nn.Tanh()(x)
out = nn.GELU()(x)

# Softmax、ReLU6
out = nn.Softmax(dim=-1)(x)
out = nn.ReLU6()(x)

Dropout 层#

Dropout 层模块速查#

模块	说明
`nn.Dropout`	Dropout，训练时随机置零
`nn.Dropout1d/2d/3d`	多维 Dropout
`nn.AlphaDropout`	Alpha Dropout，保持自归一化性质
`nn.FeatureAlphaDropout`	特征 Alpha Dropout

示例#

import torch
import torch.nn as nn

# Dropout（全连接）
dropout = nn.Dropout(p=0.5)
x = torch.randn(32, 128)
out = dropout(x)

# Dropout2d（卷积特征图）
dropout2d = nn.Dropout2d(p=0.5)
x = torch.randn(32, 64, 32, 32)
out = dropout2d(x)

全连接层#

模块	说明	公式
`nn.Linear`	全连接层（线性变换）	$y = xA^T + b$
`nn.Bilinear`	双线性层	$y = x_1^T A x_2 + b$

示例#

import torch
import torch.nn as nn

# Linear：会自动初始化 权重(Kaiming) 均匀分布；偏置(均匀分布)
fc = nn.Linear(784, 128) # nn.Linear(784,128)：特征维度
x = torch.randn(32, 784) # x维度是：batch维 + 特征维
out = fc(x) # (32, 128) 

# Bilinear
bilinear = nn.Bilinear(64, 64, 32)
x1 = torch.randn(32, 64)
x2 = torch.randn(32, 64)
out = bilinear(x1, x2) # (32, 32)

# 多层全连接（MLP）
class MLP(nn.Module):
 def __init__(self):
 super().__init__()
 self.fc1 = nn.Linear(784, 256)
 self.fc2 = nn.Linear(256, 128)
 self.fc3 = nn.Linear(128, 10)
 def forward(self, x):
 x = torch.relu(self.fc1(x))
 x = torch.relu(self.fc2(x))
 return self.fc3(x)

循环神经网络层#

循环层模块速查#

模块	说明
`nn.RNN`	基础循环神经网络
`nn.LSTM`	长短期记忆网络
`nn.GRU`	门控循环单元
`nn.RNNCell`	单个时间步的 RNN 单元
`nn.LSTMCell`	单个时间步的 LSTM 单元
`nn.GRUCell`	单个时间步的 GRU 单元

示例#

import torch
import torch.nn as nn

x = torch.randn(32, 5, 10) # (batch, seq_len, input_size)

# LSTM
lstm = nn.LSTM(input_size=10, hidden_size=20, num_layers=2, batch_first=True)
out, (h_n, c_n) = lstm(x) # out: (32, 5, 20)

# GRU
gru = nn.GRU(input_size=10, hidden_size=20, num_layers=2, batch_first=True)
out, h_n = gru(x)

# LSTMCell（单步）
cell = nn.LSTMCell(10, 20)
h, c = torch.zeros(32, 20), torch.zeros(32, 20)
for t in range(5):
 h, c = cell(x[:, t], (h, c))

嵌入层#

稀疏层模块速查#

模块	说明
`nn.Embedding`	嵌入层，将索引映射为密集向量
`nn.EmbeddingBag`	嵌入包，计算嵌入向量的和或均值

示例#

import torch
import torch.nn as nn

# Embedding
embedding = nn.Embedding(1000, 128)
x = torch.randint(0, 1000, (32, 10))
out = embedding(x) # (32, 10, 128)

# EmbeddingBag（按包聚合，如词袋）
embed_bag = nn.EmbeddingBag(1000, 128, mode='mean')
offsets = torch.tensor([0, 4, 8, 12, 16, 20, 24, 28, 32]) # 8 个包
indices = torch.randint(0, 1000, (32,))
out = embed_bag(indices, offsets) # (8, 128)

注意力机制#

Transformer 层模块速查#

模块	说明
`nn.Transformer`	完整的 Transformer 模型
`nn.TransformerEncoder`	Transformer 编码器
`nn.TransformerDecoder`	Transformer 解码器
`nn.TransformerEncoderLayer`	单个 Transformer 编码器层
`nn.TransformerDecoderLayer`	Transformer 解码器层
`nn.MultiheadAttention`	多头注意力机制

示例#

import torch
import torch.nn as nn

x = torch.randn(32, 10, 512) # (batch, seq_len, embed_dim)

# MultiheadAttention
mha = nn.MultiheadAttention(embed_dim=512, num_heads=8, batch_first=True)
out, attn_weights = mha(x, x, x) # out: (32, 10, 512)

# TransformerEncoderLayer
enc_layer = nn.TransformerEncoderLayer(d_model=512, nhead=8, batch_first=True)
out = enc_layer(x) # (32, 10, 512)

实用工具函数#

工具函数速查#

模块	说明
`nn.Flatten`	展平层
`nn.Unflatten`	反展平层
`nn.Identity`	恒等映射，不做任何操作

示例（Flatten / Unflatten / Identity）#

import torch
import torch.nn as nn

# Flatten
flatten = nn.Flatten()
x = torch.randn(32, 3, 32, 32)
out = flatten(x) # (32, 3072)

# Unflatten
unflatten = nn.Unflatten(1, (3, 32, 32))
out = unflatten(torch.randn(32, 3072)) # (32, 3, 32, 32)

# Identity
identity = nn.Identity()
out = identity(x) # 形状不变

填充层速查#

模块	说明
`nn.ZeroPad2d`	零填充
`nn.ConstantPad1d/2d/3d`	常数填充
`nn.ReflectionPad1d/2d/3d`	反射填充
`nn.ReplicationPad1d/2d/3d`	复制填充

示例（Padding）#

import torch
import torch.nn as nn

x = torch.randn(32, 3, 32, 32)

# ZeroPad2d
pad = nn.ZeroPad2d(padding=1)
out = pad(x) # (32, 3, 34, 34)

# ConstantPad2d
pad2 = nn.ConstantPad2d(padding=1, value=0)
out = pad2(x)

组合层#

容器类模块速查#

模块	说明
`nn.Module`	所有神经网络模块的基类
`nn.Sequential`	按顺序组合多个模块
`nn.ModuleList`	存储模块的列表，可动态添加
`nn.ModuleDict`	存储模块的字典
`nn.ParameterList`	存储参数的列表
`nn.ParameterDict`	存储参数的字典

示例#

import torch
import torch.nn as nn

# Sequential
model = nn.Sequential(
 nn.Conv2d(3, 64, 3, padding=1),
 nn.BatchNorm2d(64),
 nn.ReLU(),
 nn.MaxPool2d(2),
 nn.Flatten(),
 nn.Linear(64 * 16 * 16, 256),
 nn.ReLU(),
 nn.Linear(256, 10)
)

# ModuleList
class Net(nn.Module):
 def __init__(self):
 super().__init__()
 self.layers = nn.ModuleList([
 nn.Linear(10, 20),
 nn.Linear(20, 40)
 ])
 def forward(self, x):
 for layer in self.layers:
 x = layer(x)
 return x

# ParameterList
class Custom(nn.Module):
 def __init__(self):
 super().__init__()
 self.params = nn.ParameterList([nn.Parameter(torch.randn(4, 4)) for _ in range(3)])
 def forward(self, x):
 for p in self.params:
 x = x @ p
 return x

常用函数#

损失函数速查#

模块	说明	公式
`nn.L1Loss`	L1 损失（平均绝对误差）	$L = \frac{1}{N} \sum_i \\|x_i - y_i\\|$
`nn.MSELoss`	均方误差损失	$L = \frac{1}{N} \sum_i (x_i - y_i)^2$
`nn.CrossEntropyLoss`	交叉熵损失，用于多分类	-
`nn.NLLLoss`	负对数似然损失，通常与 LogSoftmax 配合使用	-
`nn.BCELoss`	二元交叉熵损失，用于二分类	-
`nn.BCEWithLogitsLoss`	带 logits 的二元交叉熵，数值更稳定	-
`nn.KLDivLoss`	KL 散度损失	-
`nn.MarginRankingLoss`	排序损失	-
`nn.HingeEmbeddingLoss`	Hinge 嵌入损失	-
`nn.MultiLabelMarginLoss`	多标签边界损失	-
`nn.SmoothL1Loss`	平滑 L1 损失（Huber 损失）	-
`nn.SoftMarginLoss`	Soft margin 损失	-
`nn.MultiLabelSoftMarginLoss`	多标签 Soft margin 损失	-
`nn.CosineEmbeddingLoss`	余弦嵌入损失	-
`nn.MultiMarginLoss`	多类多分类损失	-
`nn.TripletMarginLoss`	三元组损失	-
`nn.CTCLoss`	连接时序分类损失，用于序列标注	-
`nn.PoissonNLLLoss`	泊松负对数似然损失	-
`nn.GaussianNLLLoss`	高斯负对数似然损失	-

示例（F.* 与 nn 损失）#

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

# F.* 典型
x = torch.randn(32, 64, 32, 32)
x = F.relu(x)
x = F.max_pool2d(x, kernel_size=2, stride=2)
x = F.dropout(x, p=0.5, training=True)
x = F.interpolate(x, size=(64, 64), mode='bilinear', align_corners=False)

# F 损失
logits = torch.randn(32, 10)
targets = torch.randint(0, 10, (32,))
loss = F.cross_entropy(logits, targets)
loss = F.mse_loss(torch.randn(32, 1), torch.randn(32, 1))

# nn 损失
ce = nn.CrossEntropyLoss()
loss = ce(logits, targets)
bce = nn.BCEWithLogitsLoss()
loss = bce(torch.randn(32, 1), torch.rand(32, 1))

构建复杂模型示例#

ResNet Block#

import torch
import torch.nn as nn

class ResidualBlock(nn.Module):
 def __init__(self, in_channels, out_channels, stride=1):
 super().__init__()
 self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride=stride, padding=1)
 self.bn1 = nn.BatchNorm2d(out_channels)
 self.conv2 = nn.Conv2d(out_channels, out_channels, 3, padding=1)
 self.bn2 = nn.BatchNorm2d(out_channels)
 self.relu = nn.ReLU(inplace=True)
 
 self.shortcut = nn.Sequential()
 if stride != 1 or in_channels != out_channels:
 self.shortcut = nn.Sequential(
 nn.Conv2d(in_channels, out_channels, 1, stride=stride),
 nn.BatchNorm2d(out_channels)
 )
 
 def forward(self, x):
 residual = self.shortcut(x)
 out = self.relu(self.bn1(self.conv1(x)))
 out = self.bn2(self.conv2(out))
 out += residual
 out = self.relu(out)
 return out

Transformer Block#

import torch
import torch.nn as nn

class TransformerBlock(nn.Module):
 def __init__(self, embed_dim, num_heads, ff_dim, dropout=0.1):
 super().__init__()
 self.attention = nn.MultiheadAttention(embed_dim, num_heads, batch_first=True)
 self.norm1 = nn.LayerNorm(embed_dim)
 self.norm2 = nn.LayerNorm(embed_dim)
 
 self.feed_forward = nn.Sequential(
 nn.Linear(embed_dim, ff_dim),
 nn.GELU(),
 nn.Dropout(dropout),
 nn.Linear(ff_dim, embed_dim),
 nn.Dropout(dropout)
 )
 
 def forward(self, x):
 # 自注意力
 attn_out, _ = self.attention(x, x, x)
 x = self.norm1(x + attn_out)
 
 # 前馈网络
 ff_out = self.feed_forward(x)
 x = self.norm2(x + ff_out)
 
 return x

练习#

使用不同的层构建一个 CNN 模型
实现一个带残差连接的模块
构建一个简单的 Transformer 块
尝试使用不同的归一化层，比较效果

下一步#

掌握了常用层和函数后，学习：

优化器与损失函数

Mon, 01 Jan 0001 00:00:00 +0000

优化器与损失函数#

优化器和损失函数是训练神经网络的关键组件。本章将详细介绍 PyTorch 中常用的优化器和损失函数。

核心原理#

优化目标#

设损失函数为 $L(\theta)$ ，优化目标为：

$$ \theta^* = \arg\min_\theta L(\theta) $$

梯度下降通过迭代更新参数：$\theta_{t+1} = \theta_t - \eta \cdot g_t$ ，其中 $g_t = \nabla_\theta L(\theta_t)$ 为梯度，$\eta$ 为学习率。

关键概念#

学习率：控制每步更新幅度，过大易震荡，过小收敛慢
动量：累积历史梯度，加速收敛、平滑更新
自适应学习率：根据梯度历史为每个参数单独调整步长
权重衰减：L2 正则化，防止过拟合

优化器（Optimizers）#

优化器用于更新模型参数，最小化损失函数。

SGD（随机梯度下降）#

import torch.optim as optim

# 基本 SGD
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 带动量的 SGD（推荐）
optimizer = optim.SGD(
 model.parameters(),
 lr=0.01,
 momentum=0.9, # 动量系数
 weight_decay=1e-4, # L2 正则化
 nesterov=True # Nesterov 动量
)

更新公式（带动量）：

附录1-PyTorch 完整参考

Mon, 01 Jan 0001 00:00:00 +0000

PyTorch 完整参考#

本附录提供 PyTorch 核心 API 速查、优化器与损失函数数学公式、以及官方文档索引，便于快速查阅。

一、torch 核心 API 速查#

1.1 张量创建#

函数	说明
`torch.tensor(data)`	从数据创建张量
`torch.zeros(*size)`	全零张量
`torch.ones(*size)`	全一张量
`torch.empty(*size)`	未初始化张量
`torch.rand(*size)`	[0,1) 均匀分布
`torch.randn(*size)`	标准正态分布
`torch.arange(start, end, step)`	等差序列
`torch.linspace(start, end, steps)`	等间距序列
`torch.eye(n)`	单位矩阵
`torch.from_numpy(ndarray)`	NumPy 转张量

1.2 张量操作#

函数	说明
`torch.cat(tensors, dim)`	沿维度拼接
`torch.stack(tensors, dim)`	堆叠（新增维度）
`torch.split(tensor, split_size, dim)`	分割
`torch.chunk(tensor, chunks, dim)`	均分
`torch.gather(input, dim, index)`	按索引 gather
`torch.scatter(input, dim, index, src)`	按索引 scatter
`torch.masked_select(input, mask)`	掩码选择
`torch.where(condition, x, y)`	条件选择

1.3 数学运算#

函数	说明
`torch.matmul(a, b)`	矩阵乘法
`torch.mm(a, b)`	2D 矩阵乘法
`torch.bmm(a, b)`	批量矩阵乘法
`torch.einsum(equation, *operands)`	爱因斯坦求和
`torch.svd(A)`	奇异值分解
`torch.inverse(A)`	矩阵求逆
`torch.linalg.solve(A, B)`	线性方程组求解

1.4 设备与类型#

函数/属性	说明
`tensor.to(device)`	移至设备
`tensor.cuda()`	移至 GPU
`tensor.cpu()`	移至 CPU
`tensor.float()` / `.double()`	类型转换
`torch.cuda.is_available()`	CUDA 是否可用
`torch.set_default_device(device)`	设置默认设备

二、优化器算法原理#

2.1 SGD（随机梯度下降）#

基础形式：