2.1 单个全连接层的数学表达

一个全连接层（Fully Connected Layer，也称稠密层或Affine层）接收输入向量，通过线性变换加偏置后输出。设输入为 $\mathbf{x} \in \mathbb{R}^{d}$，则该层的输出为：

其中 $\mathbf{W} \in \mathbb{R}^{h \times d}$ 是权重矩阵，$\mathbf{b} \in \mathbb{R}^{h}$ 是偏置向量。经过激活函数 $\phi$（如ReLU、Sigmoid等）后得到该层的输出：

这里的 $\mathbf{a}$ 即为下一层的输入。

2.2 批处理版本：向量化计算

实际训练中我们一次处理一个mini-batch，设批量大小为 $m$，输入矩阵为 $\mathbf{X} \in \mathbb{R}^{m \times d}$（每行一个样本），则前向传播为：

注意这里 $\mathbf{W}^{\top}$ 的维度是 $h \times d$，$\mathbf{Z}$ 的维度是 $m \times h$，每一行对应一个样本在该层的输出。

💡 维度检验小技巧：矩阵乘法中，中间维度必须匹配。$\mathbf{X}_{m \times d} \times \mathbf{W}^{\top}_{h \times d}$ 的转置是 $\mathbf{W}_{d \times h}$，所以 $\mathbf{X}\mathbf{W}^{\top}$ 得到 $m \times h$，正好是每个样本的 $h$ 维输出。偏置 $\mathbf{b}$ 通过广播（broadcasting）加到每一行上。

2.3 Python实现：前向传播

1
import numpy as np
2

3
class FullyConnectedLayer:
4
    def __init__(self, input_dim, output_dim):
5
        # 使用Xavier初始化
6
        self.W = np.random.randn(output_dim, input_dim) * np.sqrt(2.0 / input_dim)
7
        self.b = np.zeros(output_dim)
8

9
    def forward(self, X):
10
        """
11
        X: (batch_size, input_dim)
12
        返回: (batch_size, output_dim)
13
        """
14
        self.X = X  # 保存用于反向传播
15
        self.Z = X @ self.W.T + self.b  # (m, h)
16
        return self.Z

3.1 什么是计算图？

计算图是一种有向无环图（DAG） ，用于可视化运算符和变量在计算中的依赖关系。正向传播沿着图从输入到输出顺序计算，而反向传播则按相反的顺序（从输出层到输入层） 计算和存储中间变量及参数的梯度。

反向传播的本质就是链式法则（Chain Rule） 的反复应用。让我们用一个具体的3层MLP来走一遍完整流程。

3.2 网络结构定义

考虑一个3层MLP（输入层→隐藏层1→隐藏层2→输出层）：

• 输入层：$d$ 维
• 隐藏层1：$h_1$ 个神经元，权重 $\mathbf{W}^{(1)}$，偏置 $\mathbf{b}^{(1)}$，激活函数 $\phi_1$
• 隐藏层2：$h_2$ 个神经元，权重 $\mathbf{W}^{(2)}$，偏置 $\mathbf{b}^{(2)}$，激活函数 $\phi_2$
• 输出层：$q$ 个神经元，权重 $\mathbf{W}^{(3)}$，偏置 $\mathbf{b}^{(3)}$（输出层通常不加激活函数，或用Softmax）

为简化推导，我们先考虑单个样本 $\mathbf{x} \in \mathbb{R}^{d}$，批量版本可以看作单样本版本的向量化堆叠。

前向传播的数学表达：

损失函数采用均方误差（MSE）：$L = \frac{1}{2}\|\hat{\mathbf{y}} - \mathbf{y}\|^2$，其中 $\mathbf{y}$ 是真实标签。

3.3 计算图可视化

1
x → [W¹,b¹] → z¹ → [φ₁] → a¹ → [W²,b²] → z² → [φ₂] → a² → [W³,b³] → z³ → [Loss] → L
2
     ↑                  ↑                  ↑
3
   (参数)            (参数)            (参数)

箭头方向代表数据依赖关系：$L$ 依赖于 $\mathbf{z}^{(3)}$，$\mathbf{z}^{(3)}$ 依赖于 $\mathbf{W}^{(3)}$ 和 $\mathbf{a}^{(2)}$，依此类推。

3.4 反向传播：从输出到输入的梯度回传

反向传播的核心任务是计算损失 $L$ 对每个参数（$\mathbf{W}^{(l)}$ 和 $\mathbf{b}^{(l)}$）的梯度。我们从输出层开始，逐层向前推导。

3.5 三个关键结论

观察上述推导，我们可以提炼出三层MLP反向传播的三个核心公式：

（1）误差回传公式（从第 $l+1$ 层传到第 $l$ 层）：

（2）权重梯度公式：

（3）偏置梯度公式：

