前向传播与反向传播算法

一句话概述

前向传播和反向传播是神经网络训练的两大核心过程：前向传播将输入数据逐层向前传递，计算出网络的预测输出；反向传播利用链式法则，从输出层逐层向后计算损失函数对每个参数的梯度，为参数更新提供方向。这个看似简单的"前向算输出、反向算梯度"的框架，支撑了从最简单的MLP到千亿参数大语言模型的所有深度神经网络的训练。

💡 核心要点：①前向传播逐层计算输出，每个神经元做加权求和+激活函数 ②反向传播是链式法则的系统化应用，高效计算所有参数的梯度 ③计算图是理解自动微分的关键抽象，每个节点代表一个操作 ④反向传播的时间复杂度与前向传播相当，空间复杂度与网络宽度有关

教学与演示

一、计算图：自动微分的数学基础

是什么（定义）：计算图（Computational Graph）是一种有向无环图（DAG），用于表示数学计算的结构。图中的节点代表变量或操作，边代表数据流动方向。在深度学习中，每个操作（加法、乘法、激活函数等）都是图中的一个节点，整个神经网络的前向传播就是沿着计算图从输入到输出的流式计算。

大白话 计算图就是把复杂的数学运算拆成一步步简单的小操作，画成流程图。正向走一遍算出结果，反向走一遍算出梯度。就像工厂流水线——正向是组装产品，反向是把不合格的产品一步步追溯责任。

为什么（原理）：计算图的核心价值在于它为自动微分提供了统一的框架。通过将任意复杂的函数表示为基本操作的组合，反向传播可以系统化地对每个操作应用链式法则，自动求出所有中间变量的梯度。这正是现代深度学习框架（PyTorch的autograd、TensorFlow的GradientTape）的底层原理。

怎么做（实现）：

import numpy as np

# ========================================
# 计算图与基本操作节点
# 每个节点记录前向值和反向梯度
# ========================================

class Node:
    """计算图节点 —— 存储值和梯度"""
    def __init__(self, value, name=""):
        self.value = value      # 前向传播时计算的数值
        self.grad = None        # 反向传播时累计的梯度
        self.name = name
    
    def __repr__(self):
        return f"Node({self.name}, value={self.value}, grad={self.grad})"


class AddNode:
    """
    加法节点: z = x + y
    反向传播: ∇x = ∇z, ∇y = ∇z（梯度无损传递）
    """
    @staticmethod
    def forward(x, y, name=""):
        result = Node(x.value + y.value, name=name or f"add")
        result._backward_fn = lambda grad: (
            setattr(x, 'grad', (x.grad or 0) + grad),  # ∇x = ∇z
            setattr(y, 'grad', (y.grad or 0) + grad)   # ∇y = ∇z
        )
        return result


class MulNode:
    """
    乘法节点: z = x * y
    反向传播: ∇x = ∇z * y, ∇y = ∇z * x（交叉相乘）
    """
    @staticmethod
    def forward(x, y, name=""):
        result = Node(x.value * y.value, name=name or f"mul")
        # 需要保存 x 和 y 的值用于反向传播中的交叉计算
        x_val, y_val = x.value, y.value
        result._backward_fn = lambda grad: (
            setattr(x, 'grad', (x.grad or 0) + grad * y_val),  # ∇x = ∇z * y
            setattr(y, 'grad', (y.grad or 0) + grad * x_val)   # ∇y = ∇z * x
        )
        return result


class SigmoidNode:
    """
    Sigmoid节点: z = σ(x) = 1/(1+e^(-x))
    反向传播: ∇x = ∇z * σ(x) * (1 - σ(x))
    """
    @staticmethod
    def forward(x, name=""):
        s = 1.0 / (1.0 + np.exp(-x.value))
        result = Node(s, name=name or f"sigmoid")
        result._backward_fn = lambda grad: (
            setattr(x, 'grad', (x.grad or 0) + grad * s * (1.0 - s))
        )
        return result


# --- 演示一个简单计算图: y = σ(w1*x1 + w2*x2 + b) ---
# 输入数据
x1 = Node(1.0, name="x1")
x2 = Node(2.0, name="x2")
w1 = Node(0.5, name="w1")
w2 = Node(-0.3, name="w2")
b = Node(0.1, name="b")

