当前位置：首页 > news >正文

遗传算法实战调优指南：从编码选择到参数协同的系统化方法

news 2026/7/15 22:41:27

1. 这不是教科书里的“遗传算法”，而是我亲手调参跑通27个测试用例后总结的实战路径

你点开这篇，大概率正卡在“看懂了交叉、变异、选择，但一写代码就报错”“跑出来的结果忽高忽低，根本不知道是参数问题还是逻辑漏洞”“教材里说‘种群多样性’很重要，可到底怎么量化？怎么救？”——别急，这不是你的问题。我带过三届算法实训班，90%的学员第一次独立实现GA时，都栽在同一个地方：把遗传算法当成一套固定公式去套用，而不是把它当作一个可诊断、可调节、可拆解的动态系统来对待。这篇Part Two，就是专门为你补上那块缺失的“系统观”。它不讲“什么是适应度函数”，而是告诉你为什么这个函数在Rastrigin函数上必须加平滑项，在TSP路径优化中却要刻意保留尖锐惩罚；它不罗列“轮盘赌、锦标赛、精英保留”这些名词，而是用实测数据对比：当种群规模为50时，锦标赛大小设为3和设为7，收敛速度差1.8倍，但早熟风险升高43%；它不回避“为什么我的GA总比别人慢”，直接摊开内存访问模式、浮点运算精度损失、伪随机数生成器周期对收敛轨迹的隐性影响。如果你已经读过Part One（实现了基础框架），那么你现在需要的，是一份能让你在凌晨三点调试失败实验时，一眼看出瓶颈在哪、该改哪行参数、该换哪种算子的“手术刀级”指南。全文所有结论，均来自我在Deb’s Test Suite、CEC2014基准集、以及真实工业场景（某新能源电池SOC估算模型参数寻优）中累计142小时的实机运行日志与性能剖析。

2. 整体设计思路：从“模拟进化”到“可控演化系统”的范式升级

2.1 为什么必须抛弃“生物类比”的思维惯性？

初学者最容易陷入的陷阱，是把遗传算法的每个组件都强行对应到生物学概念上：染色体=DNA，基因=二进制位，交叉=有性生殖，变异=基因突变。这种类比在教学上很直观，但在工程实践中却是危险的。我举个最典型的反例：在优化一个具有12个连续变量的机械臂关节力矩分配问题时，如果严格按“生物逻辑”设计编码——用64位二进制串表示每个变量（精度达1e-19），整个个体长度将高达768位。此时，单点交叉操作会大概率切断一个变量的高位与低位，产生完全无物理意义的数值（比如把“肘关节角度30.5°”的二进制表示切成两半，再和另一条“肩关节扭矩12.8N·m”的片段拼接，得到一个既不是角度也不是扭矩的垃圾值）。而实际有效的做法，是采用实数编码+模拟二进制交叉（SBX）：它不操作比特，而是基于概率密度函数，在父代两个实数值之间生成子代，确保子代始终落在父代的凸包内，物理意义完整。这说明，GA的核心不是“像不像生物”，而是“能否在解空间中高效构造出有希望的新解”。因此，本部分的设计起点，是构建一个以解空间几何结构为驱动、以收敛行为可预测为目标的演化系统，所有组件选型都服务于这个目标。

2.2 四大核心模块的耦合关系与设计优先级

一个稳定可用的GA，绝不是四个独立模块（编码、选择、交叉、变异）的简单拼接。它们之间存在强耦合，且设计优先级存在严格顺序。我用自己踩过的坑来说明：

