【进阶四】Python实现(MD)HVRP常见求解算法——禁忌搜索算法（TS）

关注

原创 2022-11-26 16:36:23 1.8k 阅读 AI 写同款· GEO 优化 ›

禁忌搜索(Tabu Search)算法及python实现 禁忌搜索(Tabu Search)算法解决及python实现 禁忌搜索(Tabu Search,TS,又称禁忌搜寻法）是一种现代启发式算法，由美国科罗拉多大学教授Fred Glover在1986年左右提出的，是一个用来跳脱局部最优解的搜索方法。其先创立一个初始化的方案；基于此，算法“移动”到一相邻的方案。经过许多连续的移动过程，提高解的质量。本Markdown编辑器使用StackEdit修改而来... 阅读详情

禁忌搜索算法+Split 求解异构车辆路径规划问题

苦读百卷经史不止为功名之姿，学问里自有传承和坚持

信息传递

1. 适用场景

求解HVRP或MDHVRP
多车辆类型
车辆容量不小于需求节点最大需求
（多）车辆基地
车场车辆总数满足实际需求

2. 求解效果

（1）收敛曲线
在这里插入图片描述

（2）车辆路径
在这里插入图片描述

3. 代码分析

Christian Prins给出的HVRP的Split方法过程如下：

在这里插入图片描述
以上算法在搜索过程中需求节点的备选标签规模会非常大，占用内存且降低搜索效率，因此采用了帕累托思想来遗传非支配解（19行~21行）。为了进一步控制备选标签数量，本期文章还附加实现了通过剩余容量与剩余需求来判断是否产生新的备选标签，提前避免产生不可行的标签。尽管如此，当考虑的异构车辆类型较多、需求点规模较大时，求解效率依然较低（代码结构、python特性、硬件环境）。所以本期文章进一步加入了最大标签数量参数来控制每个需求节点的备选标签规模，通过调节该参数实现速度与质量的相对均衡。

4. 数据格式

这里采用solomon开源数据对算法进行测试，数据文件结构如下图所示，共100个需求点，3个车场，3类车辆，以.csv文件储存数据。
demand.csv文件内容如下图，其中第一行为标题栏，节点id从0开始递增编号。

在这里插入图片描述
depot.csv文件内容如下图，其中第一行为标题栏，依次为：车场id，车场平面x坐标，车场平面y坐标，车辆类型，车辆装载量，车辆数量，固定成本，单位里程运输成本。

在这里插入图片描述

5. 分步实现

（1）代码整体架构
在这里插入图片描述

（2）数据结构

定义Sol()类，Demand()类，Vehicle()类，Model()类，其属性如下表：

Sol()类，表示一个可行解

属性	描述
node_id_list	需求节点id有序排列集合
obj	优化目标值
route_list	车辆路径集合，对应MDVRPTW的解
action_id	解所对应的算子id，用于禁用算子

Demand()类，表示一个需求节点

属性	描述
id	物理节点id，需唯一
x_coord	物理节点x坐标
y_coord	物理节点y坐标
demand	物理节点需求

Vehicle()类，表示一个车队节点

属性	描述
depot_id	车辆归属的车场节点节点id，需唯一
x_coord	车辆归属车场节点x坐标
y_coord	车辆归属车场节点y坐标
type	车辆类型
capacity	车辆容量
free_speed	车辆运营速度
fixed_cost	车辆固定成本
variable_cost	车辆变动成本

Model()类，存储算法参数

属性	描述
best_sol	全局最优解，值类型为Sol()
demand_dict	需求节点集合（字典），值类型为Demand()
vehicle_dict	车队集合（字典），值类型为Vehicle()
vehicle_type_list	车队id集合
demand_id_list	需求节点id集合
sol_list	种群，值类型为Sol()
distance_matrix	节点距离矩阵
number_of_demands	需求节点数量
tabu_list	禁忌表
TL	算子禁忌长度
popsize	种群规模

（3）数据读取

def readCSVFile(demand_file,depot_file,model):
    with open(demand_file,'r') as f:
        demand_reader=csv.DictReader(f)
        for row in demand_reader:
            demand = Demand()
            demand.id = int(row['id'])
            demand.x_coord = float(row['x_coord'])
            demand.y_coord = float(row['y_coord'])
            demand.demand = float(row['demand'])
            model.demand_dict[demand.id] = demand
            model.demand_id_list.append(demand.id)
        model.number_of_demands=len(model.demand_id_list)

    with open(depot_file, 'r') as f:
        depot_reader = csv.DictReader(f)
        for row in depot_reader:
            vehicle = Vehicle()
            vehicle.depot_id = row['depot_id']
            vehicle.x_coord = float(row['x_coord'])
            vehicle.y_coord = float(row['y_coord'])
            vehicle.type = row['vehicle_type']
            vehicle.capacity=float(row['vehicle_capacity'])
            vehicle.numbers=float(row['number_of_vehicle'])
            vehicle.fixed_cost=float(row['fixed_cost'])
            vehicle.variable_cost=float(row['variable_cost'])
            model.vehicle_dict[vehicle.type] = vehicle
            model.vehicle_type_list.append(vehicle.type)

（4）距离计算

"距离矩阵计算"
def calDistanceMatrix(model):
    for i in range(len(model.demand_id_list)):
        from_node_id = model.demand_id_list[i]
        for j in range(i + 1, len(model.demand_id_list)):
            to_node_id = model.demand_id_list[j]
            dist = math.sqrt((model.demand_dict[from_node_id].x_coord - model.demand_dict[to_node_id].x_coord) ** 2
                             + (model.demand_dict[from_node_id].y_coord - model.demand_dict[to_node_id].y_coord) ** 2)
            model.distance_matrix[from_node_id, to_node_id] = int(dist)
            model.distance_matrix[to_node_id, from_node_id] = int(dist)
        for _, vehicle in model.vehicle_dict.items():
            dist = math.sqrt((model.demand_dict[from_node_id].x_coord - vehicle.x_coord) ** 2
                             + (model.demand_dict[from_node_id].y_coord - vehicle.y_coord) ** 2)
            model.distance_matrix[from_node_id, vehicle.type] = int(dist)
            model.distance_matrix[vehicle.type, from_node_id] = int(dist)

（5）路径成本计算

"计算解的成本"
def calTravelCost(route_list,model):
    obj=0
    for route in route_list:
        vehicle=model.vehicle_dict[route[0]]
        distance=0
        fixed_cost=vehicle.fixed_cost
        variable_cost=vehicle.variable_cost
        for i in range(len(route) - 1):
            from_node = route[i]
            to_node = route[i + 1]
            distance += model.distance_matrix[from_node, to_node]
        obj += fixed_cost + distance * variable_cost
    return obj

（6）目标函数计算

"目标函数"
def calObj(node_id_list,model):
    vehicle_routes = splitRoutes(node_id_list, model)
    if vehicle_routes:
        return calTravelCost(vehicle_routes,model),vehicle_routes
    else:
        return 10**9,None

（7）初始解

"构造初始解"
def generateInitialSol(node_id_list):
    node_id_list_=copy.deepcopy(node_id_list)
    random.seed(0)
    random.shuffle(node_id_list_)
    return node_id_list_

（8）定义算子

"定义邻域算子"
def createActions(n):
    action_list=[]
    nswap=n//2
    # 第一种算子（Swap）：前半段与后半段对应位置一对一交换
    for i in range(nswap):
        action_list.append([1,i,i+nswap])
    # 第二中算子（DSwap）：前半段与后半段对应位置二对二交换
    for i in range(0,nswap,2):
        action_list.append([2,i,i+nswap])
    # 第三种算子（Reverse）：指定长度的序列反序
    for i in range(0,n,4):
        action_list.append([3,i,i+3])
    return action_list

（9）路径提取

"路径提取：根据标号法的求解结果，从中提取出各车辆路径"
def extractRoutes(V,node_id_list,model):
    route_list = []
    min_obj=float('inf')
    pred_label_id=None
    v_type=None
    # search the min cost label of last node of the node_id_list
    for label in V[model.number_of_demands-1]:
        if label[3]<=min_obj:
            min_obj=label[3]
            pred_label_id=label[1]
            v_type=label[2]
    # generate routes by pred_label_id
    route=[node_id_list[-1]]
    indexs=list(range(0,model.number_of_demands))[::-1]
    start=1
    while pred_label_id!=1:
        for i in indexs[start:]:
            stop=False
            for label in V[i]:
                if label[0]==pred_label_id:
                    stop=True
                    pred_label_id=label[1]
                    start=i
                    v_type_=label[2]
                    break
            if not stop:
                route.insert(0,node_id_list[i])
            else:
                route.insert(0,v_type)
                route.append(v_type)
                route_list.append(route)
                route=[node_id_list[i]]
                v_type=v_type_
    route.insert(0,v_type)
    route.append(v_type)
    route_list.append(route)
    return route_list

（10）绘制收敛曲线

def plotObj(obj_list):
    plt.rcParams['font.sans-serif'] = ['SimHei'] #show chinese
    plt.rcParams['axes.unicode_minus'] = False  # Show minus sign
    plt.plot(np.arange(1,len(obj_list)+1),obj_list)
    plt.xlabel('Iterations')
    plt.ylabel('Obj Value')
    plt.grid()
    plt.xlim(1,len(obj_list)+1)
    plt.show()

（11）绘制车辆路径

def plotRoutes(model):
    for route in model.best_sol.route_list:
        x_coord=[model.vehicle_dict[route[0]].x_coord]
        y_coord=[model.vehicle_dict[route[0]].y_coord]
        for node_id in route[1:-1]:
            x_coord.append(model.demand_dict[node_id].x_coord)
            y_coord.append(model.demand_dict[node_id].y_coord)
        x_coord.append(model.vehicle_dict[route[-1]].x_coord)
        y_coord.append(model.vehicle_dict[route[-1]].y_coord)
        plt.grid()
        if route[0]=='v1':
            plt.plot(x_coord,y_coord,marker='o',color='black',linewidth=0.5,markersize=5)
        elif route[0]=='v2':
            plt.plot(x_coord,y_coord,marker='o',color='orange',linewidth=0.5,markersize=5)
        elif route[0]=='v3':
            plt.plot(x_coord,y_coord,marker='o',color='r',linewidth=0.5,markersize=5)
        else:
            plt.plot(x_coord, y_coord, marker='o', color='b', linewidth=0.5, markersize=5)
    plt.xlabel('x_coord')
    plt.ylabel('y_coord')
    plt.show()

（12）输出结果

def outPut(model):
    work=xlsxwriter.Workbook('result.xlsx')
    worksheet=work.add_worksheet()
    worksheet.write(0, 0, 'obj')
    worksheet.write(0, 1,model.best_sol.obj)
    worksheet.write(1, 0,'vehicleID')
    worksheet.write(1, 1,'depotID')
    worksheet.write(1, 2, 'vehicleType')
    worksheet.write(1, 3,'route')
    for row,route in enumerate(model.best_sol.route_list):
        worksheet.write(row+2,0,str(row+1))
        depot_id=model.vehicle_dict[route[0]].depot_id
        worksheet.write(row+2,1,depot_id)
        worksheet.write(row+2,2,route[0])
        r=[str(i)for i in route]
        worksheet.write(row+2,3, '-'.join(r))
    work.close()

（13）主函数

def run(demand_file,depot_file,epochs,TL,max_labels):
    """
    :param demand_file: demand 文件路径
    :param depot_file: depot 文件路径
    :param epochs: 迭代次数
    :param opt_type: 优化类型:0:最小化车辆数,1:最小化行驶距离
    :return: 无
    """
    model=Model()
    model.TL=TL
    model.max_labels = max_labels
    readCSVFile(demand_file,depot_file,model)
    calDistanceMatrix(model)
    action_list=createActions(len(model.demand_id_list))
    model.tabu_list=np.zeros(len(action_list))
    history_best_obj=[]
    sol=Sol()
    sol.node_id_list=generateInitialSol(model.demand_id_list)
    sol.obj,sol.route_list=calObj(sol.node_id_list,model)
    model.best_sol=copy.deepcopy(sol)
    history_best_obj.append(sol.obj)
    start_time = time.time()
    for ep in range(epochs):
        local_new_sol=Sol()
        local_new_sol.obj=float('inf')
        for i in range(len(action_list)):
            if model.tabu_list[i]==0:
                new_sol=Sol()
                new_sol.node_id_list=doAction(sol.node_id_list,action_list[i])
                new_sol.obj,new_sol.route_list=calObj(new_sol.node_id_list,model)
                new_sol.action_id=i
                if new_sol.obj<local_new_sol.obj:
                    local_new_sol=copy.deepcopy(new_sol)
        sol=local_new_sol
        for i in range(len(action_list)):
            if i==sol.action_id:
                model.tabu_list[sol.action_id]=model.TL
            else:
                model.tabu_list[i]=max(model.tabu_list[i]-1,0)
        if sol.obj<model.best_sol.obj:
            model.best_sol=copy.deepcopy(sol)
        history_best_obj.append(model.best_sol.obj)
        print("%s/%s， best obj: %.3f， runtime: %.3f" % (ep + 1, epochs, model.best_sol.obj, time.time() - start_time))
    plotObj(history_best_obj)
    plotRoutes(model)
    outPut(model)