一、导论
演化算法是一类模拟自然界遗传进化规律的仿生学算法，它不是一个具体的算法，而是一个算法簇。遗传算法是演化算法的一个分支，由于遗传算法的整体搜索策略和优化计算是不依赖梯度信息，所以它的应用比较广泛。
本次使用遗传算法（用Python编写）来解决TSP问题。
二、算法流程
（1）首先，对城市进行编号0，1，2，3……30。
（2）采用十进制编码：直接用城市的编号进行编码，染色体{0，1，2，……30}表示路径为0-1-2-……-30。
（3）参数设计：种群规模count=300，染色体长度length=31，进化次数epoch_time=2000。
（4）初始化种群：为了加快程序的运行速度，在初始种群的选取中要选取一些较优秀的个体。使用改良圈算法求得一个较好的初始种群。随机生成一个染色体，比如{0，1，2，……30}，任意交换两城市顺序位置，如果总距离减小，则更新改变染色体，如此重复，直至不能再做修改。
（5）采用次序交叉法。首先 随机地在双亲中选择两个杂交点，再交换杂交段，其他位置根据双亲城市的相对位置确定。
（6）变异也是实现群体多样性的一种手段，同时也是全局寻优的保证。具体设计如下， 按照给定的变异率，对选定变异的个体，随机地取三个整数，满足 1<u<v<w<33 ，把 v 、u之间（包括u 和v）的基因段插到w后面。
三、代码清单
| 文件 | 定位 | 作用 |
| data.txt | 数据文件 | 存放城市信息 |
| main.py | 主程序 | 程序入口，遗传算法求解TSP问题 |
data.txt：每一行为一条城市信息，第一列为城市名，第二列、第三列为城市横坐标、纵坐标。一共有31条城市信息。
重庆,106.54,29.59
拉萨,91.11,29.97
乌鲁木齐,87.68,43.77
银川,106.27,38.47
呼和浩特,111.65,40.82
南宁,108.33,22.84
哈尔滨,126.63,45.75
长春,125.35,43.88
沈阳,123.38,41.8
石家庄,114.48,38.03
太原,112.53,37.87
西宁,101.74,36.56
济南,117,36.65
郑州,113.6,34.76
南京,118.78,32.04
合肥,117.27,31.86
杭州,120.19,30.26
福州,119.3,26.08
南昌,115.89,28.68
长沙,113,28.21
武汉,114.31,30.52
广州,113.23,23.16
台北,121.5,25.05
海口,110.35,20.02
兰州,103.73,36.03
西安,108.95,34.27
成都,104.06,30.67
贵阳,106.71,26.57
昆明,102.73,25.04
香港,114.1,22.2
澳门,113.33,22.13main.py：主程序
# -*- coding:utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
import math
from random import random, randint, shuffle
# 设置字体
matplotlib.rcParams['font.family'] = 'STSong'
# 载入数据
def read_data():
# 城市名
_name = []
# 城市坐标
_condition = []
# 读取数据
with open('data.txt', 'r', encoding='utf-8') as f:
lines = f.readlines()
for line in lines:
line = line.split('\n')[0]
line = line.split(',')
_name.append(line[0])
_condition.append([float(line[1]), float(line[2])])
_condition = np.array(_condition)
return _name, _condition
class TSP:
def __init__(self, _origin):
# 起始点
self.origin = _origin
# 进化次数
self.epochTime = 2000
# 种群数
self.populationCount = 300
# 保持率
self.retainRate = 0.3
# 变异率
self.mutationRate = 0.2
# 改良次数
self.improveCount = 10000
# 读取数据
self.cityNames, self.condition = read_data()
# 城市数目
self.cityCount = len(self.cityNames)
# 生成距离矩阵
self.mat = self.get_distance_matrix()
# 城市索引
self.cityIndex = [_ for _ in range(self.cityCount)]
self.cityIndex.remove(_origin)
# 距离矩阵
def get_distance_matrix(self):
# 使用短变量
_cnt = self.cityCount
_cdt = self.condition
# 生成矩阵
_mat = np.zeros([_cnt, _cnt])
for i in range(_cnt):
for j in range(i, _cnt):
if i == j:
_mat[i][j] = 0
else:
x2 = (_cdt[i][0] - _cdt[j][0]) ** 2
y2 = (_cdt[i][1] - _cdt[j][1]) ** 2
_mat[j][i] = _mat[i][j] = math.sqrt(x2 + y2)
return _mat
# 由路径求TSP路径总长度
def get_total_distance(self, _x):
# 使用短变量
_mat = self.mat
_origin = self.origin
# 计算长度
_dis = 0
_dis += _mat[_origin][_x[0]]
for _i in range(len(_x)):
if _i == len(_x) - 1:
_dis += _mat[_origin][_x[_i]]
else:
_dis += _mat[_x[_i]][_x[_i + 1]]
return _dis
# 生成一些较优秀的个体
def improve(self, _x):
# 改良次数
improve_count = self.improveCount
i = 0
_dis = self.get_total_distance(_x)
while i < improve_count:
u = randint(0, len(_x) - 1)
v = randint(0, len(_x) - 1)
if u != v:
new_x = _x.copy()
t = new_x[u]
new_x[u] = new_x[v]
new_x[v] = t
new_distance = self.get_total_distance(new_x)
if new_distance < _dis:
_dis = new_distance
_x = new_x.copy()
else:
continue
i += 1
return _x
# 自然选择
def selection(self, _population):
# 保持率
retain_rate = self.retainRate
# 对总距离从小到大进行排序
graded = [[self.get_total_distance(_x), _x] for _x in _population]
graded = [_x[1] for _x in sorted(graded)]
# 选出适应性强的染色体
retain_length = int(len(graded) * retain_rate)
_parents = graded[:retain_length]
# 设置弱者的存活概率
random_select_rate = 0.2
# 选出适应性不强，但是幸存的染色体
for chromosome in graded[retain_length:]:
if random() < random_select_rate:
_parents.append(chromosome)
return _parents
# 交叉
def crossover(self, _parents):
# 生成子代的个数,保证种群数目稳定
target_count = self.populationCount - len(_parents)
# 孩子列表
cs = []
while len(cs) < target_count:
male_index = randint(0, len(_parents) - 1)
female_index = randint(0, len(_parents) - 1)
if male_index != female_index:
male = _parents[male_index]
female = _parents[female_index]
left = randint(0, len(male) - 2)
right = randint(left + 1, len(male) - 1)
# 交叉片段
gene1 = male[left:right]
gene2 = female[left:right]
child1_c = male[right:] + male[:right]
child2_c = female[right:] + female[:right]
child1 = child1_c.copy()
child2 = child2_c.copy()
for o in gene2:
child1_c.remove(o)
for o in gene1:
child2_c.remove(o)
child1[left:right] = gene2
child2[left:right] = gene1
child1[right:] = child1_c[0:len(child1) - right]
child1[:left] = child1_c[len(child1) - right:]
child2[right:] = child2_c[0:len(child1) - right]
child2[:left] = child2_c[len(child1) - right:]
cs.append(child1)
cs.append(child2)
return cs
# 变异
def mutation(self, _cs):
# 变异率
mutation_rate = self.mutationRate
# 生成变异后结果
cs = []
for i in range(len(_cs)):
child = _cs[i]
if random() < mutation_rate:
u = randint(1, len(child) - 4)
v = randint(u + 1, len(child) - 3)
w = randint(v + 1, len(child) - 2)
child = child[0:u] + child[v:w] + child[u:v] + child[w:]
cs.append(child)
return cs
# 得到最佳纯输出结果
def get_best_result(self, _population):
graded = [[self.get_total_distance(_x), _x] for _x in _population]
graded = sorted(graded)
return graded[0][0], graded[0][1]
# 进化
def evolution(self):
# 使用短变量
_origin = self.origin
# 初始化种群
population = []
for i in range(self.populationCount):
# 随机生成个体
x = self.cityIndex.copy()
shuffle(x)
# 优化个体
x = self.improve(x)
# 添加
population.append(x)
# 遗传优化
register = []
i = 0
distance, result_path = self.get_best_result(population)
while i < self.epochTime:
# 选择繁殖个体群
parents = self.selection(population)
# 交叉繁殖
cs = self.crossover(parents)
# 变异操作
cs = self.mutation(cs)
# 更新种群
population = parents + cs
distance, result_path = self.get_best_result(population)
register.append(distance)
i += 1
result_path = [_origin] + result_path + [_origin]
# 输出
print(distance)
print(result_path)
print(register)
# 绘图
xs = list()
ys = list()
_names = self.cityNames
_condition = self.condition
for j in result_path:
# 画注解
plt.annotate(_names[j], [_condition[j, 0], _condition[j, 1]])
xs.append(_condition[j, 0])
ys.append(_condition[j, 1])
# 绘图
plt.xlabel('X')
plt.ylabel('Y')
plt.plot(xs, ys, '-o')
plt.show()
plt.xlabel('训练次数')
plt.ylabel('距离')
plt.plot(list(range(len(register))), register)
plt.show()
if __name__ == '__main__':
t1 = TSP(3)
t1.evolution()
四、运行结果
贪心法求解TSP问题（用于与遗传算法比较）：
起点为城市0，最短长度为188.23。路径为：0-> 26-> 27-> 5-> 23-> 30-> 29-> 21-> 19-> 20-> 18-> 15-> 14-> 16-> 17-> 22-> 12-> 9-> 10-> 4-> 3-> 24-> 11-> 25-> 13-> 8-> 7-> 6-> 28-> 1-> 2-> 0。
遗传算法求解TSP问题
运行结果1：
起点城市为3，最短路径长度为150.98。路径为：[3, 24, 11, 2, 1, 28, 26, 0, 27, 5, 23, 30, 29, 21, 19, 20, 18, 17, 22, 16, 14, 15, 12, 8, 7, 6, 4, 10, 9, 13, 25, 3]。
该结果为迭代次数为2000次时运行结果。
算法收敛情况如下：
横坐标为遗传算法的训练次数，纵坐标为最短路径长度。
五、分析与思考
（1）算法评价
| 算法 | 优点 | 缺点 |
| 贪心法 | 计算量小，运行时间较短 | 答案固定，不能获得更加优秀的解 |
| 遗传算法 | 收敛条件不够明确、计算量大、运行时间长、很多参数的确定需要多次测试 | 与贪心法相比，可以获得更优的路径解 |
| 动态规划 | 点较少时，运行时间可以接受，可以获得最优解 | 点数目较多时，运行时间过长 |
（2）遗传算法分析
1） 遗传算法终止条件：
- 当最优个体的适应度达到给定的阈值；
- 最优个体的适应度和群体适应度不再上升；
- 迭代次数达到预设的代数时，算法终止。
2） 可以通过分析算法收敛情况，修改迭代次数，减少计算量，提高运行效率。
3） 遗传算法解决TSP问题，收敛情况多种多样。可以通过修改起始点、多次运行获得更优的路径解。
（3）总结
由于遗传算法的整体搜索策略和优化计算是不依赖梯度信息，只需要影响搜索方向的目标函数和相应的适应度函数，所以它的应用比较广泛。
利用遗传算来进行大规模问题的组合优化是一种比较有效的方法，因为在目前的计算上利用枚举法求解最优解有一定的难度。
但是遗传算法也有不足之处，它对算法的精确度、可行度、计算复杂性等方面还没有有效的定量分析方法。
六、参考文献
[1] 遗传算法解决TSP问题. Springtostring.
https://blog.csdn.net/springtostring/article/details/82429604
[2] 遗传算法. 维基百科. https://zh.wikipedia.org/wiki/遗传算法
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
