1
problem = MyProblem()                              # 写清题目。
2
population = ea.Population(Encoding="RI", NIND=60) # 60 个候选方案。
3
algorithm = ea.soea_SGA_templet(problem, population, MAXGEN=100)
4
result = ea.optimize(algorithm, seed=42, drawing=0, saveFlag=False)

1
# 这是评价函数内部的片段：每行一个方案，每列一个变量。
2
v = Vars[:, 0]
3
d = Vars[:, 1]
4

5
# 单目标必须返回二维矩阵 (N, 1)，而不是一维数组 (N,)。
6
ObjV = ((v - 8) ** 2 + (d - 10) ** 2).reshape(-1, 1)
7

8
# 若保留两个独立目标，则每个目标占一列，形状为 (N, 2)。
9
ObjV_multi = np.column_stack([(v - 8) ** 2, (d - 10) ** 2])

1
CV = np.column_stack([energy - 50.0, 6.0 - stand_off])
2
# 在 evalVars 内返回两个矩阵：目标值和约束值。
3
# return ObjV, CV

1
population = ea.Population(Encoding="RI", NIND=60)

1
import geatpy as ea
2
import numpy as np
3

4

5
class IntegerProblem(ea.Problem):
6
    def __init__(self):
7
        super().__init__(name="IntegerDemo", M=1, maxormins=[1], Dim=1,
8
                         varTypes=[1], lb=[0], ub=[10], lbin=[1], ubin=[1])
9

10
    def evalVars(self, Vars):
11
        x = Vars[:, [0]]  # 双层索引保留 (N,1) 形状。
12
        return (x - 3) ** 2  # 无额外约束，只返回目标矩阵。
13

14

15
problem = IntegerProblem()
16
population = ea.Population(Encoding="RI", NIND=40)
17
algorithm = ea.soea_SGA_templet(problem, population, MAXGEN=80, logTras=10)
18
result = ea.optimize(algorithm, seed=42, drawing=0, verbose=False,
19
                     outputMsg=False, drawLog=False, saveFlag=False)
20
if result["Vars"] is None or len(result["Vars"]) == 0:
21
    raise RuntimeError("未找到可行结果，请检查问题定义和搜索预算")
22
print("找到的 x:", result["Vars"][0])
23
print("目标值:", result["ObjV"][0])

1
import geatpy as ea
2
import numpy as np
3

4

5
class ConstrainedProblem(ea.Problem):
6
    def __init__(self):
7
        super().__init__(name="ConstrainedDemo", M=1, maxormins=[1], Dim=2,
8
                         varTypes=[0, 0], lb=[0, 0], ub=[5, 5],
9
                         lbin=[1, 1], ubin=[1, 1])
10

11
    def evalVars(self, Vars):
12
        x, y = Vars[:, [0]], Vars[:, [1]]
13
        ObjV = (x - 1) ** 2 + (y - 2) ** 2
14
        CV = 5 - x - y  # x+y>=5 等价于 5-x-y<=0。
15
        return ObjV, CV
16

17

18
problem = ConstrainedProblem()
19
population = ea.Population(Encoding="RI", NIND=60)
20
algorithm = ea.soea_DE_rand_1_bin_templet(problem, population,
21
                                       MAXGEN=200, logTras=20)
22
algorithm.mutOper.F = 0.5     # 差分步长系数。
23
algorithm.recOper.XOVR = 0.7  # DE 的交叉概率 CR。
24
result = ea.optimize(algorithm, seed=42, drawing=0, verbose=False,
25
                     outputMsg=False, drawLog=False, saveFlag=False)
26
if result["Vars"] is None or len(result["Vars"]) == 0:
27
    raise RuntimeError("本次没有找到可行解")
28
best = result["Vars"][0]
29
ObjV, CV = problem.evalVars(best.reshape(1, -1))
30
print("x,y:", best)
31
print("目标值:", ObjV[0, 0])
32
print("约束左边（<=0 为可行）:", CV[0, 0])
33
assert CV[0, 0] <= 1e-8

1
import numpy as np
2

3
SEED = 42
4
N_PARTICLES = 40
5
ITERATIONS = 150
6
rng = np.random.default_rng(SEED)
7
lower = np.array([0.0, 0.0])
8
upper = np.array([5.0, 5.0])
9

10

11
def objective(positions):
12
    # 每行是一组 [x,y]，每个粒子得到一个需要最小化的目标值。
13
    return (positions[:, 0] - 1) ** 2 + (positions[:, 1] - 2) ** 2
14

15

