BP神经网络是什么意思？从数学原理到Python实现的全方位解析

1次阅读

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

BP 神经网络（Back Propagation Neural Network）是一种通过误差反向传播算法进行训练的多层前馈神经网络。它的名字来源于其独特的训练方式——反向传播（Back Propagation），即误差从输出层向输入层反向传播，用于调整网络中的权重和偏置。

BP 神经网络广泛应用于模式识别、函数逼近、数据分类等领域，是深度学习的基础之一。它能够通过学习大量样本数据，自动提取特征并建立输入与输出之间的映射关系。

一个典型的 BP 神经网络由三部分组成：

输入层：接收外部输入数据
隐藏层：进行特征提取和数据变换（可以有多个）
输出层：产生最终的输出结果

前向传播是指数据从输入层经过隐藏层最终到达输出层的过程。对于单个神经元，其输出可以表示为：

$$
z = \sum_{i=1}^n w_i x_i + b
$$
$$
a = \sigma(z)
$$

其中：
– $w_i$ 是权重
– $x_i$ 是输入
– $b$ 是偏置
– $\sigma$ 是激活函数（如 sigmoid、ReLU 等）

对于整个网络，前向传播可以表示为层层递进的函数复合：

$$
\hat{y} = f_n(f_{n-1}(…f_1(x)))
$$

反向传播是 BP 神经网络训练的核心，其目的是通过计算损失函数对各个参数的梯度，然后使用梯度下降法更新参数。主要步骤如下：

计算输出层误差：

$$
\delta^L = \nabla_a C \odot \sigma'(z^L)
$$

反向传播误差到前一层：

$$
\delta^l = ((w^{l+1})^T \delta^{l+1}) \odot \sigma'(z^l)
$$

计算权重和偏置的梯度：

$$
\frac{\partial C}{\partial w^l_{jk}} = a^{l-1}_k \delta^l_j
$$

$$
\frac{\partial C}{\partial b^l_j} = \delta^l_j
$$

更新参数：

$$
w \leftarrow w – \eta \frac{\partial C}{\partial w}
$$

$$
b \leftarrow b – \eta \frac{\partial C}{\partial b}
$$

其中 $\eta$ 是学习率。

下面我们使用 NumPy 实现一个简单的 BP 神经网络，完成一个二分类任务。

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, z):
        return 1 / (1 + np.exp(-z))

    def sigmoid_derivative(self, z):
        return self.sigmoid(z) * (1 - self.sigmoid(z))

    def forward(self, X):
        # 前向传播
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.sigmoid(self.z2)
        return self.a2

    def backward(self, X, y, learning_rate):
        # 反向传播
        m = X.shape[0]

        # 计算输出层误差
        delta2 = (self.a2 - y) * self.sigmoid_derivative(self.z2)
        dW2 = np.dot(self.a1.T, delta2) / m
        db2 = np.sum(delta2, axis=0, keepdims=True) / m

        # 计算隐藏层误差
        delta1 = np.dot(delta2, self.W2.T) * self.sigmoid_derivative(self.z1)
        dW1 = np.dot(X.T, delta1) / m
        db1 = np.sum(delta1, axis=0, keepdims=True) / m

        # 更新参数
        self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1

    def train(self, X, y, epochs, learning_rate):
        for i in range(epochs):
            # 前向传播
            output = self.forward(X)

            # 反向传播
            self.backward(X, y, learning_rate)

            # 打印损失
            if i % 100 == 0:
                loss = np.mean(np.square(y - output))
                print(f"Epoch {i}, Loss: {loss}")

# 示例使用
X = np.array([[0,0], [0,1], [1,0], [1,1]])  # 输入
Y = np.array([[0], [1], [1], [0]])           # 输出 (异或问题)

# 创建网络
nn = NeuralNetwork(input_size=2, hidden_size=4, output_size=1)

# 训练网络
nn.train(X, Y, epochs=10000, learning_rate=0.1)

在深层网络中，当使用 sigmoid 或 tanh 等激活函数时，随着反向传播的进行，梯度可能会变得越来越小，最终接近 0，导致浅层网络的权重几乎不更新。解决方案包括：