代码内容已经ok 后续补充文档即可

Author: HTmonster

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.pythonPath": "C:\\ProgramData\\Anaconda3\\python.exe"
+}

algorithms/AntColonyAlgorithm.py

@@ -0,0 +1,133 @@
+'''
+Author: Theo_hui
+Date: 2020-12-14 20:14:23
+Descripttion: 蚁群算法
+'''
+import random
+import math
+import time
+import numpy as np
+
+from .Heuristic import Heuristic
+
+class AC(Heuristic):
+    ''' 蚁群算法 '''
+
+    def __init__(self,
+                ants_num,       # 蚂蚁数量
+                alpha,          # 信息素影响因子
+                beta,           # 期望影响因子
+                Rho,            # 信息素挥发率
+                Q,              # 信息素释放的量  常量
+                TSP,            # TSP实例
+                iteration=1000  # 迭代次数
+                ):
+
+        self.ants_num   =   ants_num
+        self.alpha      =   alpha
+        self.beta       =   beta
+        self.Rho        =   Rho
+        self.Q          =   Q
+        self.TSP        =   TSP
+        self.iteration  =   iteration # 迭代次数
+    
+    def cal_path_distance(self,path_mat):
+        ''' 计算距离'''
+        dis_list=[]
+        for path in path_mat:
+            dis_list.append(self.TSP.cal_path_distance(path))
+        return dis_list
+    
+    def _remove_same_group_city(self,citys,choose):
+        ''' 移除与choose是同一物品的城市 (包括自己)'''
+        for group in self.TSP.city_index_groups:
+            if choose in group:
+                for city in group:
+                    try:
+                        citys.remove(city)
+                    except Exception as e:
+                        print(city,citys,group)
+                        raise e
+                return citys
+    
+    
+    def solve(self, record_step=100):
+        ''' 执行蚁群算法'''
+
+        #初始化
+        items_num = len(self.TSP.city_index_groups)                # 物品数量
+        citys_num = len(self.TSP.city_locations)                   # 城市数量
+        distMat=self.TSP.distMat                                   # 距离矩阵
+
+        pheromone_mat=np.ones((citys_num,citys_num))               # 信息素浓度矩阵 初始为1
+        path_mat=np.zeros((self.ants_num,items_num)).astype(int)   # 路径矩阵
+
+        star_t=time.time()
+
+        print("======================[ AC ]===========================")
+        
+        for count in range(self.iteration):
+
+            #1.=== 随机放置蚂蚁 并让所有蚂蚁爬行完毕 ====
+            for ant in range(self.ants_num):
+                unvisit_list=list(range(citys_num))                 # 未访问的
+                choose=random.choice(unvisit_list)                  # 初始随机的放置蚂蚁
+                unvisit_list=self._remove_same_group_city(unvisit_list,choose)   # 移除有同类物品的城市
+                
+                # 记录开始城市
+                path_mat[ant,0]=choose
+                
+                for j in range(1,items_num):
+                    #轮盘法选择下一个城市
+                    trans_list,trans=[],0
+                    for k in range(len(unvisit_list)):
+                        # 计算概率 与信息素浓度成正比, 与距离成反比
+                        trans +=np.power(pheromone_mat[choose][unvisit_list[k]],self.alpha)*np.power(1.0/distMat[choose][k],self.beta)
+                        trans_list.append(trans)
+                    rand=random.uniform(0,trans)#产生随机数
+
+                    # 转一次轮盘 选择
+                    for t in range(len(trans_list)):
+                        if rand <= trans_list[t]:
+                            choose_next=unvisit_list[t]
+                            break
+                        else:
+                            continue
+                    else:
+                        choose_next=unvisit_list[-1]
+                    path_mat[ant,j]=choose_next#填路径矩阵
+
+                    # 更新候选城市
+                    visit=choose_next
+                    unvisit_list=self._remove_same_group_city(unvisit_list,visit)
+
+            #所有蚂蚁的路径表填满之后，算每只蚂蚁的总距离
+            dis_all_ant_list=self.cal_path_distance(path_mat)
+
+            #3.=========== 更新信息素矩阵 ==============
+            pheromone_change=np.zeros((citys_num,citys_num))
+            for i in range(self.ants_num):
+                # 在路径上的每两个相邻城市间留下信息素，与路径距离反比
+                for j in range(items_num-1):
+                    pheromone_change[path_mat[i,j]][path_mat[i,j+1]] += self.Q/distMat[path_mat[i,j]][path_mat[i,j+1]]
+                pheromone_change[path_mat[i,items_num-1]][path_mat[i,0]] += self.Q/distMat[path_mat[i,items_num-1]][path_mat[i,0]]
+            pheromone_mat=(1-self.Rho)*pheromone_mat+pheromone_change
+
+            #记录历史最佳值       
+            if count == 0 or min(dis_all_ant_list) < dis_new:
+                dis_new=min(dis_all_ant_list)
+                path_new=path_mat[dis_all_ant_list.index(dis_new)].copy()
+                self.TSP.set_path(path_new)
+
+            # 记录迭代的值
+            if count % record_step==0:
+                self.costs.append(dis_new)
+
+            print("[{}] path:{}      cost:{}".format(count,path_new,dis_new).replace("\n",''))
+
+        end_t=time.time()
+
+        print("=============[ path:{} cost:{}  time:{:.4}s]===============".format(self.TSP.path,self.TSP.distance,end_t-star_t))
+        
+        return self.TSP
+

