掌握 Python中的遗传算法及旅行商问题应用

在当今世界，我们被复杂的问题所包围，需要有效的解决方案。

遗传算法是一种优化算法，可以通过模拟自然选择来找到问题的最佳解决方案。在本文中，我们将讨论 Python 遗传算法、它们的基本结构以及如何实现它们。

什么是遗传算法？

遗传算法（Genetic Algorithm，GA）最早是由美国的 John holland于20世纪70年代提出,该算法是根据大自然中生物体进化规律而设计提出的。是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。

遗传算法是一种模拟自然选择过程的优化算法。它的工作原理是创建一个个体群体（问题的潜在解决方案），然后根据给定的目标函数评估他们的适应性。更健康的个体更有可能被选为下一代，随着时间的推移，这会导致更适合该问题的个体群体。

遗传算法可用于解决从优化到机器学习的各种问题。例如，它们可用于找到神经网络的最佳配置、优化投资组合或提高制造过程的效率。

遗传算法的基本结构

遗传算法的基本结构如下：

1. 初始化： 创建初始个体群体（问题的潜在解决方案）。
2. 评估： 根据给定的目标函数评估每个人的适用性。
3. 选择：根据他们的健康状况选择最健康的。
4. 交叉： 通过组合所选个体的特征来创建新的个体（子个体）。
5. 变异： 对儿童进行随机变化，以增加人口的多样性。
6. 重复：对指定的代数重复步骤 2-5。

遗传算法引入变异的目的有两个:一是使遗传算法具有局部的随机搜索能力。当遗传算法通过交叉算子已接近最优解邻域时，利用变异算子的这种局部随机搜索能力可以加速向最优解收敛。显然，此种情况下的变异概率应取较小值，否则接近最优解的积木块会因变异而遭到破坏。二是使遗传算法可维持群体多样性，以防止出现未成熟收敛现象。此时收敛概率应取较大值。

Python 遗传算法超参数

Python 遗传算法超参数是指遗传算法中由用户设置的参数，用于控制算法的行为并影响其生成的解决方案的质量。遗传算法超参数的示例包括种群大小、突变率、交叉率和选择策略。这些超参数会对遗传算法的性能和收敛性产生重大影响，为它们找到最佳值通常是反复试验或使用优化技术的问题。在 Python 中，可以使用提供遗传算法实现的各种库和框架来设置和调整遗传算法超参数。

Python 遗传算法的实现

为了在 Python 中实现遗传算法，我们将首先定义我们想要解决的问题，创建潜在解决方案的初始群体，定义适应度函数，然后实现遗传算法。

假设我们想在 [0， 1] 范围内找到函数的最大值。我们可以使用遗传算法来找到最大化此函数的值。f(x) = x * sin(10 * pi * x) + 1x

初始化

我们首先创建潜在解决方案的初始群体。在这种情况下，我们可以随机生成一个 10 个个体的群体，其中每个个体都是介于 0 和 1 之间的浮点数。

import random
 
