Pytorch教程#

搭建一个神经网络#

PyTorch 常用层讲解与示例#

本教程介绍 PyTorch 中一些核心神经网络层：Linear、Conv2d、LSTM，包括它们的数学公式和对应实现代码。

1. Linear 层 (全连接层)#

数学公式：

输入向量 $x \in \mathbb{R}^{d_{in}}$ ，输出向量 $y \in \mathbb{R}^{d_{out}}$ ：

y = x W^\top + b, \quad W \in \mathbb{R}^{d_{out} \times d_{in}}, \quad b \in \mathbb{R}^{d_{out}}

解释：

每个输出节点是输入节点的加权和加上偏置
常用于全连接网络、MLP 等

示例代码：

1
import torch
2
import torch.nn as nn
3

4
class LinearExample(nn.Module):
5
    def __init__(self, d_in, d_out):
6
        super().__init__()
7
        self.linear = nn.Linear(d_in, d_out)
8

9
    def forward(self, x):
10
        return self.linear(x)
11

12
# 示例
13
x = torch.randn(4, 10)
14
model_linear = LinearExample(10, 5)
15
y = model_linear(x)
16
print("Linear 输出形状:", y.shape)

2. Conv2d 层 (二维卷积层)#

数学公式：

输入张量 $X \in \mathbb{R}^{C_{in} \times H \times W}$ ，卷积核 $K \in \mathbb{R}^{C_{out} \times C_{in} \times k_h \times k_w}$ ：

Y_{o,i,j} = \sum_{c=0}^{C_{in}-1} \sum_{m=0}^{k_h-1} \sum_{n=0}^{k_w-1} K_{o,c,m,n} \cdot X_{c,i+m,j+n} + b_o

解释：

对每个输出通道，卷积核在输入各通道上进行加权求和，并加偏置
常用于图像特征提取、卷积神经网络

示例代码：

1
import torch
2
import torch.nn as nn
3

4
class Conv2dExample(nn.Module):
5
    def __init__(self, in_channels, out_channels, kernel_size):
6
        super().__init__()
7
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size)
8

9
    def forward(self, x):
10
        return self.conv(x)
11

12
# 示例
13
x_img = torch.randn(2, 3, 32, 32)  # batch_size=2, 3通道, 32x32图像
14
model_conv = Conv2dExample(3, 6, 5)  # 输出6个通道, kernel 5x5
15
y_img = model_conv(x_img)
16
print("Conv2d 输出形状:", y_img.shape)

PyTorch 激活函数详解#

本教程介绍常用激活函数。

1. ReLU#

数学公式：

f(x) = \max(0, x)

解释：

将小于0的输入置0，大于0保持不变
计算简单，常用于卷积层或全连接层后

1
import torch
2
import torch.nn as nn
3

4
relu = nn.ReLU()
5
x = torch.tensor([[-1.0, 0.0, 2.0]])
6
y = relu(x)
7
print("ReLU 输出:\n", y)

2. Sigmoid#

数学公式：

\sigma(x) = \frac{1}{1 + e^{-x}}

解释：

将输入映射到 (0,1)
常用于二分类输出层

1
import torch
2
import torch.nn as nn
3

4
sigmoid = nn.Sigmoid()
5
x = torch.tensor([[-1.0, 0.0, 2.0]])
6
y = sigmoid(x)
7
print("Sigmoid 输出:\n", y)

3. Tanh#

数学公式：

\tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}

解释：

将输入映射到 (-1, 1)
均值为 0，有助于训练收敛
常用于序列模型或隐藏层激活函数

1
import torch
2
import torch.nn as nn
3

4
tanh = nn.Tanh()
5
x = torch.tensor([[-1.0, 0.0, 2.0]])
6
y = tanh(x)
7
print("Tanh 输出:\n", y)

4. LeakyReLU#

数学公式：

f(x) = \begin{cases} x, & x > 0 \\ \alpha x, & x \le 0 \end{cases}, \quad \alpha = 0.01

解释：

避免 ReLU 的“死亡神经元”问题
对负值仍保留小梯度，不完全置零
常用于卷积层或全连接层激活函数

1
import torch
2
import torch.nn as nn
3

4
leaky_relu = nn.LeakyReLU(negative_slope=0.01)
5
x = torch.tensor([[-1.0, 0.0, 2.0]])
6
y = leaky_relu(x)
7
print("LeakyReLU 输出:\n", y)

PyTorch 常见损失函数详解#

本教程介绍 PyTorch 中常用的损失函数，包括均方误差损失、交叉熵损失和 KL 散度损失，包含数学公式、原理解释和示例代码。

1. MSELoss（均方误差损失）#

数学公式：

\text{MSELoss} = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2

解释：