其中 $\mathbf{a}^{(0)} = \mathbf{x}$。

🔑 核心洞察：反向传播的本质就是将误差从输出层逐层”分发”回每一层。每一层收到的”误差信号” $\boldsymbol{\delta}^{(l)}$ 包含了损失对该层线性变换前输入的敏感度，再结合该层的激活函数导数和输入，就能算出参数梯度。

3.6 批量版本的矩阵形式

对于batch size为 $m$ 的情况，上述所有向量变为矩阵，逐元素乘法变为逐元素乘法（仍为Hadamard积），公式形式不变：

误差回传：

权重梯度（注意除以batch size取平均）：

3.7 Python实现：三层MLP的反向传播

1
import numpy as np
2

3
class ThreeLayerMLP:
4
    def __init__(self, d, h1, h2, q):
5
        # 初始化权重和偏置
6
        self.W1 = np.random.randn(h1, d) * np.sqrt(2.0 / d)
7
        self.b1 = np.zeros(h1)
8
        self.W2 = np.random.randn(h2, h1) * np.sqrt(2.0 / h1)
9
        self.b2 = np.zeros(h2)
10
        self.W3 = np.random.randn(q, h2) * np.sqrt(2.0 / h2)
11
        self.b3 = np.zeros(q)
12

13
    def forward(self, X):
14
        """前向传播，保存中间变量"""
15
        self.X = X
16
        self.Z1 = X @ self.W1.T + self.b1
17
        self.A1 = np.maximum(0, self.Z1)  # ReLU
18
        self.Z2 = self.A1 @ self.W2.T + self.b2
19
        self.A2 = np.maximum(0, self.Z2)  # ReLU
20
        self.Z3 = self.A2 @ self.W3.T + self.b3
21
        return self.Z3
22

23
    def backward(self, y, learning_rate=0.01):
24
        """反向传播，计算梯度并更新参数"""
25
        m = self.X.shape[0]
26

27
        # 输出层误差
28
        delta3 = self.Z3 - y  # (m, q)
29

30
        # 输出层参数梯度
31
        dW3 = delta3.T @ self.A2 / m  # (q, h2)
32
        db3 = np.mean(delta3, axis=0)  # (q,)
33

34
        # 回传到第二隐藏层
35
        delta2 = (delta3 @ self.W3) * (self.Z2 > 0).astype(float)  # (m, h2)
36
        dW2 = delta2.T @ self.A1 / m  # (h2, h1)
37
        db2 = np.mean(delta2, axis=0)  # (h2,)
38

39
        # 回传到第一隐藏层
40
        delta1 = (delta2 @ self.W2) * (self.Z1 > 0).astype(float)  # (m, h1)
41
        dW1 = delta1.T @ self.X / m  # (h1, d)
42
        db1 = np.mean(delta1, axis=0)  # (h1,)
43

44
        # SGD更新
45
        self.W3 -= learning_rate * dW3
46
        self.b3 -= learning_rate * db3
47
        self.W2 -= learning_rate * dW2
48
        self.b2 -= learning_rate * db2
49
        self.W1 -= learning_rate * dW1
50
        self.b1 -= learning_rate * db1
51

52
        return dW1, db1, dW2, db2, dW3, db3

4.1 定理在说什么？

通用近似定理（UAT）是神经网络理论中最令人惊叹的结果之一。它最经典的版本（Cybenko, 1989；Hornik et al., 1989）指出：

任何定义在紧致集上的连续函数，都可以被一个具有单隐藏层（足够宽）的前馈神经网络以任意精度近似。

换句话说，只要隐藏层有足够多的神经元，一个简单的MLP就能逼近任意复杂的函数。

4.2 直觉理解：从”砖块”到”建筑”

理解UAT最直观的方式是**“砖块构造法”（bump construction）** 。

想象一下：两个Sigmoid神经元可以组合成一个”凸起”函数（bump function） ——这个函数只在某个小区间内非零，其他地方几乎为零。具体来说：

• 一个Sigmoid神经元 $\sigma(wx + b)$ 可以看作一个”阶跃”的平滑版本
• 两个Sigmoid相减：$\sigma(wx + b_1) - \sigma(wx + b_2)$，可以形成一个**“脉冲”或”凸起”**
• 通过调节 $w$ 控制凸起的宽度，调节 $b_1, b_2$ 控制凸起的位置

现在，任意连续函数都可以看作无数个这样的”凸起”的叠加——这正是傅里叶分析或勒贝格积分的基本思想：用矩形条（或更平滑的基函数）去逼近任意函数。

只要隐藏层有足够多的神经元，每个神经元对可以生成一个”凸起”，所有凸起叠加起来就逼近了目标函数。