algorithms/GeneticAlgorithm.py

@@ -0,0 +1,162 @@
+'''
+Author: Theo_hui
+Date: 2020-12-14 20:14:23
+Descripttion: 遗传算法
+'''
+import random
+import math
+import time
+
+from .Heuristic import Heuristic
+
+class GA(Heuristic):
+    ''' 遗传算法 '''
+
+    def __init__(self,
+                M,              # 种群规模
+                Pc,             # 交叉概率
+                Pm,             # 变异概率
+                TSP,            # TSP实例
+                iteration=1000  # 迭代次数
+                ):
+
+        self.M          =   M
+        self.Pc         =   Pc
+        self.Pm         =   Pm
+        self.TSP        =   TSP
+        self.iteration  =   iteration # 迭代次数
+    
+    def Generate_initial_pops(self):
+        ''' 生成初始种群 '''
+        pops=[]
+
+        for _ in range(self.M):
+            path=[]
+            city_index=self.TSP.city_index_groups.copy()
+            
+            # 随机生成个体
+            for __ in range(len(self.TSP.city_index_groups)):
+                group=random.choice(city_index)
+                path.append(random.choice(group))
+                city_index.remove(group)
+            pops.append(path)
+
+
+        
+        return pops
+
+    def cal_adaptation(self,pops):
+        ''' 计算种群的适应度 适应度为 10000/距离'''
+
+        adaps=[]
+        for pop in pops:
+            dist    =self.TSP.cal_path_distance(pop) # 计算距离
+            adap    =10000.0/dist                    # 适应度
+            adaps.append(adap)
+        return adaps
+    
+    def select_prop_operation(self,adaps,pops):
+        ''' 比例选择运算 轮盘赌算法 '''
+        
+        # 积累分布函数
+        adap_sum,y=[],0
+        for adap in adaps:
+            y+=adap
+            adap_sum.append(y)
+        
+        # 保留M*(1-Pc-Pm)个
+        new_pops=[]
+        for _ in range(int(self.M*(1-self.Pc-self.Pm))):
+            rand=random.uniform(0,adap_sum[-1])#产生随机数 转一次轮盘
+            for j in range(len(adap_sum)):
+                if rand<adap_sum[j]:
+                    new_pops.append(pops[j])
+                    break
+        return new_pops
+    
+    def cross(self,pops):
+        ''' 单点交叉 '''
+        new_pops=pops.copy()
+
+        # 变异M*Pc个
+        for _ in range(int(self.M*self.Pc)):
+            which = random.randint(0,len(new_pops)-1) # 选择一个进行交叉
+            pop=new_pops[which].copy()
+            while pop in new_pops:
+                # 必须产生新的
+                p,q=random.randint(0,len(self.TSP.city_index_groups)-1),random.randint(0,len(self.TSP.city_index_groups)-1)
+                pop[p],pop[q]=pop[q],pop[p]          # 第一次交叉
+                # m,n=random.randint(0,len(self.TSP.city_index_groups)-1),random.randint(0,len(self.TSP.city_index_groups)-1)
+                # pop[m],pop[n]=pop[n],pop[m]          # 第二次交叉
+            new_pops.append(pop)
+        return new_pops
+    
+    def variation(self,pops):
+        ''' 变异操作 '''
+        new_pops=pops.copy()
+        # 变异M*Pm个
+        for _ in range(int(self.M*self.Pm)):
+            which = random.randint(0,len(new_pops)-1) # 选择一个进行变异
+            pop=new_pops[which].copy()
+            while pop in new_pops:
+                # 选择同一个物品的城市进行随机替换
+                group = random.choice([x for x in self.TSP.city_index_groups if len(x)>1]).copy()
+                for i in range(len(pop)):
+                    if pop[i] in group:                       
+                        group.remove(pop[i])
+                        pop[i] = random.choice(group)
+            new_pops.append(pop)
+        return new_pops
+
+    def get_best_pop(self,pops,adaps):
+        ''' 找到最适应的种群 '''
+        max_adap=max(adaps)
+        index=adaps.index(max_adap)
+
+        return pops[index]
+
+    def solve(self, record_step=100):
+        ''' 执行遗传算法'''
+
+        #0.========== 初始化种群 ===============
+        pops    = self.Generate_initial_pops()   # 初始种群
+        adaps   = self.cal_adaptation(pops)      # 适应度
+        
+        star_t=time.time()
+
+        print("======================[ GA ]===========================")
+        
+        for i in range(self.iteration):
+            
+            # 记录信息
+            if i % record_step==0:
+                pop=self.get_best_pop(pops,adaps)
+                self.costs.append(self.TSP.cal_path_distance(pop))
+
+            #1.======== 比例选择运算 ==========
+            new_pops=self.select_prop_operation(adaps,pops)
+
+            #2.======== 单点交叉     ==========   
+            new_pops=self.cross(new_pops)
+
+            #3.======== 变异操作     ==========
+            new_pops=self.variation(new_pops)
+
+            pops=new_pops
+            adaps=self.cal_adaptation(pops)
+
+            # 记录历史最优解
+            best_path = self.get_best_pop(pops,adaps)
+            
+            if self.TSP.distance and self.TSP.cal_path_distance(best_path)<self.TSP.distance: self.TSP.set_path(best_path)
+            if not self.TSP.distance: self.TSP.set_path(best_path)
+                
+
+            print("[{}] path:{} cost:{}".format(i,self.get_best_pop(pops,adaps),10000/max(adaps)))
+
+        end_t=time.time()
+
+        print("=============[ path:{} cost:{}  time:{:.4}s]===============".format(self.TSP.path,self.TSP.distance,end_t-star_t))
+        
+        return self.TSP
+

algorithms/Heuristic.py

@@ -0,0 +1,23 @@
+'''
+Author: Theo_hui
+Date: 2020-12-15 10:30:50
+Descripttion: 启发式算法的公共父类 
+'''
+import matplotlib.pyplot as plt
+
+class Heuristic:
+
+    # 每次迭代的花费
+    costs=[]
+
+    def plot_iter_cost(self):
+        ''' 画出迭代的收敛曲线 '''
+
+        x=list(range(len(self.costs)))
+        y=self.costs
+
+        plt.plot(x,y,color='b')
+        plt.title(self.__class__.__name__)
+        plt.xlabel('iters')
+        plt.ylabel('distance')
+        plt.show()