用于回归任务
衡量预测值 $\hat{y}$ 与真实值 $y$ 的平方差
对异常值较敏感

1
import torch
2
import torch.nn as nn
3

4
mse_loss = nn.MSELoss()
5
y_pred = torch.tensor([0.5, 0.8, 1.2])
6
y_true = torch.tensor([0.0, 1.0, 1.0])
7
loss = mse_loss(y_pred, y_true)
8
print("MSELoss:", loss.item())

2. CrossEntropyLoss（交叉熵损失）#

数学公式（多分类）：

\text{CrossEntropyLoss} = - \frac{1}{N} \sum_{i=1}^{N} \sum_{c=1}^{C} y_{i,c} \log \hat{y}_{i,c}

解释：

用于分类任务
$y_{i,c}$ 是真实类别的 one-hot 编码，是预测概率
PyTorch 的 CrossEntropyLoss 内部包含 Softmax，不需要手动计算概率

示例代码：

1
import torch
2
import torch.nn as nn
3

4
cross_entropy = nn.CrossEntropyLoss()
5
y_pred = torch.tensor([[2.0, 1.0, 0.1]])  # logits
6
y_true = torch.tensor([0])                # 类别索引
7
loss = cross_entropy(y_pred, y_true)
8
print("CrossEntropyLoss:", loss.item())

3. KLDivLoss（KL 散度损失）#

数学公式：

\text{KLDivLoss}(P \parallel Q) = \sum_i P(i) \log \frac{P(i)}{Q(i)}

解释：

用于衡量两个概率分布 $P$ 和 $Q$ 的差异
常用于知识蒸馏或概率分布拟合
PyTorch 要求输入为 log 概率（log_target=False 时输入为 log 概率）

示例代码：

1
import torch
2
import torch.nn as nn
3
import torch.nn.functional as F
4

5
kl_div = nn.KLDivLoss(reduction='batchmean')
6
p = F.log_softmax(torch.tensor([[0.2, 0.5, 0.3]]), dim=1)
7
q = torch.tensor([[0.1, 0.6, 0.3]])
8
loss = kl_div(p, q)
9
print("KLDivLoss:", loss.item())

PyTorch 容器（Container）详解#

PyTorch 提供了一些容器类，用于组织和管理多个子模块，常用的有 Sequential、ModuleList、ModuleDict。

1. nn.Sequential

功能：将多个子模块按顺序组合成一个整体，前一个模块的输出作为下一个模块的输入
使用场景：简单的前向顺序网络，如 MLP 或简单 CNN

示例代码：

1
import torch
2
import torch.nn as nn
3

4
model_seq = nn.Sequential(
5
    nn.Linear(10, 20),
6
    nn.ReLU(),
7
    nn.Linear(20, 5)
8
)
9

10
x = torch.randn(2, 10)
11
y = model_seq(x)
12
print("Sequential 输出形状:", y.shape)

2. nn.ModuleList

功能：保存任意数量的子模块的列表，但不会定义前向计算的顺序，需要在 forward 中手动调用
使用场景：动态网络结构、多分支网络

1
import torch
2
import torch.nn as nn
3

4
layers = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])
5
x = torch.randn(2, 10)
6
for layer in layers:
7
    x = layer(x)
8
print("ModuleList 输出形状:", x.shape)

3. nn.ModuleDict

功能：以字典形式保存子模块，便于按名字访问
使用场景：多分支或命名网络结构

1
import torch
2
import torch.nn as nn
3

4
layer_dict = nn.ModuleDict({
5
    'fc1': nn.Linear(10, 20),
6
    'relu': nn.ReLU(),
7
    'fc2': nn.Linear(20, 5)
8
})
9

10
x = torch.randn(2, 10)
11
x = layer_dict['fc1'](x)
12
x = layer_dict['relu'](x)
13
y = layer_dict['fc2'](x)
14
print("ModuleDict 输出形状:", y.shape)

优化器模块#

PyTorch 神经网络基础：`init` 与 `forward` 方法详解#

在 PyTorch 中，自定义神经网络类通常继承自 nn.Module，核心方法是 __init__ 和 forward。下面以一个简单的全连接网络为例进行讲解。

1. 模型代码示例#

1
import torch
2
import torch.nn as nn
3

4
class SimpleNN(nn.Module):
5
    def __init__(self):
6
        super(SimpleNN, self).__init__()
7
        # 定义网络结构
8
        self.fc1 = nn.Linear(28*28, 128)  # 全连接层1
9
        self.relu = nn.ReLU()             # 激活函数
10
        self.fc2 = nn.Linear(128, 10)    # 全连接层2
11
        self.softmax = nn.Softmax(dim=1) # 输出概率归一化
12

13
    def forward(self, x):
14
        # 前向计算流程
15
        x = x.view(-1, 28*28)  # 展平输入为 (batch_size, 784)
