用Python手把手复现NSGA-II算法：从理论到代码实战（附完整源码）

NSGA-II多目标优化Python实现

于 2026-05-28 12:46:44 修改

·本内容遵循CC 4.0 BY-SA版权协议

用Python手把手实现NSGA-II算法：从零构建多目标优化核心框架

当我们需要同时优化多个相互冲突的目标时，传统单目标优化方法往往束手无策。想象一下设计一款新能源汽车：我们希望电池续航最长、充电时间最短、成本最低——这些目标之间天然存在矛盾。这正是多目标优化算法大显身手的场景，而NSGA-II作为该领域的标杆算法，以其高效的排序机制和精英保留策略，成为工程实践中的首选工具。

本文将带您从零开始构建NSGA-II的完整Python实现，不仅呈现可运行的代码，更会深入剖析每个模块的设计原理。我们将重点解决算法实现中的三个关键挑战：如何高效排序解的质量（快速非支配排序）、如何保持解的多样性（拥挤度计算）、如何保留优秀基因（精英策略）。通过可视化ZDT1测试函数的优化过程，您将直观看到Pareto前沿是如何逐步形成的。

1. 环境搭建与基础架构设计

1.1 个体编码与种群初始化

任何进化算法的基础都是对个体的合理表示。我们首先定义Individual类，它不仅要存储决策变量，还需要维护算法运行所需的各种元数据：

PYTHON

import numpy as np

from collections import defaultdict

class Individual:

def __init__(self, dimension=30):

self.solution = np.random.rand(dimension) # 决策变量

self.objectives = defaultdict(float) # 目标函数值

self.rank = np.inf # 非支配层级

self.domination_count = 0 # 支配当前解的个体数

self.dominated_solutions = [] # 被当前解支配的个体

self.crowding_distance = 0 # 拥挤度距离

def evaluate(self, objective_func):

"""评估个体并计算所有目标函数值"""

self.objectives = objective_func(self.solution)

关键设计要点：

使用numpy数组存储决策变量便于向量化运算
objectives采用字典结构方便扩展多目标场景
预置算法运行所需的全部属性字段

1.2 种群初始化与边界处理

创建初始种群时，我们需要考虑变量边界约束。这里实现一个边界处理装饰器：

PYTHON

def bound_check(min_val=0, max_val=1):

def decorator(func):

def wrapper(*args, **kwargs):

individual = func(*args, **kwargs)

individual.solution = np.clip(individual.solution, min_val, max_val)

return individual

return wrapper

return decorator

@bound_check(min_val=0, max_val=1)

def create_individual(dim):

return Individual(dimension=dim)

这种设计将边界约束逻辑与个体创建解耦，后续可以灵活调整约束条件而不影响核心代码。

2. 快速非支配排序实现

2.1 支配关系判定

NSGA-II的核心在于快速区分解的优劣等级。我们首先实现支配关系判断：

PYTHON

def dominates(a, b):

"""判断个体a是否支配个体b"""

# a在所有目标上都不差于b

not_worse = all(a.objectives[k] <= b.objectives[k] for k in a.objectives)

# a至少在一个目标上严格优于b

strictly_better = any(a.objectives[k] < b.objectives[k] for k in a.objectives)

return not_worse and strictly_better

2.2 分层排序算法

基于支配关系，实现O(mN²)复杂度的快速非支配排序：

PYTHON

def fast_non_dominated_sort(population):

frontiers = defaultdict(list)

# 第一遍遍历计算支配关系

for p in population:

for q in population:

if dominates(p, q):

p.dominated_solutions.append(q)

elif dominates(q, p):

p.domination_count += 1

if p.domination_count == 0:

p.rank = 1

frontiers[1].append(p)

# 分层扩展

i = 1

while frontiers[i]:

next_front = []

for p in frontiers[i]:

for q in p.dominated_solutions:

q.domination_count -= 1

if q.domination_count == 0:

q.rank = i + 1

next_front.append(q)

i += 1

if next_front:

frontiers[i] = next_front

return frontiers

