算法实现之遗传算法

算法解释

遗传算法是一种基于自然选择和遗传机制的优化算法，用于解决优化问题。它模拟了生物进化的过程，通过模拟种群的遗传、选择、交叉和变异等操作，逐代优化解的质量。

遗传算法的基本流程如下：

1. 初始化种群：随机生成初始种群，其中每个个体代表问题空间的一个解。

2. 评估适应度：根据问题的特定要求，对种群中的每个个体进行适应度评估，将每个个体映射到一个适应度值，用于度量个体的优劣。

3. 选择：使用选择算子从当前种群中选择一部分个体作为父代，用于产生下一代。选择操作通常基于个体的适应度值，适应度高的个体被选择的概率较大。

4. 交叉：应用交叉算子，对选定的父代个体进行基因交换，生成新的个体（子代）。交叉操作模拟了生物遗传中的杂交过程，通过基因的重组，产生具有父代特征的新个体。

5. 变异：应用变异算子，在新个体中引入随机的基因变化。变异操作模拟了生物遗传中的突变过程，引入一定程度的随机性，增强搜索空间的探索能力。

6. 替换：将子代替换到当前种群中，得到下一代种群。

7. 重复上述步骤：根据设定的终止条件，如达到最大迭代次数、找到满意的解等，决定是否终止算法。若终止，则输出最优解；若不满足终止条件，则回到步骤2，继续进行迭代。

算法解决问题实例

货郎担问题

python实现

import random
import numpy as np

# 城市坐标
city_coordinates = np.array([[60, 200], [180, 200], [80, 180], [140, 180], [20, 160], [100, 160], [200, 160], [140, 140],
                            [40, 120], [100, 120], [180, 100], [60, 80], [120, 80], [180, 60], [20, 40], [100, 40], [200, 40],
                            [20, 20], [60, 20], [160, 20]])

# 遗传算法的参数
population_size = 100  # 种群大小
generations = 100  # 迭代代数
mutation_rate = 0.02  # 变异概率

# 初始化种群
def initialize_population():
    population = []
    for _ in range(population_size):
        individual = list(range(len(city_coordinates)))
        random.shuffle(individual)
        population.append(individual)
    return population

# 评估适应度
def evaluate_fitness(individual):
    total_distance = 0

    for i in range(len(individual)-1):
        city1 = individual[i]
        city2 = individual[i+1]
        total_distance += np.linalg.norm(city_coordinates[city1] - city_coordinates[city2])

    return 1 / total_distance

# 选择
def selection(population):
    selected = []
    fitness_values = [evaluate_fitness(individual) for individual in population]
    total_fitness = sum(fitness_values)
    probabilities = [fitness / total_fitness for fitness in fitness_values]
    selected_indices = np.random.choice(range(len(population)), size=len(population), p=probabilities)

    for idx in selected_indices:
        selected.append(population[idx])

    return selected

# 交叉
def crossover(parent1, parent2):
    child = [None] * len(parent1)
    start = random.randint(0, len(parent1)-1)
    end = random.randint(0, len(parent1)-1)

    if end < start:
        start, end = end, start

    for i in range(start, end+1):
        child[i] = parent1[i]

    for i in range(len(parent2)):
        if parent2[i] not in child:
            for j in range(len(child)):
                if child[j] is None:
                    child[j] = parent2[i]
                    break

    return child

# 变异
def mutation(individual):
    for i in range(len(individual)):
        if random.random() < mutation_rate:
            swap_index = random.randint(0, len(individual)-1)
            individual[i], individual[swap_index] = individual[swap_index], individual[i]
    return individual

# 遗传算法主过程
def genetic_algorithm():
    population = initialize_population()

    for _ in range(generations):
        selected_population = selection(population)
        offspring = []

        while len(offspring) < len(population):
            parent1 = random.choice(selected_population)
            parent2 = random.choice(selected_population)

            child = crossover(parent1, parent2)
            child = mutation(child)
            offspring.append(child)

        population = offspring
        
    best_individual = max(population, key=evaluate_fitness)
    best_fitness = evaluate_fitness(best_individual)
    best_route = [city_coordinates[city_idx] for city_idx in best_individual]

    return best_route, best_fitness

# 运行遗传算法
best_route, best_fitness = genetic_algorithm()

# 打印最佳路径和适应度
print("最佳路径：", best_route)
print("最佳适应度：", best_fitness)

本文仅为学习记录，如有错误欢迎指出。