16
        x = self.fc1(x)        # 第一个全连接层
17
        x = self.relu(x)       # ReLU 激活
18
        x = self.fc2(x)        # 第二个全连接层
19
        x = self.softmax(x)    # Softmax 转为概率分布
20
        return x
21

22
# 创建模型实例
23
model = SimpleNN()

2. 方法详解#

2.1 `init` 方法#

作用：定义网络的各层，包括线性层、卷积层、激活函数等。

特点：

仅声明网络结构，不进行前向计算。
注册子模块，便于 PyTorch 自动管理参数。

2.2 `forward` 方法#

作用：定义数据的前向传播流程。

特点：

输入 $x$ 会依次经过各个层，输出最终结果。
PyTorch 自动重载 __call__ 方法，调用模型实例时会触发 forward。

示例：

1
output = model(input_tensor)

相当于执行：

1
model.forward(input_tensor)

无需手动调用 forward 方法。

3. 数据流说明#

输入图像张量 $x$ 展平成 $(\text{batch size}, 784)$ 。
经过第一个全连接层 fc1，输出 $(\text{batch size}, 128)$ 。
通过 ReLU 激活函数，增加非线性。
经过第二个全连接层 fc2，输出 $(\text{batch size}, 10)$ 。
通过 Softmax 将输出转为概率分布，适合分类任务。

这种结构是典型的全连接神经网络（MLP）分类模型。

4. 补充说明#

nn.Linear(in_features, out_features)：创建全连接层，将输入特征维度 $in\_features$ 映射到输出维度 $out\_features$ 。
nn.ReLU()：激活函数，增加网络非线性能力。
nn.Softmax(dim=1)：对指定维度做归一化，使输出值可以看作概率分布。
x.view(-1, 28*28)：将输入张量展平成二维，-1 表示自动计算 batch size。
在 PyTorch 中，所有 nn.Module 的子模块都会自动注册为模型参数，无需手动管理。

PyTorch 手写体图像识别教学#

1. 导入必要库#

1
# 本教程演示如何使用 PyTorch 实现 MNIST 手写数字识别任务
2
# 包含数据加载、模型定义、训练和测试
3
import torch
4
import torch.nn as nn
5
import torch.optim as optim
6
from torchvision import datasets, transforms
7
from torch.utils.data import DataLoader

#@ 2. 数据预处理与加载 MNIST 图片为 28x28 灰度图需要将图片转换为张量并归一化到 [-1, 1] DataLoader 按批次加载数据，并支持 shuffle 功能

1
transform = transforms.Compose([
2
    transforms.ToTensor(),
3
    transforms.Normalize((0.5,), (0.5,))
4
])
5

6
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
7
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
8

9
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
10
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

3. 定义前馈神经网络#

网络结构：输入层: 28*28 = 784 个神经元隐藏层: 128 个神经元, ReLU 激活输出层: 10 个神经元, Softmax 输出概率

1
class SimpleNN(nn.Module):
2
    def __init__(self):
3
        super(SimpleNN, self).__init__()
4
        self.fc1 = nn.Linear(28*28, 128)
5
        self.relu = nn.ReLU()
6
        self.fc2 = nn.Linear(128, 10)
7
        self.softmax = nn.Softmax(dim=1)
8

9
    def forward(self, x):
10
        # 前向传播
11
        x = x.view(-1, 28*28)  # 展平
12
        x = self.fc1(x)
13
        x = self.relu(x)
14
        x = self.fc2(x)
15
        x = self.softmax(x)
16
        return x
17

18
model = SimpleNN()

4. 定义损失函数和优化器#

多分类交叉熵损失优化器: 随机梯度下降 (SGD)

1
criterion = nn.CrossEntropyLoss()
2
optimizer = optim.SGD(model.parameters(), lr=0.01)

5. 模型训练#

训练流程:#

1. 前向传播: 计算预测输出#

2. 计算损失#

3. 反向传播#

4. 参数更新#

1
num_epochs = 5
2
for epoch in range(num_epochs):
3
    running_loss = 0.0
4
    for images, labels in train_loader:
5
        outputs = model(images)
6
        loss = criterion(outputs, labels)
7

8
        optimizer.zero_grad()
9
        loss.backward()
10
        optimizer.step()
11

12
        running_loss += loss.item()
13
    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}")

6. 测试模型准确率#

在测试集上评估模型性能

1
correct = 0
2
total = 0
3
with torch.no_grad():
4
    for images, labels in test_loader:
5
        outputs = model(images)
6
        _, predicted = torch.max(outputs.data, 1)
7
        total += labels.size(0)
8
        correct += (predicted == labels).sum().item()
9

10
print(f'Test Accuracy: {100 * correct / total:.2f}%')