深入解析ANN反向传播：从数学原理到Python实现

1次阅读

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

人工神经网络（ANN）通过模拟人脑神经元的工作方式来解决复杂的模式识别问题。反向传播算法是训练神经网络的核心，它的主要任务是调整网络中的权重参数，使得网络的预测结果尽可能接近真实值。

前向传播局限性 ：前向传播负责将输入数据通过层层网络计算得到输出，但它无法自动调整权重来减少误差。
误差最小化需求 ：反向传播通过计算误差对权重的梯度，指导权重如何调整才能最小化预测误差。
高效学习机制 ：相比随机调整权重，反向传播提供了系统化的优化路径，极大提高了学习效率。

反向传播的核心是链式法则，它允许我们将误差从输出层逐层传递回输入层。假设我们有一个简单的三层网络（输入层、隐藏层、输出层），误差 E 对权重 w 的梯度可以表示为：

∂E/∂w = (∂E/∂y) * (∂y/∂z) * (∂z/∂w)

其中 y 是输出，z 是激活函数的输入。

计算输出层误差 ：比较网络输出与真实值，得到误差 E。
反向传播误差 ：将误差 E 通过链式法则传递回每一层。
计算权重梯度 ：根据误差信号和对应层的输入，计算权重梯度∂E/∂w。
更新权重 ：使用梯度下降法更新权重：w_new = w_old - η * (∂E/∂w)，其中 η 是学习率。

import numpy as np

class Layer:
    def __init__(self, input_size, output_size):
        self.weights = np.random.randn(output_size, input_size) * 0.1
        self.bias = np.zeros((output_size, 1))

    def forward(self, inputs):
        self.inputs = inputs
        self.output = np.dot(self.weights, self.inputs) + self.bias
        return self.output

    def backward(self, grad_output, learning_rate):
        grad_weights = np.dot(grad_output, self.inputs.T)
        grad_bias = np.sum(grad_output, axis=1, keepdims=True)
        grad_input = np.dot(self.weights.T, grad_output)

        # 更新参数
        self.weights -= learning_rate * grad_weights
        self.bias -= learning_rate * grad_bias

        return grad_input

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

def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(x))

# 网络初始化
input_size = 2
hidden_size = 4
output_size = 1
learning_rate = 0.1
epochs = 1000

# 创建网络层
layer1 = Layer(input_size, hidden_size)
layer2 = Layer(hidden_size, output_size)

# 训练数据
X = np.array([[0,0], [0,1], [1,0], [1,1]]).T
Y = np.array([[0], [1], [1], [0]]).T

# 训练循环
for epoch in range(epochs):
    # 前向传播
    hidden = sigmoid(layer1.forward(X))
    output = sigmoid(layer2.forward(hidden))

    # 计算误差
    error = output - Y

    # 反向传播
    grad_output = error * sigmoid_derivative(output)
    grad_hidden = layer2.backward(grad_output, learning_rate) * sigmoid_derivative(hidden)
    layer1.backward(grad_hidden, learning_rate)

    # 打印训练进度
    if epoch % 100 == 0:
        print(f"Epoch {epoch}, Loss: {np.mean(np.abs(error))}")

原因：深层网络中，梯度在反向传播时可能指数级减小（消失）或增大（爆炸）。
解决方案 ：
使用 ReLU 等不会饱和的激活函数
采用批量归一化（Batch Normalization）
使用残差连接（ResNet）

固定学习率 ：简单但可能收敛慢或不稳定
自适应学习率 ：如 Adam、RMSprop 等优化算法

Sigmoid：可能导致梯度消失
ReLU：计算简单，缓解梯度消失
LeakyReLU：解决 ReLU” 死亡神经元 ” 问题

import matplotlib.pyplot as plt

# 记录损失
loss_history = []

# 修改训练循环
for epoch in range(epochs):
    # ... 前面的训练代码...
    loss_history.append(np.mean(np.abs(error)))

# 绘制损失曲线
plt.plot(loss_history)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss Over Time')
plt.show()