精华内容
下载资源
问答
  • 人工智能遗传算法蚁群算法粒子群算法.pptx
  • 详细介绍了神经网络算法、粒子群算法遗传算法、模糊逻辑控制、免疫算法、蚁群算法、小波分析算法及其MATLAB的实现方式等内容; 第二部分详细介绍了智能算法的工程中的应用问题,包括模糊神经网络在工程中的应用、...
  • 遗传算法适合求解离散问题,具备数学理论支持,但是存在着汉明悬崖等问题....要将三种算法进行混合,就要针对特定问题,然后融合其中的优势,比如将遗传算法中的变异算子加入粒子群中就可以形成基于变异的粒子群算法....
    遗传算法适合求解离散问题,具备数学理论支持,但是存在着汉明悬崖等问题.
    粒子群算法适合求解实数问题,算法简单,计算方便,求解速度快,但是存在着陷入局部最优等问题.
    蚁群算法适合在图上搜索路径问题,计算开销会大.
    要将三种算法进行混合,就要针对特定问题,然后融合其中的优势,比如将遗传算法中的变异算子加入粒子群中就可以形成基于变异的粒子群算法.
    展开全文
  • matlab 遗传算法GA,粒子群算法PSO,蚁群算法AS 前段时间上智能计算方法实验课上,自己做的程序。帖到这里,希望有人能改进它们,交流经验这样更有价值。 遗传算法解决最小生成树问题,PURFER编码。 粒子群算法做无...
  • 粒子群算法蚁群算法优化路径问题程序源代码---以旅行商问题(TSP)为例 代码用MATLAB编写,两种算法分开编写,读者可以混合编写!
  • matlab相关最优化算法,包括遗传算法粒子群算法蚁群算法、模拟退火法等等
  • 遗传算法简单实例: matlab ...粒子群算法简单实例: matlab https://github.com/Zoyeeee/Particle-swarm-optimization-PSO- 蚁群算法简单实例: matlab https://github.com/Zoyeeee/ASO-

    遗传算法简单实例:
    matlab
    https://github.com/Zoyeeee/Genetic_Algorithm
    粒子群算法简单实例:
    matlab
    https://github.com/Zoyeeee/Particle-swarm-optimization-PSO-
    蚁群算法简单实例:
    matlab
    https://github.com/Zoyeeee/ASO-

    展开全文
  • 遗传算法 遗传算法是计算数学中用于解决最佳化的搜索算法,是进化算法的一种。进化算法最初是借鉴了进化生物学中的一些现象而发展起来的,这些现象包括遗传、突变、自然选择以及杂交等。遗传算法通常实现方式...

    遗传算法

    遗传算法是计算数学中用于解决最佳化的搜索算法,是进化算法的一种。进化算法最初是借鉴了进化生物学中的一些现象而发展起来的,这些现象包括遗传、突变、自然选择以及杂交等。遗传算法通常实现方式为一种计算机模拟。对于一个最优化问题,一定数量的候选解(称为个体)的抽象表示(称为染色体)的种群向更好的解进化。传统上,解用二进制表示(即0和1的串),但也可以用其他表示方法。进化从完全随机个体的种群开始,之后一代一代发生。在每一代中,整个种群的适应度被评价,从当前种群中随机地选择多个个体(基于它们的适应度),通过自然选择和突变产生新的生命种群,该种群在算法的下一次迭代中成为当前种群。

    主要特点

      遗传算法是解决搜索问题的一种通用算法,对于各种通用问题都可以使用。搜索算法的共同特征为:

       首先组成一组候选解

       依据某些适应性条件测算这些候选解的适应度

       根据适应度保留某些候选解,放弃其他候选解

       对保留的候选解进行某些操作,生成新的候选解。

      在遗传算法中,上述几个特征以一种特殊的方式组合在一起:遗传算法基于染色体群的并行搜索,带有猜测性质的选择操作、交换操作和突变操作。这种特殊的组合方式将遗传算法与其它搜索算法区别开来。

      遗传算法还具有以下几方面的特点:

      (1)遗传算法从问题解的串集开始搜索,而不是从单个解开始。这是遗传算法与传统优化算法的极大区别。传统优化算法是从单个初始值迭代求最优解的;容易误入局部最优解。遗传算法从串集开始搜索,覆盖面大,利于全局择优。

      (2)遗传算法同时处理群体中的多个个体,即对搜索空间中的多个解进行评估,减少了陷入局部最优解的风险,同时算法本身易于实现并行化。

      (3)遗传算法基本上不用搜索空间的知识或其它辅助信息,而仅用适应度函数值来评估个体,在此基础上进行遗传操作。适应度函数不仅不受连续可微的约束,而且其定义域可以任意设定。这一特点使得遗传算法的应用范围大大扩展。

      (4)遗传算法不是采用确定性规则,而是采用概率的变迁规则来指导他的搜索方向。

      (5)具有自组织、自适应和自学习性。遗传算法利用进化过程获得的信息自行组织搜索时,适应度大的个体具有较高的生存概率,并获得更适应环境的基因结构。


    贪婪算法

        概念:贪婪算法是一种不追求最优解,只希望得到较为满意解的方法。

      贪婪算法一般可以快速得到满意的解,因为它省去了为找最优解要穷尽所有可能而必须耗费的大量时间。贪婪算法常以当前情况为基础作最优选择,而不考虑各种可能的整体情况。例如平时购物找钱时,为使找回的零钱的硬币数最少,不考虑找零钱的所有各种发表方案,而是从最大面值的币种开始,按递减的顺序考虑各币种,先尽量用大面值的币种,当不足大面值币种的金额时才去考虑下一种较小面值的币种。这就是在使用贪婪算法。这种方法在这里总是最优,是因为银行对其发行的硬币种类和硬币面值的巧妙安排。如只有面值分别为1、5和11单位的硬币,而希望找回总额为15单位的硬币。按贪婪算法,应找1个11单位面值的硬币和4个1单位面值的硬币,共找回5个硬币。但最优的解应是3个5单位面值的硬币。


    粒子群算法


    粒子群算法,也称粒子群优化算法(Particle Swarm Optimization),缩写为 PSO, 是近年来发展起来的一种新的进化算法((Evolu2tionary Algorithm - EA)。PSO 算法属于进化算法的一种,和遗传算法相似,它也是从随机解出发,通过迭代寻找最优解,它也是通过适应度来评价解的品质,但它比遗传算法规则更为简单,它没有遗传算法的“交叉”(Crossover) 和“变异”(Mutation) 操作,它通过追随当前搜索到的最优值来寻找全局最优。这种算法以其实现容易、精度高、收敛快等优点引起了学术界的重视,并且在解决实际问题中展示了其优越性。

    优化问题是工业设计中经常遇到的问题,许多问题最后都可以归结为优化问题.为了解决各种各样的优化问题,人们提出了许多优化算法,比较著名的有爬山法、遗传算法等.优化问题有两个主要问题:一是要求寻找全局最小点,二是要求有较高的收敛速度.爬山法精度较高,但是易于陷入局部极小.遗传算法属于进化算法(EvolutionaryAlgorithms)的一种,它通过模仿自然界的选择与遗传的机理来寻找最优解.遗传算法有三个基本算子:选择、交叉和变异.但是遗传算法的编程实现比较复杂,首先需要对问题进行编码,找到最优解之后还需要对问题进行解码,另外三个算子的实现也有许多参数,如交叉率和变异率,并且这些参数的选择严重影响解的品质,而目前这些参数的选择大部分是依靠经验.1995年Eberhart博士和kennedy博士提出了一种新的算法;粒子群优化(ParticalSwarmOptimization-PSO)算法.这种算法以其实现容易、精度高、收敛快等优点引起了学术界的重视,并且在解决实际问题中展示了其优越性.

      粒子群优化(ParticalSwarmOptimization-PSO)算法是近年来发展起来的一种新的进化算法(Evolu2tionaryAlgorithm-EA).PSO算法属于进化算法的一种,和遗传算法相似,它也是从随机解出发,通过迭代寻找最优解,它也是通过适应度来评价解的品质.但是它比遗传算法规则更为简单,它没有遗传算法的“交叉”(Crossover)和“变异”(Mutation)操作.它通过追随当前搜索到的最优值来寻找全局最优.



    蚂蚁算法


    蚁群算法(ant colony optimization, ACO),又称蚂蚁算法,是一种用来在图中寻找优化路径的机率型技术。它由Marco Dorigo于1992年在他的博士论文中引入,其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。

         自然界的蚂蚁种群相当广泛,但大部分种群都有以下的能力: 蚂蚁们总能找到食物源和蚂蚁窝之间的最短路径. 一旦这条最短路径被发现, 蚂蚁们就能在这条路上排成一行, 在食物源和蚂蚁窝之间搬运食物. 蚂蚁们是怎么做到的呢?

      我们知道,2点间直线距离最短. 但蚂蚁们显然不具备这样的视力和智慧. 它们无法从远处看到食物源, 也无法计划一个合适的路径来搬运食物. 蚂蚁们采用的方法是全体在老窝的周围区域进行地毯式搜索.而他们之间的联系方式是通过分泌化学物质在爬过的路径上,这种化学物质叫信息素(Pheromone).

      蚂蚁们习惯选择信息素浓度高的路径. 下面的图解释了蚂蚁们的工作原理.

      刚开始离开窝的时候, 蚂蚁们有两条路径选择: R1和R2. 这两者机会相当. 蚂蚁们在爬过R1和R2的时候都留下了信息素. 但是, 由于R2的距离短, 所需要的时间就少, 而信息素会挥发, 所以蚂蚁们留在R2上的信息素浓度就高. 于是,越来越多的蚂蚁选择R2作为最佳路径, 即使它们是从R1来到食物源,也将选择R2返回蚂蚁窝. 而从老巢里出发的蚂蚁们也越来越倾向于R2. 在这样的趋势下, R1渐渐变的无人问津了

      根据蚂蚁们选择路径的方法而得到的启发, Dr. Dorigo在1991年发表了蚂蚁算法(Ant algorithm). 十多年来, 蚂蚁算法,以及各种改进过的蚂蚁算法,被广泛的应用在实际生活的各个方面. 在计算机技术应用中,它可以作为网络路由控制的工具. 在交通控制中, 它也成功解决了车辆调度问题.在图表制作中, 它被用来解决颜色填充问题. 此外, 它还可以被用来设计大规模的时刻表. 而推销员问题,既在多个不同地点间往返的最佳路径选择问题, 应该算是蚂蚁算法最重要的用途了.


    展开全文
  • * * 算法流程 * * 程序伪代码 For each particle Initialize particle End Do For each particle Calculate fitness value If the fitness value is better than the best fitness value (pbest) in history set ...
  • 第 三 章 遗传算法蚁群算法粒子群算法;3.1 遗传算法 ;生物在自然界中的生存繁衍显示出了其对自然环境的优异自适应能力受其启发人们致力于对生物各种生存特性的机理研究和行为模拟为人工自适应系统的设计和开发提供...
  • 遗传算法里多个个体组成一个种群、蚁群算法的蚂蚁、粒子群算法的粒子都是群优化算法的体现。 本文分别利用以上三种算法来解决31个城市的TSP问题。 二、遗传算法解决TSP问题 遗传算法简介: 遗传算法是一种...

    一、引言

    旅行商问题(Traveling Salesman Problem)就是一个经销商从n个城市中的某一城市出发,不重复的走完其余的n-1个城市并回原出发点,求所有可能的路径中路径长度最短的一条。TSP搜索空间随着城市数n的增加而增大,所有的旅程路线组合数为(n-1)!/2。当城市数较大时,TSP难以用遍历的方法找到最短路径。

    遗传算法、蚁群算法、粒子群算法都是群优化算法,也就是说我们会在解空间里面同时设置许多个个体然后来组成一个群体来进行搜索寻找最优解。好比我们现在有一个任务,周围有好多个人寻找搜索,而不是一个人寻找搜索。遗传算法里多个个体组成一个种群、蚁群算法的蚂蚁、粒子群算法的粒子都是群优化算法的体现。

    本文分别利用以上三种算法来解决31个城市的TSP问题。

    二、遗传算法解决TSP问题

    遗传算法简介:
    遗传算法是一种通过模拟自然进化过程搜索最优解的方法。基本步骤包括:编码、产生初始种群、计算适应度函数值、选择、交叉、变异、产生下一代种群、解码。

    适应度函数用来评价个体的性能到底好不好;选择体现进化,更优的个体生存下来进化到下一代可能性比较大;交叉变异保持了样本的多样性,避免算法陷入局部寻优局部求解的误区。

    计算适应度函数值->选择->交叉->变异 不停的循环迭代,最后直到满足一定的终止条件。

    流程图如下:
    在这里插入图片描述

    用来解决TSP问题:

    1.编码:在TSP问题中直接用一条路径来对应基因的编码是最简单的表示方式。例如:旅程(3->2->5->8->4->1->6->7)可以直接编码表示为(3 2 5 8 4 1 6 7)

    2.适应度函数:计算路径的距离

    3.选择算子:轮盘赌法。注意路径越短被选择的概率应该越高,反之路径越长被选择的概率应该越低,因此可以将路径的距离长度取倒数后,再进行轮盘赌选择。

    4.交叉算子:基于路径表示的编码方法,要求每个的染色体编码中不允许有重复的基因码,也就是每个城市只能访问一次。因此基本遗传算法的交叉操作不再适用。

    本文选用部分匹配交叉法(Partial-MappedCrossover),原理如下:
    首先随机产生两个交叉点,定义这两点间的区域为匹配区域,并交换两个父代的匹配区域,如下所示:

    父代A:12|3456|789
    父代B:54|6921|783

    交换后变为:

    tempA:12|6921|789
    tempB:54|3456|783

    对于tempA、tempB中匹配区域以外出现的数码重复,要依据匹配区域内的位置建立映射关系,然后替换,映射关系:
    1<->6<->3
    2<->5
    9<->4

    最终结果:

    子代A:35|6921|784
    子代B:29|3456|781

    5.变异算子:在TSP问题中基于二进制编码的变异操作不适用,不能直接将其中一个数码变成另外一个数码(会出现城市的重复)。因此可以随机的在路径抽取两个城市,然后交换他们的位置。这样就实现了个体编码的变异。

    结果显示:
    在这里插入图片描述

    在这里插入图片描述
    matlab代码:

    %% 1.清空环境变量
    clear all;
    clc;
    
    %% 2.导入数据
    load citys_data.mat;          %数据集的变量名为citys
    
    %% 3.计算城市间相互距离
    n=size(citys,1);
    D=zeros(n,n);
    
    for i=1:n
        for j=i+1:n
            D(i,j)=sqrt(sum((citys(i,:)-citys(j,:)).^2));
            D(j,i)=D(i,j);
        end
    end
    
    %% 4.初始化参数
    m=2000;                         %种群个数
    pop=zeros(m,n);                 %种群
    crospro=0.8;                    %交叉概率
    mutpro=0.1;                     %变异概率
    gen=1;                          %迭代计数器
    genmax=2000;                    %最大迭代次数
    fitness=zeros(m,1);             %适应度函数值
    Route_best=zeros(genmax,n);     %各代最佳路径
    Length_best=zeros(genmax,1);    %各代最佳路径的长度
    Length_ave=zeros(genmax,1);     %各代路径的平均长度
    
    %% 5.产生初始种群
    % 5.1随机产生初始种群
    for i=1:m
        pop(i,:)=randperm(n);
    end
    
    % 5.2计算初始种群适应度函数值
    for i=1:m
        for j=1:n-1
            fitness(i)=fitness(i) + D(pop(i,j),pop(i,j+1));
        end
        fitness(i)=fitness(i) + D(pop(i,end),pop(i,1));
    end
    
    % 5.3计算最短路径及平均距离
    [min_Length,min_index]=min(fitness);
    Length_best(1)=min_Length;
    Route_best(1,:)=pop(min_index,:);
    Length_ave(1)=mean(fitness);
    
    %% 6.迭代寻找最佳路径
    while gen<=genmax
        % 6.1更新迭代次数
        gen=gen+1;
    
        % 6.2选择算子(轮盘赌法)
        P=1./fitness;
        P=P/sum(P);        %计算每一个城市的概率
        Pc=cumsum(P);      %计算累积概率
    
        popnew=zeros(m,n);
        for i=1:m
            target_index=find(Pc>=rand);
            target=pop(target_index(1),:);
            popnew(i,:)=target;
        end
    
        % 6.3交叉算子(部分匹配交叉)
        for i=1:2:n   %两两之间相互交叉
            if crospro>rand  %判断是否进行交叉
                child1path=zeros(1,n);
                child2path=zeros(1,n);
    
                setsize=floor(n/2)-1;      %匹配区域城市的数量
                offset1=randi(setsize);    %匹配区域的下边界
                offset2=offset1+setsize-1; %匹配区域的上边界
    
                %匹配区域
                for j=offset1:offset2
                    child1path(j)=popnew(i+1,j);
                    child2path(j)=popnew(i,j);
                end
    
                % 非匹配区域
                for j=1:offset1-1
                    child1path(j)=popnew(i,j);
                    child2path(j)=popnew(i+1,j);
                end
    
                for j=offset2+1:n
                    child1path(j)=popnew(i,j);
                    child2path(j)=popnew(i+1,j);
                end
    
                % 子代1冲突检测
                for j=offset1:offset2
                    if ~ismember(child1path(j),popnew(i,offset1:offset2)) %不在交叉段内
                        %寻找映射关系
                        a1=child1path(j);
                        a2=popnew(i,j);
                        while ismember(a2,child1path(offset1:offset2))
                            temp_index=find(popnew(i+1,:)==a2);
                            a1=a2;
                            a2=popnew(i,temp_index);  
                        end 
                        %寻找重复数字位置
                        b1=find(child1path==child1path(j));
                        if length(b1)>1
                            if b1(1)>offset2||b1(1)<offset1
                                change_index=b1(1);
                            else
                                change_index=b1(2);
                            end
                        end
                        %替代重复数字
                        child1path(change_index)=a2;                
                    end
                end
    
                % 子代2冲突检测(同上)
                for j=offset1:offset2
                    if ~ismember(child2path(j),popnew(i+1,offset1:offset2)) %不在交叉段内
                        %寻找映射关系
                        a1=child2path(j);
                        a2=popnew(i+1,j);
                        while ismember(a2,child2path(offset1:offset2))
                            temp_index=find(popnew(i,:)==a2);
                            a1=a2;
                            a2=popnew(i+1,temp_index);  
                        end 
                        %寻找重复数字位置
                        b2=find(child2path==child2path(j));
                        if length(b2)>1
                            if b2(1)>offset2||b2(1)<offset1
                                change_index=b2(1);
                            else
                                change_index=b2(2);
                            end
                        end
                        %替代重复数字
                        child2path(change_index)=a2;                
                    end
                end
    
                popnew(i,:)=child1path;
                popnew(i+1,:)=child2path;
            end
        end
    
        % 6.4变异算子
        for i=1:m
            if mutpro>rand %判断是否变异
                %随机抽两个数字
                y=round(rand(1,2)*(n-1)+1);
                %交换位置
                temp=popnew(i,y(1));
                popnew(i,y(1))=popnew(i,y(2));
                popnew(i,y(2))=temp;
            end
        end
    
        % 6.5计算新一代种群适应度函数值
        pop=popnew;
        fitness=zeros(m,1);
        for i=1:m
            for j=1:n-1
                fitness(i)=fitness(i) + D(pop(i,j),pop(i,j+1));
            end
            fitness(i)=fitness(i) + D(pop(i,end),pop(i,1));
        end
    
        % 6.6计算最短路径及平均距离
        [min_Length,min_index]=min(fitness);
        Length_ave(gen)=mean(fitness);
        if min_Length<Length_best(gen-1)
            Length_best(gen)=min_Length;
            Route_best(gen,:)=pop(min_index,:);
        else
            Length_best(gen)=Length_best(gen-1);
            Route_best(gen,:)=Route_best(gen-1,:);
        end
    
    end
    
    %% 7.结果显示
    best_route=Route_best(end,:);
    best_length=Length_best(end,:);
    disp(['最短距离: ' num2str(best_length)]);
    disp(['最短路径: ' num2str(best_route)]);
    
    %% 8.绘图
    figure(1)
    plot([citys(best_route,1);citys(best_route(1),1)],[citys(best_route,2);citys(best_route(1),2)],'o-')
    for i=1:size(citys,1)
        text(citys(i,1),citys(i,2),[' ' num2str(i)]); 
    end
    text(citys(best_route(1),1),citys(best_route(1),2),'     起点');
    text(citys(best_route(end),1),citys(best_route(end),2),'     终点');
    xlabel('城市位置横坐标')
    ylabel('城市位置纵坐标')
    title(['遗传算法优化路径(最短距离:' num2str(best_length) ')'])
    
    figure(2)
    plot(1:genmax+1,Length_ave,'r:',1:genmax+1,Length_best,'b-')
    legend('平均距离','最短距离')
    xlabel('迭代次数')
    ylabel('距离')
    title('各代最短距离与平均距离对比')
    

    三、蚁群算法解决TSP问题

    蚁群算法简介:
    蚁群算法灵感来源于蚂蚁在寻找食物过程中的行为。蚂蚁在觅食时会在经过的路径上释放信息素,并且能够感知环境中信息素的含量浓度大小。蚂蚁释放的信息素浓度大小表征了这条路径距离食物的远近:这条路径距离越短,蚂蚁释放的信息素浓度越高。蚂蚁觅食时会以较大概率选择信息素浓度较高的路径,并且在走过这条路径时会释放自己身上的信息素。这样这条路走的蚂蚁越来越多,信息素浓度越高,就会形成一个正反馈。同时路径上信息素的浓度会随着时间的推进而衰减。

    蚁群算法通过 产生路径表->更新信息素->清空路径表 不停的循环迭代来寻找最优解。信息素最大的路径代表最短路径。

    流程图如下:
    在这里插入图片描述

    用来解决TSP问题:
    1.产生路径表:在计算各个城市的访问概率后,用轮盘赌选择下一个访问城市,避免局部最优。

    2.更新信息素:对于蚂蚁释放的信息素浓度,本文选用蚁周模型。

    结果显示:
    在这里插入图片描述
    在这里插入图片描述
    matlab代码:

    %% 1.清空环境变量
    clear all;
    clc;
    
    %% 2.导入数据
    load citys_data.mat;          %数据集的变量名为citys
    
    %% 3.计算城市间相互距离
    n=size(citys,1);
    D=zeros(n,n);
    
    for i=1:n
        for j=1:n
            if i~=j
                D(i,j)=sqrt(sum((citys(i,:)-citys(j,:)).^2));
            else
                D(i,j)=1e-4;
            end
        end
    end
    
    %% 4.初始化参数
    m=50;                         %蚂蚁数量
    alpha=1;                      %信息素重要程度因子
    beta=5;                       %启发函数重要程度因子
    rho=0.1;                      %信息素挥发因子
    Q=1;                          %常系数
    Eta=1./D;                     %启发函数
    Tau=ones(n,n);                %信息素矩阵
    Table=zeros(m,n);             %路径记录表
    iter=1;                       %迭代次数初值
    itermax=200;                  %最大迭代次数
    Route_best=zeros(itermax,n);  %各代最佳路径
    Length_best=zeros(itermax,1); %各代最佳路径的长度
    Length_ave=zeros(itermax,1);  %各代路径的平均长度
    
    %% 5.迭代寻找最佳路径
    while iter<=itermax
        % 5.1随机产生各个蚂蚁的起点城市
        start=zeros(m,1);
        for i=1:m
            temp=randperm(n);
            start(i,:)=temp(1);
        end
        Table(:,1)=start;
        citys_index=1:n;
    
        % 5.2产生解空间(路径表)
        %逐个蚂蚁路径选择
        for i=1:m
            %逐个城市路径选择
            for j=2:n
                tabu=Table(i,:); %已访问城市
                allow_index=~ismember(citys_index,tabu);
                allow=citys_index(allow_index);
                P=allow;
    
                % 5.3计算城市间转移概率
                for k=1:length(allow) 
                    P(k)=Tau(Table(i,j-1),allow(k))^alpha * Eta(Table(i,j-1),allow(k))^beta;
                end
    
                P=P/sum(P);
    
                % 5.4轮盘赌法选择下一个访问城市
                Pc=cumsum(P);
                target_index=find(Pc>=rand);
                target=allow(target_index(1));
                Table(i,j)=target;
            end
        end
    
        % 5.5计算各个蚂蚁的路径距离
        Length=zeros(m,1);
    
        for i=1:m
            for j=1:n-1
                Length(i,1)=Length(i,1)+D(Table(i,j),Table(i,j+1));
            end
            Length(i,1)=Length(i,1)+D(Table(i,end),Table(i,1));
        end
    
        % 5.6计算最短路径及平均距离
        if iter==1
            [min_Length,min_index]=min(Length);
            Length_best(iter)=min_Length;
            Route_best(iter,:)=Table(min_index,:);
            Length_ave(iter)=mean(Length);
        else
            [min_Length,min_index]=min(Length);
            Length_best(iter)=min(Length_best(iter-1),min_Length);
            Length_ave(iter)=mean(Length);
            if Length_best(iter-1)>min_Length
                Route_best(iter,:)=Table(min_index,:);
            else
                Route_best(iter,:)=Route_best(iter-1,:);
            end
        end
    
        % 5.7更新信息素
        Delta_Tau=zeros(n,n);
    
        %逐个蚂蚁计算
        for i=1:m
            %逐个城市计算
            for j=1:n-1
                Delta_Tau(Table(i,j),Table(i,j+1))=Delta_Tau(Table(i,j),Table(i,j+1)) + Q/Length(i);
            end
            Delta_Tau(Table(i,end),Table(i,1))=Delta_Tau(Table(i,end),Table(i,1)) + Q/Length(i);
        end
    
        Tau=(1-rho)*Tau+Delta_Tau;
    
        % 5.8迭代次数加1,清空路径表
        iter=iter+1;
        Table=zeros(m,n);
    
    end
    
    %% 6.结果显示
    best_route=Route_best(end,:);
    best_length=Length_best(end,:);
    disp(['最短距离: ' num2str(best_length)]);
    disp(['最短路径: ' num2str(best_route)]);
    
    %% 7.绘图
    figure(1)
    plot([citys(best_route,1);citys(best_route(1),1)],[citys(best_route,2);citys(best_route(1),2)],'o-')
    for i=1:size(citys,1)
        text(citys(i,1),citys(i,2),[' ' num2str(i)]);
    end
    text(citys(best_route(1),1),citys(best_route(1),2),'     起点');
    text(citys(best_route(end),1),citys(best_route(end),2),'     终点');
    xlabel('城市位置横坐标')
    ylabel('城市位置纵坐标')
    title(['蚁群算法优化路径(最短距离:' num2str(best_length) ')'])
    
    figure(2)
    plot(1:itermax,Length_ave,'r:',1:itermax,Length_best,'b-')
    legend('平均距离','最短距离')
    xlabel('迭代次数')
    ylabel('距离')
    title('各代最短距离与平均距离对比')
    

    四、粒子群算法解决TSP问题

    粒子群算法简介:
    粒子群算法源自于对鸟类捕食问题的研究。基本步骤包括:粒子位置和速度初始化、计算适应度函数值、计算个体极值和群体极值、更新速度和位置、更新适应度函数值、更新个体极值和群体极值。

    粒子相当于遗传算法里的染色体,他对应的就是解空间里面的一个解。速度是一个矢量,代表的是每个粒子下一次搜索的方向和快慢。个体极值:某一个粒子在多次迭代后它所经历的适应度函数值最好的位置,只是一个粒子的最优。群体极值:所有粒子在多次迭代后它们所经历的适应度函数值最好的位置,是整个群体的最优

    更新速度和位置->更新适应度函数值->更新个体极值和群体极值 不停的循环迭代,最后直到满足一定的终止条件。

    流程图如下:在这里插入图片描述

    用来解决TSP问题:
    在TSP问题中,粒子的位置可以使用路径来表示,速度如何表示却是一个难题。基本粒子群算法的速度和位置更新公式不再适用,因此本文重新定义了速度和位置的更新公式。

    基本粒子群算法速度位置更新公式:在这里插入图片描述

    本文重新定义了速度,以及三个运算规则:位置-位置,常数*速度,位置+速度

    1.速度定义为交换序列,位置1+速度=位置2定义为位置1通过速度这个交换序列变成位置2,速度中每一个索引对应的数字意为:位置1中索引为该数字的城市与位置1中索引为速度索引的城市对调,例如:

    位置1=[5 4 3 2 1]
    位置2=[1 2 3 4 5]

    位置2[1]=位置1[5]
    因此位置1[1]与位置1[5]互换位置,速度[1]=5

    交换位置之后:
    位置1=[1 4 3 2 5]
    位置2=[1 2 3 4 5]

    位置2[2]=位置1[4]
    因此位置1[2]与位置1[4]互换位置,速度[2]=4

    交换位置之后:
    位置1=[1 2 3 4 5]
    位置2=[1 2 3 4 5]

    位置2[3]=位置1[3]
    因此位置1[3]与位置1[3]互换位置,速度[3]=3

    由此可以推导,速度=[5 4 3 4 5]

    位置2-位置1即为速度

    2.常数*位置定义为:速度中的每一个值以该常数的概率保留,避免过早陷入局部最优解。

    结果显示:在这里插入图片描述
    在这里插入图片描述
    matlab代码:
    main.m

    %% 1.清空环境变量
    clear all;
    clc;
    
    %% 2.导入数据
    load citys_data.mat;          %数据集的变量名为citys
    
    %% 3.计算城市间相互距离
    n=size(citys,1);
    D=zeros(n,n);
    
    for i=1:n
        for j=i+1:n
            D(i,j)=sqrt(sum((citys(i,:)-citys(j,:)).^2));
            D(j,i)=D(i,j);
        end
    end
    
    %% 4.初始化参数
    c1=0.1;                         %个体学习因子
    c2=0.075;                       %社会学习因子
    w=1;                            %惯性因子
    m=500;                          %粒子数量
    pop=zeros(m,n);                 %粒子位置
    v=zeros(m,n);                   %粒子速度
    gen=1;                          %迭代计数器
    genmax=2000;                    %迭代次数
    fitness=zeros(m,1);             %适应度函数值
    Pbest=zeros(m,n);               %个体极值路径
    Pbest_fitness=zeros(m,1);       %个体极值
    Gbest=zeros(genmax,n);          %群体极值路径
    Gbest_fitness=zeros(genmax,1);  %群体极值
    Length_ave=zeros(genmax,1);     %各代路径的平均长度
    ws=1;                           %惯性因子最大值
    we=0.8;                         %惯性因子最小值
    
    %% 5.产生初始粒子
    % 5.1随机产生粒子初始位置和速度
    for i=1:m
        pop(i,:)=randperm(n);
        v(i,:)=randperm(n);
    end
    
    % 5.2计算粒子适应度函数值
    for i=1:m
        for j=1:n-1
            fitness(i)=fitness(i) + D(pop(i,j),pop(i,j+1));
        end
        fitness(i)=fitness(i) + D(pop(i,end),pop(i,1));
    end
    
    % 5.3计算个体极值和群体极值
    Pbest_fitness=fitness;
    Pbest=pop;
    [Gbest_fitness(1),min_index]=min(fitness);
    Gbest(1,:)=pop(min_index,:);
    Length_ave(1)=mean(fitness);
    
    %% 6.迭代寻优
    while gen<genmax
        % 6.1更新迭代次数与惯性因子
        gen=gen+1;
        w = ws - (ws-we)*(gen/genmax)^2;
    
        % 6.2更新速度
        %个体极值修正部分
        change1=position_minus_position(Pbest,pop);
        change1=constant_times_velocity(c1,change1);
        %群体极值修正部分
        change2=position_minus_position(repmat(Gbest(gen-1,:),m,1),pop);
        change2=constant_times_velocity(c2,change2);
        %原速度部分
        v=constant_times_velocity(w,v);
        %修正速度
        for i=1:m
            for j=1:n
                if change1(i,j)~=0
                    v(i,j)=change1(i,j);
                end
                if change2(i,j)~=0
                    v(i,j)=change2(i,j);
                end
            end
        end
    
        % 6.3更新位置
        pop=position_plus_velocity(pop,v);
    
        % 6.4适应度函数值更新
        fitness=zeros(m,1);
        for i=1:m
            for j=1:n-1
                fitness(i)=fitness(i) + D(pop(i,j),pop(i,j+1));
            end
            fitness(i)=fitness(i) + D(pop(i,end),pop(i,1));
        end
    
        % 6.5个体极值与群体极值更新
        for i=1:m
            if fitness(i)<Pbest_fitness(i)
                Pbest_fitness(i)=fitness(i);
                Pbest(i,:)=pop(i,:);
            end
        end
    
        [minvalue,min_index]=min(fitness);
        if minvalue<Gbest_fitness(gen-1)
            Gbest_fitness(gen)=minvalue;
            Gbest(gen,:)=pop(min_index,:);
        else
            Gbest_fitness(gen)=Gbest_fitness(gen-1);
            Gbest(gen,:)=Gbest(gen-1,:);
        end
    
        Length_ave(gen)=mean(fitness);
    
    end
    
    %% 7.结果显示
    [Shortest_Length,index] = min(Gbest_fitness);
    Shortest_Route = Gbest(index,:);
    disp(['最短距离:' num2str(Shortest_Length)]);
    disp(['最短路径:' num2str([Shortest_Route Shortest_Route(1)])]);
    
    %% 8.绘图
    figure(1)
    plot([citys(Shortest_Route,1);citys(Shortest_Route(1),1)],...
         [citys(Shortest_Route,2);citys(Shortest_Route(1),2)],'o-');
    grid on
    for i = 1:size(citys,1)
        text(citys(i,1),citys(i,2),['   ' num2str(i)]);
    end
    text(citys(Shortest_Route(1),1),citys(Shortest_Route(1),2),'       起点');
    text(citys(Shortest_Route(end),1),citys(Shortest_Route(end),2),'       终点');
    xlabel('城市位置横坐标')
    ylabel('城市位置纵坐标')
    title(['粒子群算法优化路径(最短距离:' num2str(Shortest_Length) ')'])
    
    figure(2)
    plot(1:genmax,Gbest_fitness,'b',1:genmax,Length_ave,'r:')
    legend('最短距离','平均距离')
    xlabel('迭代次数')
    ylabel('距离')
    title('各代最短距离与平均距离对比')
    

    position_minus_position.m

    function change=position_minus_position(best,pop)
    %记录将pop变成best的交换序列
    for i=1:size(best,1)
        for j=1:size(best,2)
            change(i,j)=find(pop(i,:)==best(i,j));
            temp=pop(i,j);
            pop(i,j)=pop(i,change(i,j));
            pop(i,change(i,j))=temp;
        end
    end
    end
    

    constant_times_velocity.m

    function change = constant_times_velocity(constant,change)
    % 以一定概率保留交换序列
    for i=1:size(change,1)
        for j=1:size(change,2)
            if rand>constant
                change(i,j)=0;
            end
        end
    end
    end
    

    position_plus_velocity.m

    function pop = position_plus_velocity(pop,v)
    %利用速度记录的交换序列进行位置修正
    for i=1:size(pop,1)
        for j=1:size(pop,2)
            if v(i,j)~=0
                temp=pop(i,j);
                pop(i,j)=pop(i,v(i,j));
                pop(i,v(i,j))=temp;
            end
        end
    end
    end
    

    五、总结

    遗传算法蚁群算法粒子群算法
    优化推进方式选择交叉变异操作信息素浓度的更新速度位置更新
    信息传递种群互相共享信息信息素个体极值和群体极值
    展开全文
  • 解决函数极值问题(二元), 采用三种群智能算法实现, 并进行比较分析 1. 问题重述 求解函数: f(x,y)=6.452(x+0.125y)(cos⁡x−cos⁡(2y))20.8+(x−4.2)2+2(y−7)2+3.226yf(x, y)=\frac{6.452(x+0.125 y)(\cos x-\cos ...
  • 分别利用三种算法进行求解旅行商问题,怎么比较其性能方面差别,并优化?</p>
  • 遗传算法粒子群算法结合的matlab源码 详细的注释
  • 一个非常好的蚁群算法粒子群算法的程序文档,内含程序源码,拷贝可直接运行。
  • 工具matlab 使用遗传算法对一元函数,求最大值,它的图像长这样: f(1.85)=3.85
  • 列举了蚁群算法粒子群算法的优缺点,以及对比,提供了一个较为完善的优化思路
  • 遗传算法蚁群算法相结合的实例代码, 验证过的 可以实现
  • ================================================ ...PSO算法和GA算法的相同点: (1)都属于仿生算法。PSO算法主要模拟鸟类觅食、人类认知等社会行为而研究;GA算法主要借用生物进化中“适者生存”的
  • 遗传蚁群粒子群算法原理

    千次阅读 2012-05-31 19:55:30
    遗传算法的基本原理:模拟生命的进化机制,也就是说,模拟了自然选择和遗传进化中发生的繁殖、交配和突变现象,从任意一个初始种群... 蚁群算法收到自然界中真实蚁群集体行为的启发,利用真实蚁群通过个体间的信息传
  • 主要针对总体主流的算法进行,例如遗传算法粒子群算法,模拟重复算法,免疫算法,蚁群算法等等一系列的算法。 | |登录微信公众号:TeaUrn 开始使用 实现版本Java,Python,MatLab多版本实现。具体详细说明单击以下...
  • 演化算法1.概念2.解决的问题 1.概念 传统算法(如梯度下降法、...预测优化:演化计算(蚁群算法粒子群算法遗传算法等) 解的聚散、多样性:通过多次聚散,尽快得出最优解(某个解不合要求,要能够发散出去) ...
  • 遗传算法、免疫算法、退火算法、粒子群算法、鱼群算法、蚁群算法和神经网络算法等常用智能算法的MATLAB实现 Introduction 在数学建模竞赛期间学习的各类智能算法,之前放在CSDN上,标了1积分的辛苦分,但是在下载...
  • 粒子群算法 模拟退火算法 蚁群算法 免疫优化算法 人工鱼群算法 项目链接: https://github.com/zhangxiao123qqq/scikit-opt 原作者链接: https://github.com/guofei9987/scikit-opt 黑盒实现,即拿即用!不要太爽...

空空如也

空空如也

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

粒子群算法蚁群算法遗传算法