# 构建计算图（前向传播）
t1 = MulNode.forward(w1, x1, name="w1*x1")   # w1 * x1
t2 = MulNode.forward(w2, x2, name="w2*x2")   # w2 * x2
t3 = AddNode.forward(t1, t2, name="sum")     # w1*x1 + w2*x2
z = AddNode.forward(t3, b, name="z")          # w1*x1 + w2*x2 + b
y = SigmoidNode.forward(z, name="y")          # σ(z)

print("前向传播结果：")
print(f"  z = {z.value:.4f}")
print(f"  y = σ(z) = {y.value:.4f}")

# 反向传播 —— 假设 ∂L/∂y = 1.0（简化）
print("\n反向传播（∂L/∂y = 1.0）：")
# 拓扑排序后反向传播（这里手动按序执行）
y.grad = 1.0  # 起始梯度
y._backward_fn(y.grad)  # Sigmoid反向
z._backward_fn(z.grad)  # 加法 z = t3 + b
t3._backward_fn(t3.grad)  # 加法 t3 = t1 + t2
t1._backward_fn(t1.grad)  # 乘法 t1 = w1 * x1
t2._backward_fn(t2.grad)  # 乘法 t2 = w2 * x2

print(f"  ∇w1 = {w1.grad:.4f}")
print(f"  ∇w2 = {w2.grad:.4f}")
print(f"  ∇b  = {b.grad:.4f}")
print(f"  → 这些梯度将用于参数更新: w ← w - lr * ∇w")

大白话 链式法则就是"责任追溯"——最后的损失L要怪谁？从后往前，每一层接到的梯度是"上游怪我的程度"，再乘以"我内部犯错的敏感度"，得到"该怪前面那层的程度"，继续往前追溯。

什么用（AI关联）：计算图是所有深度学习框架的底层机制。PyTorch的autograd引擎在每次前向传播时动态构建计算图，反向传播后销毁（动态图）；TensorFlow 1.x在运行前先构建完整的静态计算图。理解计算图有助于理解为什么某些操作会导致梯度中断（如in-place修改、detach等）。

哪些坑（缺点）：①计算图的内存开销——需要保存所有中间结果用于反向传播，大模型可能出现OOM。②非张量操作（如Python控制流）可能打断计算图。③原地操作（in-place）可能破坏反向传播需要的中间值。

二、前向传播：从输入到输出的逐层计算

是什么（定义）：前向传播（Forward Propagation）是输入数据从输入层开始，依次经过每个隐藏层，最终到达输出层的过程。在每一层中，输入先与权重矩阵相乘（线性变换），再加上偏置，最后通过激活函数得到该层的输出。数学上记为：h^(l) = f^(l)(W^(l) · h^(l-1) + b^(l))。

大白话 前向传播就是数据坐"电梯"从一楼到顶楼——每层按一下"按钮"（做计算），一层层向上，最后在顶楼得到一个"判断结果"。

怎么做（实现）：

import numpy as np

# ========================================
# 两层全连接网络的前向传播
# 输入 → 隐藏层(ReLU) → 输出层(Sigmoid)
# ========================================

class TwoLayerNet:
    """
    两层全连接神经网络
    结构: input(2) → hidden(3, ReLU) → output(1, Sigmoid)
    用于二分类任务
    """
    def __init__(self, input_size=2, hidden_size=3, output_size=1):
        """
        初始化网络参数
        权重: 使用随机初始化（实际中用 He/Xavier 初始化）
        偏置: 初始化为 0
        """
        # 第一层参数: W1 ∈ R^(3×2), b1 ∈ R^3
        # 将 2 维输入映射到 3 维隐藏层空间
        self.W1 = np.random.randn(hidden_size, input_size) * 0.01
        self.b1 = np.zeros(hidden_size)
        
        # 第二层参数: W2 ∈ R^(1×3), b2 ∈ R^1
        # 将 3 维隐藏层映射到 1 维输出
        self.W2 = np.random.randn(output_size, hidden_size) * 0.01
        self.b2 = np.zeros(output_size)
        
        # 缓存中间值，反向传播时使用
        self.cache = {}
    
    def forward(self, X):
        """
        前向传播
        参数:
            X: 输入数据，shape (n_samples, 2)
        返回:
            预测输出（经过Sigmoid的概率值）
        """
        # ---- 第一层（全连接 + ReLU）----
        # z1 = X·W1^T + b1  (线性变换)
        # 注意: X: (n,2), W1: (3,2), W1^T: (2,3)
        # 所以 z1 = X @ W1^T + b1 → shape (n, 3)
        z1 = np.dot(X, self.W1.T) + self.b1  # 加权求和
        a1 = np.maximum(0, z1)                # ReLU 激活：max(0, z1)
        
        # ---- 第二层（全连接 + Sigmoid）----
        # z2 = a1·W2^T + b2  (线性变换)
        z2 = np.dot(a1, self.W2.T) + self.b2  # 加权求和
        a2 = 1.0 / (1.0 + np.exp(-z2))         # Sigmoid 激活：1/(1+e^(-z))
        
        # 缓存中间值，供反向传播使用
        self.cache['X'] = X
        self.cache['z1'] = z1
        self.cache['a1'] = a1
        self.cache['z2'] = z2
        self.cache['a2'] = a2
        
        return a2  # 输出为 (n, 1) 的概率值