16
positions = rng.uniform(lower, upper, size=(N_PARTICLES, 2))
17
velocities = rng.uniform(-0.5, 0.5, size=positions.shape)
18
personal_best = positions.copy()
19
personal_scores = objective(personal_best)
20
global_best = personal_best[np.argmin(personal_scores)].copy()
21

22
for _ in range(ITERATIONS):
23
    r1 = rng.random(positions.shape)
24
    r2 = rng.random(positions.shape)
25
    velocities = (0.7 * velocities
26
                  + 1.5 * r1 * (personal_best - positions)
27
                  + 1.5 * r2 * (global_best - positions))
28
    # 限制搜索步长；这不是对无人机的物理限速。
29
    velocities = np.clip(velocities, -1.0, 1.0)
30
    proposed = positions + velocities
31
    # 截回边界，同时清零撞到边界的速度分量。
32
    hit_boundary = (proposed < lower) | (proposed > upper)
33
    positions = np.clip(proposed, lower, upper)
34
    velocities[hit_boundary] = 0.0
35

36
    scores = objective(positions)
37
    improved = scores < personal_scores
38
    personal_best[improved] = positions[improved]
39
    personal_scores[improved] = scores[improved]
40
    global_best = personal_best[np.argmin(personal_scores)].copy()
41

42
print("PSO 找到的 x,y:", global_best)
43
print("目标值:", objective(global_best.reshape(1, -1))[0])

1
import geatpy as ea
2
import numpy as np
3

4

5
class TradeoffProblem(ea.Problem):
6
    def __init__(self, constrained=False):
7
        self.constrained = constrained
8
        super().__init__(name="TradeoffDemo", M=2, maxormins=[1, 1], Dim=1,
9
                         varTypes=[0], lb=[0], ub=[4], lbin=[1], ubin=[1])
10

11
    def evalVars(self, Vars):
12
        x = Vars[:, [0]]
13
        ObjV = np.hstack([x ** 2, (x - 4) ** 2])  # 两个目标占两列。
14
        if self.constrained:
15
            CV = np.hstack([1 - x, x - 3])       # 1<=x<=3。
16
            return ObjV, CV
17
        return ObjV
18

19

20
problem = TradeoffProblem(constrained=True)  # 改为 False 即无额外约束。
21
population = ea.Population(Encoding="RI", NIND=80)
22
algorithm = ea.moea_NSGA2_templet(problem, population, MAXGEN=150, logTras=20)
23
result = ea.optimize(algorithm, seed=42, drawing=0, verbose=False,
24
                     outputMsg=False, drawLog=False, saveFlag=False)
25
if result["Vars"] is None or len(result["Vars"]) == 0:
26
    raise RuntimeError("本次没有得到可行的非支配解")
