如何理解神经网络训练的循环过程

正向传播 → 反向传播 → 参数更新

这个过程是一个完整的训练迭代，然后不断重复这一轮又一轮，直到模型收敛（损失函数趋于最小），这就是神经网络训练的核心流程。

---

🧠 详细解释整个循环过程：

我们把整个训练流程拆解成一个"学习周期"，它包括以下三个核心步骤：

---

1️⃣ 正向传播（Forward Propagation）

• 输入数据：x
• 计算每一层的输出，最终得到模型预测值 y(/hat)
• 根据真实值 y 计算当前损失（Loss）：比如均方误差、交叉熵等

✅ 目的：

• 得到当前参数下的预测结果
• 为反向传播提供计算梯度所需的所有中间变量

---

2️⃣ 反向传播（Backward Propagation）

• 利用链式法则（Chain Rule）从输出层开始，逐层向前计算每个参数（权重 W 、偏置 b）对损失的影响（即梯度）
• 所有梯度保存下来供后续使用

✅ 目的：

• 知道每个参数怎么影响损失函数
• 为参数更新提供依据

---

3️⃣ 参数更新（Parameter Update）

• 使用梯度下降或其他优化算法（如 Adam、SGD with momentum）来更新参数：
  W : = W − α ⋅ ∂ L ∂ W W := W - \alpha \cdot \frac{\partial L}{\partial W} W:=W−α⋅∂W∂L
  b : = b − α ⋅ ∂ L ∂ b b := b - \alpha \cdot \frac{\partial L}{\partial b} b:=b−α⋅∂b∂L
  其中 α 是学习率

✅ 目的：

• 调整参数，使下一次预测更准确
• 让损失函数逐步减小

---

🔁 循环进行：Epoch × Batch

整个流程通常是在两个嵌套循环中进行的：

for epoch in range(总训练轮数):
    for batch in 数据集:
        正向传播 → 计算预测和损失
        反向传播 → 计算梯度
        参数更新 → 梯度下降优化参数

• epoch：完整遍历一遍所有训练数据
• batch：每次使用的数据子集（mini-batch）

---

📈 整个训练过程中，我们期望看到的是：

阶段	表现
刚开始训练	损失大，预测不准
中期训练	损失逐渐下降，预测变好
接近收敛	损失稳定在一个较小值，模型表现良好

---

🎯 总结一句话：

神经网络的训练就是一个不断"预测 → 算误差 → 算梯度 → 调参数"的循环过程。通过一次次的正向传播、反向传播和参数更新，模型逐步学会如何做出更准确的预测，直到损失函数达到一个我们认为满意的最小值。

---

实践

使用 小批量梯度下降（Mini-batch Gradient Descent） 作为优化算法，以 MNIST 手写数字分类任务为例，构建一个简单的神经网络进行训练。

✅ 使用工具：PyTorch

• 自动求导机制支持反向传播；
• DataLoader 支持 mini-batch；
• SGD 优化器实现小批量梯度下降；

---

🧠 代码实现

import torch
from torch import nn, optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# ================== 1. 数据准备 ==================
# 数据预处理：标准化 + 张量转换
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 加载训练数据和测试数据
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)

# ================== 2. 模型定义 ==================
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 128)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = x.view(-1, 28 * 28)  # 展平图像
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

model = SimpleNet()

# ================== 3. 损失函数 ==================
criterion = nn.CrossEntropyLoss()

# ================== 4. 小批量梯度下降优化器 ==================
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 使用 SGD，mini-batch 已在 DataLoader 中设置

# ================== 5. 训练循环 ==================
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

num_epochs = 5

for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    # DataLoader可以实现数据分批次，train_loader是已经分批后的数据，一个images就是一个batch
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)

        # 正向传播：输入 -> 输出
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播：计算梯度
        optimizer.zero_grad()
        loss.backward()

        # 参数更新：使用小批量梯度下降（SGD）
        # 每次 optimizer.step() 就是一次参数更新 
        optimizer.step()
		
		# 记录了一个 epoch 中所有 batch 的 loss 总和，最后除以 batch 数量，得到平均 loss 并打印出来。
        running_loss += loss.item()

    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}')

---

部分参数的辅助理解可以看我另一篇文章：关于epoch、batch_size等参数含义，及optimizer.step()的含义及数学过程

📌 说明

部分	内容
数据加载	使用 DataLoader 构造 mini-batch（batch_size=64）
正向传播	outputs = model(images)
损失计算	loss = criterion(outputs, labels)
反向传播	loss.backward()
参数更新	optimizer.step()，使用的是 SGD 算法

---

✅ 小批量梯度下降的关键点

• 每次更新参数只使用一个 batch 的样本（如 64 张图片）
• 比随机梯度下降更稳定，比批量梯度下降更快
• PyTorch 的 DataLoader + SGD 优化器天然支持 mini-batch

---