自研Python神经网络反向传播时损失函数异常嘈杂的原因排查

你的代码存在几个关键错误，直接导致反向传播梯度计算异常，进而出现损失曲线嘈杂的问题：

1. 前向传播方法逻辑错误 #

forward方法中，循环处理层的切片逻辑错误，导致中间层被跳过：

for l in self.layers[:to-1]:
    last = l(last)
last = self.layers[-1](last, activation)

当to=-1（默认值）时，self.layers[:to-1]等价于self.layers[:-2]，会跳过倒数第二层，直接从倒数第三层跳到最后一层计算，导致前向传播结果完全错误，后续所有梯度计算都基于错误的中间值。

修复方案：
调整循环逻辑，正确遍历到目标层：

def forward(self, input, to=-1, activation=True):
    last = input
    # 处理到目标层（to=-1表示所有层）
    target_layer = len(self.layers) if to == -1 else to
    for l in self.layers[:target_layer-1]:
        last = l(last)
    if target_layer > 0:
        last = self.layers[target_layer-1](last, activation)
    return last

2. 反向传播中误差传递的核心错误 #

在backward_biases方法中，计算前一层误差时漏掉了权重转置的点积操作，这是反向传播中误差从后向前传递的核心步骤：

e.insert(0, activation_derivative * e[0])

正确的误差传递应该是先通过当前层的权重转置与当前误差做点积，再乘以激活函数导数。

修复方案：
修改backward_biases的误差计算逻辑，与backward_weights保持一致的误差传递：

def backward_biases(self, input, desired_out):
    e_out = deriv[self.activations[-1]](self.forward(input, -1, False)) * (self.forward(input) - desired_out)
    e = [e_out]
    for i in range(len(self.layer_lengths)-1, 0, -1):
        activation_derivative = deriv[self.activations[i-1]](self.forward(input, i, False))
        e.insert(0, activation_derivative * dot(self.weights[i].T, e[0]))
    return [array(e_layer) for e_layer in reversed(e)]

同时注意修正activations的索引：循环中i对应当前层的下一层索引，激活函数应取i-1层的。

3. 反向传播中激活函数索引错误 #

在backward_weights的循环中，deriv[self.activations[i]]的索引错误，i指向的是下一层索引，应使用当前层的索引（i-1）：

e.insert(0, deriv[self.activations[i-1]](self.forward(input, i, False)) * dot(self.weights[i].T, e[0]))

4. 重复调用forward的效率与一致性问题 #

当前反向传播中多次调用forward计算中间值，不仅效率低，还可能因权重修改导致结果不一致。建议在一次前向传播中缓存所有中间层的预激活（未经过激活函数的值）和激活值，反向传播时直接使用缓存值。

优化后的完整反向传播实现：
先修改forward添加缓存：

def forward(self, input, activation=True):
    self.cache = {'z': [], 'a': [input]}
    last = input
    for i, l in enumerate(self.layers):
        z = l(last, activation=False)
        a = l(last, activation=True)
        self.cache['z'].append(z)
        self.cache['a'].append(a)
        last = a
    # 根据需求返回激活后的值或预激活值
    return self.cache['a'][-1] if activation else self.cache['z'][-1]

然后实现统一的反向传播方法，避免重复计算：

def backward(self, desired_out):
    # 输出层误差
    dz = deriv[self.activations[-1]](self.cache['z'][-1]) * (self.cache['a'][-1] - desired_out)
    grads = {'w': [], 'b': []}
    grads['w'].append(dot(dz, self.cache['a'][-2].T))
    grads['b'].append(dz)
    
    # 从倒数第二层向前遍历计算梯度
    for i in range(len(self.layers)-2, -1, -1):
        dz = dot(self.layers[i+1].weights.T, dz) * deriv[self.activations[i]](self.cache['z'][i])
        grads['w'].insert(0, dot(dz, self.cache['a'][i].T))
        grads['b'].insert(0, dz)
    return grads

def grad_desc(self, input, desired_out, learning_rate=1e-3):
    self.forward(input)
    grads = self.backward(desired_out)
    for i in range(len(self.layers)):
        self.weights[i] -= learning_rate * grads['w'][i]
        self.biases[i] -= learning_rate * grads['b'][i]

额外优化建议 #

• 权重初始化：当前(-1,1)的随机初始化范围易导致深层网络梯度消失/爆炸，建议针对ReLU激活使用He初始化，或通用的Xavier初始化。
• 批量梯度下降：单样本梯度下降本身会造成损失曲线波动，建议实现小批量梯度下降，平均多个样本的梯度后再更新权重。
• 损失函数：当前使用的linalg.norm/len(desired_out)不够规范，回归任务建议用均方误差（MSE），分类任务用交叉熵，更适配梯度下降的优化目标。

内容的提问来源于stack exchange，提问作者Tom Brandt