深度学习基础：从数学推导到代码实现bf反向传播算法

1次阅读

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

反向传播算法（Backpropagation，简称 BP）是训练神经网络的核心算法。它的主要思想是通过链式法则计算损失函数对每个参数的梯度，然后利用梯度下降法更新网络参数。反向传播算法之所以重要，是因为它提供了一种高效计算梯度的方法，使得训练深层神经网络成为可能。

在神经网络中，前向传播负责计算输出，而反向传播则负责计算梯度。整个过程可以概括为：

前向传播：输入数据通过网络层层传递，最终得到预测输出
计算损失：比较预测输出和真实标签，计算损失值
反向传播：从输出层开始，反向计算各层参数的梯度
参数更新：使用梯度下降法更新网络参数

考虑一个简单的三层神经网络（输入层、隐藏层、输出层），前向传播过程可以表示为：

隐藏层激活值：$h = \sigma(W_1x + b_1)$
输出层预测值：$\hat{y} = \sigma(W_2h + b_2)$
损失函数：$L = \frac{1}{2}(y – \hat{y})^2$

其中 $\sigma$ 表示 Sigmoid 激活函数。

反向传播的核心是链式法则。我们以输出层权重 $W_2$ 为例，推导其梯度计算过程：

计算损失对预测输出的导数：$\frac{\partial L}{\partial \hat{y}} = \hat{y} – y$
计算预测输出对 $W_2$ 的导数：$\frac{\partial \hat{y}}{\partial W_2} = \hat{y}(1-\hat{y})h^T$
根据链式法则，$\frac{\partial L}{\partial W_2} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial W_2}$

类似地，我们可以推导出其他参数的梯度。完整的推导过程需要注意以下几点：

每一层的误差项需要反向传播到前一层
激活函数的导数需要正确计算
偏置项的梯度计算与权重略有不同

以下是反向传播算法的 Python 实现代码：

import numpy as np

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重
        self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros((1, output_size))

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

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

    def forward(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1
        self.h = self.sigmoid(self.z1)
        self.z2 = np.dot(self.h, self.W2) + self.b2
        self.y_hat = self.sigmoid(self.z2)
        return self.y_hat

    def backward(self, X, y, learning_rate):
        # 计算输出层梯度
        dL_dyhat = self.y_hat - y
        dyhat_dz2 = self.sigmoid_derivative(self.y_hat)
        dL_dz2 = dL_dyhat * dyhat_dz2
        dL_dW2 = np.dot(self.h.T, dL_dz2)
        dL_db2 = np.sum(dL_dz2, axis=0, keepdims=True)

        # 计算隐藏层梯度
        dL_dh = np.dot(dL_dz2, self.W2.T)
        dh_dz1 = self.sigmoid_derivative(self.h)
        dL_dz1 = dL_dh * dh_dz1
        dL_dW1 = np.dot(X.T, dL_dz1)
        dL_db1 = np.sum(dL_dz1, axis=0, keepdims=True)

        # 更新参数
        self.W1 -= learning_rate * dL_dW1
        self.b1 -= learning_rate * dL_db1
        self.W2 -= learning_rate * dL_dW2
        self.b2 -= learning_rate * dL_db2

在实际实现反向传播算法时，有几个常见陷阱需要注意：