27
order = np.argsort(result["Vars"][:, 0])
28
print("展示按 x 排序的部分折中解（x, f1, f2）：")
29
for index in order[::max(1, len(order) // 8)]:
30
    print(result["Vars"][index, 0], *result["ObjV"][index])

1
problem = TradeoffProblem(constrained=False)
2
population = ea.Population(Encoding="RI", NIND=80)
3
algorithm = ea.moea_MOEAD_templet(problem, population, MAXGEN=150, logTras=20)
4
result = ea.optimize(algorithm, seed=42, drawing=0, verbose=False,
5
                     outputMsg=False, drawLog=False, saveFlag=False)
6
if result["Vars"] is None or len(result["Vars"]) == 0:
7
    raise RuntimeError("本次没有得到可行的非支配解")
8
order = np.argsort(result["Vars"][:, 0])
9
for index in order[::max(1, len(order) // 8)]:
10
    print(result["Vars"][index, 0], *result["ObjV"][index])

1
import numpy as np
2

3

4
# 固定随机种子，保证重复运行时得到相同结果，便于比较和排错。
5
SEED = 42
6
POPULATION_SIZE = 80   # 每一代同时保留的候选方案数量
7
GENERATIONS = 150      # 进化轮数
8
MUTATION_RATE = 0.10   # 每个决策变量独立发生变异的概率
9

10
# 以下参数只用于说明算法，不是真实机型的飞行或安全参数。
11
MISSION_DISTANCE = 6_000.0      # 总航程，单位 m
12
INSPECTION_POINTS = 12          # 需要悬停拍摄的杆塔数量
13
BATTERY_LIMIT = 50.0            # 任务可用能量，单位 Wh
14

15
# 染色体含两个连续基因：[巡航速度(m/s), 与目标的作业距离(m)]。
16
LOWER = np.array([4.0, 5.0])
17
UPPER = np.array([12.0, 15.0])
18

19
rng = np.random.default_rng(SEED)
20

21
def mission_metrics(population: np.ndarray):
22
    """批量计算种群中每个方案的能耗、任务时间和成像惩罚。
23

24
    population 的形状为 (方案数量, 2)，因此下面的计算无需 Python 循环。
25
    这些公式是教学用代理模型；实际项目应由飞行试验或高保真仿真标定。
26
    """
27
    speed = population[:, 0]
28
    stand_off = population[:, 1]
29

30
    # 总时间 = 航程/速度 + 每个巡检点固定悬停 20 秒。
31
    mission_time = MISSION_DISTANCE / speed + INSPECTION_POINTS * 20
32

33
    # 设 7 m/s、8 m 附近功率较低；偏离越大，附加功率越高。
34
    power = 150 + 2.2 * (speed - 7) ** 2 + 0.8 * (stand_off - 8) ** 2
35

36
    # W×s 除以 3600 得到 Wh。
37
    energy = power * mission_time / 3_600
38

39
    # 8 m 被设为理想成像距离，距离偏差以二次函数惩罚。
40
    image_penalty = 1.5 * (stand_off - 8) ** 2
41
    return energy, mission_time, image_penalty
42

43

44
def objective(population: np.ndarray) -> np.ndarray:
45
    """返回需要最小化的综合代价，数值越小代表方案越好。"""
46
    energy, mission_time, image_penalty = mission_metrics(population)
47
    # 0.015 是时间项权重，用于协调 Wh、秒和无量纲图像惩罚的尺度。
48
    score = energy + 0.015 * mission_time + image_penalty
49

50
    # 罚函数把约束违反量加入目标。平方可让严重违规受到更大惩罚。
51
    # maximum(..., 0) 保证满足约束时罚项恰好为 0。
52
    score += 100 * np.maximum(energy - BATTERY_LIMIT, 0) ** 2
53
    score += 100 * np.maximum(6 - population[:, 1], 0) ** 2
54
    return score
55

56

57
def tournament_select(
58
    population: np.ndarray,
59
    scores: np.ndarray,
60
    tournament_size: int = 3,
61
) -> np.ndarray:
62
    """从随机抽取的 tournament_size 个个体中复制得分最低者。"""
63
    # 这是最小化问题，所以 np.argmin 对应锦标赛胜者。
64
    candidates = rng.integers(0, len(population), size=tournament_size)
65
    winner = candidates[np.argmin(scores[candidates])]
66
    return population[winner].copy()
67

68
# 在每个变量的上下界之间均匀采样，形成第 0 代种群。
69
population = rng.uniform(LOWER, UPPER, size=(POPULATION_SIZE, 2))
70

71
for _ in range(GENERATIONS):
72
    scores = objective(population)
73

74
    # 精英保留：直接复制当前最优个体，避免好解被交叉或变异破坏。
75
    elite = population[np.argmin(scores)].copy()
76
    next_population = [elite]
77

78
    while len(next_population) < POPULATION_SIZE:
79
        parent1 = tournament_select(population, scores)
80
        parent2 = tournament_select(population, scores)
81

82
        # 对两个基因分别做算术交叉；weight 越接近 1，子代越像 parent1。
83
        weight = rng.random(2)
84
        child = weight * parent1 + (1 - weight) * parent2
85

86
        # 每个基因独立决定是否变异，并加入均值为 0 的高斯扰动。
87
        # 两个变量量纲不同，所以分别设置 0.4 和 0.6 的扰动尺度。
88
        mutation_mask = rng.random(2) < MUTATION_RATE
89
        mutation_scale = np.array([0.4, 0.6])
90
        child[mutation_mask] += rng.normal(
91
            loc=0.0,
92
            scale=mutation_scale[mutation_mask],
93
        )
94
        # 变异可能越界，clip 将方案截回允许的速度和距离范围。
95
        child = np.clip(child, LOWER, UPPER)
96
        next_population.append(child)
97

98
    population = np.asarray(next_population)
99

100
scores = objective(population)
101
best = population[np.argmin(scores)]
102

103
# reshape 把单个方案从形状 (2,) 转为 mission_metrics 所需的 (1, 2)。
104
energy, mission_time, _ = mission_metrics(best.reshape(1, -1))
105

106
print(f"speed: {best[0]:.2f} m/s")
107
print(f"stand-off distance: {best[1]:.2f} m")
108
print(f"energy: {energy[0]:.2f} Wh")
109
print(f"mission time: {mission_time[0]:.1f} s")
110
print(f"score: {scores.min():.2f}")

1
conda create -n geatpy27 python=3.10
2
conda activate geatpy27
3
python -m pip install "numpy<2" geatpy==2.7.0

1
import geatpy as ea
2
import numpy as np
3

4

5
MISSION_DISTANCE = 6_000.0
6
INSPECTION_POINTS = 12
7
BATTERY_LIMIT = 50.0
8

9

10
def mission_metrics(variables: np.ndarray):
11
    """计算 Geatpy 传入的一批候选方案的任务指标。"""
12
    # variables 每一行依次是 [速度(m/s), 作业距离(m)]。
13
    speed = variables[:, 0]
14
    stand_off = variables[:, 1]
15
    mission_time = MISSION_DISTANCE / speed + INSPECTION_POINTS * 20
16
    power = 150 + 2.2 * (speed - 7) ** 2 + 0.8 * (stand_off - 8) ** 2
17
    energy = power * mission_time / 3_600
18
    image_penalty = 1.5 * (stand_off - 8) ** 2
19
    return energy, mission_time, image_penalty
20

21

22
class DroneInspectionProblem(ea.Problem):
23
    """把无人机参数优化问题封装成 Geatpy 可识别的 Problem。"""
24

25
    def __init__(self) -> None:
26
        # ea.Problem 保存目标数量、变量类型、上下界及端点是否可取。
27
        super().__init__(
28
            name="DroneInspection",
29
            M=1,                  # 目标函数数量
30
            maxormins=[1],        # 1 表示最小化，-1 表示最大化
31
            Dim=2,                # 决策变量数量
32
            varTypes=[0, 0],      # 0 为连续变量，1 为离散变量
33
            lb=[4.0, 5.0],       # 速度、作业距离的下界
34
            ub=[12.0, 15.0],
35
            lbin=[1, 1],          # 包含下界
36
            ubin=[1, 1],          # 包含上界
37
        )
38

39
    def evalVars(self, variables: np.ndarray):
40
        """同时评价整个种群，并返回目标矩阵 ObjV 与约束矩阵 CV。"""
41
        energy, mission_time, image_penalty = mission_metrics(variables)
42
        objective = energy + 0.015 * mission_time + image_penalty
43

44
        # Geatpy 约定 CV 的每一列对应一条约束，CV <= 0 表示满足约束。
45
        # 例如 energy - 50 <= 0 等价于 energy <= 50。
46
        constraint_violation = np.column_stack(
47
            [
48
                energy - BATTERY_LIMIT,  # 能耗不得超过 50 Wh
49
                6 - variables[:, 1],     # 作业距离不得小于 6 m
50
            ]
51
        )
52
        return objective.reshape(-1, 1), constraint_violation
53

54

55
problem = DroneInspectionProblem()
56

57
# RI 表示实数/整数混合编码；本例两个变量的 varTypes 都为 0，因此均按实数处理。
58
population = ea.Population(Encoding="RI", NIND=80)
59

60
# SEGA 是增强精英保留遗传算法模板，适合单目标优化入门。
61
algorithm = ea.soea_SEGA_templet(problem, population)
62
algorithm.MAXGEN = 150          # 最大进化代数
63
algorithm.logTras = 10          # 每 10 代记录一次日志
64
algorithm.trappedValue = 1e-8   # 小于该改进量视为目标没有明显改善
65
algorithm.maxTrappedCount = 20  # 连续 20 次无明显改善时允许提前停止
66

67
# seed 用于复现实验；关闭绘图和落盘，方便在脚本或终端中直接运行。
68
result = ea.optimize(
69
    algorithm,
70
    seed=42,
71
    verbose=True,
72
    drawing=0,
73
    outputMsg=True,
74
    drawLog=False,
75
    saveFlag=False,
76
)
77

78
# 先判断是否找到可行结果，再读取变量，避免空结果直接索引。
79
if result["Vars"] is None or len(result["Vars"]) == 0:
80
    raise RuntimeError("本次没有找到可行巡检方案，请检查约束和搜索预算")
81
best = result["Vars"][0]
82
energy, mission_time, _ = mission_metrics(best.reshape(1, -1))
83
print(f"speed: {best[0]:.2f} m/s")
84
print(f"stand-off distance: {best[1]:.2f} m")
85
print(f"energy: {energy[0]:.2f} Wh")
86
print(f"mission time: {mission_time[0]:.1f} s")
87
print(f"objective: {result['ObjV'][0, 0]:.2f}")

1
constraint_violation = np.column_stack(
2
    [
3
        # Geatpy 以“值不大于 0”为可行，因此先统一移到不等式左边。
4
        energy - 50.0,        # energy <= 50  →  energy - 50 <= 0
5
        6.0 - stand_off,      # stand_off >= 6 →  6 - stand_off <= 0
6
    ]
7
)