BP梯度下降公式详解：从数学推导到Python实现

1次阅读

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

梯度下降是神经网络训练的基石。想象你蒙着眼站在山坡上，想要找到最低点。每次用脚试探周围最陡的下坡方向，就是梯度下降的物理体现。在神经网络中，这个『山坡』就是损失函数曲面，『下坡方向』由梯度决定。

前向传播阶段
对于单个神经元 $z = w^Tx + b$，经过 Sigmoid 激活 $a = \sigma(z) = \frac{1}{1+e^{-z}}$，最终输出与真实值比较得到损失 $L = \frac{1}{2}(y – a)^2$
反向传播关键步骤
损失对输出的偏导：$\frac{\partial L}{\partial a} = -(y – a)$
激活函数的导数：$\sigma'(z) = \sigma(z)(1-\sigma(z))$
根据链式法则得到权重梯度：
$$\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w} = (a – y) \cdot a(1-a) \cdot x$$

批量梯度下降(BGD)
使用全部训练数据计算梯度，更新稳定但计算量大：
$$w := w – \eta \cdot \frac{1}{N}\sum_{i=1}^N \nabla L_i$$
随机梯度下降(SGD)
每次随机选取单个样本更新，计算快但波动大：
$$w := w – \eta \cdot \nabla L_i$$

实际常用折中的 小批量梯度下降，平衡效率与稳定性。

import numpy as np

class NeuralNetwork:
    def __init__(self, input_size):
        self.weights = np.random.randn(input_size) * 0.01  # 小权重初始化
        self.bias = 0

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def forward(self, x):
        self.z = np.dot(x, self.weights) + self.bias
        return self.sigmoid(self.z)

    def train(self, X, y, epochs=1000, lr=0.1, batch_size=32):
        n_samples = len(X)
        for epoch in range(epochs):
            # 学习率衰减
            current_lr = lr * (0.9 ** (epoch // 100))

            # 小批量训练
            indices = np.random.permutation(n_samples)
            for i in range(0, n_samples, batch_size):
                batch_idx = indices[i:i+batch_size]
                X_batch, y_batch = X[batch_idx], y[batch_idx]

                # 前向传播
                output = self.forward(X_batch)

                # 反向传播
                error = output - y_batch
                d_weights = np.dot(X_batch.T, error * self.sigmoid_derivative(output))
                d_bias = np.sum(error * self.sigmoid_derivative(output))

                # 梯度裁剪
                max_grad = 1.0
                d_weights = np.clip(d_weights, -max_grad, max_grad)

                # 更新参数
                self.weights -= current_lr * d_weights / batch_size
                self.bias -= current_lr * d_bias / batch_size