蚁群算法讲解python

简介

蚁群算法（Ant Clony Optimization， ACO）作为一个启发式群智能算法，它是由一群无智能或有轻微智能的个体通过相互协作而表现出智能行为，从而为求解复杂问题提供了一个新的可能性。

ACO是一种仿生学算法，是由自然界中蚂蚁觅食的行为而启发的。在自然界，蚂蚁觅食过程中，蚁群总能够按照寻找到一条从蚁巢和食物源的最优路径，这也就是蚁群算法的由来。

注：然而蚁群算法去做路径规划和优化智能算法或机器学习算法却不太一样。

路径规划的蚁群算法优化步骤（典型tsp问题）：

初始化一些参数。α——信息素重要程度因子；β——启发函数重要程度因子；ρ——信息素挥发因子；Q为常数；m为蚁群数量；城市规模num_city；迭代次数iter_max，信息素矩阵 $\tau _{ij}$ 等。
计算概率。 $P_{ij}^{k}(t)=\begin{cases} \frac{\tau _{ij}(t)}{\sum_{s\in allowed_{k}}^{}\tau _{is}(t)}& \text{ if } j= allowed_{k} \\ 0& \text{ if } j\neq allowed_{k} \end{cases}$ ，其中 $allowed_{k}$ 为第k只蚂蚁后续可以走的城市集合； $P_{ij}^{k}(t)$ 为第k只蚂蚁在t时刻从城市i转移到城市j的概率。
更新信息素浓度。 $\begin{cases} \tau \left ( t+1 \right )=\left ( 1-\rho \right )\tau _{ij}\left ( t \right )+\sum_{k=1}^{m}\Delta\tau _{ij}^{k} & \text{ if }0< \rho < 1 \\ \Delta \tau _{ij}^{k}=\begin{cases} \frac{Q}{L_{k}}& \text{ if } L_{k}=distant(s_{ij}^{k}) \\ 0& \text{ if } else \end{cases}& \end{cases}$ ，Lk为第k只蚂蚁曾经走过的路径。
判断是否达到最大迭代次数，达到从而结束算法。