population_size = 10
population = [random.uniform(0, 1) for _ in range(population_

评估

接下来，我们需要评估人群中每个人的适应度。在这种情况下，适应度函数只是函数的值。我们可以将适应度函数定义如下：f(x)

import math
 
def fitness_function(x):
    return x * math.sin(10 * math.pi * x) + 1
 
def evaluate_population(population):
    return [fitness_function(individual) for individual in population]

Python 遗传算法特征选择

一旦我们评估了每个人的健康状况，我们就需要选择最合适的人，以便在下一代中使用它。我们可以使用多种选择策略，例如锦标赛选择、轮盘选择或基于排名的选择。在此示例中，我们将使用基于排名的选择，其中我们根据个人在总体中的排名来选择个人。

def select_parents(population, scores):
    cumulative_scores = [sum(scores[:i+1]) for i in range(len(scores))]
    parent_indices = []
    for _ in range(2):
        random_number = random.uniform(0, cumulative_scores[-1

我们可以按如下方式实现基于等级的选择：

def select_parents(population, scores):
    rank = [i for i in range(len(scores))]
    rank.sort(key=lambda x: scores[x], reverse=True)
    rank_prob = [((2 * (len(scores)) - i) / (2 * len(scores))) for i in range(len(scores))]
    parent_indices = []
    for _ in range(2):
        random_number = random.uniform(0, 1)
        for i, p in enumerate(rank_prob):
            if random_number < p:
                parent_indices.append(rank[i])
                break
    return [population[i] for i in parent_indices]

交叉

接下来，我们需要通过结合所选个体的特征来创造新的个体（孩子）。在这种情况下，我们可以使用一个简单的交叉运算符，在其中我们随机取两个父个体中的一个点，并结合它们的特征来创建一个子个体。

def crossover(parents):
    point = random.randint(1, len(parents[0]) - 1)
    child1 = parents[0][:point] + parents[1][point:]
    child2 = parents[1][:point] + parents[0][point:]
    return [child1, child2]

变异

为了增加人口的多样性，我们可以对儿童进行随机变化。在这种情况下，我们可以使用一个简单的突变运算符，其中我们用新的随机值随机替换子项中的特征。

def mutate(child, mutation_rate):
    for i in range(len(child)):
        if random.uniform(0, 1) < mutation_rate:
            child[i] = random.uniform(0, 1)
    return child

重复

最后，我们可以重复指定世代数的选择、交叉和突变步骤。我们可以将所有这些步骤放在一起来实现遗传算法，如下所示：

def genetic_algorithm(population_size, num_generations, mutation_rate):
    # Step 1: Initialization
    population = [random.uniform(0, 1) for _ in range(population_size)]
 
    for generation in range(num_generations):
        # Step 2: Evaluation
        scores = evaluate_population(population)
 
        # Step 3: Selection
        parents = [select_parents(population, scores) for _ in range(population_size // 2)]
 
        # Step 4: Crossover
        children = [crossover(p) for p in parents]
        children = [item for sublist in children for item in sublist]
 
        # Step 5: Mutation
        mutated_children = [mutate(c, mutation_rate) for c in children]
 
        # Combine parents and children
        combined_population = parents + mutated_children
 
        # Step 2: Evaluation
        scores = evaluate_population(combined_population)
 
        # Select the fittest individuals
        ranked_population = [x for _, x in sorted(zip(scores, combined_population), reverse=True)]
        population = ranked_population[:population_size]
 
    return population[0]

Python遗传算法解决“旅行商问题”

在 Python 中，遗传算法可用于解决旅行商问题，该问题涉及找到最短的路线，该路线恰好访问给定列表中的每个城市一次并返回起始城市。该方法涉及创建可能路线的种群，根据行进的总距离评估它们的适应度，并迭代进化种群以提高适应度，直到找到最佳解决方案。

这种方法可以应用于许多城市的大规模问题，在这些城市中，穷举的搜索技术在计算上变得不可行。Python 中提供了各种库和框架，例如 DEAP 和 PyGAD，它们提供了用于解决旅行商问题和其他优化问题的遗传算法的实现。

下面是一个示例 Python 代码，用于使用 PyGAD 库的遗传算法解决旅行商问题：

完整代码示例

import numpy as np
import pygad
 
# Define the distance matrix for the cities
distance_matrix = np.array([[0, 10, 15, 20],
                            [10, 0, 35, 25],
                            [15, 35, 0, 30],
                            [20, 25, 30, 0]])
 
# Define the fitness function for a given route
def fitness_func(solution, solution_idx):
    route = np.array(solution)
    distance = 0
    for i in range(len(route) - 1):
        distance += distance_matrix[route[i], route[i+1]]
    distance += distance_matrix[route[-1], route[0]]
    fitness = 1.0 / distance
    return fitness
 
# Define the population size, number of generations, and mutation probability
num_generations = 100
population_size = 50
mutation_probability = 0.01
 
# Create the initial population and run the genetic algorithm
initial_population = pygad.initial_population(population_size, num_genes=len(distance_matrix), gene_type=int)
ga_instance = pygad.GA(initial_population=initial_population, fitness_func=fitness_func, mutation_prob=mutation_probability)
ga_instance.run(num_generations)
 
# Print the best solution and its fitness value
best_solution, best_solution_fitness = ga_instance.best_solution()
print("Best solution:", best_solution)
print("Best solution fitness:", best_solution_fitness)

此代码为一小部分城市定义距离矩阵，将适应度函数定义为给定路线的总行驶距离的倒数，设置人口规模、世代数和突变概率，然后使用 PyGAD 库运行遗传算法。最后打印出最佳解决方案及其适应度值。

常见问题

遗传算法能找到函数的全局最优吗？

遗传算法可用于为复杂问题的优化，以找到良好的解决方案，当然，这也许并不能总是找到全局最优。

遗传算法的最佳编程语言是什么？

Python 是遗传算法的热门选择，因为它的简单性、可读性和许多第三方库的可用性。