BP神经网络数据分类实战：从基础原理到Python实现

1次阅读

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

BP 神经网络（Backpropagation Neural Network）是一种常用的监督学习算法，特别适合解决分类问题。它通过多层感知器的结构，能够学习输入数据与输出标签之间的复杂非线性关系。然而，对于初学者来说，实现一个 BP 神经网络往往会遇到几个常见的问题：

梯度消失 ：在深层网络中，梯度在反向传播过程中可能会逐渐减小，导致底层权重更新缓慢甚至停止学习。
过拟合 ：模型在训练数据上表现很好，但在测试数据上表现较差，泛化能力不足。
学习率选择 ：学习率过大可能导致震荡甚至无法收敛，学习率过小则收敛速度慢。

接下来，我们将用 Python 和 NumPy 从头实现一个简单的 BP 神经网络，包含网络初始化、前向传播和反向传播三个核心环节。

首先，我们需要初始化网络的权重和偏置。这里我们使用随机初始化，确保权重在一个合理的范围内。

import numpy as np

class BPNeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重和偏置
        self.weights1 = np.random.randn(input_size, hidden_size) * 0.01
        self.bias1 = np.zeros((1, hidden_size))
        self.weights2 = np.random.randn(hidden_size, output_size) * 0.01
        self.bias2 = np.zeros((1, output_size))

前向传播是指输入数据通过网络层层传递，最终得到输出的过程。我们使用 Sigmoid 作为激活函数。

    def forward(self, X):
        # 第一层
        self.z1 = np.dot(X, self.weights1) + self.bias1
        self.a1 = 1 / (1 + np.exp(-self.z1))  # Sigmoid 激活

        # 第二层
        self.z2 = np.dot(self.a1, self.weights2) + self.bias2
        self.a2 = 1 / (1 + np.exp(-self.z2))  # Sigmoid 激活

        return self.a2

反向传播是根据输出误差调整权重和偏置的过程。这里我们使用均方误差（MSE）作为损失函数。

    def backward(self, X, y, learning_rate):
        m = X.shape[0]  # 样本数

        # 计算输出层误差
        error = self.a2 - y
        d_z2 = error * self.a2 * (1 - self.a2)  # Sigmoid 导数

        # 计算隐藏层误差
        d_a1 = np.dot(d_z2, self.weights2.T)
        d_z1 = d_a1 * self.a1 * (1 - self.a1)  # Sigmoid 导数

        # 更新权重和偏置
        self.weights2 -= learning_rate * np.dot(self.a1.T, d_z2) / m
        self.bias2 -= learning_rate * np.sum(d_z2, axis=0, keepdims=True) / m
        self.weights1 -= learning_rate * np.dot(X.T, d_z1) / m
        self.bias1 -= learning_rate * np.sum(d_z1, axis=0, keepdims=True) / m

数据预处理是神经网络训练的重要环节。以下是一些最佳实践：

标准化 ：将数据缩放到均值为 0，方差为 1 的范围，加速收敛。
One-hot 编码 ：对于多分类问题，将标签转换为 One-hot 编码形式。

学习率的选择对模型训练至关重要。常见的策略包括：

固定学习率 ：适用于简单问题，但需要手动调参。
学习率衰减 ：随着训练轮数增加逐渐减小学习率，有助于后期稳定收敛。

过拟合是神经网络常见的问题，可以通过以下方法缓解：

L2 正则化 ：在损失函数中加入权重平方和的惩罚项。
Dropout：随机丢弃一部分神经元，防止网络过于依赖某些特征。

我们以经典的鸢尾花数据集为例，展示完整的分类流程。

from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.model_selection import train_test_split

# 加载数据
iris = load_iris()
X = iris.data
y = iris.target.reshape(-1, 1)

# 数据预处理
scaler = StandardScaler()
X = scaler.fit_transform(X)
encoder = OneHotEncoder()
y = encoder.fit_transform(y).toarray()

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 初始化网络
input_size = X_train.shape[1]
hidden_size = 10
output_size = y_train.shape[1]
model = BPNeuralNetwork(input_size, hidden_size, output_size)

# 训练网络
epochs = 1000
learning_rate = 0.1
for epoch in range(epochs):
    output = model.forward(X_train)
    model.backward(X_train, y_train, learning_rate)

    # 每隔 100 轮打印损失
    if epoch % 100 == 0:
        loss = np.mean((output - y_train) ** 2)
        print(f'Epoch {epoch}, Loss: {loss:.4f}')