第2课：梯度下降与反向传播

📖 本课概述

梯度下降是深度学习的核心优化算法，反向传播是高效计算梯度的关键。本课深入理解梯度的数学本质，手动推导反向传播，并通过PyTorch验证。

🧮 一、梯度（Gradient）

1.1 什么是梯度

梯度是多元函数偏导数组成的向量，指向函数值增长最快的方向。梯度下降就是沿着梯度的反方向移动，从而最小化函数值。

1.2 PyTorch自动求导

PyTorch通过计算图和链式法则自动计算梯度：

import torch

# 手动计算梯度
x = torch.tensor([2.0], requires_grad=True)
y = x**2 + 3*x + 1  # y = x² + 3x + 1
y.backward()
print(f"函数: y = x² + 3x + 1")
print(f"x = {x.item():.1f} 时, y = {y.item():.1f}")
print(f"dy/dx = 2x + 3 = {x.grad.item():.1f}")
print(f"验证: 2*{x.item():.1f} + 3 = {2*x.item()+3:.1f}")

# 多变量梯度
print("\n=== 多变量梯度 ===")
w1 = torch.tensor([1.0], requires_grad=True)
w2 = torch.tensor([2.0], requires_grad=True)
loss = w1**2 + w2**2 + w1*w2
loss.backward()
print(f"函数: L = w1² + w2² + w1*w2")
print(f"w1=1.0, w2=2.0 时, L={loss.item():.1f}")
print(f"∂L/∂w1 = 2w1 + w2 = {w1.grad.item():.1f}")
print(f"∂L/∂w2 = 2w2 + w1 = {w2.grad.item():.1f}")

🔄 二、反向传播（Backpropagation）

2.1 计算图与链式法则

反向传播的核心是链式法则。对于复合函数 y = f(g(x))：

2.2 前向传播 vs 反向传播

2.3 反向传播实现

import torch
import torch.nn as nn

# 手动实现反向传播 vs PyTorch自动求导
torch.manual_seed(42)

# 2层网络
X = torch.randn(4, 3)
y = torch.randn(4, 1)

# 方式1：PyTorch自动求导
model = nn.Sequential(
    nn.Linear(3, 4),
    nn.Sigmoid(),
    nn.Linear(4, 1)
)

loss_fn = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

print("=== 梯度下降训练过程 ===")
for epoch in range(0, 501, 100):
    optimizer.zero_grad()
    output = model(X)
    loss = loss_fn(output, y)
    loss.backward()
    optimizer.step()
    
    # 打印梯度范数
    grad_norms = []
    for p in model.parameters():
        if p.grad is not None:
            grad_norms.append(f"{p.grad.norm().item():.6f}")
    
    print(f"Epoch {epoch:3d}: loss={loss.item():.6f}, grad_norms=[{', '.join(grad_norms)}]")

# 查看最终参数
print("\n=== 最终模型参数 ===")
for name, param in model.named_parameters():
    print(f"{name}: shape={param.shape}, norm={param.data.norm().item():.4f}")

📉 三、梯度下降的变体

3.1 不同学习率的影响

import torch
import torch.nn as nn
import numpy as np

# 可视化梯度下降轨迹（1D）
torch.manual_seed(0)
x_start = 5.0
lr_values = [0.01, 0.1, 0.5]

def f(x):
    return x**2

def df(x):
    return 2*x

print("=== 不同学习率的梯度下降轨迹 ===")
print("目标函数: f(x) = x², 最小值在 x=0")
print()

for lr in lr_values:
    x = x_start
    trajectory = [x]
    for step in range(20):
        grad = df(x)
        x = x - lr * grad
        trajectory.append(x)
    traj_str = " → ".join([f"{v:.3f}" for v in trajectory[:8]])
    print(f"lr={lr}: {traj_str} ... → {trajectory[-1]:.6f}")
    
# 梯度消失 vs 梯度爆炸演示
print("\n=== 梯度消失/爆炸演示 ===")
depths = [5, 10, 20, 50]
for depth in depths:
    x = torch.tensor([1.0])
    for i in range(depth):
        w = torch.tensor([0.9], requires_grad=True)
        x = w * x + 0.1
    x.backward()
    print(f"深度={depth:2d}: 最终输出={x.item():.8f}, 初始梯度估计~{0.9**depth:.8f}")

3.2 梯度下降三种形式

3.3 梯度消失与梯度爆炸

在深层网络中，梯度通过链式法则连乘，容易导致：

• 梯度消失：每层梯度 < 1，连乘后趋近于0，底层参数几乎不更新
• 梯度爆炸：每层梯度 > 1，连乘后趋于无穷，参数更新剧烈

🔬 四、深入计算图

4.1 静态图 vs 动态图

4.2 梯度累积技巧

4.3 高级优化技巧

学习率预热(Warmup)：训练初期用小学习率，逐步增大到目标值。防止初期参数变化太剧烈。

梯度裁剪(Gradient Clipping)：当梯度范数超过阈值时，按比例缩小。防止梯度爆炸。

📖 五、延伸阅读

📝 练习

💡 六、实践技巧总结

6.1 梯度调试方法

如何验证你的梯度计算是否正确？使用数值梯度对比：

6.2 常见梯度问题与解决

6.3 反向传播的内存优化

标准反向传播需要存储前向传播的所有中间值（O(depth)内存）。优化方法：

• 梯度检查点(Gradient Checkpointing)：只存部分中间值，需要时重新计算，用时间换空间
• 混合精度：用FP16存储激活值，内存减半
• 微批次：将大batch拆分为小batch，减少单次内存占用