BP神经网络示意图：从数学原理到可视化实现

1次阅读

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

BP 神经网络（Backpropagation Neural Network）是深度学习中最基础也最重要的模型之一。它在图像识别、语音处理、金融预测等领域有广泛应用。今天我们就来一起揭开 BP 神经网络的神秘面纱，并通过 Python 实现一个完整的可视化示例。

BP 神经网络通常由三部分组成：

输入层 ：接收原始数据，每个输入节点对应一个特征
隐藏层 ：负责特征转换和表示学习，可以有多个
输出层 ：输出最终的预测结果

每个神经元通过加权求和（权重 w）和非线性变换（激活函数）处理输入信号，然后传递给下一层。

初学者在学习 BP 神经网络时，通常会遇到两大难题：

反向传播算法难以理解 ：
涉及链式求导、偏导数等数学概念
权重更新公式抽象，缺乏直观感受
训练过程可视化不足 ：
看不到权重如何随迭代变化
不了解梯度下降的具体运作方式

下面是一个简单的 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, x):
        return 1 / (1 + np.exp(-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, learning_rate=0.1):
        # 反向传播
        m = X.shape[0]  # 样本数

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

        # 隐藏层误差
        dA1 = np.dot(dZ2, self.W2.T)
        dZ1 = dA1 * self.a1 * (1 - self.a1)
        dW1 = np.dot(X.T, dZ1) / m
        db1 = np.sum(dZ1, 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

import matplotlib.pyplot as plt

def draw_neural_net(ax, layer_sizes):
    # 绘制神经网络示意图
    v_spacing = 1.0 / float(max(layer_sizes))
    h_spacing = 1.0 / float(len(layer_sizes) - 1)

    # 节点
    for n, layer_size in enumerate(layer_sizes):
        layer_top = (v_spacing * (layer_size - 1)) / 2. + 0.5
        for m in range(layer_size):
            x = n * h_spacing
            y = layer_top - m * v_spacing
            circle = plt.Circle((x, y), v_spacing/4., color='w', ec='k', zorder=4)
            ax.add_artist(circle)

    # 连接
    for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_size[1:])):
        layer_top_a = (v_spacing * (layer_size_a - 1)) / 2. + 0.5
        layer_top_b = (v_spacing * (layer_size_b - 1)) / 2. + 0.5
        for m in range(layer_size_a):
            for o in range(layer_size_b):
                line = plt.Line2D([n*h_spacing, (n+1)*h_spacing],
                                  [layer_top_a - m*v_spacing, layer_top_b - o*v_spacing],
                                  c='k')
                ax.add_artist(line)

    ax.axis('off')

fig = plt.figure(figsize=(12, 6))
ax = fig.gca()
draw_neural_net(ax, [4, 5, 3])  # 4 输入神经元，5 隐藏神经元，3 输出神经元
plt.show()

要展示梯度下降过程，我们可以记录每次迭代的权重变化，并使用 FuncAnimation 创建动画：

from matplotlib.animation import FuncAnimation

# 训练并记录权重变化
weights_history = []
for i in range(100):
    nn.backward(X_train, y_train)
    weights_history.append(nn.W1.copy())  # 记录隐藏层权重

# 创建动画
fig, ax = plt.subplots()
def update(frame):
    ax.clear()
    # 绘制当前权重对应的网络
    # ... 省略绘制代码...
    ax.set_title(f'Epoch: {frame}')

anim = FuncAnimation(fig, update, frames=len(weights_history), interval=200)
plt.show()

BP 神经网络的核心是反向传播算法，其数学本质是链式求导法则。损失函数 $L$ 对权重 $w$ 的梯度计算如下：

$$\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \times \frac{\partial a}{\partial z} \times \frac{\partial z}{\partial w}$$

其中：
– $a$ 是激活值
– $z$ 是加权和
– $w$ 是权重参数

对于 sigmoid 激活函数，其导数为：

$$\sigma'(z) = \sigma(z)(1-\sigma(z))$$