⚠️ 重要提醒：UAT是存在性定理，它告诉我们”存在这样一个网络”，但没有告诉我们如何找到它（即如何训练）。而且，虽然单隐藏层在理论上足够，但实践中深度网络往往比宽度网络更高效——用$2k$层比用$2^k$个神经元的单层要高效得多。

4.3 一个简单的可视化思考

想象你要用乐高积木拼出一个复杂的曲线：

• 浅层宽网络（单隐藏层，很多神经元）：就像你有很多种不同形状的积木，每种只用一块
• 深层窄网络（多层，每层少量神经元）：就像你只有几种基本形状的积木，但可以反复组合复用

UAT告诉我们：只要有足够多的基本积木（神经元），总能拼出任何形状。但实际操作中，深度网络通过层次化组合能用更少的参数实现更复杂的函数。

5.1 为什么需要Batch Normalization？

深层神经网络在训练时面临一个棘手的问题：每一层的输入分布随着前一层参数的变化而变化——这被称为”内部协变量偏移”（Internal Covariate Shift）。Batch Normalization（BN）通过对每一层的输入进行归一化来解决这个问题，使每层的输入保持近似零均值和单位方差。

5.2 BN的核心操作

对于某个全连接层的输入 $\mathbf{x}$（一个mini-batch，大小为 $m$），BN执行以下变换：

Step 1：计算batch的均值和方差

Step 2：归一化

其中 $\epsilon$ 是一个很小的常数（如 $10^{-5}$），防止除零。

Step 3：缩放和平移（可学习参数）

这里的 $\gamma$ 和 $\beta$ 是可训练参数，用于恢复模型的表达能力——如果标准化破坏了有用的特征分布，网络可以学习如何”撤销”部分标准化效果。

5.3 训练时的滑动平均更新

这里有一个关键的细节：在训练时，BN使用的是当前mini-batch的均值和方差进行归一化。但到了推理（测试）阶段，我们面对的往往只有一个样本（或很小的batch），无法计算有统计意义的均值和方差。

因此，BN在训练过程中需要维护全局统计量——即整个训练集的均值和方差的估计值。这个维护是通过指数加权移动平均（Exponential Moving Average, EMA） 实现的：

其中：

• $\mu_{\text{global}}$ 和 $\sigma_{\text{global}}^2$ 是累积的全局均值和方差
• $\mu_{\mathcal{B}}$ 和 $\sigma_{\mathcal{B}}^2$ 是当前mini-batch的均值和方差
• momentum 是一个超参数，通常设为0.9或0.99

📌 momentum的直觉：momentum越大，全局统计量更新越平滑，对历史数据的”记忆”越长（0.99相当于平均过去100个batch）；momentum越小，更新越快，对当前batch更敏感（0.9相当于平均过去10个batch）。

5.4 训练 vs 推理的行为差异

在推理模式下（如PyTorch中调用model.eval()），BN层冻结全局统计量，直接用训练时累积的均值和方差进行归一化。这保证了推理时无论输入batch大小如何，都能得到稳定一致的输出。

5.5 Python实现：BN层的前向与滑动更新

1
class BatchNorm:
2
    def __init__(self, num_features, momentum=0.9, eps=1e-5):
3
        self.num_features = num_features
4
        self.momentum = momentum
5
        self.eps = eps
6

7
        # 可训练参数
8
        self.gamma = np.ones(num_features)
9
        self.beta = np.zeros(num_features)
10

11
        # 全局统计量（非训练参数，通过滑动平均更新）
12
        self.running_mean = np.zeros(num_features)
13
        self.running_var = np.ones(num_features)
14

15
        # 保存中间变量用于反向传播
16
        self.x_centered = None
17
        self.std_inv = None
18
        self.x_norm = None
19

20
    def forward(self, X, training=True):
21
        """
22
        X: (batch_size, num_features)
23
        training: True表示训练模式，False表示推理模式
24
        """
25
        if training:
26
            # 计算当前batch的统计量
27
            batch_mean = np.mean(X, axis=0)      # (num_features,)
28
            batch_var = np.var(X, axis=0)        # (num_features,)
29

30
            # 归一化
31
            self.x_centered = X - batch_mean
32
            self.std_inv = 1.0 / np.sqrt(batch_var + self.eps)
33
            self.x_norm = self.x_centered * self.std_inv
34

35
            # 滑动平均更新全局统计量
36
            self.running_mean = self.momentum * self.running_mean + \
37
                                (1 - self.momentum) * batch_mean
38
            self.running_var = self.momentum * self.running_var + \
39
                               (1 - self.momentum) * batch_var
40
        else:
41
            # 推理模式：使用累积的全局统计量
42
            self.x_norm = (X - self.running_mean) / np.sqrt(self.running_var + self.eps)
43

44
        # 缩放和平移
45
        out = self.gamma * self.x_norm + self.beta
46
        return out