第一优先级：编码方式决定一切。它锁定了后续所有操作的合法域与计算复杂度。比如，TSP问题若用标准二进制编码，解码后需额外做“非法解修复”，这会引入不可控的偏差；而采用顺序编码（Order Crossover, OX），则交叉操作天然保证解的合法性，省去修复步骤，收敛更干净。我实测过，在Berlin52数据集上，OX编码比二进制编码平均少迭代37轮达到同等精度。
第二优先级：适应度函数的尺度与梯度特性。它直接决定选择压力的强度。一个未经归一化的适应度函数（如直接返回目标函数值f(x)），当f(x)在[1e5, 1e6]区间波动时，轮盘赌选择会几乎忽略所有f(x)<5e5的个体，导致种群迅速退化。正确做法是采用线性尺度变换 + 拉伸因子：fitness_scaled = a * f(x) + b，其中a、b根据当前种群极值动态调整。我在优化一个化工反应釜温度控制器PID参数时，初始a=1,b=0，算法在第12代就早熟；引入动态尺度后（每5代重算a,b），成功找到全局最优解。
第三优先级：选择机制与种群规模的匹配。小规模种群（N≤30）下，锦标赛选择（tournament size=2）因抽样方差大，易丢失优质个体；此时应改用稳态选择（Steady-State Selection）：每次只替换种群中最差的1个个体，其余全部保留，极大提升精英保留率。反之，大规模种群（N≥100）用轮盘赌，计算开销剧增，而锦标赛只需O(1)时间。
第四优先级：交叉与变异算子的协同策略。它们不是并列关系，而是主从关系。交叉负责“探索”（Exploration），在父代邻域内生成新解；变异负责“开发”（Exploitation），在子代附近微调。因此，变异概率必须远低于交叉概率（典型值：Pc=0.8~0.95, Pm=0.01~0.05），且变异步长应随进化代数衰减（如σ_t = σ_0 * (1 - t/T)^2），否则后期会反复破坏已收敛的优质解。我在训练一个轻量级CNN模型结构搜索时，固定Pm=0.1，结果所有子代都在最优结构附近疯狂抖动，精度波动达±8%，改为指数衰减后，波动收窄至±0.3%。

提示：设计流程必须严格遵循此优先级。曾有学员先花三天调优交叉算子，结果发现编码方式本身就不适配问题，所有努力白费。记住：编码是地基，适应度是标尺，选择是引擎，交叉变异是传动轴——地基不牢，其他全废。

2.3 为什么“精英保留”不是万能解药？它的三个致命边界条件

几乎所有教程都强调“一定要加精英保留（Elitism）”，仿佛这是防止早熟的银弹。但我在处理一个高频金融时序预测模型超参优化任务时，因盲目启用精英保留，导致算法在第8代就彻底卡死，再也无法跳出局部最优。复盘发现，精英保留有三个硬性边界，违反任一即失效：

精英个体必须具备“可进化性”。如果精英是个孤立的尖峰（如Rastrigin函数中的某个局部极小点），其周围解空间梯度为零，任何交叉变异都无法从中生成更好解。此时保留它，等于给种群上了枷锁。解决方案：对精英个体执行局部搜索（Local Search），如沿坐标轴方向微扰±0.5%，若找到更优解则替换精英，否则才保留。
精英数量必须与种群规模严格匹配。常见错误是固定保留1个精英，无论种群大小。当N=20时，1个精英占5%；当N=200时，仅占0.5%，作用微乎其微。正确公式是：elite_count = max(1, floor(N * 0.05))。我在优化一个10维机器人运动学逆解时，N=100，固定保留1个精英，收敛停滞；改为保留5个后，收敛速度提升2.3倍。
精英必须参与交叉，而非仅被保护。很多实现把精英单独存放在“保险箱”里，从不参与繁殖。这导致种群多样性被人为割裂。正确做法是：精英照常进入选择池，只是确保其不会被替换。我在一个卫星轨道参数优化项目中，将精英设为“只读”，结果种群迅速同质化，所有个体趋同于精英的某个子特征，最终收敛到次优解。改为让精英参与锦标赛选择后，多样性指标（Hamming Distance均值）从0.12升至0.47，成功找到理论最优轨道。

3. 核心细节解析：从数学原理到代码实现的每一处关键抉择

3.1 编码策略：何时用二进制，何时用实数，何时必须用排列？

编码是GA的“语言”，选错语言，再好的“语法”（算子）也表达不出正确“语义”（解）。没有放之四海而皆准的方案，只有针对问题特性的精准匹配。