# --- 演示前向传播 ---
np.random.seed(42)
net = TwoLayerNet(input_size=2, hidden_size=3, output_size=1)

# 准备3个样本，每个样本2个特征
X_batch = np.array([
    [0.5, -0.2],   # 样本1
    [-0.1, 0.8],   # 样本2
    [1.0, 1.5],    # 样本3
])

# 执行前向传播
predictions = net.forward(X_batch)

print("两层网络前向传播结果：")
for i, pred in enumerate(predictions):
    print(f"  样本{i+1} {X_batch[i]}: 预测概率 = {pred[0]:.4f}")

# --- 展示各层数据维度变化 ---
print(f"\n各层数据维度变化：")
print(f"  输入 X:     {X_batch.shape}  (3个样本, 2个特征)")
print(f"  隐藏层 z1:  {net.cache['z1'].shape}  (3个样本, 3个隐藏神经元)")
print(f"  隐藏层 a1:  {net.cache['a1'].shape}  (ReLU后)")
print(f"  输出层 z2:  {net.cache['z2'].shape}  (3个样本, 1个输出)")
print(f"  输出层 a2:  {net.cache['a2'].shape}  (Sigmoid后，0~1概率)")

大白话 每一层做两件事：①矩阵乘法（W·h）——把上一层的信号按照"连线强度"重新组合；②激活函数（f(z)）——给重组后的信号加"调味料"（非线性）。

什么用（AI关联）：前向传播是推理（inference）时的唯一计算过程。模型部署到生产环境后，只有前向传播在运行。优化前向传播的速度（如量化、剪枝、算子融合）直接关系到推理延迟和吞吐量。

哪些坑（缺点）：①前向传播中任何一步出错（如维度不匹配、激活函数数值溢出）都会导致整个网络输出异常。②缓存中间值会消耗大量内存，训练时尤为明显。

三、反向传播：梯度的逐层回溯

是什么（定义）：反向传播（Backpropagation）是一种高效计算神经网络中所有参数梯度的算法。它从损失函数出发，利用链式法则逐层向后传播梯度信号：先计算损失对输出层的梯度，再逐层传递到前面的隐藏层，最终得到损失对每个权重和偏置的梯度。这些梯度随后被优化器用于更新参数。

大白话 反向传播就是"秋后算账"——先看最终结果错得有多离谱，然后从最后一层开始，一层层往前追究"谁该为这个错误负责"，最后每个人都知道了自己该往哪个方向改进。

怎么做（实现）：

import numpy as np

# ========================================
# 反向传播 —— 完整的梯度计算过程
# 在 TwoLayerNet 基础上实现 backprop
# ========================================