注意：实际工程中可以考虑使用更高效的并行化实现，特别是处理大规模种群时。

3. 多样性保持机制

3.1 拥挤度计算

为了保证解在Pareto前沿上分布均匀，我们需要计算每个解的拥挤度：

PYTHON

def crowding_distance_assignment(front):

"""计算同一非支配层中个体的拥挤度距离"""

if not front:

return

# 初始化所有个体的拥挤距离

for ind in front:

ind.crowding_distance = 0

# 对每个目标分别计算

for obj_idx in front[0].objectives.keys():

# 按当前目标函数值排序

front.sort(key=lambda x: x.objectives[obj_idx])

# 边界个体获得无限大拥挤度

front[0].crowding_distance = float('inf')

front[-1].crowding_distance = float('inf')

# 归一化目标值

min_obj = front[0].objectives[obj_idx]

max_obj = front[-1].objectives[obj_idx]

norm = max_obj - min_obj if max_obj != min_obj else 1

# 计算中间个体的拥挤度

for i in range(1, len(front)-1):

front[i].crowding_distance += (

front[i+1].objectives[obj_idx] -

front[i-1].objectives[obj_idx]

) / norm

3.2 精英选择策略

结合非支配等级和拥挤度进行选择：

PYTHON

def elitist_selection(population, offspring, pop_size):

"""精英保留策略"""

combined = population + offspring

frontiers = fast_non_dominated_sort(combined)

new_pop = []

i = 1

while len(new_pop) + len(frontiers[i]) <= pop_size:

new_pop.extend(frontiers[i])

i += 1

# 如果当前前沿不能全部加入，按拥挤度排序选择

if len(new_pop) < pop_size:

remaining = pop_size - len(new_pop)

frontiers[i].sort(key=lambda x: -x.crowding_distance)

new_pop.extend(frontiers[i][:remaining])

return new_pop

4. 遗传算子实现

4.1 模拟二进制交叉(SBX)

PYTHON

def sbx_crossover(parent1, parent2, eta=1):

"""模拟二进制交叉"""

dim = len(parent1.solution)

child1 = Individual(dim)

child2 = Individual(dim)

for i in range(dim):

u = np.random.random()

if u <= 0.5:

beta = (2*u)**(1/(eta+1))

else:

beta = (1/(2*(1-u)))**(1/(eta+1))

child1.solution[i] = 0.5*(

(1+beta)*parent1.solution[i] +

(1-beta)*parent2.solution[i]

)

child2.solution[i] = 0.5*(

(1-beta)*parent1.solution[i] +

(1+beta)*parent2.solution[i]

)

return child1, child2

4.2 多项式变异

PYTHON

def polynomial_mutation(individual, eta=1, mutation_prob=0.1):

"""多项式变异算子"""

mutated = Individual(len(individual.solution))

mutated.solution = individual.solution.copy()

for i in range(len(mutated.solution)):

if np.random.random() < mutation_prob:

u = np.random.random()

if u < 0.5:

delta = (2*u)**(1/(eta+1)) - 1

else:

delta = 1 - (2*(1-u))**(1/(eta+1))

mutated.solution[i] += delta

return mutated

5. 完整算法流程与可视化

5.1 主循环实现

PYTHON

def nsga2(params):

"""NSGA-II主算法"""

population = [create_individual(params['dim']) for _ in range(params['pop_size'])]

for ind in population:

ind.evaluate(params['obj_func'])

for gen in range(params['max_gen']):

# 选择父代(二元锦标赛)

parents = []

for _ in range(params['pop_size']):

a, b = np.random.choice(population, 2, replace=False)

parents.append(a if a.rank < b.rank or

(a.rank == b.rank and

a.crowding_distance > b.crowding_distance) else b)

# 生成子代

offspring = []

for i in range(0, params['pop_size'], 2):

p1, p2 = parents[i], parents[i+1]

c1, c2 = sbx_crossover(p1, p2, params['eta'])

c1 = polynomial_mutation(c1, params['eta'])

c2 = polynomial_mutation(c2, params['eta'])

