共计 2592 个字符，预计需要花费 7 分钟才能阅读完成。

数学原理与计算过程

前向传播 (FP) 的数学定义

给定 L 层神经网络，前向传播过程可表示为复合函数：

$$
\begin{aligned}
z^{(l)} &= W^{(l)}a^{(l-1)} + b^{(l)} \
a^{(l)} &= \sigma(z^{(l)})
\end{aligned}
$$

其中 $l \in [1,L]$, $a^{(0)}=x$ 为输入，$\sigma$ 为激活函数。

反向传播 (BP) 的链式法则

根据损失函数 $\mathcal{L}$，输出层梯度：

$$
\delta^{(L)} = \frac{\partial \mathcal{L}}{\partial z^{(L)}} = \frac{\partial \mathcal{L}}{\partial a^{(L)}} \odot \sigma'(z^{(L)})
$$

隐藏层梯度通过链式法则反向传播：

$$
\delta^{(l)} = (W^{(l+1)T}\delta^{(l+1)}) \odot \sigma'(z^{(l)})
$$

参数梯度计算：

$$
\frac{\partial \mathcal{L}}{\partial W^{(l)}} = \delta^{(l)}a^{(l-1)T}, \quad
\frac{\partial \mathcal{L}}{\partial b^{(l)}} = \delta^{(l)}
$$

框架实现对比

PyTorch 动态图特性

import torch

x = torch.randn(10, 5)
w = torch.randn(5, 2, requires_grad=True)

y = x @ w  # 前向传播
y.backward(torch.ones_like(y))  # 自动构建计算图
print(w.grad)  # 梯度自动计算

优势：
– 运行时动态构建计算图
– 便于调试和模型修改

TensorFlow 静态图优化

import tensorflow as tf

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        pred = model(x)
        loss = loss_fn(y, pred)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))

优势：
– 编译时优化计算图
– 更高效的算子融合

完整代码实现

手动实现全连接层

import numpy as np
from typing import Tuple, List

class DenseLayer:
    def __init__(self, input_dim: int, output_dim: int):
        self.weights = np.random.randn(input_dim, output_dim) * 0.01
        self.bias = np.zeros((1, output_dim))

    def forward(self, x: np.ndarray) -> np.ndarray:
        self.x = x  # Cache input for backward
        return x @ self.weights + self.bias

    def backward(self, dout: np.ndarray) -> np.ndarray:
        dx = dout @ self.weights.T
        self.dw = self.x.T @ dout
        self.db = np.sum(dout, axis=0, keepdims=True)
        return dx

自动微分实现

import torch
import torch.nn as nn

model = nn.Sequential(nn.Linear(784, 256),
    nn.ReLU(),
    nn.Linear(256, 10)
)

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 前向传播
output = model(inputs)
loss = criterion(output, labels)

# 反向传播
optimizer.zero_grad()
loss.backward()
optimizer.step()

生产环境实践

梯度问题处理

1. 梯度裁剪：

   torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

2. 权重初始化：

   nn.init.kaiming_normal_(layer.weight, mode='fan_in')

3. 梯度检查：

   torch.autograd.gradcheck(func, inputs, eps=1e-6)

混合精度训练

scaler = torch.cuda.amp.GradScaler()

with torch.cuda.amp.autocast():
    output = model(input)
    loss = criterion(output, target)

scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

性能优化

显存优化策略

计算图优化

1. 算子融合（如 Conv+ReLU）
2. 梯度检查点技术

   from torch.utils.checkpoint import checkpoint
   
   def custom_forward(x):
       return model(x)
   
   output = checkpoint(custom_forward, inputs)

开放性问题

1. 如何设计适应不同网络深度的自适应梯度裁剪策略？
2. 在超大模型训练中，如何平衡计算图优化与内存占用的关系？
3. 二阶优化算法能否与自动微分系统高效结合？

参考文献

1. Rumelhart et al. (1986) Learning representations by back-propagating errors
2. Paszke et al. (2019) PyTorch: An Imperative Style, High-Performance Deep Learning Library
3. Abadi et al. (2016) TensorFlow: A System for Large-Scale Machine Learning