退火算法解决TSP问题，python描述

模拟退火算法来源于固体退火原理，将固体加温至充分高，再让其徐徐冷却，加温时，固体内部粒子随温升变为无序状，内能增大，而徐徐冷却时粒子渐趋有序，在每个温度都达到平衡态，最后在常温时达到基态，内能减为最小。根据 Metropolis 准则，粒子在温度T时趋于平衡的概率为 e-ΔE/(kT) ，其中 E 为温度 T 时的内能， ΔE 为其改变量， k 为 Boltzmann 常数。用固体退火模拟组合优化问题，将内能E模拟为目标函数值 f ，温度 T 演化成控制参数 t ，即得到解组合优化问题的模拟退火算法：由初始解 i 和控制参数初值 t 开始，对当前解重复“产生新解计算目标函数差接受或舍弃”的迭代，并逐步衰减t值，算法终止时的当前解即为所得近似最优解，这是基于蒙特卡罗迭代求解法的一种启发式随机搜索过程。退火过程由冷却进度表 (Cooling Schedule) 控制，包括控制参数的初值 t 及其衰减因子 Δt 、每个 t 值时的迭代次数 L 和停止条件 S 。
模拟退火算法的模型
模拟退火算法可以分解为解空间、目标函数和初始解三部分。

模拟退火的基本思想:
(1) 初始化：初始温度 T (充分大)，初始解状态 S (是算法迭代的起点)， 每个 T 值的迭代次数 L

(2) 对 k=1，……，L 做第 3 至第 6 步：

(3) 产生新解 S’

(4) 计算增量 Δt′=C(S′)-C(S) ，其中 C(S) 为评价函数

(5) 若 Δt′<0 则接受 S′ 作为新的当前解，否则以概率 exp(-Δt′/T) 接受 S′ 作为新的当前解.

(6) 如果满足终止条件则输出当前解作为最优解，结束程序。 终止条件通常取为连续若干个新解都没有被接受时终止算法。

(7) T 逐渐减少，且 T->0 ，然后转第 2 步。

模拟退火的算法流程图如下:

模拟退火算法新解的产生和接受可分为如下四个步骤：

第一步是由一个产生函数从当前解产生一个位于解空间的新解；为便于后续的计算和接受，减少算法耗时，通常选择由当前新解经过简单地变换即可产生新解的方法，如对构成新解的全部或部分元素进行置换、互换等，注意到产生新解的变换方法决定了当前新解的邻域结构，因而对冷却进度表的选取有一定的影响。

第二步是计算与新解所对应的目标函数差。因为目标函数差仅由变换部分产生，所以目标函数差的计算最好按增量计算。事实表明，对大多数应用而言，这是计算目标函数差的最快方法。

第三步是判断新解是否被接受,判断的依据是一个接受准则，最常用的接受准则是 Metropolis 准则: 若 Δt′<0 则接受 S′ 作为新的当前解 S ，否则以概率 exp(-Δt′/T) 接受 S′ 作为新的当前解 S 。

第四步是当新解被确定接受时，用新解代替当前解，这只需将当前解中对应于产生新解时的变换部分予以实现，同时修正目标函数值即可。此时，当前解实现了一次迭代。可在此基础上开始下一轮试验。而当新解被判定为舍弃时，则在原当前解的基础上继续下一轮试验。模拟退火算法与初始值无关，算法求得的解与初始解状态 S (是算法迭代的起点)无关；模拟退火算法具有渐近收敛性，已在理论上被证明是一种以概率 l 收敛于全局最优解的全局优化算法；模拟退火算法具有并行性

如果你对退火的物理意义还是晕晕的，没关系我们还有更为简单的理解方式。想象一下如果我们现在有下面这样一个函数，现在想求函数的（全局）最优解。如果采用 Greedy 策略，那么从 A 点开始试探，如果函数值继续减少，那么试探过程就会继续。而当到达点B时，显然我们的探求过程就结束了（因为无论朝哪个方向努力，结果只会越来越大）。最终我们只能找打一个局部最后解 B 。

根据Metropolis准则，粒子在温度T时趋于平衡的概率为 exp(-ΔE/(kT)) ，其中 E 为温度 T 时的内能，ΔE为其改变数, k 为 Boltzmann 常数。 Metropolis 准则常表示为