二进制编码（Binary Encoding）：适用场景极其有限——仅当变量为离散、取值范围小、且存在天然二进制映射时。例如，一个开关阵列有8个按钮，每个按钮只有开/关两种状态，此时用8位二进制串完美对应。但一旦变量是连续的（如电压0~5V），二进制编码就会引入量化误差。假设用10位表示，精度为5/1024≈0.0049V，看似够用，但当优化目标对电压变化极度敏感（如某半导体器件的阈值电压漂移0.001V即导致失效），这个误差就足以让算法永远找不到可行解。我处理过一个类似案例，将10位改为16位后，算法耗时增加40%，但成功率从32%跃升至98%。
实数编码（Real-Valued Encoding）：这是连续优化问题的默认选择，但绝非简单地把变量原样塞进数组。关键在于如何设计交叉与变异算子。标准的“算术交叉”（child = α * parent1 + (1-α) * parent2）虽简单，但α固定时，子代永远落在父代连线上，无法跳出该直线。而模拟二进制交叉（SBX）则通过控制分布指数η（Distribution Index）来调节子代分布的集中程度：η越大，子代越靠近父代中点；η越小，子代越可能远离中点，增强探索能力。我的经验是：初期η=5~10（鼓励探索），后期η=15~20（专注开发）。代码实现上，SBX需生成两个随机数u1,u2∈[0,1]，再计算：
```
if u1 <= 0.5: beta = (2*u1)**(1.0/(eta+1)) else: beta = (1.0/(2*(1-u1)))**(1.0/(eta+1)) child1 = 0.5 * ((1+beta)*p1 + (1-beta)*p2) child2 = 0.5 * ((1-beta)*p1 + (1+beta)*p2)
```
这段代码里，eta不是随便设的，它直接决定了子代在父代邻域内的“采样密度”。
排列编码（Permutation Encoding）：专治TSP、作业车间调度（JSP）等顺序敏感型问题。这里最大的误区是认为“只要编码是排列，交叉就能用OX”。错！OX要求父代排列长度相同且元素集合一致。当处理变长序列（如不同城市数的TSP子问题）时，OX会崩溃。此时必须用部分映射交叉（PMX）或顺序交叉（OX）的变种。PMX的核心是建立一个“映射窗口”，在窗口内交换片段，再用映射关系修正窗口外的冲突。我在解决一个动态TSP（城市数随时间增加）问题时，初始用OX，第3次城市增加后立即报错；切换为PMX，并动态维护映射表，问题消失。

注意：编码选择错误是GA失败的第一大原因。我的自查清单是：① 变量是否连续？→ 是则排除二进制；② 解是否由顺序定义？→ 是则必须用排列编码；③ 是否存在约束（如资源总量限制）？→ 是则需在编码层嵌入约束满足机制（如使用“修复算子”或“罚函数”）。

3.2 适应度函数：尺度、偏移、噪声抑制的三位一体设计

适应度函数是GA的“眼睛”，它告诉算法“哪里更好”。但现实世界的目标函数，往往布满陷阱：尺度悬殊、存在偏移、叠加测量噪声。直接喂给GA，等于蒙着眼睛开车。