c1.evaluate(params['obj_func'])

c2.evaluate(params['obj_func'])

offspring.extend([c1, c2])

# 精英选择

population = elitist_selection(population, offspring, params['pop_size'])

# 可视化当前前沿

if gen % 10 == 0:

plot_front(population, gen)

return population

5.2 测试函数与可视化

实现经典的ZDT1测试函数：

PYTHON

def zdt1(x):

"""ZDT1测试函数"""

f1 = x[0]

g = 1 + 9 * np.sum(x[1:]) / (len(x)-1)

f2 = g * (1 - np.sqrt(f1/g))

return {1: f1, 2: f2}

def plot_front(population, generation):

"""绘制Pareto前沿"""

plt.figure(figsize=(8,6))

f1 = [ind.objectives[1] for ind in population if ind.rank == 1]

f2 = [ind.objectives[2] for ind in population if ind.rank == 1]

plt.scatter(f1, f2, c='red', s=30, edgecolors='grey')

plt.title(f'Generation {generation}')

plt.xlabel('Objective 1')

plt.ylabel('Objective 2')

plt.grid(True)

plt.show()

6. 参数调优与实战建议

6.1 关键参数设置

根据实践经验，推荐以下参数范围：

参数	推荐值	作用
种群大小	50-200	平衡计算开销和多样性
交叉概率	0.8-1.0	控制基因重组频率
变异概率	1/dim	与变量维度相关
分布指数η	10-30	控制交叉和变异的强度

6.2 常见问题排查

收敛过早：
- 增加种群大小
- 提高变异概率
- 减小η值增强探索能力
分布不均匀：
- 检查拥挤度计算是否正确
- 确保边界个体被保留
- 尝试自适应η值策略
计算效率低：
- 采用快速非支配排序实现
- 考虑使用Numba加速
- 对大规模问题使用参考点方法

PYTHON

# 典型参数配置示例

params = {

'pop_size': 100,

'max_gen': 200,

'dim': 30,

'eta': 20,

'obj_func': zdt1,

'cx_prob': 0.9,

'mut_prob': 1/30

}

7. 算法扩展与工程应用

7.1 约束处理技术

实际工程问题常带有约束条件，可通过以下方式扩展：

PYTHON

def constrained_domination(a, b):

"""带约束的支配关系判断"""

# 约束违反程度

a_violation = sum(max(0, c) for c in a.constraints)

b_violation = sum(max(0, c) for c in b.constraints)

# 规则1：可行解支配不可行解

if a_violation == 0 and b_violation > 0:

return True

if b_violation == 0 and a_violation > 0:

return False

# 规则2：两个不可行解，违反程度小的获胜

if a_violation > 0 and b_violation > 0:

return a_violation < b_violation

# 规则3：两个可行解，按原始支配关系判断

return dominates(a, b)

7.2 高维目标优化

当目标维度超过3个时，传统拥挤度度量可能失效，可改用：

PYTHON

def reference_point_approach(front, num_ref_points=10):

"""基于参考点的多样性保持"""

# 生成均匀分布的参考点

ref_points = np.random.dirichlet(np.ones(len(front[0].objectives)), num_ref_points)

# 关联个体到最近参考点

for ind in front:

objectives = np.array(list(ind.objectives.values()))

ind.ref_distance = [np.linalg.norm(objectives - p) for p in ref_points]

ind.assigned_ref = np.argmin(ind.ref_distance)

# 计算参考点拥挤度

ref_counts = np.zeros(num_ref_points)

for ind in front:

ref_counts[ind.assigned_ref] += 1

# 分配适应度

for ind in front:

ind.crowding_distance = 1 / (1 + ref_counts[ind.assigned_ref])

在真实项目中应用NSGA-II时，我发现算法的表现高度依赖于问题特性。对于复杂的多峰优化问题，可能需要将种群大小增加到300以上才能获得满意的Pareto前沿。另一个实用技巧是采用自适应参数策略——在早期迭代中使用较大的变异强度增强探索，在后期则减小变异强度以精细调优。