import random
import math
import numpy as np
import matplotlib.pyplot as pltclass ACO(object):def __init__(self, num_city, data):self.m = 50  # 蚂蚁数量self.alpha = 0.5  # 信息素重要程度因子self.beta = 5  # 启发函数重要因子self.rho = 0.1  # 信息素挥发因子self.Q = 1  # 常量系数self.num_city = num_city  # 城市规模self.location = data  # 城市坐标self.Tau = np.zeros([num_city, num_city])  # 信息素矩阵self.Table = [[0 for _ in range(num_city)] for _ in range(self.m)]  # 生成的蚁群self.iter = 1self.iter_max = 500self.dis_mat = self.compute_dis_mat(num_city, self.location)  # 计算城市之间的距离矩阵self.Eta = 10. / self.dis_mat  # 启发式函数self.paths = None  # 蚁群中每个个体的长度# 存储存储每个温度下的最终路径，画出收敛图self.iter_x = []self.iter_y = []# self.greedy_init(self.dis_mat,100,num_city)def greedy_init(self, dis_mat, num_total, num_city):start_index = 0result = []for i in range(num_total):rest = [x for x in range(0, num_city)]# 所有起始点都已经生成了if start_index >= num_city:start_index = np.random.randint(0, num_city)result.append(result[start_index].copy())continuecurrent = start_indexrest.remove(current)# 找到一条最近邻路径result_one = [current]while len(rest) != 0:tmp_min = math.inftmp_choose = -1for x in rest:if dis_mat[current][x] < tmp_min:tmp_min = dis_mat[current][x]tmp_choose = xcurrent = tmp_chooseresult_one.append(tmp_choose)rest.remove(tmp_choose)result.append(result_one)start_index += 1pathlens = self.compute_paths(result)sortindex = np.argsort(pathlens)       # argsort()是将X中的元素从小到大排序后，提取对应的索引index，然后输出到yindex = sortindex[0]result = result[index]for i in range(len(result)-1):s = result[i]s2 = result[i+1]self.Tau[s][s2] = 1self.Tau[result[-1]][result[0]] = 1# for i in range(num_city):#     for j in range(num_city):# return result# 轮盘赌选择def rand_choose(self, p):x = np.random.rand()for i, t in enumerate(p):x -= tif x <= 0:breakreturn i# 生成蚁群def get_ants(self, num_city):for i in range(self.m):start = np.random.randint(num_city - 1)self.Table[i][0] = startunvisit = list([x for x in range(num_city) if x != start])current = startj = 1while len(unvisit) != 0:P = []# 通过信息素计算城市之间的转移概率for v in unvisit:P.append(self.Tau[current][v] ** self.alpha * self.Eta[current][v] ** self.beta)P_sum = sum(P)P = [x / P_sum for x in P]# 轮盘赌选择一个一个城市index = self.rand_choose(P)current = unvisit[index]self.Table[i][j] = currentunvisit.remove(current)j += 1# 计算不同城市之间的距离def compute_dis_mat(self, num_city, location):dis_mat = np.zeros((num_city, num_city))for i in range(num_city):for j in range(num_city):if i == j:dis_mat[i][j] = np.infcontinuea = location[i]b = location[j]tmp = np.sqrt(sum([(x[0] - x[1]) ** 2 for x in zip(a, b)]))dis_mat[i][j] = tmpreturn dis_mat# 计算一条路径的长度def compute_pathlen(self, path, dis_mat):a = path[0]b = path[-1]result = dis_mat[a][b]for i in range(len(path) - 1):a = path[i]b = path[i + 1]result += dis_mat[a][b]return result# 计算一个群体的长度def compute_paths(self, paths):result = []for one in paths:length = self.compute_pathlen(one, self.dis_mat)result.append(length)return result# 更新信息素def update_Tau(self):delta_tau = np.zeros([self.num_city, self.num_city])paths = self.compute_paths(self.Table)for i in range(self.m):for j in range(self.num_city - 1):a = self.Table[i][j]b = self.Table[i][j + 1]delta_tau[a][b] = delta_tau[a][b] + self.Q / paths[i]a = self.Table[i][0]b = self.Table[i][-1]delta_tau[a][b] = delta_tau[a][b] + self.Q / paths[i]self.Tau = (1 - self.rho) * self.Tau + delta_taudef aco(self):best_lenth = math.inf           # math.inf返回浮点正无穷大best_path = Nonefor cnt in range(self.iter_max):# 生成新的蚁群self.get_ants(self.num_city)  # out>>self.Tableself.paths = self.compute_paths(self.Table)# 取该蚁群的最优解tmp_lenth = min(self.paths)tmp_path = self.Table[self.paths.index(tmp_lenth)]# 可视化初始的路径if cnt == 0:init_show = self.location[tmp_path]init_show = np.vstack([init_show, init_show[0]])# 更新最优解if tmp_lenth < best_lenth:best_lenth = tmp_lenthbest_path = tmp_path# 更新信息素self.update_Tau()# 保存结果self.iter_x.append(cnt)self.iter_y.append(best_lenth)print(cnt,best_lenth)return best_lenth, best_pathdef run(self):best_length, best_path = self.aco()return self.location[best_path], best_length# 读取数据
def read_tsp(path):lines = open(path, 'r').readlines()assert 'NODE_COORD_SECTION\n' in linesindex = lines.index('NODE_COORD_SECTION\n')data = lines[index + 1:-1]tmp = []for line in data:line = line.strip().split(' ')if line[0] == 'EOF':continuetmpline = []for x in line:if x == '':continueelse:tmpline.append(float(x))if tmpline == []:continuetmp.append(tmpline)data = tmpreturn datadata = read_tsp('data/st70.tsp')data = np.array(data)
data = data[:, 1:]
# 加上一行因为会回到起点
show_data = np.vstack([data, data[0]])aco = ACO(num_city=data.shape[0], data=data.copy())
Best_path, Best = aco.run()
print(Best)
Best_path = np.vstack([Best_path, Best_path[0]])
plt.plot(Best_path[:, 0], Best_path[:, 1])
plt.title('st70:aco-tsp')
plt.show()

