精华内容
下载资源
问答
  • 蚁群算法原理介绍;蚁群算法起源;蚁群行为描述;蚁群行为描述;基本蚁群算法的机制原理;基本蚁群算法的系统学特征;蚁群算法是一个系统;蚁群算法满足分布式计算;蚁群算法具有自组织的特征;蚁群算法具有正反馈的特征;自...
  • 第 PAGE 页码 页码 页 / 总页数 NUMPAGES 总页数 总页数 页 蚁群算法原理及其应用浅谈指导变异蚁群算法 摘要蚁群算法是意大利学者Dorigo于1991年提出的一种模拟进化算法通过模拟蚂蚁在协作搜索食物时的搜索行为来...
  • 蚁群算法原理简述

    2019-07-27 16:14:45
    蚁群算法原理简述
  • 蚁群算法原理

    千次阅读 2019-08-25 09:28:53
    旅行商问题介绍 ...蚁群算法(AG)是一种模拟蚂蚁觅食行为的模拟优化算法,它是由意大利学者Dorigo M等人于1991年首先提出,并首先使用在解决TSP(旅行商问题)上 要点即为 1. 状态转移 2. 信息素更新

    旅行商问题介绍

    TSP(Traveling Salesman Problem)即旅行商问题,是数学领域中著名问题之一。这个问题是这样的:假设有一个旅行商人要拜访n个城市,他必须选择所要走的路径,路径的限制是每个城市只能拜访一次,而且最后要回到原来出发的城市。路径的选择目标是要求得的路径长度为所有路径之中的最小值。TSP是一个典型的组合优化问题,且是一个NP完全难题,关于NP的这个概念本文就不做详细介绍了,但简单的说就是:TSP问题目前尚不能找到一个多项式时间复杂度的算法来求解。

    蚁群算法(AG)是一种模拟蚂蚁觅食行为的模拟优化算法,它是由意大利学者Dorigo M等人于1991年首先提出,并首先使用在解决TSP(旅行商问题)上

    要点即为 1. 状态转移 2. 信息素更新

    展开全文
  • 算法设计与分析-蚁群算法原理及应用.zip
  • 蚁群算法原理及其应用,只是深入讲解蚁群算法!感谢作者.
  • 蚁群算法原理介绍PPT学习教案.pptx
  • 智能优化算法的蚁群算法详细资料,蚁群算法原理及其应用+2005.pdf,462页+完整版%2B目录
  • 蚁群算法原理及应用 科学出版社 段海滨 适合于入门 pdf很清晰
  • 蚁群算法原理及其应用 段海滨。 这本书是介绍蚁群算法的经典书籍。 书中,介绍了蚁群算法的收敛性,以及取得最优解的概率,及证明,是想 深入了解蚁群算法的研究者必备的书籍
  • 蚁群算法原理及其应用,段海滨经典著作。 学习蚁群算法不可多得的好书。
  • 蚁群算法大 纲蚁群算法的起源蚁群行为描述蚁群算法的基本思想基本蚁群算法的系统学特征TSP问题描述基本蚁群算法的数学模型基本蚁群算法的应用举例总结蚁群算法起源蚁群算法(ant colony optimization, ACO)Dorigo M于...
  • 蚁群算法原理以及应用

    万次阅读 多人点赞 2019-03-09 09:05:12
    本文首先对启发式算法和蚁群算法的由来以及含义做简要介绍,然后讲述蚁群算法的求解原理,再分别用两个案例解释蚁群算法,观察蚁群算法的求解结果;通过对蚁群算法的使用方法做简要介绍,可以了解近似解的含义以及正...

    关键词:启发式算法 蚁群算法 迭代 正反馈
    1.蚁群算法(ant colony algorithm,ACA)起源和发展历程
    Marco Dorigo等人在研究新型算法的过程中,发现蚁群在寻找食物时,通过分泌一种称为信息素的生物激素交流觅食信息从而能快速的找到目标,于是在1991年在其博士论文中首次系统地提出一种基于蚂蚁种群的新型智能优化算法“蚂蚁系统(Ant system,简称AS)”,后来,提出者及许多研究者对该算法作了各种改进,将其应用于更为广泛的领域,如图着色问题、二次分配问题、工件排序问题、车辆路径问题、车间作业调度问题、网络路由问题、大规模集成电路设计等。近些年来,M.Dorigo等人把蚂蚁算法进一步发展成一种通用的优化技术“蚁群优化(Ant Colony Optimization,简称ACO)”,并将所有符合ACO框架的算法称为“蚁群优化算法(ACO algorithm)”。
    初始蚁群爬行路线最终蚁群爬行路线
    具体来说,各个蚂蚁在没有事先告知食物在什么地方的前提下开始寻找食物。当一只找到食物以后,它会向环境释放一种挥发性分泌物pheromone (称为信息素,该物质随着时间的推移会逐渐挥发消失,信息素浓度的大小表征路径的远近)信息素能够让其他蚂蚁感知从而起到一个引导的作用。通常多个路径上均有信息素时,蚂蚁会优先选择信息素浓度高的路径,从而使浓度高的路径信息素浓度更高,形成一个正反馈。有些蚂蚁并没有像其它蚂蚁一样总重复同样的路,他们会另辟蹊径,如果另开辟的道路比原来的其他道路更短,那么,渐渐地,更多的蚂蚁被吸引到这条较短的路上来。最后,经过一段时间运行,可能会出现一条最短的路径被大多数蚂蚁重复着。最终,信息素浓度最高的路径即是最终被蚂蚁选中的最优路径。
    与其他算法相比,蚁群算法是一种比较年轻的算法,具有分布式计算、无中心控制、个体之间异步间接通信等特点,并且易于与其他优化算法相结合,经过不少仁人志士的不断探索,到今天已经发展出了各式各样的改进蚁群算法,不过蚁群算法的原理仍是主干。
    2蚁群算法的求解原理
    基于上述对蚁群觅食行为的描述,该算法主要对觅食行为进行以下几个方面模拟:
    1模拟的图场景中包含了两种信息素,一种表示家,一种表示食物的地点,并且这两种信息素都在以一定的速率进行挥发。
    2 每个蚂蚁只能感知它周围的小部分地方的信息。蚂蚁在寻找食物的时候,如果在感知范围内,就可以直接过去,如果不在感知范围内,就要朝着信息素多的地方走,蚂蚁可以有一个小概率不往信息素多的地方走,而另辟蹊径,这个小概率事件很重要,代表了一种找路的创新,对于找到更优的解很重要。
    3、蚂蚁回窝的规则与找食物的规则相同。
    4、蚂蚁在移动时候首先会根据信息素的指引,如果没有信息素的指引,会按照自己的移动方向惯性走下去,但也有一定的机率改变方向,蚂蚁还可以记住已经走过的路,避免重复走一个地方。
    5、蚂蚁在找到食物时留下的信息素最多,然后距离食物越远的地方留下的信息素越少。找到窝的信息素留下的量的规则跟食物相同。蚁群算法有以下几个特点:正反馈算法、并发性算法、较强的鲁棒性、概率型全局搜索、不依赖严格的数学性质、搜索时间长,易出现停止现象。
    蚂蚁转移概率公式:
    在这转移概率公式里插入图片描述
    公式中:是蚂蚁k从城市i转移到j的概率;α,β分别为信息素和启发式因子的相对重要程度;为边(i,j)上的信息素量;为启发式因子;为蚂蚁k下步允许选择的城市。上述公式即为蚂蚁系统中的信息素更新公式,是边(i,j)上的信息素量;ρ是信息素蒸发系数,0<ρ<1;为第k只蚂蚁在本次迭代中留在边(i,j)上的信息素量;Q为一正常系数;为第k只蚂蚁在本次周游中的路径长度。
    在蚂蚁系统中,信息素更新公式为:
    信息素更新公式
    3蚁群算法的求解步骤
    1.初始化参数在计算之初,需要对相关参数进行初始化,如蚁群规模(蚂蚁数量)m、信息素重要程度因子α、启发函数重要程度因子β、信息素会发银子ρ、信息素释放总量Q、最大迭代次数iter_max、迭代次数初值iter=1。
    1. 构建解空间将各个蚂蚁随机地置于不同的出发点,对每个蚂蚁k(k=1,2,3…m),按照(2-1)计算其下一个待访问城市,直到所有蚂蚁访问完所有城市。
    2. 更新信息苏计算每个蚂蚁经过路径长度Lk(k=1,2,…,m),记录当前迭代次数中的最优解(最短路径)。同时,根据式(2-2)和(2-3)对各个城市连接路径上信息素浓度进行更新。
    3. 判断是否终止若iter<iter_max,则令iter=iter+1,清空蚂蚁经过路径的记录表,并返回步骤2;否则,终止计算,输出最优解。
    4. 判断是否终止若iter<iter_max,则令iter=iter+1,清空蚂蚁经过路径的记录表,并返回步骤2;否则,终止计算,输出最优解。3. 判断是否终止若iter<iter_max,则令iter=iter+1,清空蚂蚁经过路径的记录表,并返回步骤2;否则,终止计算,输出最优解。
    蚁群算法流程简图
    4简单案例–依据蚁群算法的步骤求解二元函数最小值优化二元函数:
    (4-1)优化思路:首先,通过对约束条件求解, 我们可以得到满足约束条件的可行解所构成的搜索空间。这是一个二维的凸空间,如果把各个分量的范围搜索等分成离散的点,那么空间整个的大小可以由分量xi的划分粗细来确定。假设,xi被划分成了Ni份,那么整个搜索空间就有2*Ni个。而且为了求得精确解将分量 xi 的区间划分得很细, 那么搜索空间将变得十分巨大, 这也正是问题求解的困难所在,当然这种划分区间的方法也是许多优化算法所一般采用的方法。)将每个分量的取值区间等分成N个点,那么xi就有N种选择二维决策量x就有N^2种选择组合。并将每个分量的N个取值点看作N个城市City。最开始将m个蚂蚁Ant随机地放到x1的N中的m个City上。搜索开始后,Ant按照转移概率进行城市选择。在第一次选择时,用rand函数随机选择,之后可按照选择概率转移。
    本案例的具体步骤为:(1)求解约束条件得出各分量的区间,由题意知[-1,1];(2)将分量区间细化,建立搜索空间,本案例细分成73份,xi=[-1,-1+2/73,…1];(3)判断精度是否满足要求,若满足,则输出最优解并结束, 否则继续(4);(4)每个路径上设置信息量初始值;(5)随机选择路径求解;(6)每个蚂蚁按照选择概率来选择路径求解;
    (7)若每个蚂蚁都找到解,则继续(8),否则转(4);(8)将当前最优解的分量再细化, 转(2)。

    展开全文
  • 蚁群算法原理及其实现(python)

    万次阅读 多人点赞 2018-05-20 11:08:23
    蚁群算法(AG)是一种模拟蚂蚁觅食行为的模拟...之后,又系统研究了蚁群算法的基本原理和数学模型.蚁群算法的基本思想:# -*- coding: utf-8 -*- import random import copy import time import sys import math impor...
    蚁群算法(AG)是一种模拟蚂蚁觅食行为的模拟优化算法,它是由意大利学者Dorigo M等人于1991年首先提出,并首先使用在解决TSP(旅行商问题)上。
    之后,又系统研究了蚁群算法的基本原理和数学模型.
    蚁群算法的基本思想:


    蚁群算法的基本原理:

    1、蚂蚁在路径上释放信息素。

    2、碰到还没走过的路口,就随机挑选一条路走。同时,释放与路径长度有关的信息素。

    3、信息素浓度与路径长度成反比。后来的蚂蚁再次碰到该路口时,就选择信息素浓度较高路径。

    4、最优路径上的信息素浓度越来越大。

    5、最终蚁群找到最优寻食路径。

    人工蚁群与真实蚁群对比:

    基于TSP问题的基本蚁群算法:

    TSP求解中,假设蚁群算法中的每只蚂蚁是具有以下特征的简单智能体:

    每次周游,每只蚂蚁在其经过的支路(i,j)上都留下信息素。

    蚂蚁选择城市的概率与城市之间的距离和当前连接支路上所包含的信息素余量有关。

    ƒ为了强制蚂蚁进行合法的周游,直到一次周游完成后,才允许蚂蚁游走已访问过的城市(这可由禁忌表来控制)。

    基本蚁群的两个过程:

    (1)状态转移

    (2)信息素更新

    (1)状态转移

    为了避免残留信息素过多而淹没启发信息,在每只蚂蚁走完一步或者完成对所有n个城市的遍历(也即一个循环结束)后,要对残留信息进行更新处理。

    由此,t+n时刻在路径(i,j)上的信息量可按如下规则进行调整: 

    (2)信息素更新模型

    蚁周模型(Ant-Cycle模型)

    蚁量模型(Ant-Quantity模型)

    蚁密模型(Ant-Density模型)

    区别:

    1.蚁周模型利用的是全局信息,即蚂蚁完成一个循环后更新所有路径上的信息素;

    2.蚁量和蚁密模型利用的是局部信息,即蚂蚁完成一步后更新路径上的信息素。

    蚁群算法基本流程:

    蚁群算法中主要参数的选择:

    蚁群算法中主要参数的理想选择如下:

    国内外,对于离散域蚁群算法的改进研究成果很多,例如自适应蚁群算法、基于信息素扩散的蚁群算法等,这里仅介绍离散域优化问题的自适应蚁群算法。

    自适应蚁群算法:对蚁群算法的状态转移概率、信息素挥发因子、信息量等因素采用自适应调节策略为一种基本改进思路的蚁群算法。

    自适应蚁群算法中两个最经典的方法:蚁群系统(AntColony System, ACS)和最大-最小蚁群系统(MAX-MINAnt System, MMAS)。

    蚁群系统对基本蚁群算法改进:

    蚂蚁的状态转移规则不同;

    ②全局更新规则不同;


    ③新增了对各条路径信息量调整的局部更新规则

    下面是Python实现求50个城市之间最短距离的代码

    # -*- coding: utf-8 -*-
    import random
    import copy
    import time
    import sys
    import math
    import tkinter #//GUI模块
    import threading
    from functools import reduce
    
    
    # 参数
    '''
    ALPHA:信息启发因子,值越大,则蚂蚁选择之前走过的路径可能性就越大
          ,值越小,则蚁群搜索范围就会减少,容易陷入局部最优
    BETA:Beta值越大,蚁群越就容易选择局部较短路径,这时算法收敛速度会
         加快,但是随机性不高,容易得到局部的相对最优
    '''
    (ALPHA, BETA, RHO, Q) = (1.0,2.0,0.5,100.0)
    # 城市数,蚁群
    (city_num, ant_num) = (50,50)
    distance_x = [
        178,272,176,171,650,499,267,703,408,437,491,74,532,
        416,626,42,271,359,163,508,229,576,147,560,35,714,
        757,517,64,314,675,690,391,628,87,240,705,699,258,
        428,614,36,360,482,666,597,209,201,492,294]
    distance_y = [
        170,395,198,151,242,556,57,401,305,421,267,105,525,
        381,244,330,395,169,141,380,153,442,528,329,232,48,
        498,265,343,120,165,50,433,63,491,275,348,222,288,
        490,213,524,244,114,104,552,70,425,227,331]
    #城市距离和信息素
    distance_graph = [ [0.0 for col in range(city_num)] for raw in range(city_num)]
    pheromone_graph = [ [1.0 for col in range(city_num)] for raw in range(city_num)]
    
    
    
    #----------- 蚂蚁 -----------
    class Ant(object):
    
        # 初始化
        def __init__(self,ID):
            
            self.ID = ID                 # ID
            self.__clean_data()          # 随机初始化出生点
    
        # 初始数据
        def __clean_data(self):
        
            self.path = []               # 当前蚂蚁的路径           
            self.total_distance = 0.0    # 当前路径的总距离
            self.move_count = 0          # 移动次数
            self.current_city = -1       # 当前停留的城市
            self.open_table_city = [True for i in range(city_num)] # 探索城市的状态
            
            city_index = random.randint(0,city_num-1) # 随机初始出生点
            self.current_city = city_index
            self.path.append(city_index)
            self.open_table_city[city_index] = False
            self.move_count = 1
        
        # 选择下一个城市
        def __choice_next_city(self):
            
            next_city = -1
            select_citys_prob = [0.0 for i in range(city_num)]  #存储去下个城市的概率
            total_prob = 0.0
    
            # 获取去下一个城市的概率
            for i in range(city_num):
                if self.open_table_city[i]:
                    try :
                        # 计算概率:与信息素浓度成正比,与距离成反比
                        select_citys_prob[i] = pow(pheromone_graph[self.current_city][i], ALPHA) * pow((1.0/distance_graph[self.current_city][i]), BETA)
                        total_prob += select_citys_prob[i]
                    except ZeroDivisionError as e:
                        print ('Ant ID: {ID}, current city: {current}, target city: {target}'.format(ID = self.ID, current = self.current_city, target = i))
                        sys.exit(1)
            
            # 轮盘选择城市
            if total_prob > 0.0:
                # 产生一个随机概率,0.0-total_prob
                temp_prob = random.uniform(0.0, total_prob)
                for i in range(city_num):
                    if self.open_table_city[i]:
                        # 轮次相减
                        temp_prob -= select_citys_prob[i]
                        if temp_prob < 0.0:
                            next_city = i
                            break
    
            # 未从概率产生,顺序选择一个未访问城市
            # if next_city == -1:
            #     for i in range(city_num):
            #         if self.open_table_city[i]:
            #             next_city = i
            #             break
    
            if (next_city == -1):
                next_city = random.randint(0, city_num - 1)
                while ((self.open_table_city[next_city]) == False):  # if==False,说明已经遍历过了
                    next_city = random.randint(0, city_num - 1)
    
            # 返回下一个城市序号
            return next_city
        
        # 计算路径总距离
        def __cal_total_distance(self):
            
            temp_distance = 0.0
    
            for i in range(1, city_num):
                start, end = self.path[i], self.path[i-1]
                temp_distance += distance_graph[start][end]
    
            # 回路
            end = self.path[0]
            temp_distance += distance_graph[start][end]
            self.total_distance = temp_distance
            
        
        # 移动操作
        def __move(self, next_city):
            
            self.path.append(next_city)
            self.open_table_city[next_city] = False
            self.total_distance += distance_graph[self.current_city][next_city]
            self.current_city = next_city
            self.move_count += 1
            
        # 搜索路径
        def search_path(self):
    
            # 初始化数据
            self.__clean_data()
    
            # 搜素路径,遍历完所有城市为止
            while self.move_count < city_num:
                # 移动到下一个城市
                next_city =  self.__choice_next_city()
                self.__move(next_city)
    
            # 计算路径总长度
            self.__cal_total_distance()
    
    #----------- TSP问题 -----------
            
    class TSP(object):
    
        def __init__(self, root, width = 800, height = 600, n = city_num):
    
            # 创建画布
            self.root = root                               
            self.width = width      
            self.height = height
            # 城市数目初始化为city_num
            self.n = n
            # tkinter.Canvas
            self.canvas = tkinter.Canvas(
                    root,
                    width = self.width,
                    height = self.height,
                    bg = "#EBEBEB",             # 背景白色 
                    xscrollincrement = 1,
                    yscrollincrement = 1
                )
            self.canvas.pack(expand = tkinter.YES, fill = tkinter.BOTH)
            self.title("TSP蚁群算法(n:初始化 e:开始搜索 s:停止搜索 q:退出程序)")
            self.__r = 5
            self.__lock = threading.RLock()     # 线程锁
    
            self.__bindEvents()
            self.new()
    
            # 计算城市之间的距离
            for i in range(city_num):
                for j in range(city_num):
                    temp_distance = pow((distance_x[i] - distance_x[j]), 2) + pow((distance_y[i] - distance_y[j]), 2)
                    temp_distance = pow(temp_distance, 0.5)
                    distance_graph[i][j] =float(int(temp_distance + 0.5))
    
        # 按键响应程序
        def __bindEvents(self):
    
            self.root.bind("q", self.quite)        # 退出程序
            self.root.bind("n", self.new)          # 初始化
            self.root.bind("e", self.search_path)  # 开始搜索
            self.root.bind("s", self.stop)         # 停止搜索
    
        # 更改标题
        def title(self, s):
    
            self.root.title(s)
    
        # 初始化
        def new(self, evt = None):
    
            # 停止线程
            self.__lock.acquire()
            self.__running = False
            self.__lock.release()
    
            self.clear()     # 清除信息 
            self.nodes = []  # 节点坐标
            self.nodes2 = [] # 节点对象
    
            # 初始化城市节点
            for i in range(len(distance_x)):
                # 在画布上随机初始坐标
                x = distance_x[i]
                y = distance_y[i]
                self.nodes.append((x, y))
                # 生成节点椭圆,半径为self.__r
                node = self.canvas.create_oval(x - self.__r,
                        y - self.__r, x + self.__r, y + self.__r,
                        fill = "#ff0000",      # 填充红色
                        outline = "#000000",   # 轮廓白色
                        tags = "node",
                    )
                self.nodes2.append(node)
                # 显示坐标
                self.canvas.create_text(x,y-10,              # 使用create_text方法在坐标(302,77)处绘制文字
                        text = '('+str(x)+','+str(y)+')',    # 所绘制文字的内容
                        fill = 'black'                       # 所绘制文字的颜色为灰色
                    )
                
            # 顺序连接城市
            #self.line(range(city_num))
            
            # 初始城市之间的距离和信息素
            for i in range(city_num):
                for j in range(city_num):
                    pheromone_graph[i][j] = 1.0
                    
            self.ants = [Ant(ID) for ID in range(ant_num)]  # 初始蚁群
            self.best_ant = Ant(-1)                          # 初始最优解
            self.best_ant.total_distance = 1 << 31           # 初始最大距离
            self.iter = 1                                    # 初始化迭代次数 
                
        # 将节点按order顺序连线
        def line(self, order):
            # 删除原线
            self.canvas.delete("line")
            def line2(i1, i2):
                p1, p2 = self.nodes[i1], self.nodes[i2]
                self.canvas.create_line(p1, p2, fill = "#000000", tags = "line")
                return i2
            
            # order[-1]为初始值
            reduce(line2, order, order[-1])
    
        # 清除画布
        def clear(self):
            for item in self.canvas.find_all():
                self.canvas.delete(item)
    
        # 退出程序
        def quite(self, evt):
            self.__lock.acquire()
            self.__running = False
            self.__lock.release()
            self.root.destroy()
            print (u"\n程序已退出...")
            sys.exit()
    
        # 停止搜索
        def stop(self, evt):
            self.__lock.acquire()
            self.__running = False
            self.__lock.release()
            
        # 开始搜索
        def search_path(self, evt = None):
    
            # 开启线程
            self.__lock.acquire()
            self.__running = True
            self.__lock.release()
            
            while self.__running:
                # 遍历每一只蚂蚁
                for ant in self.ants:
                    # 搜索一条路径
                    ant.search_path()
                    # 与当前最优蚂蚁比较
                    if ant.total_distance < self.best_ant.total_distance:
                        # 更新最优解
                        self.best_ant = copy.deepcopy(ant)
                # 更新信息素
                self.__update_pheromone_gragh()
                print (u"迭代次数:",self.iter,u"最佳路径总距离:",int(self.best_ant.total_distance))
                # 连线
                self.line(self.best_ant.path)
                # 设置标题
                self.title("TSP蚁群算法(n:随机初始 e:开始搜索 s:停止搜索 q:退出程序) 迭代次数: %d" % self.iter)
                # 更新画布
                self.canvas.update()
                self.iter += 1
    
        # 更新信息素
        def __update_pheromone_gragh(self):
    
            # 获取每只蚂蚁在其路径上留下的信息素
            temp_pheromone = [[0.0 for col in range(city_num)] for raw in range(city_num)]
            for ant in self.ants:
                for i in range(1,city_num):
                    start, end = ant.path[i-1], ant.path[i]
                    # 在路径上的每两个相邻城市间留下信息素,与路径总距离反比
                    temp_pheromone[start][end] += Q / ant.total_distance
                    temp_pheromone[end][start] = temp_pheromone[start][end]
    
            # 更新所有城市之间的信息素,旧信息素衰减加上新迭代信息素
            for i in range(city_num):
                for j in range(city_num):
                    pheromone_graph[i][j] = pheromone_graph[i][j] * RHO + temp_pheromone[i][j]
    
        # 主循环
        def mainloop(self):
            self.root.mainloop()
    
    #----------- 程序的入口处 -----------
                    
    if __name__ == '__main__':
    
        print (u""" 
    --------------------------------------------------------
        程序:蚁群算法解决TPS问题程序 
        作者:许彬 
        日期:2015-12-10
        语言:Python 2.7 
    -------------------------------------------------------- 
        """)
        TSP(tkinter.Tk()).mainloop()
        
    

    展开全文
  • 蚁群算法原理与应用讲解,介绍的比较详细,初学者可以看看
  • 蚁群算法原理应用

    2012-10-18 20:38:02
    介绍蚁群算法的基础 从介绍蚁群算法开始到最后的应用介绍
  • 蚁群算法原理简述.pdf

    2019-07-26 14:55:42
    蚁群算法是一种基于种群的启发式仿生进化系统,,该算法采用了分布式正反馈并行计算机制,易于与其他方法结合,而 且具有较强的鲁棒性。
  • 使用广泛,结合案例的讲解,还是很适合初学者的,蚁群算法算是进化算法中优秀的几种算法,鲁棒性很强,适合的应用场景也很多
  • 蚁群算法原理及matlab代码实现

    万次阅读 多人点赞 2019-04-27 15:13:30
    蚁群算法基本原理: 背景: 在自然界中,生物群体所表现出的智能得到越来越多的关注,许多的群智能优化算法都是通过对群体智能的模拟而实现的。其中模拟蚂蚁群体觅食的蚁群算法成为一种主要的群智能算法。 算法...

    蚁群算法基本原理:

    背景: 在自然界中,生物群体所表现出的智能得到越来越多的关注,许多的群智能优化算法都是通过对群体智能的模拟而实现的。其中模拟蚂蚁群体觅食的蚁群算法成为一种主要的群智能算法。

    算法原理:

    在自然界中,对于觅食的蚂蚁群体,其可以在任何和没有提示的情况下找到食物和巢穴之间的最短路径。并且能够根据和环境的变迁,自适应地找到新的最优路径。根据生物学家研究,蚂蚁群体这一行为的根本原因是:蚂蚁在寻找食物的过程中,能在其走过的路径上释放一种特殊的物质----信息素,随着时间的推移,这种信息素会逐渐地挥发,而对于后来的蚂蚁,选择某条路径的概率与该路径上信息素的浓度成正比。当某一条路径上通过的蚂蚁越多的时候,这条路径上的信息素的浓度就会累积越大,后来的蚂蚁选择此路径的概率也就越大。路径上蚂蚁越多,导致信息素浓度越高,从而会吸引更多的蚂蚁,从而形成一种正反馈机制,通过这种机制,最终蚁群可以发现最短路径。

    真实蚁群觅食过程:

            在觅食的初始阶段,环境中没有信息素,所以蚂蚁选择哪条路径完全是随机的。之后选择路径就会受到信息素的影响。这里需要说明的时是,信息素是一种生物体内分泌的化学物质,会随着时间的推移而挥发,如果每只蚂蚁在单位距离上留下的信息素浓度相同,则对于越短的路径,信息素的残留浓度就会越高,这被后来的蚂蚁选择的概率也就越大。而经过的蚂蚁越多,由于群体中的正反馈机制,路径上信息素的浓度也就越大,最终会导致整个蚁群寻找到最短路径。

    举个栗子:

    如下图所示:

     

    假设从A点到B点,A,B之间的距离一定,有三条路径可选。

    初始时每条路径分配一只蚂蚁,记为1,2,3,假设L(ACB)=2*L(ADB), L(AEB)=3*L(ADB),所有蚂蚁的行走速度相同。假设蚂蚁沿着ADB从A到B,需要4个单位时间;所以在t取不同值的时候:

    t=4:

    蚂蚁1到达D, 蚂蚁2走到一半路程,蚂蚁3走了三分之一的路程

    t=8:

    蚂蚁1返回A, 蚂蚁2到达B,蚂蚁3走了三分之二的路程

    .....

    t=48:

    蚂蚁1往返于AB之间6次, 蚂蚁2往返于AB间3次,蚂蚁3往返于AB间2次

    在不考虑信息素挥发的条件下:

    三条路径上信息素浓度之比:D(ADB):D(ACB):D(AEB)=6:3:2

    按照蚁群寻找路径的正反馈机制:按照信息素的指导,蚁群在路径ADB上指派6只蚂蚁,在路径ACB上指派3只蚂蚁,在路径AEB上指派2只蚂蚁.

    若继续寻找,则按照正反馈机制,最终所有蚂蚁都会选择最短的路径ABD,而放弃其他两条路径。

    蚁群算法数学模型的建立:

    1.在对实际的蚁群进行建模的过程中,需要解决,蚁群中蚂蚁个体的建模问题,信息素的更新机制,以及整个蚁群的内部机制

    a. 信息素的更新机制:

           信息素的更新方式有两种,一种是挥发,也就是所有路径上的信息素以一定的比率减少。另一种是信息素的增强,给有蚂蚁走过的路径增加信息素。

    b. 蚂蚁个体的建模问题:

           虽然单个蚂蚁可以构造出问题的可行解,但是蚂蚁个体之间需要通过协作才能找出待优化问题的最优解或者次优解,而信息素就是蚂蚁之间进行互相协作的媒介。信息素的蒸发机制使得对过去的寻优历史有一定的遗忘度,避免使后来的蚂蚁在搜索中受到较差解的影响。

    下面以TSP问题为例,给出蚁群算法的模型:
    参考文献:【1】M. Dorigo, V. Maniezzo and A. Colorni, "Ant system: optimization by a colony of cooperating agents," in IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics), vol. 26, no. 1, pp. 29-41, Feb. 1996.

    TSP问题: 

    在一张地图上有n个城市,一名推销员需要不重复的一次走过n个城市进行推销,求解他按照怎样的路径,从才能使走过的距离最短。

    这个问题的解法可以描述如下:

    假设城市 i 的坐标坐标为

    城市i,j之间的距离可以表示为:

    为每只蚂蚁设置一个禁忌表,记录其走过的城市(防止重复走过城市),禁忌表中第一个位置是蚂蚁是初始时刻蚂蚁所在的城市,当所有城市都加入禁忌表的时候,表示蚂蚁走完了所有的城市,完成一次周游。令 为城市i, j之间的信息素的量,初始时刻其取值为:

    假设在(t, t+n)时刻所有蚂蚁完成一次周游,则在t+n时刻城市i, j 之间的信息素含量可以表示为:

    其中:表示时间段 (t, t+n) 之间信息素的挥发系数。则表示信息素的剩余量。挥发系数取值范围(0, 1)

              表示在时间段 (t, t+n) 之间信息素的增加量,其计算方式如下所示:

    表示第k只蚂蚁在本次迭代中留在路径i, j之间的信息素的量, 计算方式如下所示(ant-cycle模型):

    其中:是正常数, 表示蚂蚁k在周游中经过的路径。

    原文中对参数的解释如下:

    同时论文中还提到两种的计算方式:

    (1)ant-density模型

    (2)ant-quantity模型:

      ant-cycle模型的实际效果更好,因为他应用了全局信息更新路径上的信息素,而其他两种模型只是用了局部信息。

    在t时刻, 蚂蚁k从城市i转移到城市可的概率可以由以下方式计算得到:

    其中:是一个启发式因子,计算方式为:

    表示蚂蚁从城市i转移到城市j的期望程度。

    表示在城市i处蚂蚁k可以选择走的城市的集合。表示信息素和期望启发式因子的相对重要程度。

    分析上面的公式可知:

     路径i,j信息素含量越高,蚂蚁选择该路径的概率越大,而路径i.j之间的距离越大吗,启发式因子就越小,则蚂蚁选择该路径的概率就越小,蚂蚁选择路径i,j的概率与上述两个因素都有关系。

    matlab代码实现:

    clear all;
    close all;
    clc;
    C = [1304 2312;         % 城市坐标
        3639 1315;
        4177 2244;
        3712 1399;
        3488 1535;
        3326 1556;
        3238 1229;
        4196 1044;
        4312 790;
        4386 570;
        3007 1970;
        2562 1756;
        2788 1491;
        2381 1676;
        1332 695;
        3715 1678;
        3918 2179;
        4061 2370;
        3780 2212;
        3676 2578;
        4029 2838;
        4263 2931;
        3429 1980;
        3507 2376;
        3394 2643;
        3439 3201;
        2935 3240;
        3140 3550;
        2545 2357;
        2778 2826;
        2370 2975];
    % figure(1);
    % scatter(C(:,1),C(:,2),'k','d');
    % title('城市分布图');
    
    [M,N] = size(C);
    % M为问题的规模  M个城市
    distance = zeros(M,M);     % 用来记录任意两个城市之间的距离
    % 求任意两个城市之间的距离
    for m=1:M
        for n=1:M
            distance(m,n) = sqrt(sum((C(m,:)-C(n,:)).^2));
        end
    end
    m = 50;   % 蚂蚁的个数   一般取10-50    
    alpha = 1;   %  信息素的重要程度    一般取【1,4】
    beta = 5;    %  启发式英子的重要程度   一般取【3,5】
    rho = 0.25;    % 信息素蒸发系数
    G = 150;
    Q = 100; % 信息素增加系数
    Eta = 1./distance;  % 启发式因子
    Tau = ones(M,M);  % 信息素矩阵  存储着每两个城市之间的信息素的数值
    Tabu = zeros(m,M);  % 禁忌表,记录每只蚂蚁走过的路程
    gen = 1;  
    R_best = zeros(G,M);  % 各代的最佳路线
    L_best = inf.*ones(G,1);   % 每一代的最佳路径的长度     初始假设为无穷大
    %   开始迭代计算
    while gen<G
        %  将m只蚂蚁放到n个城市上
        random_pos = [];
        for i=1:(ceil(m/M))  % m只蚂蚁随即放到M座城市 
            random_pos = [random_pos,randperm(M)];   %  random_pos=[1~31 + 1~31]   将每只蚂蚁放到随机的城市  在random_pos 中随机选择m个数,代表蚂蚁的初始城市
        end
        Tabu(:,1) = (random_pos(1,1:m))';   % 第一次迭代每只蚂蚁的禁忌表
        
        for i=2:M      %  从第二个城市开始
            for j=1:m   %  每只蚂蚁
                visited = Tabu(j,1:(i-1));   %  在访问第i个城市的时候,第j个蚂蚁访问过的城市
                % visited=visited(1,:);
                unvisited = zeros(1,(M+1-i));  %  待访问的城市
                visit_P = unvisited;   %  蚂蚁j访问剩下的城市的概率
                count = 1;
                for k=1:M   % 这个循环是找出未访问的城市  
                    if isempty(find(visited==k))   %还没有访问过的城市  如果成立。则证明第k个城市没有访问过
                        unvisited(count) = k;
                        count = count+1;
                    end
                end
                %  计算待选择城市的概率
                for k=1:length(unvisited)    % Tau(visited(end),unvisited(k))访问过的城市的最后一个与所有未访问的城市之间的信息素
                    visit_P(k) = ((Tau(visited(end),unvisited(k)))^alpha)*(Eta(visited(end),unvisited(k))^beta);
                end
                visit_P = visit_P/sum(visit_P);   %  访问每条路径的概率的大小
                %   按照概率选择下一个要访问的城市
                %   这里运用轮盘赌选择方法      这里也可以选择选择概率最大的路径去走, 这里采用轮盘赌选择法。
                Pcum = cumsum(visit_P);
                selected = find(Pcum>=rand);
                to_visited = unvisited(selected(1));
                Tabu(j,i) = to_visited;  % 添加到禁忌表
            end
        end
        if gen>=2
            Tabu(1,:) = R_best(gen-1,:);
        end
        %  记录m只蚂蚁迭代的最佳路线
        L = zeros(1,m);
        for i=1:m
            R = Tabu(i,:);
            L(i) = distance(R(M),R(1));   % 因为要走一周回到原来的地点    
            for j=1:(M-1)
                L(i) = L(i)+distance(R(j),R(j+1));
            end
        end
        L_best(gen) = min(L);    %  记录每一代中路径的最短值
        pos = find(L==L_best(gen));
        R_best(gen,:) = Tabu(pos(1),:);   % 最优的路径
        
        %  更新信息素的值
        Delta_Tau = zeros(M,M);
        for i=1:m   %  m只蚂蚁
            for j=1:(M-1)   %  M座城市
                Delta_Tau(Tabu(i,j),Tabu(i,j+1)) = Delta_Tau(Tabu(i,j),Tabu(i,j+1)) + Q/L(i);    %  m只蚂蚁的信息素累加 这里采用的是论文中ant-cycle模型
            end
            Delta_Tau(Tabu(i,M),Tabu(i,1)) = Delta_Tau(Tabu(i,M),Tabu(i,1)) + Q/L(i);
        end
        Tau = (1-rho).*Tau+Delta_Tau;   % 更新路径上的信息素含量
        %  禁忌表清零
        Tabu = zeros(m,M);
        
        for i=1:(M-1)
            plot([C(R_best(gen,i),1),C(R_best(gen,i+1),1)],[C(R_best(gen,i),2),C(R_best(gen,i+1),2)],'bo-');
            hold on;
        end
        plot([C(R_best(gen,n),1),C(R_best(gen,1),1)],[C(R_best(gen,n),2),C(R_best(gen,1),2)],'ro-');
        title(['最短路径:',num2str(L_best(gen))]);
        hold off;
        pause(0.05);
        gen = gen+1;
    end
    
    figure(2);
    plot(L_best);
    title('路径长度变化曲线');
    xlabel('迭代次数');
    ylabel('路径长度数值');

    运行结果:

     

    最优路径相同,只是起点不一样。

     

    展开全文
  • 蚁群算法原理及其应用(完整版.高清版)
  • 蚁群算法原理解决多任务多车间车间调度问题,C,C++源码
  • 蚁群算法原理及Matlab实现

    千次阅读 2019-09-19 00:19:05
    之后,又系统研究了蚁群算法的基本原理和数学模型. 蚁群算法的基本思想: 蚁群算法的基本原理: 1、蚂蚁在路径上释放信息素。 2、碰到还没走过的路口,就随机挑选一条路走。同时,释放与路径长度有关的信息素。 3、...
  • 转自:... 原 蚁群算法原理及Matlab实现 2018年05月17日 10:48:47 DemonHunter211 阅读数:39879 ...
  • 蚁群算法原理及python代码实现

    千次阅读 多人点赞 2020-04-04 22:26:20
    蚁群算法(AG)是一种模拟蚂蚁觅食行为的模拟优化...之后,又系统研究了蚁群算法的基本原理和数学模型.蚁群算法的基本思想:蚁群算法的基本原理:1、蚂蚁在路径上释放信息素。2、碰到还没走过的路口,就随机挑选一条路走...
  • 蚁群算法原理及其应用 2005.pdf,462页 很经典 完整版+目录
  • 蚁群算法原理及c++实现

    千次阅读 2021-01-11 13:31:47
    一、原理 1. 蚂蚁觅食行为 蚁群在寻找食物时,总能找到一条蚁穴到食物的最短路径,并且能随着...2.蚁群算法 又称蚂蚁算法,是一种基于群体智能的算法,用来在图中寻找优化路径的概率型。它由Marco Dorigo于1992年在他的
  • 蚁群算法原理与实现(python)

    千次阅读 2019-12-25 19:45:29
    文章目录蚁群算法的背景蚁群算法的思想蚁群算法的python实现实例总结 蚁群算法的背景 古有牛顿在苹果树下被苹果砸中发现万有引力,三十年前有人观察蚂蚁觅食发明蚁群算法蚁群算法是意大利学者Dorigo、Maniezzo等人...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,433
精华内容 1,773
关键字:

蚁群算法原理