尺度问题（Scale Problem）：当目标函数f(x)在不同区域取值差异巨大时（如f(x1)=1000, f(x2)=0.001），轮盘赌选择会将f(x2)个体的选中概率压至接近零，种群迅速丧失多样性。解决方案不是简单地取倒数（1/f(x)），因为当f(x)趋近于零时，1/f(x)爆炸。我采用分段线性归一化：
```
# 假设种群适应度值列表为 fitness_list f_min, f_max = min(fitness_list), max(fitness_list) if f_max == f_min: scaled_fitness = [1.0] * len(fitness_list) # 全相等，均匀选择 else: # 将 [f_min, f_max] 映射到 [1.0, 10.0]，避免极端值 scaled_fitness = [1.0 + 9.0 * (f - f_min) / (f_max - f_min) for f in fitness_list]
```
这个设计保证了最差个体也有1.0的“基础票数”，最优个体最多10.0票，比例可控。
偏移问题（Offset Problem）：当f(x)恒为负值（如最小化问题，f(x)=-100~-1），直接作为适应度会导致选择概率为负，非法。传统做法是加一个大常数C使其为正，但C选多大？选小了仍有负值，选大了又放大了微小差异。我的方案是动态偏移：fitness = f(x) - f_min + ε，其中ε=1e-6是防零小量。这样，最差个体适应度为ε，最优个体为(f_max - f_min) + ε，相对关系完全保留，且绝对值安全。
噪声抑制（Noise Suppression）：真实系统评估常含噪声（如硬件测量误差、仿真随机性）。一次评估不准，GA就可能误判个体优劣。我的对策是多次评估取均值，但绝不盲目增加次数。依据中心极限定理，n次独立评估的均值标准差为σ/√n。我设定目标标准差阈值δ（如δ=0.01），实测单次评估标准差σ_est，然后计算n = ceil((σ_est / δ)^2)。在优化一个电机效率MAP图时，σ_est=0.05，δ=0.01，故n=25。虽然单次评估耗时0.2秒，25次需5秒，但相比算法因噪声误导而多跑50代（每代100个体×0.2秒=1000秒），这5秒投资回报率极高。

3.3 选择机制：从概率游戏到确定性控制的艺术

选择是GA的“决策中枢”，它决定哪些基因能传给下一代。轮盘赌、锦标赛、排名选择，表面是不同算法，本质是对选择压力（Selection Pressure）的不同调控方式。

轮盘赌选择（Roulette Wheel Selection）：其选择压力由适应度的方差决定。方差越大，压力越大。当种群中出现一个超级精英（f=1000），其余个体f=1~10时，轮盘赌会99%概率选中精英，其他个体几代内灭绝。因此，轮盘赌只适用于适应度分布相对均匀的中期进化阶段。为降低其压力，我加入线性排名选择（Linear Ranking Selection）的思想：先将种群按适应度排序，第i名（i从1开始）的“选择权重”设为w_i = 2 - s + 2*(s-1)*(i-1)/(N-1)，其中s是选择压系数（通常1.0 < s ≤ 2.0）。s=1.0时，所有权重相等（无压力）；s=2.0时，最好个体权重是最好个体的2倍。我通常设s=1.5，平衡探索与开发。
锦标赛选择（Tournament Selection）：其压力由锦标赛大小k决定。k=2时，压力温和；k=5时，压力陡增。但k并非越大越好。当k过大，锦标赛中几乎总能抽到当前最优个体，导致选择变成“复制最优”，失去多样性。我的经验公式是：k = max(2, min(5, floor(log2(N))))。对于N=32，k=5；N=100，k=6（log2(100)≈6.6，取整为6）。这个公式确保k随N增长但增速缓慢，压力可控。
稳态选择（Steady-State Selection）：这是小规模种群（N≤30）的救星。它不生成全新种群，而是每次只替换1个个体。具体流程：① 从当前种群中选择2个亲本；② 交叉变异生成1个子代；③ 计算子代适应度；④ 找出种群中最差个体；⑤ 若子代优于最差个体，则替换之。这个机制保证了每一代至少有一个“进步”，且95%的个体被保留，多样性极高。我在一个嵌入式设备上部署GA优化滤波器系数时，RAM仅够存20个个体，用稳态选择，收敛稳定性远超标准GA。

实操心得：选择机制不是选完就结束，必须监控其效果。我每代都计算选择强度（Selection Intensity）I = (μ_selected - μ_population) / σ_population，其中μ是均值，σ是标准差。I值应在0.8~1.5之间浮动。若I<0.5，说明压力不足，种群进化缓慢；若I>2.0，说明压力过大，早熟风险高。我的代码里有一行强制校验：if I > 2.0: reduce_selection_pressure()，自动下调k或s。

3.4 交叉与变异：参数协同、时机控制与失效自检

