别再死磕梯度下降了！用Python手搓一个遗传算法，轻松搞定那些‘不听话’的优化问题

遗传算法实战：用Python突破传统优化困局

当你的优化目标函数像阿尔卑斯山脉一样起伏不平时，梯度下降这类传统方法很容易陷入局部最优的"山谷"中无法自拔。而遗传算法（Genetic Algorithm, GA）则像一群带着登山装备的探险队，能从多个方向同时搜索，大大增加找到全局最高峰的概率。本文将带你从零实现一个完整的遗传算法框架，并应用于实际优化问题。

1. 为什么需要遗传算法？

在机器学习和工程优化中，我们经常遇到以下棘手场景：

• 非凸函数优化：损失函数表面凹凸不平，存在多个局部极值点
• 离散参数空间：超参数取值不连续，无法计算梯度
• 高维搜索：参数维度爆炸，网格搜索计算量不可承受
• 黑箱函数：只能获取输出值，无法得知内部结构信息

传统梯度下降方法在这些场景下表现乏力。以一个简单的Rastrigin函数为例：

import numpy as np def rastrigin(x): """典型的多模态优化测试函数""" return 10*len(x) + sum([(xi**2 - 10*np.cos(2*np.pi*xi)) for xi in x])

这个函数在二维情况下看起来就像布满凹坑的平面，梯度下降几乎一定会被困在某个局部最小值中。而遗传算法通过模拟自然进化过程，可以有效地探索这种复杂空间。

2. 遗传算法核心架构设计

一个完整的遗传算法包含以下关键组件，我们可以用面向对象的方式来实现：

2.1 种群初始化

首先定义个体基因的表示方式。对于连续优化问题，浮点数向量是自然的选择：

class Individual: def __init__(self, gene_length, bounds): self.gene = np.random.uniform(bounds[0], bounds[1], size=gene_length) self.fitness = None

种群则是多个个体的集合：

class Population: def __init__(self, size, gene_length, bounds): self.individuals = [Individual(gene_length, bounds) for _ in range(size)] self.best_individual = None

2.2 适应度评估

适应度函数将基因映射为可比较的标量值。以最大化问题为例：

def evaluate_fitness(population, objective_func): for ind in population.individuals: ind.fitness = objective_func(ind.gene) population.best_individual = max(population.individuals, key=lambda x: x.fitness)

2.3 选择算子

轮盘赌选择是最常用的策略之一，适应度高的个体有更大几率被选中：

def roulette_wheel_selection(population): total_fitness = sum(ind.fitness for ind in population.individuals) pick = random.uniform(0, total_fitness) current = 0 for ind in population.individuals: current += ind.fitness if current > pick: return ind return random.choice(population.individuals)

2.4 交叉算子

模拟生物基因重组，这里实现模拟二进制交叉（SBX）：

def sbx_crossover(parent1, parent2, eta=20): child1, child2 = parent1.copy(), parent2.copy() for i in range(len(parent1)): if random.random() <= 0.5: if abs(parent1[i] - parent2[i]) > 1e-14: x1, x2 = min(parent1[i], parent2[i]), max(parent1[i], parent2[i]) beta = 1.0 + (2.0 * (x1 - bounds[0]) / (x2 - x1)) alpha = 2.0 - beta**(-eta-1) u = random.random() if u <= 1.0/alpha: beta_q = (u * alpha)**(1.0/(eta+1)) else: beta_q = (1.0/(2.0 - u*alpha))**(1.0/(eta+1)) c1 = 0.5*((x1+x2) - beta_q*(x2-x1)) beta = 1.0 + (2.0 * (bounds[1] - x2) / (x2 - x1)) alpha = 2.0 - beta**(-eta-1) if u <= 1.0/alpha: beta_q = (u * alpha)**(1.0/(eta+1)) else: beta_q = (1.0/(2.0 - u*alpha))**(1.0/(eta+1)) c2 = 0.5*((x1+x2) + beta_q*(x2-x1)) child1[i], child2[i] = c1, c2 return child1, child2

2.5 变异算子

多项式变异保持种群多样性：

def polynomial_mutation(individual, bounds, eta=20): mutated = individual.copy() for i in range(len(individual)): if random.random() < mutation_prob: delta1 = (mutated[i] - bounds[0]) / (bounds[1] - bounds[0]) delta2 = (bounds[1] - mutated[i]) / (bounds[1] - bounds[0]) mut_pow = 1.0 / (eta + 1.0) r = random.random() if r <= 0.5: xy = 1.0 - delta1 val = 2.0 * r + (1.0 - 2.0 * r) * xy**(eta + 1) delta_q = val**mut_pow - 1.0 else: xy = 1.0 - delta2 val = 2.0 * (1.0 - r) + 2.0 * (r - 0.5) * xy**(eta + 1) delta_q = 1.0 - val**mut_pow mutated[i] += delta_q * (bounds[1] - bounds[0]) return mutated

3. 完整算法流程实现

将上述组件整合成完整的遗传算法：