蚁群算法优化智能算法（以优化函数为例）：

初始化种群pop_size=100 ，最大迭代次数NGEN=50，信息素挥发因子rou=0.8，Q常量为1。
随机产生蚂蚁初始位置，计算适应度函数值，设为初始信息素，计算信息素转移概率
```
pi[i] = (t_max - t[i]) / t_max
```

依据概率计算下一时刻位置

 if pi[i] < np.random.uniform(0, 1):self.pop_x[i][j] = self.pop_x[i][j] + np.random.uniform(-1, 1) * lamdaelse:self.pop_x[i][j] = self.pop_x[i][j] + np.random.uniform(-1, 1) * (self.bound[1][j] - self.bound[0][j]) / 2

信息素更新。

t[i] = (1 - rou) * t[i] + Q * self.fitness(self.pop_x[i])

反复迭代，直到达到最大迭代次数

完整python代码：

import numpy as np
import matplotlib.pyplot as pltclass ACO:def __init__(self, parameters):# 初始化self.NGEN = parameters[0]  # 迭代的代数self.pop_size = parameters[1]  # 种群大小self.var_num = len(parameters[2])  # 变量个数self.bound = []  # 变量的约束范围self.bound.append(parameters[2])self.bound.append(parameters[3])self.pop_x = np.zeros((self.pop_size, self.var_num))  # 所有蚂蚁的位置self.g_best = np.zeros((1, self.var_num))  # 全局蚂蚁最优的位置# 初始化第0代初始全局最优解temp = -1for i in range(self.pop_size):for j in range(self.var_num):self.pop_x[i][j] = np.random.uniform(self.bound[0][j], self.bound[1][j])fit = self.fitness(self.pop_x[i])if fit > temp:self.g_best = self.pop_x[i]temp = fitdef fitness(self, ind_var):"""个体适应值计算"""x1 = ind_var[0]x2 = ind_var[1]x3 = ind_var[2]y = 4*x1 ** 2 + 2*x2 + x3 ** 3return ydef update_operator(self, gen, t, t_max):"""更新算子：根据概率更新下一时刻的位置"""rou = 0.8  # 信息素挥发系数Q = 1  # 信息释放总量lamda = 1 / genpi = np.zeros(self.pop_size)for i in range(self.pop_size):for j in range(self.var_num):pi[i] = (t_max - t[i]) / t_max# 更新位置if pi[i] < np.random.uniform(0, 1):self.pop_x[i][j] = self.pop_x[i][j] + np.random.uniform(-1, 1) * lamdaelse:self.pop_x[i][j] = self.pop_x[i][j] + np.random.uniform(-1, 1) * (self.bound[1][j] - self.bound[0][j]) / 2# 越界保护if self.pop_x[i][j] < self.bound[0][j]:self.pop_x[i][j] = self.bound[0][j]if self.pop_x[i][j] > self.bound[1][j]:self.pop_x[i][j] = self.bound[1][j]# 更新t值t[i] = (1 - rou) * t[i] + Q * self.fitness(self.pop_x[i])# 更新全局最优值if self.fitness(self.pop_x[i]) > self.fitness(self.g_best):self.g_best = self.pop_x[i]t_max = np.max(t)return t_max, tdef main(self):popobj = []best = np.zeros((1, self.var_num))[0]for gen in range(1, self.NGEN + 1):if gen == 1:tmax, t = self.update_operator(gen, np.array(list(map(self.fitness, self.pop_x))),np.max(np.array(list(map(self.fitness, self.pop_x)))))else:tmax, t = self.update_operator(gen, t, tmax)print('############ Generation {} ############'.format(str(gen)))print(self.g_best)print(self.fitness(self.g_best))if self.fitness(self.g_best) > self.fitness(best):best = self.g_best.copy()popobj.append(self.fitness(best))print('最好的位置：{}'.format(best))print('最大的函数值：{}'.format(self.fitness(best)))print("---- End of (successful) Searching ----")plt.figure()plt.title("Figure1")plt.xlabel("iterators", size=14)plt.ylabel("fitness", size=14)t = [t for t in range(1, self.NGEN + 1)]plt.plot(t, popobj, color='b', linewidth=2)plt.show()if __name__ == '__main__':NGEN = 100popsize = 50low = [1, 1, 1]up = [30, 30, 30]parameters = [NGEN, popsize, low, up]aco = ACO(parameters)aco.main()

