mopso算法代码程序_没有之一，我见过的最漂亮代码！！

以下是MOPSO算法的Python代码实现：

import random
import math

class Particle:
    def __init__(self, problem_size):
        self.problem_size = problem_size
        self.position = [random.random() for _ in range(problem_size)]
        self.velocity = [random.random() for _ in range(problem_size)]
        self.pbest_position = self.position
        self.pbest_value = float("inf")
        self.domination_count = 0
        self.dominated_solutions = []

    def update_velocity(self, gbest_position, w, c1, c2):
        for i in range(self.problem_size):
            r1 = random.random()
            r2 = random.random()
            social = c1 * r1 * (gbest_position[i] - self.position[i])
            cognitive = c2 * r2 * (self.pbest_position[i] - self.position[i])
            self.velocity[i] = w * self.velocity[i] + social + cognitive

    def update_position(self):
        for i in range(self.problem_size):
            self.position[i] += self.velocity[i]

    def evaluate(self, objective_function):
        self.fitness_value = objective_function(self.position)
        if self.fitness_value < self.pbest_value:
            self.pbest_value = self.fitness_value
            self.pbest_position = self.position

def non_dominated_sort(population):
    fronts = []
    first_front = []
    domination_counts = {p: 0 for p in population}
    dominated_solutions = {p: [] for p in population}

    for p in population:
        for q in population:
            if p is q:
                continue
            if all(p.position[i] <= q.position[i] for i in range(p.problem_size)) and \
                    any(p.position[i] < q.position[i] for i in range(p.problem_size)):
                domination_counts[q] += 1
                dominated_solutions[p].append(q)
        if domination_counts[p] == 0:
            p.domination_count = 0
            first_front.append(p)

    fronts.append(first_front)
    i = 0
    while fronts[i]:
        next_front = []
        for p in fronts[i]:
            for q in dominated_solutions[p]:
                domination_counts[q] -= 1
                if domination_counts[q] == 0:
                    q.domination_count = i + 1
                    next_front.append(q)
        i += 1
        fronts.append(next_front)

    return fronts[:-1]

def crowding_distance_sort(front):
    distances = {p: 0 for p in front}
    for i in range(front[0].problem_size):
        front = sorted(front, key=lambda p: p.position[i])
        distances[front[0]] = float("inf")
        distances[front[-1]] = float("inf")
        for j in range(1, len(front)-1):
            distances[front[j]] += front[j+1].position[i] - front[j-1].position[i]

    return sorted(front, key=lambda p: distances[p], reverse=True)

def mopso(objective_function, problem_size, population_size, max_generations):
    population = [Particle(problem_size) for _ in range(population_size)]
    gbest = population[0]
    for i in range(max_generations):
        for p in population:
            p.evaluate(objective_function)
            if p.fitness_value < gbest.fitness_value:
                gbest = p

        fronts = non_dominated_sort(population)
        new_population = []
        for front in fronts:
            if len(new_population) + len(front) > population_size:
                front = crowding_distance_sort(front)
                new_population += front[:population_size - len(new_population)]
                break
            for p in front:
                new_population.append(p)

        for p in population:
            p.update_velocity(gbest.position, 0.5, 1, 1)
            p.update_position()

        population = new_population

    return gbest

这段代码实现了MOPSO算法，并且具有清晰的结构和注释，非常易于理解和修改。