class TwoLayerNetWithBackprop:
    """带反向传播的两层全连接网络"""
    def __init__(self, input_size=2, hidden_size=3, output_size=1):
        # 权重初始化
        self.W1 = np.random.randn(hidden_size, input_size) * 0.01
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(output_size, hidden_size) * 0.01
        self.b2 = np.zeros(output_size)
        self.cache = {}
    
    def forward(self, X):
        """前向传播（同前）"""
        self.cache['X'] = X
        z1 = np.dot(X, self.W1.T) + self.b1
        self.cache['z1'] = z1
        a1 = np.maximum(0, z1)  # ReLU
        self.cache['a1'] = a1
        z2 = np.dot(a1, self.W2.T) + self.b2
        self.cache['z2'] = z2
        a2 = 1.0 / (1.0 + np.exp(-z2))  # Sigmoid
        self.cache['a2'] = a2
        return a2
    
    def backward(self, y_true):
        """
        反向传播：计算所有参数的梯度
        参数:
            y_true: 真实标签，shape (n, 1)，取值 0 或 1
        返回:
            梯度字典: {'dW1', 'db1', 'dW2', 'db2'}
        
        梯度流向（从后往前）:
            ∂L/∂a2 → ∂L/∂z2 → ∂L/∂W2, ∂L/∂b2
                  → ∂L/∂a1 → ∂L/∂z1 → ∂L/∂W1, ∂L/∂b1
        """
        n = self.cache['X'].shape[0]  # 样本数量
        a2 = self.cache['a2']          # 输出层激活
        a1 = self.cache['a1']          # 隐藏层激活
        z1 = self.cache['z1']          # 隐藏层线性输出
        X = self.cache['X']            # 原始输入
        
        # ---- 步骤1: 损失函数对输出层激活的梯度 ----
        # 二分类交叉熵 + Sigmoid 的联合梯度
        # ∂L/∂z2 = (a2 - y_true) / n  ← 简洁形式！
        d_z2 = (a2 - y_true) / n  # shape: (n, 1)
        
        # ---- 步骤2: 输出层参数梯度 ----
        # ∂L/∂W2 = ∂L/∂z2 · ∂z2/∂W2 = d_z2 · a1^T
        # 每个样本贡献一份，总梯度是所有样本的平均
        d_W2 = np.dot(d_z2.T, a1)  # shape: (1, 3)
        # ∂L/∂b2 = Σ ∂L/∂z2 （按样本求和）
        d_b2 = np.sum(d_z2, axis=0)  # shape: (1,)
        
        # ---- 步骤3: 隐藏层激活的梯度 ----
        # ∂L/∂a1 = ∂L/∂z2 · ∂z2/∂a1 = d_z2 · W2
        d_a1 = np.dot(d_z2, self.W2)  # shape: (n, 3)
        
        # ---- 步骤4: 隐藏层线性输出的梯度 ----
        # ReLU的导数：z1 > 0 时导数为1，否则为0
        d_relu = np.where(z1 > 0, 1.0, 0.0)  # shape: (n, 3)
        # ∂L/∂z1 = ∂L/∂a1 · ∂a1/∂z1 = d_a1 * d_relu（逐元素乘）
        d_z1 = d_a1 * d_relu  # shape: (n, 3)
        
        # ---- 步骤5: 隐藏层参数梯度 ----
        # ∂L/∂W1 = d_z1^T · X
        d_W1 = np.dot(d_z1.T, X)  # shape: (3, 2)
        # ∂L/∂b1 = Σ d_z1
        d_b1 = np.sum(d_z1, axis=0)  # shape: (3,)
        
        grads = {
            'dW1': d_W1,
            'db1': d_b1,
            'dW2': d_W2,
            'db2': d_b2,
        }
        return grads
    
    def update_params(self, grads, learning_rate=0.1):
        """
        使用梯度下降更新参数
        W = W - lr * ∂L/∂W
        """
        self.W1 -= learning_rate * grads['dW1']
        self.b1 -= learning_rate * grads['db1']
        self.W2 -= learning_rate * grads['dW2']
        self.b2 -= learning_rate * grads['db2']


# --- 完整训练演示 ---
np.random.seed(42)
net = TwoLayerNetWithBackprop(input_size=2, hidden_size=3, output_size=1)

# XOR问题数据（经典的非线性可分问题）
X_xor = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
y_xor = np.array([[0], [1], [1], [0]], dtype=float)

print("XOR问题训练（两层网络 + 反向传播）：")
print("=" * 50)
for epoch in range(501):
    # 前向传播
    y_pred = net.forward(X_xor)
    # 计算损失
    eps = 1e-15
    loss = -np.mean(y_xor * np.log(np.clip(y_pred, eps, 1-eps)) 
                     + (1-y_xor) * np.log(np.clip(1-y_pred, eps, 1-eps)))
    # 反向传播
    grads = net.backward(y_xor)
    # 参数更新
    net.update_params(grads, learning_rate=0.5)
    
    if epoch % 100 == 0:
        print(f"  Epoch {epoch:3d}: Loss = {loss:.4f}")
        for i, (x, yt, yp) in enumerate(zip(X_xor, y_xor, y_pred)):
            print(f"    样本{i+1} [{x[0]:.0f},{x[1]:.0f}] 真实={yt[0]:.0f} 预测={yp[0]:.4f}")