效果不好时，大家记得调节参数。

总结：

蚁群算法缺点：

收敛速度慢
易于陷入局部最优

参数作用：

蚂蚁数量：种群数量越多，得到的最优解就越精确,但是会有大量蚂蚁重复路过同一路径,运行时间增多。
alpha 信息素重要程度因子：alpha值过大,蚂蚁选择之前走过的路径可能性就越大,蚁群搜索路径的随机性减弱。alpha值过小,蚁群搜索范围就会减少,易陷入局部最优解。
beta 启发函数因子：beta值增大,蚁群更容易选择局部较短路径,能加快算法的运行速度,但是可能陷入局部最优解。
ruo 信息素挥发因子：当ruo很小的时候，每条路径的残留信息很多，就会反复进行搜索，运算时间增加；ruo很大的时候,会放弃搜索很多有效路径,可能会丢失最优值。

蚁群算法讲解python相关推荐

python蚁群算法路径规划_蚁群算法(1) - Python实现
1 importnumpy as np2 importmatplotlib.pyplot as plt3 4 5 #建立"蚂蚁"类 6 classAnt(object):7 def ...
02 求解旅行商问题的蚁群算法的python实现
旅行商问题可描述为:给定一个城市列表及城市间距离矩阵,如何从一个城市出发最终返回该城市的路径最短. 蚁群算法是受蚁群及其分散觅食行为启发而开发的一款群智能算法.整个蚁群可被视为一个分散的有机体:蚁后拥 ...
【建模算法】基于蚁群算法求解TSP问题（Python实现）
[建模算法]基于蚁群算法(ACA)求解TSP问题(Python实现) TSP (traveling salesman problem,旅行商问题)是典型的NP完全问题,即其最坏情况下的时间复杂度随着问 ...
python闭环最短路径_深度学习经典算法 | 蚁群算法解析
蚁群算法基本思想蚁群算法的基本原理来源于自然界中蚂蚁觅食的最短路径问题.根据昆虫学家的观察,发现自然界的蚂蚁虽然视觉不发达,但它可以在没有任何提示的情况下找到从食物源到巢穴的最短路径,并且能在环境发 ...
蚁群算法（详解）python
only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays ...
蚂蚁算法python_蚁群算法python编程实现
前言这篇文章主要介绍了Python编程实现蚁群算法详解,涉及蚂蚁算法的简介,主要原理及公式,以及Python中的实现代码,具有一定参考价值,需要的朋友可以了解下. 蚁群算法简介蚁群算法(ant c ...
Python实现VRP常见求解算法——蚁群算法（ACO）
基于python语言,实现经典蚁群算法(ACO)对车辆路径规划问题(CVRP)进行求解. 目录优质资源 1. 适用场景 2. 求解效果 3. 问题分析 4. 数据格式 5. 分步实现 6. 完整代码 ...
【进阶四】Python实现(MD)HVRP常见求解算法——蚁群算法（ACO）
蚁群算法+Split 求解异构车辆路径规划问题目录信息传递 1. 适用场景 2. 求解效果 3. 代码分析 4. 数据格式 5. 分步实现 6. 完整代码参考信息传递 python实现6种智能 ...
集货运输优化：数学建模步骤，Python实现蚁群算法（解决最短路径问题），蚁群算法解决旅行商问题（最优路径问题），节约里程算法
目录数学建模步骤 Python实现蚁群算法(解决最短路径问题) 蚁群算法解决旅行商问题(最优路径问题) 节约里程算法

蚁群算法讲解python

简介

路径规划的蚁群算法优化步骤（典型tsp问题）：

蚁群算法优化智能算法（以优化函数为例）：

完整python代码：

总结：

蚁群算法讲解python相关推荐

最新文章

热门文章