BP神经网络运用实战：从数学原理到Python实现

1次阅读

没有评论

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

感知机（Perceptron）是最简单的神经网络结构，由输入层和输出层组成，只能解决线性可分问题。但现实世界的数据往往是非线性可分的，因此需要更复杂的网络结构。

BP（Back Propagation）神经网络通过引入隐藏层和非线性激活函数，能够解决非线性可分问题。其核心思想是通过反向传播算法，将误差从输出层逐层传播回输入层，调整各层权重和偏置，使网络输出接近期望值。

前向传播是指输入数据从输入层经过隐藏层最终到达输出层的过程。对于第 $l$ 层的第 $j$ 个神经元，其输入 $z_j^l$ 和输出 $a_j^l$ 分别为：

$$ z_j^l = \sum_i w_{ji}^l a_i^{l-1} + b_j^l $$

$$ a_j^l = \sigma(z_j^l) $$

其中，$w_{ji}^l$ 表示第 $l-1$ 层第 $i$ 个神经元到第 $l$ 层第 $j$ 个神经元的权重，$b_j^l$ 是偏置，$\sigma$ 是激活函数。

反向传播的核心是通过链式法则计算损失函数对权重和偏置的梯度。以均方误差（MSE）损失函数为例：

$$ L = \frac{1}{2} \sum_k (y_k – a_k^L)^2 $$

其中，$y_k$ 是真实值，$a_k^L$ 是输出层的输出。

对于输出层的第 $k$ 个神经元，误差项 $\delta_k^L$ 为：

$$ \delta_k^L = \frac{\partial L}{\partial a_k^L} \frac{\partial a_k^L}{\partial z_k^L} = (a_k^L – y_k) \sigma'(z_k^L) $$

对于隐藏层的第 $j$ 个神经元，误差项 $\delta_j^l$ 为：

$$ \delta_j^l = \sum_k w_{kj}^{l+1} \delta_k^{l+1} \sigma'(z_j^l) $$

根据误差项，可以计算权重和偏置的梯度：

$$ \frac{\partial L}{\partial w_{ji}^l} = a_i^{l-1} \delta_j^l $$

$$ \frac{\partial L}{\partial b_j^l} = \delta_j^l $$

下面是一个完整的 BP 神经网络实现，使用 NumPy 库。

import numpy as np
from typing import List, Tuple

class NeuralNetwork:
    def __init__(self, layer_sizes: List[int]) -> None:
        """
        初始化神经网络
        :param layer_sizes: 每层的神经元数量，如 [784, 128, 10] 表示输入层 784 个神经元，隐藏层 128 个，输出层 10 个
        """
        self.layer_sizes = layer_sizes
        self.num_layers = len(layer_sizes)

        # 初始化权重和偏置
        self.weights = [np.random.randn(y, x) / np.sqrt(x) for x, y in zip(layer_sizes[:-1], layer_sizes[1:])]
        self.biases = [np.random.randn(y, 1) for y in layer_sizes[1:]]

    def sigmoid(self, z: np.ndarray) -> np.ndarray:
        """Sigmoid 激活函数"""
        return 1 / (1 + np.exp(-z))

    def sigmoid_prime(self, z: np.ndarray) -> np.ndarray:
        """Sigmoid 函数的导数"""
        s = self.sigmoid(z)
        return s * (1 - s)

    def forward(self, x: np.ndarray) -> np.ndarray:
        """前向传播"""
        a = x
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            a = self.sigmoid(z)
        return a

    def train(self, x: np.ndarray, y: np.ndarray, learning_rate: float) -> None:
        """训练网络，执行一次反向传播"""
        # 前向传播，保存各层的激活值和加权输入
        activations = [x]
        zs = []
        a = x
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            zs.append(z)
            a = self.sigmoid(z)
            activations.append(a)

        # 反向传播
        delta = (activations[-1] - y) * self.sigmoid_prime(zs[-1])
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w[-1] = np.dot(delta, activations[-2].T)
        nabla_b[-1] = delta

        for l in range(2, self.num_layers):
            z = zs[-l]
            sp = self.sigmoid_prime(z)
            delta = np.dot(self.weights[-l+1].T, delta) * sp
            nabla_w[-l] = np.dot(delta, activations[-l-1].T)
            nabla_b[-l] = delta

        # 更新参数
        self.weights = [w - learning_rate * nw for w, nw in zip(self.weights, nabla_w)]
        self.biases = [b - learning_rate * nb for b, nb in zip(self.biases, nabla_b)]

    def evaluate(self, test_data: List[Tuple[np.ndarray, np.ndarray]]) -> int:
        """评估网络在测试集上的准确率"""
        test_results = [(np.argmax(self.forward(x)), np.argmax(y)) for x, y in test_data]
        return sum(int(x == y) for x, y in test_results) / len(test_data)

学习率过大可能导致震荡甚至发散
学习率过小会导致收敛缓慢
建议从 0.01 或 0.001 开始尝试，根据训练效果调整

Sigmoid 函数在深层网络中容易出现梯度消失问题
ReLU 及其变体（如 Leaky ReLU）通常是更好的选择
输出层根据任务选择激活函数（如分类任务用 Softmax，回归任务用线性激活）

输入数据应归一化到相同尺度（如 [0,1] 或[-1,1]）
归一化可以加速收敛并提高模型性能
常见归一化方法：Min-Max 归一化、Z-Score 标准化

from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# 加载数据
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 数据预处理
x_train = x_train.reshape(-1, 784).T / 255.0
x_test = x_test.reshape(-1, 784).T / 255.0
y_train = to_categorical(y_train, 10).T
y_test = to_categorical(y_test, 10).T

# 创建网络
net = NeuralNetwork([784, 128, 10])

# 训练
epochs = 10
batch_size = 32
learning_rate = 0.1

for epoch in range(epochs):
    for i in range(0, x_train.shape[1], batch_size):
        x_batch = x_train[:, i:i+batch_size]
        y_batch = y_train[:, i:i+batch_size]
        net.train(x_batch, y_batch, learning_rate)

    accuracy = net.evaluate(list(zip(x_test.T, y_test.T)))
    print(f"Epoch {epoch+1}, Test Accuracy: {accuracy:.4f}")

批量归一化（Batch Normalization）如何帮助解决深层神经网络的训练问题？
与卷积神经网络（CNN）相比，BP 神经网络在图像识别任务中有哪些局限性？
如何改进 BP 神经网络的结构或训练过程以提升其在复杂任务上的表现？

本文从数学原理到 Python 实现，详细讲解了 BP 神经网络的核心概念和实现方法。通过 MNIST 数据集的实验，我们可以看到即使是简单的 BP 网络也能达到不错的分类准确率。在实际应用中，还需要根据具体任务调整网络结构、优化超参数，并考虑使用更先进的优化技术和正则化方法。希望这篇文章能帮助初学者理解 BP 神经网络的基本原理和实现方法，为进一步学习深度学习打下坚实基础。

正文完