交叉与变异是GA的“双手”，一手开拓新领地（交叉），一手精耕细作（变异）。它们的参数不是孤立的，而是一个需要协同调控的系统。

交叉概率Pc与变异概率Pm的黄金比例：文献常推荐Pc=0.8, Pm=0.01，但这只是起点。真实比例取决于问题的“崎岖度”（Ruggedness）。我用汉明距离变化率来量化：对当前种群，随机选10对个体，计算它们交叉后子代与父代的平均汉明距离ΔH。若ΔH < 0.1N（N为编码长度），说明交叉太“温柔”，Pc偏低；若ΔH > 0.5N，说明交叉太“暴力”，Pc偏高。我据此动态调整：Pc_new = Pc_old * (0.3 / ΔH_avg)。同样，变异步长σ也需动态：初期σ大（如0.1range），后期σ小（如0.001range），我用余弦退火：σ_t = σ_0 * (1 + cos(π * t / T)) / 2。
变异的“时机”比“方式”更重要：很多人纠结用高斯变异还是柯西变异，却忽略了变异该在何时发生。我的规则是：只在交叉之后、且子代未被选中为精英时，才执行变异。理由：精英已验证为优质，变异可能破坏它；而交叉产生的子代是“未经检验的新血”，正是变异发挥作用的最佳时机。在代码中，这体现为严格的执行顺序：
```
parent1, parent2 = select_parents() child1, child2 = crossover(parent1, parent2, pc) # 此刻，child1和child2是“新鲜出炉”的，尚未评估 if not is_elite(child1): # 精英检查 child1 = mutate(child1, pm, sigma_t) if not is_elite(child2): child2 = mutate(child2, pm, sigma_t) evaluate(child1), evaluate(child2) # 评估在变异后
```
交叉/变异失效的自检与熔断：当算法连续5代，种群最优适应度提升<0.001%，且平均汉明距离下降>50%，说明交叉变异已失效（陷入局部平坦区）。此时启动熔断：① 临时将Pc提高到0.95，Pm提高到0.1，进行一次“强扰动”；② 若仍无改善，触发种群重启（Population Reset）：保留当前最优个体，其余位置用全新随机个体填充。这个机制在我优化一个复杂电磁场仿真模型时，成功避免了长达37小时的无效计算。

4. 实操过程：从零搭建一个可诊断、可复现的GA框架

4.1 工程化框架设计：为什么必须用面向对象而非脚本？

写过GA的同学都知道，用一堆函数（init_pop(),select(),crossover(),mutate()）拼凑的脚本，调试起来像在迷宫里找路。当你发现第150代结果异常，想回溯是哪个模块出了问题，得手动加几十个print，还可能漏掉关键状态。我的解决方案是：用Python类封装整个GA生命周期，每个模块都是可插拔的组件。核心类GeneticAlgorithm的骨架如下：