def genetic_algorithm(objective_func, bounds, gene_length, pop_size=100, max_gen=1000, crossover_prob=0.9, mutation_prob=0.1): # 初始化种群 population = Population(pop_size, gene_length, bounds) evaluate_fitness(population, objective_func) # 进化循环 for gen in range(max_gen): new_individuals = [] # 生成新一代 while len(new_individuals) < pop_size: # 选择 parent1 = roulette_wheel_selection(population) parent2 = roulette_wheel_selection(population) # 交叉 if random.random() < crossover_prob: child1, child2 = sbx_crossover(parent1.gene, parent2.gene) else: child1, child2 = parent1.gene.copy(), parent2.gene.copy() # 变异 child1 = polynomial_mutation(child1, bounds) child2 = polynomial_mutation(child2, bounds) new_individuals.extend([child1, child2]) # 更新种群 population.individuals = [Individual(gene_length, bounds) for _ in range(pop_size)] for i, ind in enumerate(population.individuals): ind.gene = new_individuals[i] evaluate_fitness(population, objective_func) # 输出当前最优解 print(f"Generation {gen}: Best fitness = {population.best_individual.fitness:.4f}") return population.best_individual

4. 实战案例：神经网络超参数优化

让我们用遗传算法来优化一个简单神经网络的超参数：

from sklearn.neural_network import MLPClassifier from sklearn.datasets import load_iris from sklearn.model_selection import cross_val_score # 加载数据 iris = load_iris() X, y = iris.data, iris.target def evaluate_nn(params): """将超参数转换为适应度""" hidden_layer_sizes = (int(params[0]), int(params[1])) learning_rate_init = params[2] alpha = params[3] model = MLPClassifier( hidden_layer_sizes=hidden_layer_sizes, learning_rate_init=learning_rate_init, alpha=alpha, max_iter=200, random_state=42 ) # 使用交叉验证评估模型 scores = cross_val_score(model, X, y, cv=5) return np.mean(scores) # 最大化准确率 # 定义搜索空间 bounds = [ (5, 100), # 第一隐藏层神经元数 (5, 100), # 第二隐藏层神经元数 (0.0001, 0.1), # 学习率 (0.0001, 0.1) # L2正则化系数 ] # 运行遗传算法 best_solution = genetic_algorithm( objective_func=evaluate_nn, bounds=bounds, gene_length=4, pop_size=50, max_gen=100 ) print(f"最优超参数组合：{best_solution.gene}") print(f"验证集准确率：{best_solution.fitness:.4f}")

在这个案例中，遗传算法可以同时优化网络结构和训练参数，避免了传统网格搜索的高计算成本。

5. 高级技巧与调参策略

要让遗传算法发挥最佳性能，需要关注以下几个关键点：

5.1 参数自适应

优秀的遗传算法应该能动态调整参数：

def adaptive_parameters(gen, max_gen): """随着进化代数动态调整交叉和变异概率""" crossover_prob = 0.9 - 0.5 * (gen / max_gen) mutation_prob = 0.1 + 0.4 * (gen / max_gen) return crossover_prob, mutation_prob

5.2 精英保留策略

确保最优个体不会在进化过程中丢失：

def elitism(population, new_population, elite_size=2): """将精英个体直接保留到下一代""" elites = sorted(population.individuals, key=lambda x: x.fitness, reverse=True)[:elite_size] new_individuals = sorted(new_population.individuals, key=lambda x: x.fitness, reverse=True) return elites + new_individuals[:-elite_size]

5.3 多样性维护

当种群过早收敛时增加多样性：

def diversity_maintenance(population, threshold=0.1): """检测并处理种群多样性下降""" fitness_std = np.std([ind.fitness for ind in population.individuals]) if fitness_std < threshold * np.mean([ind.fitness for ind in population.individuals]): # 随机替换部分个体 replace_count = int(0.2 * len(population.individuals)) for _ in range(replace_count): idx = random.randint(0, len(population.individuals)-1) population.individuals[idx] = Individual(gene_length, bounds)

6. 性能对比：遗传算法 vs 传统方法

我们使用标准测试函数比较不同算法的表现：

表：各算法在30维标准测试函数上的平均表现（越小越好），运行10次取平均值±标准差

从结果可以看出，遗传算法在高维非凸函数优化中具有明显优势。特别是在Rastrigin函数上，遗传算法能找到比其他方法更优的解。

7. 实际工程中的注意事项

在将遗传算法应用于实际问题时，需要注意以下几点：

1. 编码方式选择：

   • 连续问题：实数编码
   • 离散问题：二进制编码或排列编码
   • 混合问题：多种编码组合

2. 适应度缩放：

   • 线性缩放：f' = a*f + b
   • 指数缩放：f' = f^k
   • 窗口缩放：基于最近几代的适应度范围

3. 并行化实现：

   from concurrent.futures import ProcessPoolExecutor def parallel_evaluation(population, objective_func, workers=4): with ProcessPoolExecutor(max_workers=workers) as executor: futures = [executor.submit(objective_func, ind.gene) for ind in population.individuals] for ind, future in zip(population.individuals, futures): ind.fitness = future.result()

4. 早停机制：

   if gen > 50 and abs(best_fitness - population.best_individual.fitness) < 1e-6: print(f"连续50代没有显著改进，提前终止") break

5. 可视化监控：

   import matplotlib.pyplot as plt def plot_evolution(fitness_history): plt.plot(fitness_history) plt.xlabel('Generation') plt.ylabel('Best Fitness') plt.title('Evolution Progress') plt.grid(True) plt.show()

遗传算法虽然强大，但也不是万能的。对于光滑、凸的优化问题，传统梯度方法可能更高效。但在面对复杂的非凸、多模态优化问题时，遗传算法提供了一种可靠的全局搜索方案。