BP神经网络详解：从数学推导到Python实战

1次阅读

没有评论

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

BP 神经网络作为深度学习的基础，理解其数学原理和实现细节对于机器学习工程师至关重要。本文将带你从数学推导到实际代码实现，全面掌握 BP 神经网络的核心要点。

前向传播是神经网络的基础，通过矩阵运算将输入数据逐层传递到输出层。对于一个三层的神经网络（输入层、隐藏层、输出层），前向传播的数学表达式如下：

输入层到隐藏层 ：
$$
z^{(1)} = W^{(1)}x + b^{(1)}
$$
$$
a^{(1)} = f(z^{(1)})
$$
其中，(W^{(1)}) 是权重矩阵，(b^{(1)}) 是偏置向量，(f) 是激活函数（如 ReLU 或 Sigmoid）。
隐藏层到输出层 ：
$$
z^{(2)} = W^{(2)}a^{(1)} + b^{(2)}
$$
$$
a^{(2)} = g(z^{(2)})
$$
其中，(g) 通常是 Sigmoid 或 Softmax 函数，用于输出层的概率预测。

反向传播通过链式法则计算梯度，用于更新权重和偏置。核心步骤如下：

计算输出层误差 ：
$$
\delta^{(2)} = (a^{(2)} – y) \odot g'(z^{(2)})
$$
其中，(y) 是真实标签，(\odot) 表示逐元素乘法。
计算隐藏层误差 ：
$$
\delta^{(1)} = (W^{(2)T} \delta^{(2)}) \odot f'(z^{(1)})
$$
更新权重和偏置 ：
$$
W^{(2)} := W^{(2)} – \eta \delta^{(2)} a^{(1)T}
$$
$$
b^{(2)} := b^{(2)} – \eta \delta^{(2)}
$$
$$
W^{(1)} := W^{(1)} – \eta \delta^{(1)} x^T
$$
$$
b^{(1)} := b^{(1)} – \eta \delta^{(1)}
$$
其中，(\eta) 是学习率。

输入数据的标准化（Z-score）是防止梯度爆炸的关键步骤：

import numpy as np

def normalize(X):
    mean = np.mean(X, axis=0)
    std = np.std(X, axis=0)
    return (X - mean) / (std + 1e-8)  # 防止除以零

隐藏层支持 ReLU 和 Sigmoid 两种激活函数，并标注梯度计算陷阱：

class HiddenLayer:
    def __init__(self, input_size, output_size, activation='relu'):
        self.W = np.random.randn(input_size, output_size) * 0.01
        self.b = np.zeros((1, output_size))
        self.activation = activation

    def forward(self, X):
        self.z = np.dot(X, self.W) + self.b
        if self.activation == 'relu':
            self.a = np.maximum(0, self.z)
        elif self.activation == 'sigmoid':
            self.a = 1 / (1 + np.exp(-self.z))
        return self.a

    def backward(self, X, delta_next):
        if self.activation == 'relu':
            delta = delta_next * (self.z > 0)  # ReLU 梯度陷阱：负值梯度为零
        elif self.activation == 'sigmoid':
            delta = delta_next * self.a * (1 - self.a)  # Sigmoid 梯度
        dW = np.dot(X.T, delta)
        db = np.sum(delta, axis=0, keepdims=True)
        delta_prev = np.dot(delta, self.W.T)
        return delta_prev, dW, db

交叉熵损失函数需要处理 log 溢出问题：

def cross_entropy(y_pred, y_true):
    epsilon = 1e-12  # 防止 log(0)
    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)  # 防止 log 溢出
    return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))

比较 SGD、Momentum 和 Adam 在图像分类任务中的收敛速度：