BP神经网络推导：从数学原理到Python实现

1次阅读

没有评论

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

BP（Back Propagation）神经网络是一种多层前馈神经网络，通过误差反向传播算法进行训练。它的核心思想是通过不断调整网络中的权重和偏置，使得网络的输出尽可能接近预期的目标值。

输入层：接收原始数据
隐藏层：负责特征提取和转换
输出层：产生最终预测结果
激活函数：引入非线性因素，常用 Sigmoid、ReLU 等

神经网络的学习过程本质上是求解最优参数（权重 w 和偏置 b）的过程，通过最小化损失函数来实现。

损失函数：衡量预测值与真实值的差异，常用均方误差(MSE)
```
E = \frac{1}{2}\sum_{k}(y_k - t_k)^2
```
梯度下降：通过计算损失函数对各参数的偏导来更新参数
```
w_{new} = w_{old} - \eta\frac{\partial E}{\partial w}
```

以三层网络（输入层、单隐藏层、输出层）为例：

输入层到隐藏层
```
h_j = f(\sum_{i}w_{ji}x_i + b_j)
```
隐藏层到输出层
```
y_k = f(\sum_{j}w_{kj}h_j + b_k)
```
其中 f 为激活函数，本文以 Sigmoid 为例：
```
f(x) = \frac{1}{1+e^{-x}}
```

误差反向传播的关键是链式求导法则：

输出层误差计算
```
\delta_k = (y_k - t_k)f'(net_k)
```

隐藏层误差计算

\delta_j = (\sum_{k}w_{kj}\delta_k)f'(net_j)

权重更新公式

\Delta w_{kj} = -\eta\delta_k h_j

\Delta w_{ji} = -\eta\delta_j x_i

import numpy as np

class BPNeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重
        self.W1 = np.random.randn(input_size, hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size)
        self.b1 = np.zeros(hidden_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.hidden = self.sigmoid(np.dot(X, self.W1) + self.b1)
        self.output = self.sigmoid(np.dot(self.hidden, self.W2) + self.b2)
        return self.output

    def backward(self, X, y, output, learning_rate):
        # 反向传播
        output_error = y - output
        output_delta = output_error * self.sigmoid_derivative(output)

        hidden_error = np.dot(output_delta, self.W2.T)
        hidden_delta = hidden_error * self.sigmoid_derivative(self.hidden)

        # 更新权重
        self.W2 += learning_rate * np.dot(self.hidden.T, output_delta)
        self.W1 += learning_rate * np.dot(X.T, hidden_delta)
        self.b2 += learning_rate * np.sum(output_delta, axis=0)
        self.b1 += learning_rate * np.sum(hidden_delta, axis=0)

    def train(self, X, y, epochs, learning_rate):
        for epoch in range(epochs):
            output = self.forward(X)
            self.backward(X, y, output, learning_rate)