构建多层 BP 神经网络：Python 代码指南

2023-12-28 00:09:32

引言

构建多层 BP（反向传播）神经网络是机器学习和神经网络领域的关键任务。BP 神经网络因其在解决复杂非线性问题方面的卓越能力而广受欢迎，从图像识别到自然语言处理不一而足。本文将指导您使用 Python 构建多层 BP 神经网络，从两层结构开始，逐步升级至更深层次的架构。

建立基础：两层 BP 神经网络

首先，让我们从最简单的两层 BP 神经网络开始。它由一个输入层、一个隐藏层和一个输出层组成。输入层接收数据，隐藏层处理数据，输出层产生预测。

import numpy as np

class TwoLayerBPNetwork:

    def __init__(self, input_size, hidden_size, output_size):
        # 定义权重和偏置
        self.w1 = np.random.randn(input_size, hidden_size)
        self.b1 = np.zeros((1, hidden_size))
        self.w2 = np.random.randn(hidden_size, output_size)
        self.b2 = np.zeros((1, output_size))

    def forward_pass(self, X):
        # 前向传播
        z1 = X.dot(self.w1) + self.b1
        a1 = np.tanh(z1)
        z2 = a1.dot(self.w2) + self.b2
        a2 = np.tanh(z2)
        return a2

    def backward_pass(self, X, Y, a2):
        # 反向传播
        d2 = (a2 - Y) * (1 - a2**2)
        d1 = (d2.dot(self.w2.T)) * (1 - a1**2)
        dw1 = X.T.dot(d1)
        db1 = np.sum(d1, axis=0)
        dw2 = a1.T.dot(d2)
        db2 = np.sum(d2, axis=0)
        return dw1, db1, dw2, db2

    def update_weights(self, dw1, db1, dw2, db2, learning_rate):
        # 更新权重
        self.w1 -= learning_rate * dw1
        self.b1 -= learning_rate * db1
        self.w2 -= learning_rate * dw2
        self.b2 -= learning_rate * db2

    def train(self, X, Y, epochs, learning_rate):
        # 训练模型
        for i in range(epochs):
            a2 = self.forward_pass(X)
            dw1, db1, dw2, db2 = self.backward_pass(X, Y, a2)
            self.update_weights(dw1, db1, dw2, db2, learning_rate)

# 使用示例
network = TwoLayerBPNetwork(2, 4, 1)
X = np.array([[1, 2], [3, 4]])
Y = np.array([[0], [1]])
network.train(X, Y, 1000, 0.01)

扩展至多层架构

为了构建多层 BP 神经网络，我们将遵循以下步骤：

增加隐藏层： 在隐藏层之间添加额外的隐藏层，以增加网络的复杂性和学习能力。
修改前向传播： 将前向传播过程扩展到新添加的隐藏层。
调整反向传播： 修改反向传播算法以计算所有隐藏层的梯度。
优化权重： 使用梯度下降算法更新所有权重和偏置。

Python 代码示例：

class MultiLayerBPNetwork:

    def __init__(self, layer_sizes):
        # 定义层大小
        self.layer_sizes = layer_sizes
        # 随机初始化权重和偏置
        self.weights = [np.random.randn(l1, l2) for l1, l2 in zip(layer_sizes[:-1], layer_sizes[1:])]
        self.biases = [np.zeros((1, l)) for l in layer_sizes[1:]]

    def forward_pass(self, X):
        # 前向传播
        for w, b in zip(self.weights, self.biases):
            X = np.tanh(X.dot(w) + b)
        return X

    def backward_pass(self, X, Y, a):
        # 反向传播
        grads = []
        # 计算输出层梯度
        d = (a - Y) * (1 - a**2)
        grads.append((d.dot(self.weights[-1].T), np.sum(d, axis=0)))
        # 计算隐藏层梯度
        for l in range(len(self.weights) - 2, 0, -1):
            d = (d.dot(self.weights[l + 1].T)) * (1 - a[l]**2)
            grads.append((d.dot(self.weights[l].T), np.sum(d, axis=0)))
        # 反转梯度顺序
        grads = list(reversed(grads))
        return grads

    def update_weights(self, grads, learning_rate):
        # 更新权重
        for i, (dw, db) in enumerate(grads):
            self.weights[i] -= learning_rate * dw
            self.biases[i] -= learning_rate * db

    def train(self, X, Y, epochs, learning_rate):
        # 训练模型
        for i in range(epochs):
            a = self.forward_pass(X)
            grads = self.backward_pass(X, Y, a)
            self.update_weights(grads, learning_rate)

# 使用示例
network = MultiLayerBPNetwork([2, 4, 3, 1])
X = np.array([[1, 2], [3, 4]])
Y = np.array([[0], [1]])
network.train(X, Y, 1000, 0.01)