Python实现nsag-2代码

NSGA-2（Non-dominated Sorting Genetic Algorithm 2）是一种多目标优化算法，可以用于解决具有多个目标函数的优化问题。下面是一个使用Python实现NSGA-2算法的示例代码：

import random

# 定义目标函数
def obj_func(x):
    f1 = x[0]**2 + x[1]**2
    f2 = (x[0]-1)**2 + x[1]**2
    return [f1, f2]

# 定义个体类
class Individual:
    def __init__(self, x):
        self.x = x
        self.fitness = None
        self.rank = None
        self.crowding_distance = None

# 定义NSGA-2算法
def nsga2(population, n_parents):
    # 计算每个个体的适应度值
    for individual in population:
        individual.fitness = obj_func(individual.x)

    # 计算每个个体的支配集和被支配数
    for individual1 in population:
        individual1.dominated_set = []
        individual1.n_dominated = 0
        for individual2 in population:
            if individual1.fitness != individual2.fitness:
                if dominates(individual1.fitness, individual2.fitness):
                    individual1.dominated_set.append(individual2)
                elif dominates(individual2.fitness, individual1.fitness):
                    individual1.n_dominated += 1

    # 计算每个个体的排名和拥挤距离
    fronts = [[]]
    for individual in population:
        if individual.n_dominated == 0:
            individual.rank = 0
            fronts[0].append(individual)
    i = 0
    while len(fronts[i]) > 0:
        next_front = []
        for individual1 in fronts[i]:
            for individual2 in individual1.dominated_set:
                individual2.n_dominated -= 1
                if individual2.n_dominated == 0:
                    individual2.rank = i+1
                    next_front.append(individual2)
        i += 1
        fronts.append(next_front)
    for front in fronts[:-1]:
        for individual in front:
            individual.crowding_distance = 0
        for obj in range(2):
            front = sorted(front, key=lambda individual: individual.fitness[obj])
            front[0].crowding_distance = float('inf')
            front[-1].crowding_distance = float('inf')
            for i in range(1, len(front)-1):
                front[i].crowding_distance += front[i+1].fitness[obj] - front[i-1].fitness[obj]

    # 选择父代个体
    parents = []
    for i in range(n_parents):
        front = random.choice(fronts[:-1])
        parent = random.choice(front)
        parents.append(parent)

    # 交叉和变异
    offspring = []
    for i in range(n_parents):
        parent1 = parents[i]
        parent2 = parents[(i+1) % n_parents]
        child = Individual([0, 0])
        for j in range(2):
            if random.random() < 0.5:
                child.x[j] = parent1.x[j]
            else:
                child.x[j] = parent2.x[j]
        if random.random() < 0.1:
            child.x[0] += random.gauss(0, 0.1)
        if random.random() < 0.1:
            child.x[1] += random.gauss(0, 0.1)
        offspring.append(child)

    # 合并父代和子代个体
    population.extend(parents)
    population.extend(offspring)

    # 保留前N个个体
    population = sorted(population, key=lambda individual: individual.rank)
    population = population[:n_parents]

    return population

# 判断a是否支配b
def dominates(a, b):
    return all(x1 <= x2 for x1, x2 in zip(a, b)) and any(x1 < x2 for x1, x2 in zip(a, b))

# 初始化种群
population = []
for i in range(100):
    x = [random.uniform(-5, 5), random.uniform(-5, 5)]
    individual = Individual(x)
    population.append(individual)

# 迭代100次
for i in range(100):
    population = nsga2(population, 100)

# 输出结果
for individual in population:
    print(individual.fitness)

该示例代码实现了一个简单的二维优化问题，可以将其扩展到更多维度的问题。