多目标粒子群优化算法的代码

以下是多目标粒子群优化算法的Python代码实现：

import random

class Particle:
    def __init__(self, dim, bounds):
        self.position = [random.uniform(bounds[i][0], bounds[i][1]) for i in range(dim)]
        self.velocity = [0.0 for i in range(dim)]
        self.best_position = self.position[:]
        self.best_fitness = float('inf')
        self.fitness = [0.0 for i in range(2)]
    
    def evaluate(self, evaluate_func):
        self.fitness = evaluate_func(self.position)
        if self.fitness[0] < self.best_fitness:
            self.best_fitness = self.fitness[0]
            self.best_position = self.position[:]
    
    def update_velocity(self, gbest, w, c1, c2):
        for i in range(len(self.velocity)):
            r1, r2 = random.random(), random.random()
            cognitive = c1 * r1 * (self.best_position[i] - self.position[i])
            social = c2 * r2 * (gbest[i] - self.position[i])
            self.velocity[i] = w * self.velocity[i] + cognitive + social
    
    def update_position(self, bounds):
        for i in range(len(self.position)):
            self.position[i] += self.velocity[i]
            if self.position[i] < bounds[i][0]:
                self.position[i] = bounds[i][0]
                self.velocity[i] = 0.0
            elif self.position[i] > bounds[i][1]:
                self.position[i] = bounds[i][1]
                self.velocity[i] = 0.0

class MultiObjectivePSO:
    def __init__(self, n_particles, dim, bounds, evaluate_func, w=0.7, c1=1.4, c2=1.4):
        self.n_particles = n_particles
        self.dim = dim
        self.bounds = bounds
        self.evaluate_func = evaluate_func
        self.w = w
        self.c1 = c1
        self.c2 = c2
        self.particles = [Particle(dim, bounds) for i in range(n_particles)]
        self.gbest = self.particles[0].position[:]
        self.gbest_fitness = [float('inf') for i in range(2)]
    
    def optimize(self, n_iter):
        for i in range(n_iter):
            for particle in self.particles:
                particle.evaluate(self.evaluate_func)
                if particle.fitness[1] < self.gbest_fitness[1]:
                    self.gbest = particle.position[:]
                    self.gbest_fitness = particle.fitness[:]
            for particle in self.particles:
                particle.update_velocity(self.gbest, self.w, self.c1, self.c2)
                particle.update_position(self.bounds)
    
    def get_particles(self):
        return [particle.position for particle in self.particles]
    
    def get_gbest(self):
        return self.gbest
    
    def get_gbest_fitness(self):
        return self.gbest_fitness

使用方法：

1. 定义目标函数，例如：

def evaluate_func(position):
    x = position[0]
    y = position[1]
    f1 = x**2 + y**2
    f2 = (x-1)**2 + y**2
    return [f1, f2]

2. 创建MultiObjectivePSO对象，并调用optimize方法进行优化，例如：

n_particles = 50
dim = 2
bounds = [(-5, 5), (-5, 5)]
pso = MultiObjectivePSO(n_particles, dim, bounds, evaluate_func)
pso.optimize(100)

3. 获取优化结果，例如：

particles = pso.get_particles()
gbest = pso.get_gbest()
gbest_fitness = pso.get_gbest_fitness()