深入解析bp梯度下降公式：从数学原理到代码实现

1次阅读

没有评论

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

神经网络训练本质上是一个参数优化问题。假设我们有一个包含数百万参数的复杂网络，如何找到使损失函数最小的参数组合？梯度下降给出了答案：通过计算损失函数对每个参数的偏导数（梯度），沿着梯度反方向逐步调整参数值。

想象你身处多山峰的地形中，闭着眼要找到最低点。梯度下降就像用脚感知周围坡度，每次向最陡的下坡方向迈一小步。这个 ” 感知坡度 ” 的过程就是计算梯度，” 迈步 ” 就是参数更新。

反向传播（Backpropagation）是高效计算梯度的算法，核心是链式法则。让我们推导一个简单全连接网络的梯度公式：

前向传播 ：
第 l 层输出：$z^{(l)} = W^{(l)}a^{(l-1)} + b^{(l)}$
激活值：$a^{(l)} = \sigma(z^{(l)})$
损失函数 （以 MSE 为例）：
$L = \frac{1}{2}\sum(y – a^{(L)})^2$
反向传播关键步骤 ：
输出层误差：$\delta^{(L)} = \nabla_a L \odot \sigma'(z^{(L)})$
隐藏层误差：$\delta^{(l)} = (W^{(l+1)T}\delta^{(l+1)}) \odot \sigma'(z^{(l)})$
参数梯度：
$\frac{\partial L}{\partial W^{(l)}} = \delta^{(l)}a^{(l-1)T}$
$\frac{\partial L}{\partial b^{(l)}} = \delta^{(l)}$

SGD（随机梯度下降）：
优点：简单，内存占用小
缺点：收敛震荡，易陷入局部最优
Momentum：
引入速度项：$v = \gamma v + \eta \nabla_\theta J(\theta)$
参数更新：$\theta = \theta – v$
效果：缓解震荡，加速平坦区域收敛
Adam：
结合动量与自适应学习率
维护一阶矩估计和二阶矩估计
适合稀疏梯度场景

import numpy as np

class NeuralNetwork:
    def __init__(self, layers):
        self.weights = [np.random.randn(y, x) * 0.1 
                        for x, y in zip(layers[:-1], layers[1:])]
        self.biases = [np.zeros((y, 1)) for y in layers[1:]]

    def forward(self, x):
        a = x
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            a = 1/(1+np.exp(-z))  # Sigmoid
        return a

    def backprop(self, x, y):
        # 初始化梯度存储
        grad_w = [np.zeros_like(w) for w in self.weights]
        grad_b = [np.zeros_like(b) for b in self.biases]

        # 前向传播
        activation = x
        activations = [x]
        zs = []
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, activation) + b
            zs.append(z)
            activation = 1/(1+np.exp(-z))
            activations.append(activation)

        # 反向传播
        delta = (activations[-1] - y) * activations[-1] * (1 - activations[-1])
        grad_b[-1] = delta
        grad_w[-1] = np.dot(delta, activations[-2].T)

        for l in range(2, len(self.weights)+1):
            z = zs[-l]
            sp = 1/(1+np.exp(-z)) * (1 - 1/(1+np.exp(-z)))
            delta = np.dot(self.weights[-l+1].T, delta) * sp
            grad_b[-l] = delta
            grad_w[-l] = np.dot(delta, activations[-l-1].T)

        return grad_w, grad_b

    def update_params(self, grads, lr=0.01):
        for i in range(len(self.weights)):
            self.weights[i] -= lr * grads[0][i]
            self.biases[i] -= lr * grads[1][i]