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

1次阅读

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

传统感知机（Perceptron）使用单一线性分类器，其核心缺陷是 无法处理非线性可分问题。例如经典的异或（XOR）问题：

# XOR 问题示例
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([0, 1, 1, 0])  # 无法用直线分隔

BPNN 通过以下改进突破限制：

引入 隐藏层 构建非线性组合
使用 Sigmoid 等激活函数 实现非线性映射
反向传播算法 自动调整权重

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

输入层到隐藏层：
$$
h = \sigma(W_1 X + b_1)
$$
隐藏层到输出层：
$$
\hat{y} = \sigma(W_2 h + b_2)
$$

其中 $\sigma(z)=\frac{1}{1+e^{-z}}$ 是 Sigmoid 函数。

关键公式推导（以均方误差损失 $E=\frac{1}{2}(y-\hat{y})^2$ 为例）：

输出层权重梯度：
$$
\frac{\partial E}{\partial W_2} = \underbrace{(\hat{y}-y)}_{\delta_2} \circ \sigma'(z_2) \cdot h^T
$$
隐藏层权重梯度：
$$
\frac{\partial E}{\partial W_1} = \underbrace{(W_2^T \delta_2)}_{\delta_1} \circ \sigma'(z_1) \cdot X^T
$$

符号说明：$\circ$ 表示逐元素乘法，上标 $T$ 表示矩阵转置

import numpy as np

class BPNN:
    def __init__(self, input_size, hidden_size, output_size):
        # Xavier 初始化权重
        self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(1/input_size)
        self.W2 = np.random.randn(hidden_size, output_size) * np.sqrt(1/hidden_size)
        self.b1 = np.zeros(hidden_size)
        self.b2 = np.zeros(output_size)

    def sigmoid(self, z):
        return 1 / (1 + np.exp(-z))

    def sigmoid_derivative(self, z):
        s = self.sigmoid(z)
        return s * (1 - s)

def train(self, X, y, epochs=1000, lr=0.1, batch_size=32, lambd=0.01):
    for epoch in range(epochs):
        # 小批量梯度下降
        indices = np.random.permutation(len(X))
        for i in range(0, len(X), batch_size):
            batch_idx = indices[i:i+batch_size]
            X_batch, y_batch = X[batch_idx], y[batch_idx]

            # 前向传播
            z1 = X_batch.dot(self.W1) + self.b1
            h = self.sigmoid(z1)
            z2 = h.dot(self.W2) + self.b2
            y_pred = self.sigmoid(z2)

            # 反向传播
            delta2 = (y_pred - y_batch) * self.sigmoid_derivative(z2)
            dW2 = h.T.dot(delta2) + lambd * self.W2  # L2 正则化

            delta1 = delta2.dot(self.W2.T) * self.sigmoid_derivative(z1)
            dW1 = X_batch.T.dot(delta1) + lambd * self.W1

            # 参数更新
            self.W1 -= lr * dW1
            self.W2 -= lr * dW2
            self.b1 -= lr * delta1.mean(axis=0)
            self.b2 -= lr * delta2.mean(axis=0)

学习率选择：从 0.1 开始尝试，观察损失曲线
```
# 学习率衰减示例
lr = 0.1 * (0.95 ** (epoch//10))
```
梯度裁剪：防止梯度爆炸
```
grad = np.clip(grad, -1, 1)
```

隐藏层神经元数：通常取输入输出的几何平均数
$$
N_{hidden} = \sqrt{N_{input} \cdot N_{output}}
$$

输入标准化：加速收敛

X = (X - X.mean(axis=0)) / X.std(axis=0)

from sklearn.datasets import load_iris
from sklearn.preprocessing import OneHotEncoder

# 数据准备
iris = load_iris()
X = iris.data
y = OneHotEncoder().fit_transform(iris.target.reshape(-1,1)).toarray()

# 训练测试分割
np.random.seed(42)
indices = np.random.permutation(len(X))
train_size = int(0.8 * len(X))
X_train, y_train = X[indices[:train_size]], y[indices[:train_size]]
X_test, y_test = X[indices[train_size:]], y[indices[train_size:]]

# 模型训练
model = BPNN(input_size=4, hidden_size=5, output_size=3)
model.train(X_train, y_train, epochs=2000, lr=0.05)

# 评估
preds = model.predict(X_test)
accuracy = np.mean(np.argmax(preds, axis=1) == np.argmax(y_test, axis=1))
print(f"Test Accuracy: {accuracy:.2%}")