Metropolis 准则表明，在温度为 T 时，出现能量差为 dE 的降温的概率为 P(dE)，表示为： P(dE) = exp(dE/(kT)) 。其中 k 是一个常数， exp 表示自然指数，且 dE<0 。所以 P 和 T 正相关。这条公式就表示：温度越高，出现一次能量差为 dE 的降温的概率就越大；温度越低，则出现降温的概率就越小。又由于 dE 总是小于 0 （因为退火的过程是温度逐渐下降的过程），因此 dE/kT < 0 ，所以 P(dE) 的函数取值范围是 (0,1) 。随着温度 T 的降低， P(dE) 会逐渐降低。
我们将一次向较差解的移动看做一次温度跳变过程，我们以概率 P(dE) 来接受这样的移动。也就是说，在用固体退火模拟组合优化问题，将内能E模拟为目标函数值 f，温度T演化成控制参数 t，即得到解组合优化问题的模拟退火演算法：由初始解 i 和控制参数初值 t 开始，对当前解重复“产生新解计算目标函数差接受或丢弃”的迭代，并逐步衰减 t 值，算法终止时的当前解即为所得近似最优解，这是基于蒙特卡罗迭代求解法的一种启发式随机搜索过程。退火过程由冷却进度表 (Cooling Schedule) 控制，包括控制参数的初值 t 及其衰减因子 Δt 、每个 t 值时的迭代次数 L 和停止条件 S 。

总结起来就是：

若 f( Y(i+1) ) <= f( Y(i) ) (即移动后得到更优解)，则总是接受该移动；
若 f( Y(i+1) ) > f( Y(i) ) (即移动后的解比当前解要差)，则以一定的概率接受移动，而且这个概率随着时间推移逐渐降低（逐渐降低才能趋向稳定）相当于上图中，从 B 移向 BC 之间的小波峰时，每次右移（即接受一个更糟糕值）的概率在逐渐降低。如果这个坡特别长，那么很有可能最终我们并不会翻过这个坡。如果它不太长，这很有可能会翻过它，这取决于衰减 t 值的设定。

模拟退火算法的简单应用
作为模拟退火算法应用，讨论货郎担问题 ( Travelling Salesman Problem ，简记为 TSP )：设有 n 个城市，用数码1,…,n 代表。城市i和城市j之间的距离为 d(i，j) i, j=1,…,n ．TSP 问题是要找遍访每个域市恰好一次的一条回路，且其路径总长度为最短.。

求解 TSP 的模拟退火算法模型可描述如下：

解空间 解空间S是遍访每个城市恰好一次的所有回路，是 {1，……，n} 的所有循环排列的集合， S 中的成员记为(w1,w2 ,……，wn) ，并记 wn+1= w1 。初始解可选为 (1，……，n)

目标函数 此时的目标函数即为访问所有城市的路径总长度或称为代价函数：

我们要求此代价函数的最小值。

新解的产生 随机产生 1 和 n 之间的两相异数 k 和 m ，若 k

(w1, w2 ,…，wk , wk+1 ,…，wm ,…，wn)

变为：

(w1, w2 ,…，wm , wm-1 ,…，wk+1 , wk ,…，wn) .

如果是 k>m ，则将

(w1, w2 ,…，wk , wk+1 ,…，wm ,…，wn)

变为：

(wm, wm-1 ,…，w1 , wm+1 ,…，wk-1 ,wn , wn-1 ,…，wk) .

上述变换方法可简单说成是“逆转中间或者逆转两端”。

也可以采用其他的变换方法，有些变换有独特的优越性，有时也将它们交替使用，得到一种更好方法。

代价函数差 设将 (w1, w2 ,……，wn) 变换为 (u1, u2 ,……，un) , 则代价函数差为：

根据上述分析，可写出用模拟退火算法求解 TSP 问题的伪程序：

import numpy as np
import matplotlib.pyplot as plt
import math

