写一个粒子群优化bp 网络的二分类程序

以下是一个使用粒子群优化算法训练BP神经网络进行二分类的Python代码示例：

import numpy as np

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

# 定义BP神经网络类
class BPNetwork:
    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.hidden_weights = np.random.randn(self.input_size, self.hidden_size)
        self.hidden_bias = np.random.randn(self.hidden_size)
        # 初始化输出层权值和偏置
        self.output_weights = np.random.randn(self.hidden_size, self.output_size)
        self.output_bias = np.random.randn(self.output_size)
    
    # 前向传播函数
    def forward(self, X):
        self.hidden_output = sigmoid(np.dot(X, self.hidden_weights) + self.hidden_bias)
        self.output = sigmoid(np.dot(self.hidden_output, self.output_weights) + self.output_bias)
        return self.output
    
    # 后向传播函数
    def backward(self, X, y, learning_rate):
        # 计算输出层误差
        output_error = y - self.output
        output_delta = output_error * self.output * (1 - self.output)
        # 计算隐含层误差
        hidden_error = np.dot(output_delta, self.output_weights.T)
        hidden_delta = hidden_error * self.hidden_output * (1 - self.hidden_output)
        # 更新输出层权值和偏置
        self.output_weights += learning_rate * np.dot(self.hidden_output.T, output_delta)
        self.output_bias += learning_rate * np.sum(output_delta, axis=0)
        # 更新隐含层权值和偏置
        self.hidden_weights += learning_rate * np.dot(X.T, hidden_delta)
        self.hidden_bias += learning_rate * np.sum(hidden_delta, axis=0)
    
    # 预测函数
    def predict(self, X):
        return np.round(self.forward(X))
    
# 定义粒子类
class Particle:
    def __init__(self, position, velocity, network):
        self.position = position
        self.velocity = velocity
        self.network = network
        self.best_position = position
        self.best_fitness = float('inf')
    
    # 评估适应度函数
    def evaluate_fitness(self, X, y):
        fitness = 0
        for i in range(len(X)):
            output = self.network.forward(X[i])
            error = y[i] - output
            fitness += np.sum(error ** 2)
        fitness /= len(X)
        if fitness < self.best_fitness:
            self.best_position = self.position
            self.best_fitness = fitness
        return fitness
    
    # 更新粒子速度和位置函数
    def update(self, global_best_position, omega, phi_p, phi_g):
        r_p = np.random.rand(*self.position.shape)
        r_g = np.random.rand(*self.position.shape)
        self.velocity = omega * self.velocity + phi_p * r_p * (self.best_position - self.position) + phi_g * r_g * (global_best_position - self.position)
        self.position += self.velocity
        self.network.hidden_weights = self.position[:self.network.input_size * self.network.hidden_size].reshape(self.network.input_size, self.network.hidden_size)
        self.network.hidden_bias = self.position[self.network.input_size * self.network.hidden_size:self.network.input_size * self.network.hidden_size + self.network.hidden_size]
        self.network.output_weights = self.position[self.network.input_size * self.network.hidden_size + self.network.hidden_size:self.network.input_size * self.network.hidden_size + self.network.hidden_size + self.network.hidden_size * self.network.output_size].reshape(self.network.hidden_size, self.network.output_size)
        self.network.output_bias = self.position[self.network.input_size * self.network.hidden_size + self.network.hidden_size + self.network.hidden_size * self.network.output_size:]
    
# 定义粒子群优化算法函数
def PSO(X, y, input_size, hidden_size, output_size, num_particles, max_iterations, omega, phi_p, phi_g, learning_rate):
    particles = []
    global_best_fitness = float('inf')
    global_best_position = None
    # 初始化粒子
    for i in range(num_particles):
        network = BPNetwork(input_size, hidden_size, output_size)
        position = np.hstack((network.hidden_weights.flatten(), network.hidden_bias, network.output_weights.flatten(), network.output_bias))
        velocity = np.zeros_like(position)
        particle = Particle(position, velocity, network)
        fitness = particle.evaluate_fitness(X, y)
        if fitness < global_best_fitness:
            global_best_fitness = fitness
            global_best_position = particle.best_position
        particles.append(particle)
    # 迭代优化
    for iteration in range(max_iterations):
        for particle in particles:
            particle.update(global_best_position, omega, phi_p, phi_g)
            fitness = particle.evaluate_fitness(X, y)
            if fitness < global_best_fitness:
                global_best_fitness = fitness
                global_best_position = particle.best_position
        # 使用全局最优位置更新神经网络权值和偏置
        network = BPNetwork(input_size, hidden_size, output_size)
        network.hidden_weights = global_best_position[:input_size * hidden_size].reshape(input_size, hidden_size)
        network.hidden_bias = global_best_position[input_size * hidden_size:input_size * hidden_size + hidden_size]
        network.output_weights = global_best_position[input_size * hidden_size + hidden_size:input_size * hidden_size + hidden_size + hidden_size * output_size].reshape(hidden_size, output_size)
        network.output_bias = global_best_position[input_size * hidden_size + hidden_size + hidden_size * output_size:]
        for i in range(len(X)):
            network.backward(X[i], y[i], learning_rate)
    return network

# 测试
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
network = PSO(X, y, input_size=2, hidden_size=4, output_size=1, num_particles=10, max_iterations=100, omega=0.5, phi_p=0.5, phi_g=0.5, learning_rate=0.1)
print(network.predict(X))

在这个示例中，我们定义了一个BP神经网络类BPNetwork，其中包括前向传播函数forward、后向传播函数backward和预测函数predict。我们还定义了一个粒子类Particle，其中包括评估适应度函数evaluate_fitness和更新粒子速度和位置函数update。最后，我们定义了一个粒子群优化算法函数PSO，它利用多个粒子进行全局搜索，每个粒子表示一个神经网络的权值和偏置。

在这个示例中，我们使用了一个二元分类问题作为测试用例，输入数据X为4个二元组，输出数据y为相应的标签（0或1）。我们使用PSO算法对BP神经网络进行训练，其中包括4个隐含层节点，10个粒子，100次迭代，学习率为0.1。最后，我们打印出模型对输入数据的预测结果。