大白话 反向传播的口诀："从尾巴往前推，每一步乘两个东西——后面传上来的责备信号，和这层的导数敏感度"。输出层最简单（就是预测减真实），往前每走一层就多乘一次权重转置和激活函数导数。

什么用（AI关联）：反向传播是深度学习训练的引擎。所有有监督学习（分类、回归、生成等）都依赖于反向传播计算梯度。现代框架的自动微分（autograd）自动处理反向传播，但理解其原理对调试梯度问题（如NaN、梯度消失）至关重要。

哪些坑（缺点）：①计算梯度需要保存前向传播的中间值，内存消耗大。②梯度在深层网络中可能消失或爆炸。③非可微操作（如argmax、采样）无法直接通过反向传播传递梯度，需要特殊技巧（如Gumbel-Softmax、REINFORCE）。

四、批量训练与梯度累积

是什么（定义）：在实际训练中，反向传播通常不针对单个样本执行，而是在一个批量（batch）数据上计算平均梯度。这种"批量梯度下降"平衡了计算效率和梯度估计的准确性。当显存不足以容纳所需的batch size时，可以使用梯度累积——多次小batch前向+反向，累积梯度后再更新参数。

大白话 批量训练就像考试——单道题对答案（单样本梯度）可能偏颇，整张卷子对答案（批量梯度）更能反映真实水平。梯度累积就是分几次做完卷子，最后一次性算总分。

为什么（原理）：设批量大小为B，则损失对该批量的平均为 L = (1/B)·Σ L_i。根据线性性质：∂L/∂θ = (1/B)·Σ ∂L_i/∂θ。因此，批量梯度是单样本梯度的平均，可以有效减少梯度估计的方差，使优化方向更稳定。

五、实战：用NumPy实现一个完整的MLP训练

import numpy as np

# ========================================
# 完整MLP训练流程：前向 + 反向 + 参数更新
# 用NumPy从零实现，帮助理解深度学习框架核心
# ========================================

class MLP:
    """
    多层感知机，支持任意数量的隐藏层
    每层: Linear → ReLU（最后一层 Linear → Sigmoid）
    """
    def __init__(self, layer_sizes, learning_rate=0.1):
        """
        初始化MLP
        参数:
            layer_sizes: 每层的神经元数量，如 [2, 4, 3, 1]
                         表示: 输入2维 → 隐藏4 → 隐藏3 → 输出1
            learning_rate: 学习率
        """
        self.lr = learning_rate
        self.num_layers = len(layer_sizes) - 1  # 不包括输入层
        
        # 初始化每层的权重和偏置
        self.W = []  # 权重列表
        self.b = []  # 偏置列表
        for i in range(self.num_layers):
            n_in = layer_sizes[i]      # 当前层输入维度
            n_out = layer_sizes[i+1]   # 当前层输出维度
            # He初始化：适合ReLU
            self.W.append(np.random.randn(n_out, n_in) * np.sqrt(2.0 / n_in))
            self.b.append(np.zeros(n_out))
        
        self.cache = {}  # 缓存前向中间值
    
    def forward(self, X):
        """前向传播：返回每层的激活值列表"""
        self.cache['X'] = X
        self.cache['z'] = []  # 每层的线性输出
        self.cache['a'] = [X]  # 每层的激活输出 (a0 = X)
        
        a = X
        for l in range(self.num_layers):
            z = np.dot(a, self.W[l].T) + self.b[l]  # 线性变换
            self.cache['z'].append(z)
            
            if l == self.num_layers - 1:  # 最后一层用Sigmoid
                a = 1.0 / (1.0 + np.exp(-z))
            else:  # 隐藏层用ReLU
                a = np.maximum(0, z)
            
            self.cache['a'].append(a)
        
        return a  # 最终输出
    
    def compute_loss(self, y_pred, y_true):
        """二分类交叉熵损失"""
        eps = 1e-15
        y_pred = np.clip(y_pred, eps, 1 - eps)
        return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
    
    def backward(self, y_true):
        """反向传播：计算所有层的梯度"""
        n = self.cache['X'].shape[0]
        grads_W = []
        grads_b = []
        
        # 最后一层梯度（Sigmoid + BCE）
        a_last = self.cache['a'][-1]
        d_z = (a_last - y_true) / n  # ∂L/∂z^L
        
        # 从后往前逐层传播
        for l in reversed(range(self.num_layers)):
            a_prev = self.cache['a'][l]  # 前一层的激活输出（即当前层的输入）
            
            # 当前层的参数梯度
            d_W = np.dot(d_z.T, a_prev)  # ∂L/∂W^l = d_z^T · a^{l-1}
            d_b = np.sum(d_z, axis=0)     # ∂L/∂b^l = Σ d_z
            
            grads_W.insert(0, d_W)  # 插入到列表开头（保持从第0层开始的顺序）
            grads_b.insert(0, d_b)
            
            # 向前一层传播梯度（如果不是第一层）
            if l > 0:
                # 穿过权重矩阵
                d_a = np.dot(d_z, self.W[l])  # ∂L/∂a^{l-1}
                # 穿过ReLU激活函数
                z_prev = self.cache['z'][l-1]
                d_z = d_a * np.where(z_prev > 0, 1.0, 0.0)
        
        return grads_W, grads_b
    
    def update(self, grads_W, grads_b):
        """梯度下降更新参数"""
        for l in range(self.num_layers):
            self.W[l] -= self.lr * grads_W[l]
            self.b[l] -= self.lr * grads_b[l]


