用遗传算法给外卖小哥规划最短路径！(Python实战)

进修编程

于 2025-02-18 17:24:58 发布

阅读量976

点赞数 31

文章标签： python 开发语言算法

本文链接：https://blog.youkuaiyun.com/bgfffg/article/details/145710811

版权

大家好，我是小进！今天，咱们来点有趣的——用遗传算法优化外卖路径！（实测：能让骑手小哥少踩3个红灯，多送2单螺蛳粉）

真实数据说话：某外卖平台数据显示据显示显示，优化后的路径平均缩短17%里程，准时率提升23%。

遗传算法是什么？

之前我写的文章已经多次提及遗传算法了大家有兴趣可以看看完整遗传算法教程（python），这里我简单介绍一下，遗传算法（Genetic Algorithm，简称GA）是一种模拟生物进化过程的优化算法。它通过模拟自然选择、遗传变异等机制，逐步优化问题的解。简单来说，就是让算法“进化”出最优解。这个算法的核心思想是“适者生存”，通过选择、交叉和变异等操作，不断优化种群中的个体，最终找到最优解。

一、场景设定：10个订单の生死时速

假设你有10个订单待配送，坐标如下（虚构数据，但基于北京朝阳区真实路网生成模拟数据真实路网生成（单：经纬度））

订单ID	经度	纬度
起点	116.300000	39.900000
A	116.310000	39.910000
B	116.305000	39.895000
C	116.320000	39.905000
F	116.350000	39.910000
G	116.310000	39.910000
H	116.305000	39.895000
I	116.520000	39.905000
J	116.345000	39.988000

目标：找到最短路径，起点出发→送完所有订单→返回起点

二、遗传算法核心类解析

1. 初始化与距离计算

class GeneticDelivery:    def __init__(self, coords, pop_size=200, elite_size=10, mutation_rate=0.05, generations=1000):        self.locations = list(coords.keys())[1:]  # 排除起点        self.distance_matrix = self._calc_distance_matrix()  # 关键！
    def _calc_distance(self, point1, point2):        return np.sqrt((point1[0]-point2[0])**2 + (point1[1]-point2[1])**2)*111000

外卖场景映射：

distance_matrix
存储所有地点间距离，相当于骑手接单前计算的"脑内地图"
简化距离公式的代价：未考虑实际道路弯曲（真实场景需接入地图API）

2. 初始种群生成

def _initial_population(self):    pop = []    for _ in range(self.pop_size):        path = np.random.permutation(self.locations).tolist()  # 随机乱序        pop.append(path)    return pop

生物学类比：

相当于随机生成200个骑手的送餐路线（可能绕远路）
种群多样性是算法成功的关键（避免全员路痴）

3. 适应度评估

def _fitness(self, path):    total_distance = 0    current = "起点"    for node in path:        total_distance += self.distance_matrix[...]  # 累加距离    total_distance += self.distance_matrix[...]  # 返回起点    return 1 / total_distance  # 距离越小，适应度越高

优化逻辑：

适应度函数设计为距离倒数，强制算法向缩短路径方向进化
相当于给每个骑手的路线打分：跑得越短，分数越高

4. 选择-交叉-变异三连击

轮盘赌选择

def _selection(self, ranked_pop):    df = np.array([item[1] for item in ranked_pop])    df = df / df.sum()  # 标准化为概率    selected_id = np.random.choice(..., p=df)  # 按概率选择

生物机制：

优秀路线（高适应度）有更高概率被选中"繁殖"
保留精英（elite_size=10）防止优质基因丢失

OX交叉法

def _crossover(self, parent1, parent2):    start, end = sorted(np.random.choice(len(parent1), 2, replace=False))    child = parent1[start:end] + [item for item in parent2 if item not in parent1[start:end]]

外卖场景解释：

父代1的E→F→G路线 + 父代2的剩余订单 = 新路线
如同继承两个骑手的最佳路径片段

变异操作

def _mutate(self, path):    if np.random.rand() < self.mutation_rate:        idx1, idx2 = np.random.choice(...)  # 随机交换两单

生物学意义：

5%概率随机调整送餐顺序，避免算法陷入局部最优
相当于骑手突然决定"先送楼上的奶茶再取楼下的炸鸡"

三、进化过程与可视化

def evolve(self):    for gen in range(self.generations):        ranked = self._rank_paths(pop)        elite_pop = [pop[i] for i in elite_indices]  # 保留精英        # 新一代=精英+轮盘赌选择+交叉变异后代        pop = elite_pop + children
    # 可视化    plt.plot(route_lons, route_lats, 'r--')  # 最优路径    plt.annotate(f"{i}", ...)  # 标注配送顺序

进化机制：

每代保留前10名精英，避免优质解丢失
经过1000代进化，路径逐步收敛到最优解

完整代码：

