遗传算法：从头开始构建你的 Python 实现

2023-10-19 17:59:45

遗传算法 (GA) 是一种强大的优化技术，它模拟自然选择过程来解决复杂的问题。在本文中，我们将深入了解 GA 的基础知识并从头开始构建一个 Python 实现。

遗传算法的步骤

遗传算法遵循一个迭代过程，包括以下主要步骤：

初始化种群： 随机生成一组潜在解决方案（染色体）。
适应度函数： 评估每个染色体的适应度，即它解决问题的有效性。
选择： 根据适应度选择最佳染色体进行繁殖。
交叉： 将选定的染色体组合起来创建新的后代。
变异： 随机更改后代的基因以引入多样性。
重复： 重复步骤 2-5 直到达到停止条件。

Python 实现

初始化种群

import random

def init_population(pop_size, chromosome_length):
    """
    初始化一个随机的二进制种群。

    参数：
        pop_size（int）：种群大小。
        chromosome_length（int）：染色体长度（基因数量）。

    返回：
        一个包含二进制染色体的列表。
    """

    population = []
    for _ in range(pop_size):
        chromosome = [random.randint(0, 1) for _ in range(chromosome_length)]
        population.append(chromosome)

    return population

适应度函数

适应度函数根据问题具体情况而定。在这里，我们使用一个示例适应度函数来最大化染色体中的 1 的数量：

def fitness_function(chromosome):
    """
    计算染色体的适应度。

    参数：
        chromosome（list）：二进制染色体。

    返回：
        染色体的适应度（1 的数量）。
    """

    return sum(chromosome)

选择

选择操作根据适应度选择染色体进行繁殖。我们使用轮盘赌选择方法：

def selection(population, fitness_values):
    """
    根据适应度值进行轮盘赌选择。

    参数：
        population（list）：种群。
        fitness_values（list）：染色体的适应度值。

    返回：
        一个包含选定染色体的列表。
    """

    # 计算总适应度
    total_fitness = sum(fitness_values)

    # 随机选择染色体
    selected_chromosomes = []
    for _ in range(len(population)):
        random_fitness = random.uniform(0, total_fitness)

        current_fitness = 0
        for i, fitness in enumerate(fitness_values):
            current_fitness += fitness
            if current_fitness >= random_fitness:
                selected_chromosomes.append(population[i])
                break

    return selected_chromosomes

交叉

交叉操作将选定的染色体组合起来创建新的后代。我们使用单点交叉：

def crossover(chromosome1, chromosome2):
    """
    对两个染色体进行单点交叉。

    参数：
        chromosome1（list）：第一个染色体。
        chromosome2（list）：第二个染色体。

    返回：
        两个新后代。
    """

    # 随机选择交叉点
    crossover_point = random.randint(0, len(chromosome1) - 1)

    # 创建新后代
    child1 = chromosome1[:crossover_point] + chromosome2[crossover_point:]
    child2 = chromosome2[:crossover_point] + chromosome1[crossover_point:]

    return child1, child2

变异

变异操作随机更改后代的基因以引入多样性。我们使用位翻转变异：

def mutation(chromosome, mutation_rate):
    """
    对染色体进行位翻转变异。

    参数：
        chromosome（list）：染色体。
        mutation_rate（float）：变异率。

    返回：
        变异后的染色体。
    """

    # 遍历每个基因
    for i in range(len(chromosome)):
        # 根据变异率随机翻转基因
        if random.random() < mutation_rate:
            chromosome[i] = 1 - chromosome[i]

    return chromosome

主循环

主循环重复执行遗传算法的步骤，直到达到停止条件（例如最大迭代次数或达到最佳适应度）：

def genetic_algorithm(init_pop, fitness_function, selection, crossover, mutation, pop_size, max_iterations):
    """
    运行遗传算法。

    参数：
        init_pop（function）：初始化种群的函数。
        fitness_function（function）：适应度函数。
        selection（function）：选择函数。
        crossover（function）：交叉函数。
        mutation（function）：变异函数。
        pop_size（int）：种群大小。
        max_iterations（int）：最大迭代次数。

    返回：
        最佳染色体及其适应度。
    """

    # 初始化种群
    population = init_pop(pop_size)

    # 迭代遗传算法
    for iteration in range(max_iterations):
        # 评估种群的适应度
        fitness_values = [fitness_function(chromosome) for chromosome in population]

        # 选择最佳染色体进行繁殖
        selected_chromosomes = selection(population, fitness_values)

        # 交叉选定的染色体
        new_population = []
        for i in range(0, len(selected_chromosomes), 2):
            child1, child2 = crossover(selected_chromosomes[i], selected_chromosomes[i+1])
            new_population.append(child1)
            new_population.append(child2)

        # 对后代进行变异
        for chromosome in new_population:
            mutation(chromosome, 0.1)

        # 更新种群
        population = new_population

    # 返回最佳染色体及其适应度
    best_chromosome = max(population, key=fitness_function)
    best_fitness = fitness_function(best_chromosome)
    return best_chromosome, best_fitness