神经网络模型实战：从零实现前向传播、反向传播与训练过程

1次阅读

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

很多刚接触深度学习的同学喜欢直接调用 TensorFlow 或 PyTorch 的 API 搭建模型，这确实能快速实现功能，但也带来了几个典型问题：

黑箱操作 ：框架的自动微分机制掩盖了梯度计算的核心数学原理
调试困难 ：当模型出现 NaN 损失或性能异常时，难以定位问题根源
定制局限 ：无法自由实现特殊网络结构或优化算法

我在第一次实现图像分类任务时，就遇到过模型准确率卡在 10%（随机猜测水平）的情况。后来发现是因为完全依赖框架的 nn.Linear，没有正确初始化权重导致梯度消失。这让我意识到必须掌握底层实现逻辑。

对比维度	手动实现	框架自动微分
调试透明度	可逐层检查中间结果	计算图抽象层级较高
计算效率	需要优化向量化实现	已内置高性能算子
数学理解	强制推导梯度公式	隐藏求导细节
开发速度	初期实现较慢	快速原型开发

对于学习阶段，我强烈建议至少完整实现一次基础版本。下面用 Numpy 演示关键步骤：

全连接层的核心是矩阵乘法运算。假设输入 $x\in\mathbb{R}^{n\times d}$（n 为 batch 大小，d 为特征维度），权重 $W\in\mathbb{R}^{d\times h}$，则前向传播为：

import numpy as np

def dense_forward(x: np.ndarray, W: np.ndarray, b: np.ndarray) -> np.ndarray:
    """
    全连接层前向传播
    公式: z = x @ W + b
    """
    return x @ W + b  # @表示矩阵乘法

激活函数以 ReLU 为例：

def relu(x: np.ndarray) -> np.ndarray:
    """ReLU(x) = max(0, x)"""
    return np.maximum(0, x)

以交叉熵损失函数为例，我们需要计算损失 $L$ 对权重 $W$ 的梯度 $\frac{\partial L}{\partial W}$。根据链式法则：

$$
\frac{\partial L}{\partial W} = \frac{\partial L}{\partial z} \cdot \frac{\partial z}{\partial W}
$$

具体实现时，通常先计算上层传递的梯度 dout，再逐层回传：

def dense_backward(
    dout: np.ndarray,  # 上层梯度
    cache: tuple[np.ndarray, np.ndarray]  # 前向传播保存的输入
) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
    """
    全连接层反向传播
    返回: (dx, dW, db)
    """
    x, W = cache
    dx = dout @ W.T  # 对输入的梯度
    dW = x.T @ dout  # 对权重的梯度
    db = np.sum(dout, axis=0)  # 对偏置的梯度
    return dx, dW, db

基础 SGD 优化器的参数更新非常简单：

class SGD:
    def __init__(self, lr: float = 0.01):
        self.lr = lr

    def update(self, params: dict, grads: dict) -> None:
        for key in params:
            params[key] -= self.lr * grads[key]  # W = W - lr * dW

实际训练时建议添加学习率衰减：

# 指数衰减示例
lr = initial_lr * (0.95 ** (epoch // 10))

通过数值方法验证解析梯度的正确性：

def grad_check(f: callable, x: np.ndarray, analytic_grad: np.ndarray, eps=1e-7) -> bool:
    """数值梯度检验"""
    numeric_grad = np.zeros_like(x)
    it = np.nditer(x, flags=['multi_index'])

    while not it.finished:
        idx = it.multi_index
        orig_val = x[idx]

        x[idx] = orig_val + eps
        fx_high = f(x)

        x[idx] = orig_val - eps
        fx_low = f(x)

        numeric_grad[idx] = (fx_high - fx_low) / (2 * eps)
        x[idx] = orig_val  # 恢复原值
        it.iternext()

    diff = np.linalg.norm(analytic_grad - numeric_grad)
    return diff < 1e-5

Softmax 计算避免指数爆炸：

def stable_softmax(x: np.ndarray) -> np.ndarray:
    exps = np.exp(x - np.max(x, axis=1, keepdims=True))
    return exps / np.sum(exps, axis=1, keepdims=True)

交叉熵损失添加微小值：

def cross_entropy(pred: np.ndarray, y: np.ndarray, eps=1e-12) -> float:
    """
    pred: 预测概率 [n, c]
    y: 真实标签 [n,]
    """
    probs = pred[np.arange(len(y)), y]
    return -np.mean(np.log(probs + eps))