BPNN神经网络：从数学原理到Python实战

1次阅读

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

神经网络模仿人脑神经元的工作方式，通过多层连接的节点（神经元）进行信息处理。BPNN（Back Propagation Neural Network）是最基础的前馈神经网络，其核心在于通过反向传播算法调整网络参数。

前向传播 ：输入数据从输入层经过隐藏层最终到达输出层，每一层都会对数据进行加权求和并通过激活函数进行非线性变换。
反向传播 ：通过计算损失函数对权重的梯度，从输出层反向逐层调整权重，使用梯度下降法最小化损失。
激活函数 ：常用 Sigmoid、Tanh 或 ReLU，引入非线性，使网络能拟合复杂函数。

BPNN：适合结构化数据（如表格数据），处理分类和回归问题，但在图像、语音等非结构化数据上效果有限。
CNN：专为图像设计，通过卷积核提取局部特征，适合图像识别、目标检测等任务。
RNN：处理序列数据（如文本、时间序列），具有记忆功能，适合自然语言处理、语音识别。

以下是使用 NumPy 实现 BPNN 的关键代码：

import numpy as np
from typing import List, Tuple

class BPNN:
    def __init__(self, layer_sizes: List[int]):
        """初始化网络权重"""
        self.weights = [np.random.randn(y, x) * 0.1 
                        for x, y in zip(layer_sizes[:-1], layer_sizes[1:])]
        self.biases = [np.random.randn(y, 1) * 0.1 for y in layer_sizes[1:]]

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

    def backward(self, x: np.ndarray, y: np.ndarray) -> Tuple[List[np.ndarray], List[np.ndarray]]:
        """反向传播计算梯度"""
        # 存储各层激活值和加权输入
        activations = [x]
        zs = []

        # 前向传播
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, activations[-1]) + b
            zs.append(z)
            activations.append(sigmoid(z))

        # 计算输出层误差
        delta = (activations[-1] - y) * 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, len(self.weights) + 1):
            delta = np.dot(self.weights[-l+1].T, delta) * sigmoid_prime(zs[-l])
            nabla_w[-l] = np.dot(delta, activations[-l-1].T)
            nabla_b[-l] = delta

        return nabla_w, nabla_b

    def update_params(self, nabla_w: List[np.ndarray], nabla_b: List[np.ndarray], lr: float):
        """更新权重和偏置"""
        self.weights = [w - lr * nw for w, nw in zip(self.weights, nabla_w)]
        self.biases = [b - lr * nb for b, nb in zip(self.biases, nabla_b)]

def sigmoid(z: np.ndarray) -> np.ndarray:
    return 1.0 / (1.0 + np.exp(-z))

def sigmoid_prime(z: np.ndarray) -> np.ndarray:
    return sigmoid(z) * (1 - sigmoid(z))

学习率选择 ：
太大导致震荡，太小收敛慢。
使用学习率衰减或自适应方法（如 Adam）。
梯度消失 ：
深层网络中梯度逐层减小，导致底层权重更新缓慢。
使用 ReLU 激活函数、批归一化（BatchNorm）或残差连接。
过拟合 ：
模型在训练集表现好，测试集差。
使用 Dropout 随机失活部分神经元，或 L2 正则化惩罚大权重。

from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split

# 加载数据
mnist = fetch_openml('mnist_784')
X, y = mnist.data / 255.0, mnist.target.astype(int)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# 初始化网络
net = BPNN([784, 128, 10])

# 训练
for epoch in range(10):
    for x, y in zip(X_train.values, y_train):
        x = x.reshape(-1, 1)
        y_onehot = np.zeros((10, 1))
        y_onehot[y] = 1

        nabla_w, nabla_b = net.backward(x, y_onehot)
        net.update_params(nabla_w, nabla_b, lr=0.01)

# 测试
correct = 0
for x, y in zip(X_test.values, y_test):
    pred = np.argmax(net.forward(x.reshape(-1, 1)))
    correct += int(pred == y)
print(f"Accuracy: {correct / len(X_test):.2%}")