BP神经网络优化实战：从基础原理到高效实现

1次阅读

没有评论

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

BP 神经网络是一种经典的前馈神经网络，它通过反向传播算法来调整网络权重，从而实现对复杂函数的逼近。BP 神经网络的结构通常由输入层、隐藏层和输出层组成，每一层由多个神经元节点构成，节点之间通过权重连接。

BP 神经网络的基本工作原理可以概括为三个步骤：

前向传播：输入数据从输入层逐层传播到输出层
误差计算：比较网络输出与真实值的差异
反向传播：将误差从输出层反向传播到输入层，并调整各层权重

在深度学习领域，BP 神经网络被广泛应用于分类、回归、模式识别等任务。

梯度消失是指误差在反向传播过程中逐渐减小，导致浅层网络的权重更新非常缓慢。与之相反，梯度爆炸则是指梯度在反向传播过程中指数级增长，导致权重更新过大。

过拟合是指模型在训练集上表现很好，但在测试集上表现较差。这是由于模型过于复杂，记住了训练数据的噪声而非真实模式。

收敛速度慢是指模型需要经过大量迭代才能达到较好的性能，这会显著增加训练时间。

下面是使用 NumPy 实现的 BP 神经网络代码，包含多种优化技术：

import numpy as np

class NeuralNetwork:
    def __init__(self, layers, learning_rate=0.01, momentum=0.9):
        self.layers = layers
        self.learning_rate = learning_rate
        self.momentum = momentum

        # 初始化权重和偏置
        self.weights = []
        self.biases = []
        self.prev_dw = []  # 用于动量法
        self.prev_db = []

        for i in range(len(layers)-1):
            # Xavier 初始化
            limit = np.sqrt(6 / (layers[i] + layers[i+1]))
            w = np.random.uniform(-limit, limit, (layers[i], layers[i+1]))
            b = np.zeros((1, layers[i+1]))
            self.weights.append(w)
            self.biases.append(b)
            self.prev_dw.append(np.zeros_like(w))
            self.prev_db.append(np.zeros_like(b))

    # ReLU 激活函数
    def relu(self, x):
        return np.maximum(0, x)

    # ReLU 导数
    def relu_derivative(self, x):
        return (x > 0).astype(float)

    # 前向传播
    def forward(self, x):
        self.activations = [x]
        self.z_values = []

        for i in range(len(self.weights)):
            z = np.dot(self.activations[-1], self.weights[i]) + self.biases[i]
            self.z_values.append(z)

            # 最后一层使用线性激活
            if i == len(self.weights)-1:
                a = z
            else:
                a = self.relu(z)

            self.activations.append(a)

        return self.activations[-1]

    # 反向传播
    def backward(self, x, y):
        m = x.shape[0]  # 样本数量

        # 计算输出层误差
        error = self.activations[-1] - y
        delta = error

        # 反向传播
        for i in reversed(range(len(self.weights))):
            # 计算梯度
            dw = np.dot(self.activations[i].T, delta) / m
            db = np.sum(delta, axis=0, keepdims=True) / m

            # 应用动量
            dw = self.momentum * self.prev_dw[i] + (1 - self.momentum) * dw
            db = self.momentum * self.prev_db[i] + (1 - self.momentum) * db

            # 更新权重
            self.weights[i] -= self.learning_rate * dw
            self.biases[i] -= self.learning_rate * db

            # 保存当前梯度用于下一轮动量计算
            self.prev_dw[i] = dw
            self.prev_db[i] = db

            # 如果不是第一层，计算前一层的误差
            if i > 0:
                delta = np.dot(delta, self.weights[i].T) * self.relu_derivative(self.z_values[i-1])

    # 训练函数
    def train(self, x, y, epochs, batch_size=32, verbose=True):
        n_samples = x.shape[0]

        # 学习率衰减
        initial_learning_rate = self.learning_rate

        for epoch in range(epochs):
            # 学习率衰减
            self.learning_rate = initial_learning_rate * (1 / (1 + 0.01 * epoch))

            # 随机打乱数据
            indices = np.random.permutation(n_samples)
            x_shuffled = x[indices]
            y_shuffled = y[indices]

            # 小批量训练
            for i in range(0, n_samples, batch_size):
                x_batch = x_shuffled[i:i+batch_size]
                y_batch = y_shuffled[i:i+batch_size]

                # 前向传播
                self.forward(x_batch)

                # 反向传播
                self.backward(x_batch, y_batch)

            # 打印训练信息
            if verbose and epoch % 100 == 0:
                loss = np.mean(np.square(self.forward(x) - y))
                print(f"Epoch {epoch}, Loss: {loss:.4f}, Learning Rate: {self.learning_rate:.6f}")

# 使用示例
if __name__ == "__main__":
    # 创建一个简单的数据集
    np.random.seed(42)
    X = np.random.rand(1000, 5)
    y = np.sin(X.sum(axis=1)).reshape(-1, 1)

    # 创建并训练网络
    nn = NeuralNetwork(layers=[5, 64, 32, 1], learning_rate=0.01, momentum=0.9)
    nn.train(X, y, epochs=1000, batch_size=32)