Python反向传播算法教程

什么是反向传播算法？

反向传播（Backpropagation）是训练神经网络的核心算法，它通过计算损失函数相对于网络权重的梯度，然后使用梯度下降法来更新权重。

反向传播算法的主要步骤：

前向传播计算预测值
计算损失函数
反向传播计算梯度
使用梯度下降更新权重

反向传播的数学原理

反向传播基于微积分中的链式法则，用于计算复合函数的导数。对于一个神经网络，损失函数L相对于权重w的梯度可以表示为：

∂L/∂w = ∂L/∂a * ∂a/∂z * ∂z/∂w

其中：

L：损失函数
a：激活函数的输出
z：神经元的加权输入
w：权重参数

反向传播过程可视化

输入

→

隐藏层

→

输出

←

梯度

←

反向传播：从输出层向输入层传播误差梯度

Python实现反向传播

以下是一个简单的神经网络实现，包含完整的前向传播和反向传播过程：

神经网络反向传播代码示例

import numpy as np

class NeuralNetwork:
    def __init__(self):
        # 初始化权重和偏置
        self.weights1 = np.random.randn(2, 4)  # 输入层到隐藏层
        self.bias1 = np.zeros((1, 4))
        self.weights2 = np.random.randn(4, 1)  # 隐藏层到输出层
        self.bias2 = np.zeros((1, 1))
    
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))
    
    def sigmoid_derivative(self, x):
        return x * (1 - x)
    
    def forward(self, X):
        # 前向传播
        self.hidden = self.sigmoid(np.dot(X, self.weights1) + self.bias1)
        self.output = self.sigmoid(np.dot(self.hidden, self.weights2) + self.bias2)
        return self.output
    
    def backward(self, X, y, output, lr=0.1):
        # 反向传播
        # 计算输出层误差
        output_error = y - output
        output_delta = output_error * self.sigmoid_derivative(output)
        
        # 计算隐藏层误差
        hidden_error = output_delta.dot(self.weights2.T)
        hidden_delta = hidden_error * self.sigmoid_derivative(self.hidden)
        
        # 更新权重和偏置
        self.weights2 += self.hidden.T.dot(output_delta) * lr
        self.bias2 += np.sum(output_delta, axis=0, keepdims=True) * lr
        self.weights1 += X.T.dot(hidden_delta) * lr
        self.bias1 += np.sum(hidden_delta, axis=0, keepdims=True) * lr
    
    def train(self, X, y, epochs=10000):
        for i in range(epochs):
            output = self.forward(X)
            self.backward(X, y, output)
            
            # 每1000次迭代打印损失
            if i % 1000 == 0:
                loss = np.mean(np.square(y - output))
                print(f"Epoch {i}, Loss: {loss:.6f}")

# 示例数据 (XOR问题)
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

# 创建并训练神经网络
nn = NeuralNetwork()
nn.train(X, y)

# 测试训练结果
print("\nTest results:")
for i in range(len(X)):
    print(f"Input: {X[i]}, Predicted: {nn.forward(X[i].reshape(1, -1))[0][0]:.4f}")

代码解析：

初始化：创建具有一个隐藏层的神经网络
前向传播：计算隐藏层和输出层的激活值
反向传播：
- 计算输出层误差和梯度
- 计算隐藏层误差和梯度
- 使用梯度下降更新权重和偏置
训练循环：迭代训练并输出损失值

反向传播关键概念

梯度下降

通过沿着梯度反方向更新参数来最小化损失函数：

w = w - η * (∂L/∂w)

其中η是学习率，控制更新步长

激活函数

常用的激活函数及其导数：

Sigmoid: σ(z) = 1/(1+e⁻ᶻ), σ' = σ(1-σ)
ReLU: max(0,z), 导数为0或1
Tanh: (eᶻ-e⁻ᶻ)/(eᶻ+e⁻ᶻ), 导数为1-tanh²(z)

损失函数

用于衡量预测值与真实值的差异：

均方误差：L = (1/2)(y - ŷ)²
交叉熵：L = -Σ yᵢ log(ŷᵢ)

反向传播常见问题

梯度消失/爆炸问题

当网络层数较深时，梯度可能变得非常小（消失）或非常大（爆炸），导致训练困难。

解决方案：

使用ReLU等激活函数
使用Batch Normalization
使用残差连接
梯度裁剪

学习率选择

学习率过大可能导致震荡不收敛，过小则收敛缓慢。

解决方案：

学习率衰减策略
自适应优化器（Adam, RMSprop）
学习率网格搜索

Python反向传播算法教程 | 原理与实现详解

什么是反向传播算法？