神经网络基础实战：前向传播与反向传播的工程实现与调优

1次阅读

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

在实际项目中实现神经网络时，前向传播和反向传播看似简单，但隐藏着许多工程实现上的坑。最常见的问题包括：

矩阵维度不匹配 ：特别是在自定义层时，输入输出维度计算错误会导致运行时错误。比如全连接层要求(batch_size, input_dim) 的输入，但实际传入的可能是 (input_dim,) 的单样本。
梯度爆炸 / 消失：深层网络中，梯度在反向传播时可能指数级增大或减小。例如使用 Sigmoid 激活函数时，梯度很容易接近 0，导致权重无法更新。
计算效率低下：未向量化的实现（如用 for 循环处理 batch）会使训练速度慢 10 倍以上，这在工业级应用中是不可接受的。

反向传播的核心是链式法则。以一个简单的两层网络为例：

$$
z^{(2)} = W^{(2)}a^{(1)} + b^{(2)} \
a^{(2)} = \sigma(z^{(2)}) \
\frac{\partial L}{\partial W^{(2)}} = \frac{\partial L}{\partial a^{(2)}} \cdot \frac{\partial a^{(2)}}{\partial z^{(2)}}} \cdot \frac{\partial z^{(2)}}{\partial W^{(2)}}
$$

其中 $\sigma$ 是激活函数。关键在于高效计算这些局部梯度并正确传递。

import torch
import torch.nn as nn

class VectorizedLinear(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.weight = nn.Parameter(torch.randn(output_dim, input_dim) * 0.01)
        self.bias = nn.Parameter(torch.zeros(output_dim))

    def forward(self, x):
        # x shape: (batch_size, input_dim)
        return x @ self.weight.t() + self.bias  # 关键矩阵运算

def gradient_check(layer, x, epsilon=1e-7):
    params = list(layer.parameters())
    analytic_grads = [p.grad.clone() for p in params]

    for i, param in enumerate(params):
        for j in range(param.numel()):
            old_val = param.data.flatten()[j]

            # 正向扰动
            param.data.flatten()[j] = old_val + epsilon
            loss_plus = criterion(model(x), y)

            # 负向扰动
            param.data.flatten()[j] = old_val - epsilon
            loss_minus = criterion(model(x), y)

            # 数值梯度
            numeric_grad = (loss_plus - loss_minus) / (2 * epsilon)
            diff = abs(analytic_grads[i].flatten()[j] - numeric_grad)

            if diff > 1e-5:
                print(f'Gradient mismatch: {diff.item()}')

            param.data.flatten()[j] = old_val  # 恢复原值

from torch.optim.lr_scheduler import LambdaLR

def get_lr_scheduler(optimizer, warmup_steps=1000):
    def lr_lambda(step):
        if step < warmup_steps:
            return float(step) / warmup_steps
        return 0.95 ** (step // 10000)  # 每 1 万步衰减 5%

    return LambdaLR(optimizer, lr_lambda)

在 CIFAR-10 上实测不同激活函数的显存占用（batch_size=128）：