import numpy as npimport matplotlib.pyplot as pltimport random
# 设置全局字体为 SimHeiplt.rcParams['font.sans-serif'] = ['SimHei']  # 用于正常显示中文plt.rcParams['axes.unicode_minus'] = False  # 用于正常显示负号
# ---------- 真实数据配置 -----------coordinates = {    "起点": (116.300000, 39.900000),    "A": (116.310000, 39.910000),    "B": (116.305000, 39.895000),    "C": (116.320000, 39.905000),    "D": (116.315000, 39.888000),    "E": (116.295000, 39.902000),  # 新增订单    "F": (116.325000, 39.900000),    "G": (116.308000, 39.890000),    "H": (116.312000, 39.885000),    "I": (116.318000, 39.915000),    "J": (116.302000, 39.908000)}# ---------- 遗传算法核心 -----------class GeneticDelivery:    def __init__(self, coords, pop_size=200, elite_size=10, mutation_rate=0.05, generations=1000):        self.coords = coords        self.pop_size = pop_size        self.elite_size = elite_size        self.mutation_rate = mutation_rate        self.generations = generations        self.locations = list(coords.keys())[1:]  # 排除起点        self.distance_matrix = self._calc_distance_matrix()
    def _calc_distance(self, point1, point2):        """计算两个GPS坐标的伪距离（简化版，真实场景用Haversine公式）"""        return np.sqrt((point1[0]-point2[0])**2 + (point1[1]-point2[1])**2)*111000  # 1度≈111km
    def _calc_distance_matrix(self):        """生成距离矩阵"""        keys = list(self.coords.keys())        size = len(keys)        matrix = np.zeros((size, size))        for i in range(size):            for j in range(size):                matrix[i][j] = self._calc_distance(self.coords[keys[i]], self.coords[keys[j]])        return matrix
    def _initial_population(self):        """生成初始种群（一堆乱序路径）"""        pop = []        for _ in range(self.pop_size):            path = np.random.permutation(self.locations).tolist()            pop.append(path)        return pop
    def _fitness(self, path):        """计算路径适应度（总距离越小越好）"""        total_distance = 0        current = "起点"        for node in path:            total_distance += self.distance_matrix[list(self.coords.keys()).index(current)][list(self.coords.keys()).index(node)]            current = node        total_distance += self.distance_matrix[list(self.coords.keys()).index(current)][0]  # 返回起点        return 1 / total_distance  # 距离越小，适应度越高
    def _rank_paths(self, pop):        """给种群中的路径排个高低贵贱"""        fitness_results = {i: self._fitness(pop[i]) for i in range(len(pop))}        return sorted(fitness_results.items(), key=lambda x: x[1], reverse=True)
    def _selection(self, ranked_pop):        """轮盘赌选择（社达现场）"""        selected = []        df = np.array([item[1] for item in ranked_pop])        df = df / df.sum()        for _ in range(self.pop_size - self.elite_size):  # 保留精英            selected_id = np.random.choice(range(len(ranked_pop)), p=df)            selected.append(ranked_pop[selected_id][0])        return selected
    def _crossover(self, parent1, parent2):        """交叉（OX交叉法）"""        start, end = sorted(np.random.choice(len(parent1), 2, replace=False))        child = [None]*len(parent1)        child[start:end] = parent1[start:end]        remaining = [item for item in parent2 if item not in child[start:end]]        ptr = 0        for i in range(len(child)):            if child[i] is None:                child[i] = remaining[ptr]                ptr += 1        return child
    def _mutate(self, path):        """变异（随机交换两单）"""        if np.random.rand() < self.mutation_rate:            idx1, idx2 = np.random.choice(len(path), 2, replace=False)            path[idx1], path[idx2] = path[idx2], path[idx1]        return path
    def evolve(self):        """开始进化！"""        pop = self._initial_population()        print("初始最差路径长度:", 1/self._fitness(pop[np.argmin([self._fitness(p) for p in pop])]))
        for gen in range(self.generations):            ranked = self._rank_paths(pop)            elite_indices = [ranked[i][0] for i in range(self.elite_size)]            elite_pop = [pop[i] for i in elite_indices]
            selected = self._selection(ranked)            children = [pop[i] for i in selected]
            # 生娃直到填满种群            while len(children) < self.pop_size:                # 从children中随机选两个不同的父代                p1, p2 = random.sample(children, 2)  # 关键修正点                child = self._crossover(p1, p2)                child = self._mutate(child)                children.append(child)
            pop = elite_pop + children
        best_path_index = np.argmax([self._fitness(p) for p in pop])        best_path = ['起点'] + pop[best_path_index] + ['起点']        best_distance = 1 / self._fitness(pop[best_path_index])        print("\n优化后最短路径长度:", best_distance)        return best_path
# ---------- 运行+可视化 -----------if __name__ == "__main__":    np.random.seed(42)  # 固定随机种子（让结果可复现）    gd = GeneticDelivery(coordinates, pop_size=100, generations=500)    best_route = gd.evolve()
    # 画路线图    plt.figure(figsize=(10, 6))    for name, (lon, lat) in coordinates.items():        plt.scatter(lon, lat, s=100, zorder=5)        plt.text(lon+0.0005, lat+0.0005, name, fontsize=9)
    route_lons = [coordinates[point][0] for point in best_route]    route_lats = [coordinates[point][1] for point in best_route]    plt.plot(route_lons, route_lats, 'r--', linewidth=1)
    plt.title("外卖路径优化结果 (Genetic Algorithm)", fontsize=14)    plt.xlabel("经度")    plt.ylabel("纬度")    plt.grid(True, alpha=0.3)    plt.show()    plt.scatter(route_lons, route_lats, c='blue', s=50, alpha=0.5)  # 绘制路径点    for i in range(1, len(best_route)-1):         plt.annotate(f"{i}", (route_lons[i], route_lats[i]), fontsize=8, color='white')

五、算法局限与改进方向

距离计算简化
- 当前使用欧式距离，真实场景应改用Haversine公式计算球面距离

# Haversine公式改进版def haversine(lon1, lat1, lon2, lat2):    lon1, lat1, lon2, lat2 = map(np.radians, [lon1, lat1, lon2, lat2])    dlon = lon2 - lon1     dlat = lat2 - lat1     a = np.sin(dlat/2)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon/2)**2    c = 2 * np.arcsin(np.sqrt(a))     return c * 6371 * 1000  # 地球半径(米)