从零开始理解反向传播算法

2023-09-16 06:37:36

反向传播，又称后向传播，是一种广为使用的深度学习算法，主要用于训练神经网络。其核心思想是通过层层回溯，计算损失函数对神经网络权重和偏置的梯度，再根据这些梯度更新权重和偏置，使神经网络能够逐渐逼近最优解。

简化例子

为了让反向传播算法易于理解，我们以一个简单的神经网络为例：

输入层：[x1, x2]
隐藏层：[h1, h2] = [w11*x1 + w12*x2 + b1, w21*x1 + w22*x2 + b2]
输出层：y = w31*h1 + w32*h2 + b3

其中，w是权重，b是偏置。

正向传播

正向传播是从输入层到输出层的前向计算：

计算隐藏层输出：
- h1 = w11x1 + w12x2 + b1
- h2 = w21x1 + w22x2 + b2
计算输出层输出：
- y = w31h1 + w32h2 + b3

反向传播

反向传播是从输出层到输入层的反向计算梯度：

输出层 ：计算输出层偏导数：
- ∂y/∂w31 = ∂L/∂y * h1
- ∂y/∂w32 = ∂L/∂y * h2
- ∂y/∂b3 = ∂L/∂y
隐藏层 ：计算隐藏层偏导数：
- ∂L/∂h1 = ∂L/∂y * w31
- ∂L/∂h2 = ∂L/∂y * w32
- ∂L/∂w11 = ∂L/∂h1 * x1
- ∂L/∂w12 = ∂L/∂h1 * x2
- ∂L/∂w21 = ∂L/∂h2 * x1
- ∂L/∂w22 = ∂L/∂h2 * x2
- ∂L/∂b1 = ∂L/∂h1
- ∂L/∂b2 = ∂L/∂h2
更新权重和偏置 ：使用计算的梯度更新权重和偏置：
- w31 = w31 - α * ∂L/∂w31
- w32 = w32 - α * ∂L/∂w32
- b3 = b3 - α * ∂L/∂b3
- w11 = w11 - α * ∂L/∂w11
- w12 = w12 - α * ∂L/∂w12
- w21 = w21 - α * ∂L/∂w21
- w22 = w22 - α * ∂L/∂w22
- b1 = b1 - α * ∂L/∂b1
- b2 = b2 - α * ∂L/∂b2

其中，α是学习率。

代码示例

以下是一个反向传播算法的Python代码示例：

import numpy as np

class NeuralNetwork:
    def __init__(self, n_input, n_hidden, n_output):
        # 随机初始化权重和偏置
        self.w1 = np.random.randn(n_hidden, n_input)
        self.b1 = np.zeros((n_hidden, 1))
        self.w2 = np.random.randn(n_output, n_hidden)
        self.b2 = np.zeros((n_output, 1))

    def forward(self, X):
        # 正向传播
        h = np.dot(self.w1, X) + self.b1
        h = np.tanh(h)
        y = np.dot(self.w2, h) + self.b2
        return y

    def backward(self, X, y, lr):
        # 反向传播
        # 计算输出层梯度
        d_L_y = y - X
        # 计算隐藏层梯度
        d_L_h = np.dot(self.w2.T, d_L_y) * (1 - np.tanh(h) ** 2)
        # 更新权重和偏置
        self.w2 -= lr * np.dot(d_L_y, h.T)
        self.b2 -= lr * np.sum(d_L_y, axis=0, keepdims=True)
        self.w1 -= lr * np.dot(d_L_h, X.T)
        self.b1 -= lr * np.sum(d_L_h, axis=0, keepdims=True)

    def train(self, X, y, epochs, lr):
        # 训练神经网络
        for i in range(epochs):
            # 正向传播
            y_pred = self.forward(X)
            # 反向传播
            self.backward(X, y_pred, lr)