遗传算法 python 避障

遗传算法是一种优化算法，可以用于解决许多问题，包括避障问题。在避障问题中，我们可以将每个个体看作是一个行走路径，通过适应度函数来评估每条路径的好坏程度。

以下是一个简单的遗传算法 python 代码示例，用于解决避障问题：

import random

# 定义迷宫地图，其中0表示空地，1表示障碍物
maze = [
    [0, 0, 0, 0, 1],
    [1, 0, 1, 0, 0],
    [0, 0, 1, 0, 1],
    [0, 1, 0, 0, 0],
    [0, 0, 0, 1, 0]
]

# 定义每个个体的染色体长度
chromosome_length = 20

# 定义种群大小
population_size = 50

# 定义交叉概率和变异概率
crossover_probability = 0.8
mutation_probability = 0.1

# 定义适应度函数
def fitness_function(chromosome):
    # 将染色体转换成路径
    path = []
    for i in range(0, chromosome_length, 2):
        x = chromosome[i]
        y = chromosome[i + 1]
        if x < 0 or x >= len(maze) or y < 0 or y >= len(maze[0]) or maze[x][y] == 1:
            break
        path.append((x, y))

    # 计算路径长度作为适应度
    return len(path)

# 定义选择函数，采用轮盘赌选择
def selection(population):
    fitness_sum = sum(fitness_function(chromosome) for chromosome in population)
    pointer = random.uniform(0, fitness_sum)
    fitness_cumulative = 0
    for chromosome in population:
        fitness_cumulative += fitness_function(chromosome)
        if fitness_cumulative >= pointer:
            return chromosome

# 定义交叉函数，采用单点交叉
def crossover(chromosome1, chromosome2):
    if random.random() < crossover_probability:
        point = random.randint(1, chromosome_length - 1)
        chromosome1_new = chromosome1[:point] + chromosome2[point:]
        chromosome2_new = chromosome2[:point] + chromosome1[point:]
        return chromosome1_new, chromosome2_new
    else:
        return chromosome1, chromosome2

# 定义变异函数，采用随机变异
def mutation(chromosome):
    if random.random() < mutation_probability:
        point = random.randint(0, chromosome_length - 1)
        chromosome[point] = random.randint(0, len(maze) - 1)
        chromosome[point + 1] = random.randint(0, len(maze[0]) - 1)
        return chromosome
    else:
        return chromosome

# 初始化种群
population = []
for i in range(population_size):
    chromosome = [random.randint(0, len(maze) - 1) for j in range(chromosome_length)]
    population.append(chromosome)

# 迭代
for generation in range(100):
    # 评估适应度
    fitnesses = [fitness_function(chromosome) for chromosome in population]

    # 打印当前最优解
    best_fitness = max(fitnesses)
    best_chromosome = population[fitnesses.index(best_fitness)]
    best_path = []
    for i in range(0, chromosome_length, 2):
        x = best_chromosome[i]
        y = best_chromosome[i + 1]
        if x < 0 or x >= len(maze) or y < 0 or y >= len(maze[0]) or maze[x][y] == 1:
            break
        best_path.append((x, y))
    print("Generation:", generation, "Best Path:", best_path)

    # 选择、交叉、变异
    new_population = []
    for i in range(population_size):
        chromosome1 = selection(population)
        chromosome2 = selection(population)
        chromosome1_new, chromosome2_new = crossover(chromosome1, chromosome2)
        chromosome1_new = mutation(chromosome1_new)
        chromosome2_new = mutation(chromosome2_new)
        new_population.append(chromosome1_new)
        new_population.append(chromosome2_new)

    population = new_population

在上面的代码中，我们定义了一个5x5的迷宫地图，其中0代表空地，1代表障碍物。我们的个体是一个长度为20的染色体，其中每两个基因代表一个坐标，表示路径上的一个点。我们使用轮盘赌选择、单点交叉和随机变异来生成新的种群，并计算每个个体的适应度函数来评估其好坏程度。最后，我们迭代100代，并输出每代的最优路径。

这段代码可以解决简单的避障问题，但是对于复杂的地图和动态的障碍物，可能需要更复杂的算法来解决。