# 子程序：计算各城市间的距离，得到距离矩阵
def getdistMat(coordinates):
    num = coordinates.shape[0]  # 坐标点
    distmat = np.zeros((num, num))  # 距离矩阵
    for i in range(num):
        for j in range(i, num):
        	if i==j:
        		distmat[i][j] =10000
        	else:
            	distmat[i][j] = distmat[j][i] = np.linalg.norm(coordinates[i] - coordinates[j])
    return distmat

# 子程序：初始化模拟退火算法的控制参数
def initPara():
    tInitial = 1000.0  # 设定初始退火温度(initial temperature)
    tFinal = 1.0  # 设定终止退火温度(stop temperature)
    nMarkov = 1000  # Markov链长度，也即内循环运行次数
    alpha = 0.99  # 设定降温参数，T(k)=alpha*T(k-1)
    return tInitial, tFinal, alpha, nMarkov


def drawtour(tourGiven, value, coordinates,nameCity):
    fig = plt.figure()
    num = len(tourGiven)
    plt.title("Optimization result of TSP{:d}".format(num))
    plt.rcParams['font.sans-serif'] = [u'SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    x0, y0 = coordinates[tourGiven[num - 1]]
    x1, y1 = coordinates[tourGiven[0]]
    plt.scatter(int(x0), int(y0), s=15, c='g')  # 绘制城市坐标点 C(n-1)
    plt.plot([x1, x0], [y1, y0], c='r')  # 绘制旅行路径 C(n-1)~C(0)
    for i in range(num - 1):
        x0, y0 = coordinates[tourGiven[i]]
        x1, y1 = coordinates[tourGiven[i + 1]]
        plt.text(int(x0), int(y0),nameCity[tourGiven[i]], ha='center', va='bottom', fontsize=10.5)
        plt.scatter(int(x0), int(y0), s=15, c='r')  # 绘制城市坐标点 C(i)
        plt.plot([x1, x0], [y1, y0], c='b')  # 绘制旅行路径 C(i)~C(i+1)
    plt.xlabel("Total mileage of the tour:{:.1f}".format(value))  # 设置 x轴标注
    plt.show()


# 距离迭代图
def drawiter(recordNow, recordBest, recordNew):
    fig = plt.figure()
    plt.title("Distance iteration graph")  # 设置图形标题
    plt.plot(np.array(recordNow), 'g-', label='Now')  # 绘制 valueNow曲线
    plt.plot(np.array(recordNew), 'b-', label='New')  # 绘制 valuenew曲线
    plt.plot(np.array(recordBest), 'r-', label='Best')  # 绘制 valueBest曲线
    plt.xlabel("Number of iterations")  # 设置 x轴标注
    plt.ylabel("Distance value")  # 设置 y轴标注
    plt.legend()  # 显示图例
    plt.show()


# 子程序：计算 TSP 路径长度
def calTourMileage(tourGiven, nCity, distMat):
    tourMileage = 0
    for i in range(nCity - 1):  # dist(0,1),...dist((n-2)(n-1))
        tourMileage += distMat[tourGiven[i], tourGiven[i + 1]]
    tourMileage += distMat[tourGiven[nCity - 1], tourGiven[0]]  # dist((n-1),0)
    return round(tourMileage)


def greedy(distMat, start_index):
    sum_distance, seq_result, n = 0, [start_index, ], len(distMat)
    for path_index in range(n - 1):
        distance_list = distMat[start_index]
        min_dis = max(distance_list)
        for index, distance in enumerate(distance_list):
            if (index not in seq_result) and (distance < min_dis):
                min_dis = distance
                start_index = index
        sum_distance += min_dis
        seq_result.append(start_index)
    return sum_distance, seq_result


def mutateSwap(tourGiven, nCity):
    if np.random.rand() > 0.5:  # 交换路径中的这2个节点的顺序，np.random.rand()产生[0, 1)区间的均匀随机数
        while True:  # 产生两个不同的随机数
            loc1 = np.int(np.ceil(np.random.rand() * (nCity - 1)))  # np.ceil表示向大于等于该值的向上取整；np.floor:向下取整
            loc2 = np.int(np.ceil(np.random.rand() * (nCity - 1)))
            if loc1 != loc2:
                break
        tourGiven[loc1], tourGiven[loc2] = tourGiven[loc2], tourGiven[loc1]
    else:  # 三交换
        while True:
            loc1 = np.int(np.ceil(np.random.rand() * (nCity - 1)))
            loc2 = np.int(np.ceil(np.random.rand() * (nCity - 1)))
            loc3 = np.int(np.ceil(np.random.rand() * (nCity - 1)))
            if ((loc1 != loc2) & (loc2 != loc3) & (loc1 != loc3)):
                break
            # 下面的三个判断语句使得loc1
        if loc1 > loc2:
            loc1, loc2 = loc2, loc1
        if loc2 > loc3:
            loc2, loc3 = loc3, loc2
        if loc1 > loc2:
            loc1, loc2 = loc2, loc1
            # 下面的三行代码将[loc1,loc2)区间的数据插入到loc3之后
        tourTmp = tourGiven[loc1:loc2].copy()
        tourGiven[loc1:loc3 - loc2 + 1 + loc1] = tourGiven[loc2:loc3 + 1].copy()
        tourGiven[loc3 - loc2 + 1 + loc1:loc3 + 1] = tourTmp.copy()  # 通过 交换操作 产生新路径
    return tourGiven


# 主程序


def main():
    city_name = []
    coordinates = []
    with open('18城市坐标.txt', 'r', encoding='UTF-8') as f:
        lines = f.readlines()
        # 调用readlines()一次读取所有内容并按行返回list给lines
        # for循环每次读取一行
        for line in lines:
            line = line.split('\n')[0]
            line = line.split(',')
            city_name.append(line[0])
            coordinates.append([float(line[1]), float(line[2])])
    coordinates = np.array(coordinates)  # 获取30城市坐标
    nCity = coordinates.shape[0]
    distMat = getdistMat(coordinates)  # 得到距离矩阵
    tourNew = np.arange(nCity)
    tourNow = np.arange(nCity)  # 产生初始路径，返回一个初值为0、步长为1、长度为nCity的排列
    valueNow = 0
    valueNow = calTourMileage(tourNow, nCity, distMat)  # 计算当前路径的总长度
    # valueNow,tourNow=greedy(distMat, 51)
    tourBest = tourNow.copy()  # 初始化最优路径，复制 tourNow

    print(valueNow, tourNow)
    valueBest = valueNow  # 初始化最优路径的总长度，复制 valueNow
    valueNew = 0
    recordBest = []  # 初始化最优路径记录表
    recordNow = []  # 初始化当前路径记录表
    recordNew = []
    # 开始模拟退火优化过程
    tInitial, tFinal, alpha, nMarkov = initPara()
    nMarkov = nCity  # Markov链 的初值设置
    tNow = tInitial

    # 通过 交换操作 产生新路径
    while tNow > tFinal:
        # 外循环，直到当前温度达到终止温度时结束
        for i in np.arange(nMarkov):
            mutateSwap(tourNew, nCity)
            valueNew = calTourMileage(tourNew, nCity, distMat)
            deltaE = valueNew - valueNow
            if deltaE < 0:
                tourNow = tourNew.copy()
                valueNow = valueNew
                if valueNew < valueBest:  # 如果新解的目标函数好于最优解，则将新解保存为最优解
                    valueBest = valueNew
                    tourBest = tourNew.copy()
            else:  # 按一定的概率接受该解
                if np.random.rand() < np.exp(-(deltaE) / tNow):
                    valueNow = valueNew
                    tourNow = tourNew.copy()
                else:
                    tourNew = tourNow.copy()
        tNow = alpha * tNow
        # 平移当前路径，以解决变换操作避开 0,（n-1）所带来的问题，并未实质性改变当前路径。
        #tourNow = np.roll(tourNow,1)                # 循环移位函数，沿指定轴滚动数组元素
        recordBest.append(valueBest)
        recordNow.append(valueNow)
        recordNew.append(valueNew)
    # 结束模拟退火过程
    # 图形化显示优化结果
    drawtour(tourBest, valueBest, coordinates,city_name)

    drawiter(recordNow, recordBest, recordNew)
    print("路线: \n", tourBest)
    print("里程: {:.1f}".format(valueBest))


if __name__ == '__main__':
    main()

![计算迭代图