粒子群算法

HFKuAng HFKuAng 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1.5k累计阅读 1.6k平均单平台 已同步平台 CSDN 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄11年
关注
转载 最新推荐文章于 2023-07-25 11:17:49 发布 1.5k 阅读 AI 写同款· GEO 优化 ›
遗传算法求解车间调度问题(附python代码) 车间调度问题（Job Shop Scheduling Problem, JSSP）是一类经典的组合优化问题，它在制造业和生产管理中有着广泛的应用。JSSP 的目标是对车间中的一系列作业进行排程，以使得作业在不同机器上的加工顺序是最优的，达到某种特定的优化目标，比如最小化总的作业完成时间（即使得总完工时间尽可能短），或者最小化延迟时间、最大化产量等。车间调度问题通常被描述为一系列作业集合 J 和一系列机器集合 M，每个作业由一系列操作组成，每个操作需要在特定的机器上加工一定时间。 阅读详情

一.产生背景

   

❃粒子群算法(particleswarm optimization，PSO)由Kennedy和Eberhart在1995年提出，该算法对于Hepper的模拟鸟群(鱼群)的模型进行修正，以使粒子能够飞向解空间，并在最好解处降落，从而得到了粒子群优化算法。

❃同遗传算法类似，也是一种基于群体叠代的，但并没有遗传算法用的交叉以及变异，而是粒子在解空间追随最优的粒子进行搜索。

❃PSO的优势在于简单，容易实现，无需梯度信息，参数少，特别是其天然的实数编码特点特别适合于处理实优化问题。同时又有深刻的智能背景，既适合科学研究，又特别适合工程应用。

设想这样一个场景：一群鸟在随机的搜索食物。在这个区域里只有一块食物，所有的鸟都不知道食物在哪。但是它们知道自己当前的位置距离食物还有多远。

                         那么找到食物的最优策略是什么？

最简单有效的就是搜寻目前离食物最近的鸟的周围区域。

二.算法介绍
(1)简述

❃每个寻优的问题解都被想像成一只鸟，称为“粒子”。所有粒子都在一个D维空间进行搜索。

❃所有的粒子都由一个fitness-function确定适应值以判断目前的位置好坏。

❃每一个粒子必须赋予记忆功能，能记住所搜寻到的最佳位置。

❃每一个粒子还有一个速度以决定飞行的距离和方向。这个速度根据它本身的飞行经验以及同伴的飞行经验进行动态调整。 

(2) 基本PSO算法

  a.  D维空间中，有m个粒子；

  粒子i位置：xi=(xi1,xi2,…xiD)

  粒子i速度：vi=(vi1,vi2,…viD)，1≤i≤m,1 ≤d ≤D

  粒子i经历过的历史最好位置：pi=(pi1,pi2,…piD)

  群体内（或领域内）所有粒子所经历过的最好位置：

  pg =(pg1,pg2,…pgD)

  PS:一般来说，粒子的位置和速度都是在连续的实数空间内进行取值。


   b.基本PSO公式


(3)基本PSO算法流程图


关于每个粒子的更新速度和位置的公式如下:


三.简单应用

  

(1)•编码：因为问题的维数为5，所以每个粒子为5维的实数向量。
(2)•初始化范围：根据问题要求，设定为[-30，30]。根据前面的参数分析，我们知道，可以将最大速度设定为Vmax=60。
(3)•种群大小：为了说明方便，这里采用一个较小的种群规模，m=5。
(4)•停止准则：设定为最大迭代次数100次。
(5)•惯性权重：采用固定权重0.5。
(6)邻域拓扑结构：使用星形拓扑结构，即全局版本的粒子群优化算法

算法执行的过程如下:









