BP神经网络概述：从数学原理到Python实现

1次阅读

没有评论

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

BP 神经网络（Backpropagation Neural Network）是一种常见的人工神经网络，广泛应用于分类、回归、模式识别等领域。它的优势在于能够自动学习数据中的复杂模式，通过多层神经元的非线性变换实现高精度的预测。

BP 神经网络特别适合处理以下场景：

图像识别（如手写数字识别）
语音识别
自然语言处理
金融预测

前向传播是神经网络从输入到输出的计算过程。假设我们有一个简单的三层网络（输入层、隐藏层、输出层），其数学表达如下：

输入层到隐藏层的计算：

$$ z^{(1)} = W^{(1)}x + b^{(1)} $$
$$ a^{(1)} = \sigma(z^{(1)}) $$

隐藏层到输出层的计算：

$$ z^{(2)} = W^{(2)}a^{(1)} + b^{(2)} $$
$$ a^{(2)} = \sigma(z^{(2)}) $$

其中，$\sigma$ 是激活函数（如 Sigmoid），$W$ 是权重矩阵，$b$ 是偏置项。

反向传播是通过计算损失函数对权重的梯度来更新网络参数的过程。关键步骤如下：

计算输出层误差：

$$ \delta^{(2)} = (a^{(2)} – y) \odot \sigma'(z^{(2)}) $$

计算隐藏层误差：

$$ \delta^{(1)} = (W^{(2)})^T \delta^{(2)} \odot \sigma'(z^{(1)}) $$

更新权重和偏置：

$$ W^{(2)} := W^{(2)} – \alpha \delta^{(2)} (a^{(1)})^T $$
$$ b^{(2)} := b^{(2)} – \alpha \delta^{(2)} $$
$$ W^{(1)} := W^{(1)} – \alpha \delta^{(1)} x^T $$
$$ b^{(1)} := b^{(1)} – \alpha \delta^{(1)} $$

其中，$\alpha$ 是学习率，$\odot$ 表示逐元素相乘。

以下是使用 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)
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size)
        self.b2 = np.zeros(output_size)

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

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    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, output, learning_rate):
        # 反向传播
        error = output - y
        delta2 = error * self.sigmoid_derivative(output)
        dW2 = np.dot(self.a1.T, delta2)
        db2 = np.sum(delta2, axis=0)

        delta1 = np.dot(delta2, self.W2.T) * self.sigmoid_derivative(self.a1)
        dW1 = np.dot(X.T, delta1)
        db1 = np.sum(delta1, axis=0)

        # 更新权重
        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 epoch in range(epochs):
            output = self.forward(X)
            self.backward(X, y, output, learning_rate)
            if epoch % 1000 == 0:
                loss = np.mean(np.square(y - output))
                print(f"Epoch {epoch}, Loss: {loss:.4f}")

在深层网络中，梯度可能在反向传播过程中变得越来越小，导致浅层权重几乎不更新。解决方案：