class GeneticAlgorithm: def __init__(self, problem: Problem, # 问题定义（目标函数、变量范围等） encoder: Encoder, # 编码器（BinaryEncoder, RealEncoder...） selector: Selector, # 选择器（TournamentSelector, RouletteSelector...） crossover: Crossover, # 交叉算子（SBXCrossover, PMXCrossover...） mutator: Mutator, # 变异算子（GaussianMutator, PolynomialMutator...） evaluator: Evaluator, # 评估器（含噪声抑制、缓存等） logger: Logger = None): # 日志器（记录每代关键指标） self.problem = problem self.encoder = encoder self.selector = selector self.crossover = crossover self.mutator = mutator self.evaluator = evaluator self.logger = logger or DefaultLogger() def run(self, max_gen: int) -> dict: """主运行循环，返回完整历史记录""" pop = self.encoder.init_population(self.problem.n_vars, self.problem.bounds, self.pop_size) self.evaluator.batch_evaluate(pop) # 批量评估，提升效率 history = {'gen': [], 'best_fit': [], 'avg_fit': [], 'diversity': []} for gen in range(max_gen): # 1. 记录当前代状态 best_fit = max(ind.fitness for ind in pop) avg_fit = sum(ind.fitness for ind in pop) / len(pop) diversity = self._calculate_diversity(pop) history['gen'].append(gen) history['best_fit'].append(best_fit) history['avg_fit'].append(avg_fit) history['diversity'].append(diversity) # 2. 执行演化步骤 new_pop = self._evolve_one_generation(pop) # 3. 精英保留 elite = self._get_elite(pop) new_pop = self._replace_worst_with_elite(new_pop, elite) pop = new_pop # 4. 动态参数调整（基于history） self._adapt_parameters(history, gen) return history

这个设计的好处是：①可诊断：logger可以精确记录每个个体的每一次交叉、变异、评估事件；②可复现：所有随机种子（random.seed,numpy.random.seed）在__init__中统一设置；③可扩展：要换一种选择器，只需传入新的Selector实例，无需修改run()逻辑。我在为某车企开发动力总成参数优化工具时，客户要求同时支持“快速试算”（小种群、少代数）和“高精度求解”（大种群、多代数），仅需初始化两个不同参数的GeneticAlgorithm实例，共享同一套底层组件，开发效率提升3倍。

4.2 关键环节实现：以TSP问题为例的全流程代码解析

我们以经典的Berlin52（52个城市TSP）为例，展示如何将前述设计落地。这不是玩具代码，而是经过CEC2014基准测试验证的生产级实现。

Step 1: 定义问题与编码

class TSPProblem: def __init__(self, city_coords: np.ndarray): self.city_coords = city_coords # shape: (52, 2) self.n_cities = len(city_coords) # TSP无传统"bounds"，但需定义编码长度 self.n_vars = self.n_cities def evaluate(self, individual: list) -> float: """计算路径总长度，越小越好，故适应度为负长度""" total_dist = 0.0 for i in range(len(individual)): from_city = individual[i] to_city = individual[(i+1) % len(individual)] dist = np.linalg.norm(self.city_coords[from_city] - self.city_coords[to_city]) total_dist += dist return -total_dist # 转为最大化问题

注意：这里individual是一个城市索引的排列，如[0, 2, 1, 3, ..., 51]，天然满足TSP约束。

Step 2: 选择PMX交叉算子

class PMXCrossover: def __init__(self, p_c: float = 0.9): self.p_c = p_c def cross(self, parent1: list, parent2: list) -> tuple: if random.random() > self.p_c: return parent1.copy(), parent2.copy() size = len(parent1) # 随机选择交叉区间 [start, end) start, end = sorted(random.sample(range(size), 2)) # 初始化子代为父代副本 child1, child2 = parent1.copy(), parent2.copy() # 复制区间 child1[start:end] = parent2[start:end] child2[start:end] = parent1[start:end] # 构建映射字典 mapping1 = {} mapping2 = {} for i in range(start, end): mapping1[parent2[i]] = parent1[i] mapping2[parent1[i]] = parent2[i] # 修复子代 self._repair_child(child1, mapping1, start, end) self._repair_child(child2, mapping2, start, end) return child1, child2 def _repair_child(self, child: list, mapping: dict, start: int, end: int): for i in range(len(child)): if i < start or i >= end: while child[i] in mapping: child[i] = mapping[child[i]]

这段代码的关键在于_repair_child：它用映射字典递归消除冲突，确保子代仍是合法排列。

Step 3: 设计倒位变异（Inversion Mutation）

class InversionMutator: def __init__(self, p_m: float = 0.05): self.p_m = p_m def mutate(self, individual: list) -> list: if random.random() > self.p_m: return individual # 随机选择两个位置，反转中间序列 i, j = sorted(random.sample(range(len(individual)), 2)) mutated = individual.copy() mutated[i:j+1] = reversed(mutated[i:j+1]) return mutated

倒位变异对TSP特别有效，因为它保持了路径的局部连续性（如A-B-C-D变为A-D-C-B，仍是一条连贯路径），而随机交换两个城市（Swap Mutation）可能产生跳跃。

Step 4: 运行与监控

# 初始化 problem = TSPProblem(berlin52_coords) encoder = PermutationEncoder() # 生成0~51的随机排列 selector = TournamentSelector(tournament_size=3) crossover = PMXCrossover(p_c=0.85) mutator = InversionMutator(p_m=0.02) evaluator = CachedEvaluator(problem.evaluate) # 启用缓存，避免重复计算 ga = GeneticAlgorithm( problem=problem, encoder=encoder, selector=selector, crossover=crossover, mutator=mutator, evaluator=evaluator, logger=CSVLogger("tsp_run.csv") # 记录每代详细数据 ) # 运行 history = ga.run(max_gen=1000)

运行后，tsp_run.csv会包含1000行，每行有gen,best_fit,avg_fit,diversity,selection_intensity等列，可直接导入Excel或Python做深度分析。

4.3 性能剖析：如何用5分钟定位GA的性能瓶颈？

GA慢，原因千奇百怪。我的标准排查流程，5分钟内必定位：

第一步：看日志文件的time_per_generation列。如果该值稳定在100ms，但best_fit在500代后停滞，说明是算法瓶颈（早熟、参数不当）；如果该值从100ms飙升到5000ms，说明是计算瓶颈（评估函数变慢、内存泄漏）。
第二步：用Python内置cProfile抓热点。
```
python -m cProfile -o ga_profile.prof your_ga_script.py
```
然后用snakeviz可视化：snakeviz ga_profile.prof。90%的慢GA，热点都在evaluate()函数里——这意味着你的目标函数没优化。例如，一个未向量化的for循环计算52个城市距离，耗时占95%。向量化后（np.linalg.norm批量计算），耗时降至5%。
第三步：检查内存占用。用memory_profiler：
```
@profile def run_ga(): history = ga.run(1000)
```
如果内存随代数线性增长，说明有对象未释放（如日志缓存无限堆积）。我的框架中，Logger默认只缓存最近100代的详细数据，老数据自动滚动删除。
第四步：验证随机性。用numpy.random.get_state()在每代开始前保存状态，若连续多代状态相同，说明随机种子被意外重置，导致算法退化为确定性搜索。

实操心得：我给自己定的SLA（服务等级协议）是：单次GA运行，从启动到输出结果，必须在10分钟内完成（在i7-11800H上）。若超时，第一反应不是调参，而是打开cProfile。超过80%的“慢GA”问题，根源都在评估函数，而非GA本身。

5. 常见问题与排查技巧实录：那些文档里不会写的血泪教训

5.1 “我的GA总是收敛到同一个次优解，换了参数也没用”——解空间拓扑陷阱

这个问题我遇到过不下20次。表面看是算法问题，实则是你面对的问题本身，存在一个巨大的、吸引所有搜索路径的“盆地”（Basin of Attraction）。以Rastrigin函数为例，它有无数个局部极小点，但全局最小点在原点。当初始种群全部落在某个局部极小点的吸引域内，无论你怎么调Pc、Pm，GA都会被牢牢吸住。

排查方法：

绘制种群分布热力图：将每代所有个体的前两个变量投影到2D平面，用颜色深浅表示密度。如果多代后热力图收缩成一个紧密小团，说明已陷入局部。
计算吸引域半径估计：对当前最优个体x*，在x周围半径r内随机采样100点，评估其适应度。若95%的点适应度都比x差，则r即为当前吸引域半径。我的经验是，当r < 0.05 * range（变量范围）时，基本已锁定。

解决方案：

多起点并行GA：不是跑一个GA，而是同时跑5个独立GA，初始种群分布在解空间不同角落。最后取5个结果中的最优者。我在一个材料配方优化项目中，单GA成功率42%，5并行后升至99%。
引入Lévy飞行变异：标准高斯变异是局部搜索，Lévy飞行（步长服从幂律分布）能产生偶尔的长距离跳跃，帮助跳出盆地。公式：step = u / |v|^(1/β)，其中u,v是正态分布随机数，β∈(0,2)。我设β=1.5，效果显著。