生成BP神经网络优化粒子群代码

以下是一个简单的基于粒子群优化的BP神经网络训练代码实现，你可以根据自己的需求进行修改和优化。

import numpy as np

#定义BP神经网络模型类
class BPNN(object):
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化神经网络参数
        self.input_size = input_size  # 输入层大小
        self.hidden_size = hidden_size  # 隐藏层大小
        self.output_size = output_size  # 输出层大小

        self.W1 = np.random.randn(self.input_size, self.hidden_size)  # 输入层到隐藏层的权重矩阵
        self.b1 = np.zeros((1, self.hidden_size))  # 隐藏层偏置项
        self.W2 = np.random.randn(self.hidden_size, self.output_size)  # 隐藏层到输出层的权重矩阵
        self.b2 = np.zeros((1, self.output_size))  # 输出层偏置项

    # 定义sigmoid激活函数
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    # 定义前向传播函数
    def forward(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1  # 隐藏层输入
        self.a1 = self.sigmoid(self.z1)  # 隐藏层输出
        self.z2 = np.dot(self.a1, self.W2) + self.b2  # 输出层输入
        self.y_hat = self.sigmoid(self.z2)  # 输出层输出
        return self.y_hat

    # 定义代价函数
    def cost(self, X, y):
        self.y_hat = self.forward(X)
        J = 0.5 * np.sum((y - self.y_hat) ** 2)
        return J

    # 定义反向传播函数
    def backward(self, X, y):
        self.y_hat = self.forward(X)

        delta3 = np.multiply(-(y - self.y_hat), self.sigmoid(self.z2) * (1 - self.sigmoid(self.z2)))
        dW2 = np.dot(self.a1.T, delta3)
        db2 = np.sum(delta3, axis=0, keepdims=True)

        delta2 = np.dot(delta3, self.W2.T) * self.sigmoid(self.z1) * (1 - self.sigmoid(self.z1))
        dW1 = np.dot(X.T, delta2)
        db1 = np.sum(delta2, axis=0)

        return dW1, db1, dW2, db2

# 定义优化器类
class ParticleSwarmOptimizer(object):
    def __init__(self, cost_func, num_particles, input_size, hidden_size, output_size, max_iter=100, inertia_weight=0.729, cognitive_weight=1.49445, social_weight=1.49445):
        self.cost_func = cost_func  # 代价函数
        self.num_particles = num_particles  # 粒子数
        self.input_size = input_size  # 输入层大小
        self.hidden_size = hidden_size  # 隐藏层大小
        self.output_size = output_size  # 输出层大小

        self.max_iter = max_iter  # 最大迭代次数
        self.inertia_weight = inertia_weight  # 惯性权重
        self.cognitive_weight = cognitive_weight  # 个体认知权重
        self.social_weight = social_weight  # 群体社会权重

        self.particles = []  # 粒子数组
        self.velocities = []  # 速度数组
        self.pbest_positions = []  # 粒子历史最优位置数组
        self.pbest_scores = []  # 粒子历史最优得分数组
        self.gbest_position = None  # 群体历史最优位置
        self.gbest_score = float('inf')  # 群体历史最优得分

        # 初始化粒子和速度
        for i in range(self.num_particles):
            nn = BPNN(self.input_size, self.hidden_size, self.output_size)  # 初始化神经网络模型
            self.particles.append(nn)
            self.velocities.append((np.random.randn(nn.W1.shape[0], nn.W1.shape[1]), np.random.randn(nn.W2.shape[0], nn.W2.shape[1])))

            # 初始化粒子历史最优得分和位置
            score = self.cost_func(X, y)
            self.pbest_scores.append(score)
            self.pbest_positions.append((nn.W1.copy(), nn.b1.copy(), nn.W2.copy(), nn.b2.copy()))

            # 初始化群体历史最优得分和位置
            if score < self.gbest_score:
                self.gbest_score = score
                self.gbest_position = (nn.W1.copy(), nn.b1.copy(), nn.W2.copy(), nn.b2.copy())

    # 定义粒子群优化算法
    def optimize(self, X, y):
        for iter in range(self.max_iter):
            for i in range(self.num_particles):
                nn = self.particles[i]
                velocity = self.velocities[i]

                # 计算新的速度
                new_velocity = (
                    self.inertia_weight * velocity[0] +
                    self.cognitive_weight * np.random.rand() * (self.pbest_positions[i][0] - nn.W1) +
                    self.social_weight * np.random.rand() * (self.gbest_position[0] - nn.W1),

                    self.inertia_weight * velocity[1] +
                    self.cognitive_weight * np.random.rand() * (self.pbest_positions[i][2] - nn.W2) +
                    self.social_weight * np.random.rand() * (self.gbest_position[2] - nn.W2)
                )

                # 更新权重矩阵和偏置项
                nn.W1 += new_velocity[0]
                nn.b1 += new_velocity[0]
                nn.W2 += new_velocity[1]
                nn.b2 += new_velocity[1]

                # 计算代价函数得分
                score = self.cost_func(X, y)

                # 更新粒子历史最优得分和位置
                if score < self.pbest_scores[i]:
                    self.pbest_scores[i] = score
                    self.pbest_positions[i] = (nn.W1.copy(), nn.b1.copy(), nn.W2.copy(), nn.b2.copy())

                    # 更新群体历史最优得分和位置
                    if score < self.gbest_score:
                        self.gbest_score = score
                        self.gbest_position = (nn.W1.copy(), nn.b1.copy(), nn.W2.copy(), nn.b2.copy())

            print('Iteration:', iter, 'Cost:', self.gbest_score)

# 生成训练数据
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

# 初始化优化器
optimizer = ParticleSwarmOptimizer(cost_func=BPNN(X.shape[1], 4, y.shape[1]).cost, num_particles=10, input_size=X.shape[1], hidden_size=4, output_size=y.shape[1])

# 进行模型训练
optimizer.optimize(X, y)

需要注意的是，本代码实现仅供参考，具体实现方式可能因人而异，你需要根据自己的需求进行修改和优化。