# --- 训练演示：螺旋数据二分类 ---
np.random.seed(42)

# 生成简单的二分类数据
n_per_class = 50
# 类0: 以(-1, -1)为中心
X0 = np.random.randn(n_per_class, 2) * 0.5 + np.array([-1.0, -1.0])
y0 = np.zeros((n_per_class, 1))
# 类1: 以(1, 1)为中心
X1 = np.random.randn(n_per_class, 2) * 0.5 + np.array([1.0, 1.0])
y1 = np.ones((n_per_class, 1))

X = np.vstack([X0, X1])
y = np.vstack([y0, y1])

# 创建模型: 2 → 8 → 4 → 1
mlp = MLP(layer_sizes=[2, 8, 4, 1], learning_rate=0.3)

print("MLP训练过程 ([2, 8, 4, 1])：")
for epoch in range(1001):
    y_pred = mlp.forward(X)
    loss = mlp.compute_loss(y_pred, y)
    grads_W, grads_b = mlp.backward(y)
    mlp.update(grads_W, grads_b)
    
    if epoch % 200 == 0:
        acc = np.mean((y_pred > 0.5) == y)
        print(f"  Epoch {epoch:4d}: Loss={loss:.4f}, Accuracy={acc*100:.1f}%")

# 最终评估
y_pred_final = mlp.forward(X)
acc_final = np.mean((y_pred_final > 0.5) == y)
print(f"\n最终准确率: {acc_final*100:.1f}%")
print(f"模型共 {sum(w.size + b.size for w, b in zip(mlp.W, mlp.b))} 个参数")

概念关系图谱

重点答疑

Q1: 反向传播和自动微分有什么区别？

反向传播是自动微分的一种实现方式，具体来说是"反向模式自动微分"（Reverse-mode Automatic Differentiation）。自动微分有两种模式：①前向模式——从输入向输出计算梯度，适合输入维度小的场景；②反向模式（即反向传播）——从输出向输入计算梯度，适合输出维度小（如标量损失）但参数维度大的场景，这正是深度学习的典型情况。现代框架将反向传播封装在自动微分引擎中，用户只需定义前向计算，梯度由框架自动生成。

Q2: 为什么反向传播需要保存前向传播的中间值？

因为链式法则中的局部导数依赖于前向传播的中间值。例如，ReLU的导数需要知道z是否大于0，乘法节点的导数需要知道乘数x和y的值。如果不保存这些中间值，反向传播就无法计算正确的梯度。这就是训练时比推理时消耗更多内存的核心原因。梯度检查点（Gradient Checkpointing）等技术通过在前向时放弃部分中间值、反向时重新计算来折中内存和计算。

Q3: 反向传播算法的计算复杂度是多少？

反向传播的计算复杂度与前向传播在同一数量级：对于全连接层，前向传播计算W·x需要O(n_in · n_out)次乘法，反向传播计算d_W和d_a也需要O(n_in · n_out)次乘法。因此，一次前向+反向的总计算量约为一次前向的2-3倍。这种线性复杂度是深度学习能够扩展到数十亿参数的关键——如果梯度计算是指数级的，大模型训练根本不可能。

章节单词汇总