四.代码实现:运用粒子群算法解决 TSP问题
1.matlab实现
[plain]  view plain  copy
  1. close all;  
  2. clear all;  
  3.   
  4. PopSize=500;%种群大小  
  5. CityNum = 14;%城市数  
  6.   
  7. OldBestFitness=0;%旧的最优适应度值  
  8.   
  9. Iteration=0;%迭代次数  
  10. MaxIteration =2000;%最大迭代次数  
  11. IsStop=0;%程序停止标志   
  12. Num=0;%取得相同适应度值的迭代次数  
  13.   
  14. c1=0.5;%认知系数  
  15. c2=0.7;%社会学习系数  
  16. w=0.96-Iteration/MaxIteration;%惯性系数,随迭代次数增加而递减  
  17.   
  18. %节点坐标  
  19. node=[16.47 96.10; 16.47 94.44; 20.09 92.54; 22.39 93.37; 25.23 97.24;...  
  20.      22.00 96.05; 20.47 97.02; 17.20 96.29; 16.30 97.38; 14.05 98.12;...  
  21.      16.53 97.38; 21.52 95.59; 19.41 97.13; 20.09 94.55];  
  22.   
  23. %初始化各粒子，即产生路径种群  
  24. Group=ones(CityNum,PopSize);     
  25. for i=1:PopSize  
  26.     Group(:,i)=randperm(CityNum)';  
  27. end  
  28. Group=Arrange(Group);  
  29.   
  30. %初始化粒子速度（即交换序）  
  31. Velocity =zeros(CityNum,PopSize);     
  32. for i=1:PopSize  
  33.     Velocity(:,i)=round(rand(1,CityNum)'*CityNum); %round取整  
  34. end  
  35.   
  36. %计算每个城市之间的距离  
  37. CityBetweenDistance=zeros(CityNum,CityNum);     
  38. for i=1:CityNum  
  39.     for j=1:CityNum  
  40.         CityBetweenDistance(i,j)=sqrt((node(i,1)-node(j,1))^2+(node(i,2)-node(j,2))^2);  
  41.     end  
  42. end  
  43.   
  44. %计算每条路径的距离  
  45. for i=1:PopSize     
  46.         EachPathDis(i) = PathDistance(Group(:,i)',CityBetweenDistance);  
  47. end  
  48.   
  49. IndivdualBest=Group;%记录各粒子的个体极值点位置,即个体找到的最短路径  
  50. IndivdualBestFitness=EachPathDis;%记录最佳适应度值,即个体找到的最短路径的长度  
  51. [GlobalBestFitness,index]=min(EachPathDis);%找出全局最优值和相应序号   
  52.   
  53. %初始随机解  
  54. figure;  
  55. subplot(2,2,1);  
  56. PathPlot(node,CityNum,index,IndivdualBest);  
  57. title('随机解');  
  58.   
  59. %寻优  
  60. while(IsStop == 0) & (Iteration < MaxIteration)   
  61.     %迭代次数递增  
  62.     Iteration = Iteration +1;    
  63.       
  64.     %更新全局极值点位置,这里指路径  
  65.     for i=1:PopSize     
  66.         GlobalBest(:,i) = Group(:,index);  
  67.         
  68.     end  
  69.       
  70.     %求pij-xij ,pgj-xij交换序，并以概率c1，c2的保留交换序  
  71.     pij_xij=GenerateChangeNums(Group,IndivdualBest);    
  72.     pij_xij=HoldByOdds(pij_xij,c1);   
  73.     pgj_xij=GenerateChangeNums(Group,GlobalBest);  
  74.     pgj_xij=HoldByOdds(pgj_xij,c2);  
  75.       
  76.     %以概率w保留上一代交换序  
  77.     Velocity=HoldByOdds(Velocity,w);  
  78.   
  79.     Group = PathExchange(Group,Velocity); %根据交换序进行路径交换  
  80.     Group = PathExchange(Group,pij_xij);  
  81.     Group = PathExchange(Group,pgj_xij);  
  82.     for i = 1:PopSize    % 更新各路径总距离  
  83.           EachPathDis(i) = PathDistance(Group(:,i)',CityBetweenDistance);  
  84.       
  85.     end  
  86.   
  87.     IsChange = EachPathDis<IndivdualBestFitness;%更新后的距离优于更新前的，记录序号  
  88.     IndivdualBest(:, find(IsChange)) = Group(:, find(IsChange));%更新个体最佳路径  
  89.     IndivdualBestFitness = IndivdualBestFitness.*( ~IsChange) + EachPathDis.*IsChange;%更新个体最佳路径距离  
  90.     [GlobalBestFitness, index] = min(EachPathDis);%更新全局最佳路径,记录相应的序号  
  91.      
  92.     if GlobalBestFitness==OldBestFitness %比较更新前和更新后的适应度值;  
  93.         Num=Num+1; %相等时记录加一;  
  94.     else  
  95.         OldBestFitness=GlobalBestFitness;%不相等时更新适应度值，并记录清零;  
  96.         Num=0;  
  97.     end      
  98.     if Num >= 20 %多次迭代的适应度值相近时程序停止  
  99.         IsStop=1;  
  100.     end  
  101.   
  102.      BestFitness(Iteration) =GlobalBestFitness;%每一代的最优适应度  
  103.   
  104.   
  105. end  
  106.   
  107. %最优解  
  108. subplot(2,2,2);  
  109. PathPlot(node,CityNum,index,IndivdualBest);  
  110. title('优化解');  
  111. %进化曲线  
  112. subplot(2,2,3);  
  113. plot((1:Iteration),BestFitness(1:Iteration));  
  114. grid on;  
  115. title('进化曲线');  
  116. %最小路径值  
  117. GlobalBestFitness  
  118.   
  119. 运行结果如下:  

2.java 实现
[java]  view plain  copy
  1. package pso;  
  2. import java.awt.*;  
  3. import java.awt.event.*;  
  4. import java.io.ByteArrayInputStream;  
  5. import java.io.InputStream;  
  6.   
  7. import javax.swing.*;  
  8. import javax.swing.event.*;  
  9. public class Pso extends Frame implements Runnable  
  10. {  
  11.     private static int particleNumber;  //粒子的数量  
  12.     private static int iterations;      //迭代的次数  
  13.     private static int k=1;             //记录迭代的次数  
  14.     final private static float C1=2;    //学习因子  
  15.     final private static float C2=2;  
  16.     final private static float WMIN=-200;  
  17.     final private static float WMAX=200;  
  18.     final private static float VMAX=200;  
  19.     private static float r1;           //随机数0-1之间  
  20.     private static float r2;  
  21.     private static float x[][];  
  22.     private static float v[][];  
  23.     private static float xpbest[][];  
  24.     private static float pbest[];        
  25.     private static float gbest=0;  
  26.     private static float xgbest[];  
  27.     private static float w;           //惯性因子  
  28.     private static float s;  
  29.     private static float h;  
  30.     private static float fit[];  
  31.     public Sounds sound;  
  32.       
  33.     //粒子群的迭代函数  
  34. public void lzqjs()  
  35. {  
  36.         
  37.         w=(float)(0.9-k*(0.9-0.4)/iterations);  
  38.         for(int i=0;i<particleNumber;i++)  
  39.         {  
  40.                    fit[i]= (float)(1/(Math.pow(x[i][0],2)+Math.pow(x[i][1],2))); //求适值函数最大值  
  41.                    System.out.print("粒子"+i+"本次适应值函数f为：" + fit[i]);  
  42.                    System.out.println();  
  43.                    if(fit[i]>pbest[i])  
  44.                    {  
  45.                     pbest[i]=fit[i];  
  46.                     xpbest[i][0]=x[i][0];  
  47.                     xpbest[i][1]=x[i][1];  
  48.                    }  
  49.                    if(pbest[i]>gbest)  
  50.                    {  
  51.                     gbest=pbest[i];  
  52.                     xgbest[0]=xpbest[i][0];  
  53.                     xgbest[1]=xpbest[i][1];  
  54.                    }  
  55.          }  
  56.          for(int i=0;i<particleNumber;i++)  
  57.          {  
  58.                    for(int j=0;j<2;j++)  
  59.                    {  
  60.                        //粒子速度和位置迭代方程:  
  61.                     v[i][j]=(float)(w*v[i][j]+C1*Math.random()*(xpbest[i][j]-x[i][j])+C2*Math.random()*(xgbest[j]-x[i][j]));  
  62.                      
  63.                     x[i][j]=(float)(x[i][j]+v[i][j]);  
  64.                      
  65.                    }  
  66.                 System.out.print("粒子"+i+"本次X1的速度变化幅度:"+v[i][0]+";本次X2的速度变化幅度:"+v[i][1]);  
  67.                 System.out.println();  
  68.                 System.out.print("粒子"+i+"本次X1为："+x[i][0]+";本次X2为："+x[i][1]);  
  69.                 System.out.println();  
  70.          }  
  71. }  
  72.     public static void main(String[] args)  
  73.     {  
  74.           
  75.         particleNumber=Integer.parseInt(JOptionPane.showInputDialog("请输入粒子个数1-500）"));  
  76.         iterations=Integer.parseInt(JOptionPane.showInputDialog("请输入迭代次数"));  
  77.         x=new float [particleNumber][2];  
  78.         v=new float [particleNumber][2];  
  79.         fit=new float [particleNumber];    //存储适值函数值  
  80.         pbest=new float [particleNumber];  //存储整个粒子群的最有位置  
  81.         xpbest=new float [particleNumber][2];  
  82.         xgbest=new float [2];  
  83.         for(int i=0;i<particleNumber;i++)  
  84.         {  
  85.               
  86.             //对数组的初始化操作  
  87.             pbest[i]=0;  
  88.             xpbest[i][0]=0;  
  89.             xpbest[i][1]=0;  
  90.         }  
  91.         xgbest[0]=0;  
  92.         xgbest[1]=0;  
  93.          System.out.println("开始初始化：");  
  94.         for(int i=0;i<particleNumber;i++)  
  95.         {  
  96.               
  97.             for(int j=0;j<2;j++)  
  98.             {  
  99.                 //任意给定每个位置一定的位置值和速度值  
  100.                 x[i][j]=(float)(WMAX*Math.random()+WMIN);  
  101.                 v[i][j]=(float)(VMAX*Math.random());  
  102.             }  
  103.             System.out.print("粒子"+i+"本次X1的变化幅度:"+v[i][0]+";本次X2的变化幅度:"+v[i][1]);  
  104.              System.out.println();  
  105.             System.out.print("粒子"+i+"本次X1为："+x[i][0]+";本次X2为："+x[i][1]);  
  106.              System.out.println();  
  107.         }  
  108.         System.out.println("初始化数据结束，开始迭代.....");  
  109.     Pso threada=new Pso();  
  110.     threada.setTitle("基于粒子群的粒子位置动态显示");  
  111.     threada.setSize(800,800);  
  112.     threada.addWindowListener(new gbck());  
  113.     threada.setVisible(true);  
  114.         Thread threadc=new Thread(threada);  
  115.         threadc.start();  
  116.     }  
  117.     static class gbck extends WindowAdapter  
  118.     {  
  119.         public void windowClosing(WindowEvent e)  
  120.         {  
  121.             System.exit(0);  
  122.         }  
  123.     }  
  124.       
  125.     //开启的额外线程用于声音的播放  
  126.     public void run()  
  127.     {  
  128.          
  129.         repaint();  
  130.           
  131.         for(int i=0;i<iterations;i++){  
  132.             sound();  
  133.         }  
  134.     }  
  135.     public void paint(Graphics g)  
  136.     {  
  137.            
  138.            g.setColor(new Color(0,0,0));  
  139.            for(int i=0;i<particleNumber;i++)  
  140.            {  
  141.             g.drawString("*",(int)(x[i][0]+200),(int)(x[i][1]+200));  
  142.            }  
  143.            g.setColor(new Color(255,0,0));  
  144.            g.drawString("全局最优适应度函数值："+gbest+"      参数1："+xgbest[0]+"     参数2："+xgbest[1]+"    迭代次数："+ k,50,725);  
  145.   
  146.     try  
  147.     {  
  148.     lzqjs();  //开始迭代  
  149.       
  150.     if(k>=iterations)  
  151.     {  
  152.           
  153.         Thread.sleep((int)(5000));  
  154.         System.exit(0);  
  155.     }  
  156.     k=k+1;  //每次迭代一次加1操作  
  157.     Thread.sleep((int)(1000));  
  158.     }  
  159.     catch(InterruptedException e)  
  160.     {  
  161.          System.out.println(e.toString());  
  162.     }  
  163.     repaint();  
  164.     }  
  165.     public  void sound(){  
  166.           sound =new Sounds("050.wav");  
  167.           InputStream stream =new ByteArrayInputStream(sound.getSamples());  
  168.           // play the sound  
  169.           sound.play(stream);  
  170.           // exit  
  171.   
  172.     }  
  173. }  
运行的结果如下:


算法代码地址:http://download.csdn.net/detail/u012017783/9700118(Matlab ,java两个版本)

收录于
算法学习

当前文章被收录于：

算法学习
5 篇文章 0 人学习
订阅专栏 查看详情
8.粒子群算法（理论部分） 本文主要介绍基础粒子群算法的主要理论，并简单介绍自适应权重分配与压缩因子的用法（即速度更新公式的三个系数改进）。 实际上粒子群算法经历了数十年发展，衍生出的改进算法多种多样，这里就不再过多介绍。下面开始正文部分： 一.定义 粒子群优化算法(Particle Swarm optimization,PSO)又翻译为粒子群算法、微粒群算法、或微粒群优化算法。是通过模拟鸟群觅食行为而发展起来的一种基于群体协作的随机搜索算法。通常认为它是群集智能 (Swarm intelligence, SI) 的一种。它可以被纳入 阅读详情

相关推荐

【PSO】量子粒子群算法（QPSO）

占坑

小白兔的窝 3万+

JSSP问题论文集

关于JSSP问题的论文集

大话算法 -- 粒子群算法

粒子群算法是数学建模比赛中非常常用的算法，L学长今天给大家介绍一下什么是粒子群算法，以及该怎么使用它。粒子群算法（Particle Swarm Optimization,PSO）是一种模仿鸟群、鱼群觅食行为发展起来的一种进化算法。其概念简单易于编程实现且运行效率高、参数相对较少，应用非常广泛。粒子群算法于1995年提出，距今（2019）已有24年历史。 　　 　　粒子群算法中每一个粒子的位置代表了待求问题的一个候选解。每一个粒子的位置在空间内的好坏由该粒子的位置在待求问题中的适应度值决定。每一个粒子在下一代

dc_sinor的博客 1万+

Smart-Algorithm：智能算法-遗传算法，蚁群算法，粒子群算法实现。实现版本Java，Python，MatLab多版本实现

智能算法 智能算法是路线规划，深度学习等等各个领域所使用的优化算法，是算法进阶之路的必备之路。 简介 主要针对总体主流的算法进行，例如遗传算法，粒子群算法，模拟重复算法，免疫算法，蚁群算法等等一系列的算法。 | |登录微信公众号：TeaUrn 开始使用 实现版本Java，Python，MatLab多版本实现。具体详细说明单击以下连接针对每个算法都有详细的说明。 联系方式： 微信公众号： TeaUrn或者扫描下方二维码进行关注。里面有惊喜等你哦~~ 捐赠 如果您觉得文章对您有所帮助，可以请作者喝 :hot_beverage: 。 支付宝/微信/ QQ

车间作业调度问题（JSSP）描述以及编码解码

车间作业调度问题

m0_59466752的博客 7085

粒子群算法(PSO)——Java实现PSO算法(详细注释) 优化算法

https://blog.csdn.net/daaikuaichuan/article/details/81382794https://blog.csdn.net/daaikuaichuan/article/details/81382794代码||注释||结果 package PSO; /* * Target function : F(x, y) = x^2 + y^2; * Opti Solution is F(0, 0) = 0, Certainly; * * According to

cccddduil的博客 2711

【运筹优化】PSO粒子群算法求解无约束多元函数最值(Java代码实现)

粒子群优化算法(Particle Swarm optimization,PSO)又翻译为粒子群算法、微粒群算法、或微粒群优化算法。是通过模拟鸟群觅食行为而发展起来的一种基于群体协作的随机搜索算法。通常认为它是群集智能 (Swarm intelligence, SI) 的一种。它可以被纳入多主体优化系统(Multiagent Optimization System, MAOS)。粒子群优化算法是由Eberhart博士和kennedy博士发明。PSO模拟鸟群的捕食行为。一群鸟在随机搜索食物，在这个区域里只有一块

知不足而奋进，望远山而前行 2万+

数学建模：18 粒子群算法

particleswarm、学习因子、惯性权重

m0_54625820的博客 7124

【PSO】离散粒子群算法（DPSO）和离散二进制粒子群算法（BPSO ）

1. 什么是离散粒子群算法？ 普通粒子群算法（Particle Swarm Optimization Algorithm，PSO）的粒子初始位置、更新速度都是连续函数，与之对应，位置和速度更新均为离散值的算法是离散PSO算法（Discrete Particle Swarm Optimization Algorithm，DPSO）； 一般就是在跟新粒子位置后，对粒子进行离散点处理； 比如：你

小白兔的窝 5万+

Juffrou:适用于我们其余人的Java实用程序框架-开源

Juffrou代表“我们其余人的Java实用工具框架”，并且是有助于Java开发人员的有用类或微型框架的集合。 如果您对高性能的Java Bean处理感兴趣，请签出juffrou-reflect模块。 还有一个易于使用的xml marshaller / unmarshaller，具有一些很酷的功能，例如嵌套bean的简化编组。

Python之粒子群算法（含代码实例）

Python粒子群算法(含代码实例)

m0_60307882的博客 3万+

【MATLAB】混合粒子群算法原理、代码及详解

本博主的一篇粒子群整定PID算法的文章介绍了全局粒子群算法的原理及其在PID参数自整定上的应用。这篇文章则是介绍了在全局粒子群算法的改进算法——混合粒子群算法。该算法相比全局粒子群算法收敛速度更慢，但可以有效避免多极值情况下收敛到局部最优解。

体会编程语言独到的美 1万+

粒子群算法（PSO）

粒子群优化算法来源于鸟类群体活动的规律性，进而利用群体智能建立一个简化的模型。它模拟鸟类的觅食行为，将求解问题的搜索空间比作鸟类的飞行空间，将每只鸟抽象成一个没有质量和体积的粒子，用它来表征问题的一个可能解，将寻找问题最优解的过程看成鸟类寻找食物的过程，进而求解复杂的优化问题。粒子群优化算法与其他进化算法一样，也是基于“种群”和“进化”的概念，通过个体间的协作与竞争，实现复杂空间最优解的搜索。

太可惹的博客 1万+

混沌粒子群算法原理_优化 | 粒子群算法介绍

张浩然责任编辑：苏向阳文章发表于微信公众号【运筹OR帷幄】：优化 | 粒子群算法介绍编者按：粒子群算法是计算数学中用于解决最优化的搜索算法，也是最为经典的智能算法之一。应用主要是在工程和计算机科学还有行为管理研究科学里面。通过阅读这篇文章，你将了解粒子群算法的概念，优缺点以及发展方向。 1、简介粒子群算法(Particle Swarm Optimization,简称PSO)是1995年Eberha...

weixin_42571476的博客 7105

粒子群算法原理

粒子群算法实例计算，必须弄懂！

二郎银的博客 1万+

粒子群算法的简单介绍

粒子群算法 粒子群算法是一种启发式算法，它的核心是思想是利用群体中的个体对信息的共享使整个群体的运动在问题求解空间中产生从无序到有序的演化过程，从而获得问题的可行解。 思想就是放一群鸟，每过一段时间更新（迭代）每只鸟的位置和速度。 粒子（鸟）的速度主要与三个因素有关，1、惯性；2、自己飞行过程中的最佳位置（自我认知）；3、整个鸟群飞行过程中的最佳位置（社会认知）。 核心公式有 vid=wvid−1+c1r1(pbestid−xid)+c2r2(gbestd−xid)xid+1=xid+vid v_i^

luxurie的小窝 5583
上一篇： C++中Static的完全解析
下一篇： 漫谈 C# 在游戏领域的应用
点赞 0
评论 0
书签 书签 3
HFKuAng
HFKuAng
博客等级 码龄11年 69粉丝 13原创
+ 关注 专栏目录 订阅专栏
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值