遗传算法python代码详解nyⅡ

### Python 实现遗传算法代码详解

#### 初始化种群
为了初始化种群，通常会随机生成一定数量的个体。这些个体代表可能的解决方案，在二元函数优化的情况下，可以表示为一组参数。

import numpy as np

def initialize_population(pop_size, chrom_length):
    """初始化种群"""
    population = []
    for i in range(pop_size):
        chromosome = np.random.randint(0, 2, size=chrom_length).tolist()
        population.append(chromosome)
    return population

此段代码创建了一个由`pop_size`指定大小、染色体长度为`chrom_length`的初始种群[^1]。

#### 计算适应度
适应度函数用于评估每个个体的好坏程度。对于不同的问题领域，适应度计算方式不同；这里假设目标是最小化某个给定的成本函数：

from functools import partial

def fitness_function(individual, cost_func):
    """基于成本函数计算单个个体的适应度"""
    params = decode_chromsome_to_params(individual)  # 将基因编码转换成实际参数值
    return 1 / (cost_func(params) + 1e-6)

def evaluate_fitness(population, cost_func):
    """评价整个群体中的所有成员"""
    fit_values = list(map(partial(fitness_function, cost_func=cost_func), population))
    return fit_values

上述代码定义了如何通过特定的成本函数来衡量每一个体的表现，并据此得出其适应度得分[^2]。

#### 选择操作
选择机制模仿自然界中适者生存的原则，让更优秀的个体有更大机会被选中参与繁殖下一代。

def selection(population, fit_values):
    """轮盘赌法进行选择"""
    total_fit = sum(fit_values)
    rel_fit = [f/total_fit for f in fit_values]
    cum_prob = np.cumsum(rel_fit)
    
    new_pop = []
    for _ in range(len(population)):
        r = np.random.rand()
        idx = next(i for i,p in enumerate(cum_prob) if p >= r)
        new_pop.append(population[idx])
        
    return new_pop

这段程序实现了基于比例的选择策略——即所谓的“轮盘赌”，其中较优解具有更高的概率进入下一轮迭代。

#### 交叉重组
交叉是指两个父代之间交换部分DNA片段形成新的子代。这是GA中最核心的操作之一，有助于探索搜索空间内的新区域。

def crossover(parents, cross_rate):
    """单点交叉"""
    offspring = parents.copy()
    for child_i in range(0, len(offspring)-1, 2):
        if np.random.rand() < cross_rate:
            point = int(np.random.uniform(1,len(offspring[child_i])-1))
            temp = offspring[child_i][:point]
            offspring[child_i][:point] = offspring[child_i+1][:point]
            offspring[child_i+1][:point] = temp
            
    return offspring

该方法采用简单的单点交叉方案，当满足一定的概率条件时才会发生交叉事件。

#### 变异处理
变异是对某些位上的基因值做微调，防止过早收敛并增加多样性。

def mutate(children, mutation_rate):
    """按位翻转突变"""
    mutated_children = children.copy()
    for i in range(len(mutated_children)):
        if np.random.rand() < mutation_rate:
            pos_to_mutate = np.random.randint(0, len(mutated_children[i]))
            mutated_children[i][pos_to_mutate] = 1 - mutated_children[i][pos_to_mutate]

    return mutated_children

此处展示了基本的按位翻转变异逻辑，它会在极低的概率条件下改变选定位置的状态。

#### 主循环结构
最后一步是将以上各个组件组合起来构成完整的遗传算法框架。

def genetic_algorithm(cost_func, pop_size=50, generations=100, chrom_length=8,
                      cross_rate=0.7, mutaion_rate=0.01):
    """
    执行标准遗传算法流程
    
    参数说明：
      @param cost_func 成本函数
      @param pop_size 种群规模，默认50
      @param generations 进化世代数，默认100
      @param chrom_length 染色体长度，默认8比特
      @param cross_rate 杂交率，默认0.7
      @param mutaion_rate 突变率，默认0.01
      
    返回最终找到的最佳个体及其对应的最小代价。
    """

    best_solution = None
    min_cost = float('inf')

    # Step 1: Initialize Population
    population = initialize_population(pop_size, chrom_length)

    for gen in range(generations):

        # Evaluate Fitnesses
        fits = evaluate_fitness(population, cost_func)

        # Select Parents For Next Generation
        selected_parents = selection(population, fits)

        # Crossover To Generate Offsprings
        crossed_offsprings = crossover(selected_parents, cross_rate)

        # Mutate Some Genes Of New Individuals
        mutated_new_gen = mutate(crossed_offsprings, mutaion_rate)

        # Update Best Solution Found So Far If Necessary
        current_best_idx = np.argmax(fits)
        curr_min_cost = 1/fits[current_best_idx]-1e-6
        
        if curr_min_cost < min_cost:
            min_cost = curr_min_cost
            best_solution = population[current_best_idx].copy()

        # Prepare For The Next Round By Replacing Old Pop With New One
        population = mutated_new_gen[:]

    return best_solution, min_cost

这个主函数封装了遗传算法的主要工作流，包括但不限于初始化、评估、选择、杂交以及突变等环节。经过多轮迭代之后返回发现的最佳可行解和相应的最低开销。