BP神经网络原理详解与CSDN实战：从数学推导到Python实现

1次阅读

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

BP 神经网络（Backpropagation Neural Network）是一种多层前馈神经网络，通过反向传播算法进行训练。它在图像识别、自然语言处理、金融预测等领域有着广泛应用。相比于传统机器学习算法，BP 神经网络能够自动学习特征，处理非线性关系，具有很强的表达能力。

输入层到隐藏层：
输入向量 x 通过权重矩阵 W1 和偏置 b1 线性变换
经过激活函数 f(如 sigmoid、ReLU)得到隐藏层输出 h = f(W1*x + b1)
隐藏层到输出层：
隐藏层输出 h 通过权重矩阵 W2 和偏置 b2 线性变换
经过输出层激活函数 g(如 softmax)得到预测输出 y_hat = g(W2*h + b2)

损失函数计算：
常用交叉熵损失 (分类) 或均方误差(回归)
L = -Σ[ylog(y_hat) + (1-y)log(1-y_hat)]
输出层梯度：
δ_output = (y_hat – y) * g'(z)
∂L/∂W2 = h.T * δ_output
∂L/∂b2 = δ_output
隐藏层梯度：
δ_hidden = (δ_output * W2.T) * f'(z)
∂L/∂W1 = x.T * δ_hidden
∂L/∂b1 = δ_hidden

Sigmoid：容易梯度消失，输出非零中心
Tanh：输出零中心，但仍会梯度消失
ReLU：计算简单，缓解梯度消失，但可能有神经元死亡

import numpy as np

class BPNeuralNetwork:
    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, 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):
        # 反向传播
        m = X.shape[0]

        # 输出层误差
        delta2 = (output - y) * self.sigmoid_derivative(output)
        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.a1)
        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, output, learning_rate)
            if i % 100 == 0:
                loss = np.mean(np.square(y - output))
                print(f'Epoch {i}, Loss: {loss:.4f}')