精华内容
下载资源
问答
  • 粒子群算法(PSO) C
    千次阅读
    2018-09-21 19:56:02

    粒子群算法的核心的两个公式为:
    速度更新公式:
    Vid(k+1)=wVid(k)+c1r1*(Pid(k)-Xid(k))+c2r2(Pgd(k)-Xid(k))
    位置更新公式:
    Xid(k+1) = Xid(k) + Vid(k+1)

    w称之为惯性权重,体现的是粒子继承先前速度的能力。 经验表明:一个较大的惯性权重有利于全局搜索,而一个较小的惯性权重则更有利于局部搜索。

    为了更好地平衡算法的全局搜索能力与局部搜索能力,Shi.Y提出了线性递减惯性权重(LDIW)
    即:w(k) = w_end + (w_start- w_end)*(Tmax-k)/Tmax。*其中w_start 为初始惯性权重,w_end 为迭代至最大次数时的惯性权重;k为当前迭代次数, Tmax为最大迭代次数。

    一般来说,w_start=0.9,w_end=0.4时,算法的性能最好。这样随着迭代的进行,惯性权重从0.9递减到0.4,迭代初期较大的惯性权重使算法保持了较强的全局搜索能力。而迭代后期较小的惯性权重有利于算法进行更精确的局部搜索。线性惯性权重,只是一种经验做法,常用的惯性权重还包括 以下几种。*

    (3) w(k) = w_start - (w_start-w_end)(k/Tmax)^2
    (4) w(k) = w_start + (w_start-w_end)
    (2k/Tmax - (k/Tmax)^2)
    (5) w(k) = w_end
    (w_start/w_end)^(1/(1+c*k/Tmax)) ,c为常数,比如取10等。

    本例的目的就是比较这5种不同的w取值,对于PSO寻优的影响。比较的方法为每种w取值,重复实验若干次(比如100次),比较平均最优解的大小,陷入次优解的次数,以及接近最优解的次数。 这样对于5种方法的优劣可以有一个直观的比较。

    代码:

    /*
    * 本例的寻优非线性函数为
    * f(x, y) = sin(sqrt(x ^ 2 + y ^ 2)) / (sqrt(x ^ 2 + y ^ 2)) + exp((cos(2 * PI*x) + cos(2 * PI*y)) / 2) - 2.71289
    * 该函数有很多局部极大值点,而极限位置为(0, 0), 在(0, 0)附近取得极大值
    */
    
    #include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    #include<time.h>
    #define c1 1.49445 //加速度因子一般是根据大量实验所得
    #define c2 1.49445
    #define maxgen 300  // 迭代次数
    #define repeat 100 // 重复实验次数
    #define sizepop 20 // 种群规模
    #define popmax 2 // 个体位置最大取值
    #define popmin -2 // 个体位置最小取值
    #define Vmax 0.5 // 速度最大值
    #define Vmin -0.5 //速度最小值
    #define dim 2 // 粒子的维数
    #define w_start 0.9
    #define w_end 0.4
    #define PI 3.1415926 //圆周率
    
    double pop[sizepop][dim]; // 定义种群数组
    double V[sizepop][dim]; // 定义种群速度数组
    double fitness[sizepop]; // 定义种群的适应度数组
    double result[maxgen];  //定义存放每次迭代种群最优值的数组
    double pbest[sizepop][dim];  // 个体极值的位置
    double gbest[dim]; //群体极值的位置
    double fitnesspbest[sizepop]; //个体极值适应度的值
    double fitnessgbest; // 群体极值适应度值
    double genbest[maxgen][dim]; //每一代最优值取值粒子
    
    double func(double * arr);	//适应度函数
    void pop_init(void);	 // 种群初始化
    double * max(double * fit, int size);	// max()函数定义
    void PSO_func(int n);	// 迭代寻优,传入的参数为一个整数,取值为1到5,分别代表5种不同的计算w的方法
    
    
    int main(void)
    {
    	clock_t start, finish; //程序开始和结束时间
    	start = clock(); //开始计时
    	srand((unsigned)time(NULL)); // 初始化随机数种子
    	for (int i = 1; i <= 5; i++)
    	{
    		int near_best = 0; // 接近最优解的次数
    		double best_sum = 0; // 重复最优值求和
    		double best = 0; // 重复实验得到的最优解
    		for (int j = 0; j < repeat; j++)    //repeat为迭代次数
    		{
    			PSO_func(i); // 第i种w参数取值,表示采用第i种惯性权重w的线性递减方式,完成粒子群搜索
    			double * best_fit_index = max(result, maxgen);  //result是存放每次迭代最优值的数组,maxgen迭代次数
    			double best_result = *(best_fit_index + 1); //最优解
    			if (best_result > 0.95)
    				near_best++;
    			if (best_result > best)
    				best = best_result;
    			best_sum += best_result;
    		}
    		double average_best = best_sum / repeat; //重复实验平均最优值
    		printf("w参数的第%d种方法:\n", i);
    		printf("重复实验%d次,每次实验迭代%d次,接近最优解的实验次数为%d次,求得最优值为:%lf,平均最优值为:%lf\n",
    			    repeat, maxgen, near_best, best, average_best);
    	}
    	finish = clock(); //结束时间
    	double duration = (double)(finish - start) / CLOCKS_PER_SEC; // 程序运行时间
    	printf("程序运行耗时:%lf\n", duration);
    	system("pause");
    	return 0;
    }
    							 
    double func(double * arr)	//适应度函数
    {
    	double x = *arr; //x 的值
    	double y = *(arr + 1); //y的值
    	double fitness = sin(sqrt(x*x + y*y)) / (sqrt(x*x + y*y)) + exp((cos(2 * PI*x) + cos(2 * PI*y)) / 2) - 2.71289;
    	return fitness;
    
    }
    
    void pop_init(void)	 // 种群初始化
    {
    	for (int i = 0; i<sizepop; i++)
    	{
    		for (int j = 0; j<dim; j++)   //dim为粒子维数2
    		{
    			pop[i][j] = (((double)rand()) / RAND_MAX - 0.5) * 4; //-2到2之间的随机数
    			V[i][j] = ((double)rand()) / RAND_MAX - 0.5; //-0.5到0.5之间
    		}
    		fitness[i] = func(pop[i]); //计算适应度函数值
    								   //pop[i]表示二维数组pop的pop[i][0]的地址
    	}
    }
    
    double * max(double * fit, int size)	// 求适应度函数值最大值及其位置
    {
    	int index = 0; // 初始化序号
    	double max = *fit; //初始化最大值为数组第一个元素
    	static double best_fit_index[2];
    	for (int i = 1; i<size; i++)
    	{
    		if (*(fit + i) > max)
    			max = *(fit + i);
    		index = i;
    	}
    	best_fit_index[0] = index;
    	best_fit_index[1] = max;
    	return best_fit_index;
    }
    
    void PSO_func(int n)	// 迭代寻优,传入的参数为一个整数,取值为1到5,分别代表5种不同的计算w的方法
    {
    	pop_init();
    	double * best_fit_index; // 用于存放群体极值和其位置(序号)
    	best_fit_index = max(fitness, sizepop); //求群体极值
    	int index = (int)(*best_fit_index);
    	// 群体极值位置
    	for (int i = 0; i<dim; i++)    //dim为粒子维数2
    	{
    		gbest[i] = pop[index][i];
    	}
    	// 个体极值位置
    	for (int i = 0; i<sizepop; i++)
    	{
    		for (int j = 0; j<dim; j++)
    		{
    			pbest[i][j] = pop[i][j];
    		}
    	}
    	// 个体极值适应度值
    	for (int i = 0; i<sizepop; i++)
    	{
    		fitnesspbest[i] = fitness[i];
    	}
    	//群体极值适应度值
    	double bestfitness = *(best_fit_index + 1);
    	fitnessgbest = bestfitness;
    
    	//迭代寻优
    	for (int i = 0; i<maxgen; i++)
    	{
    		for (int j = 0; j<sizepop; j++)
    		{
    			//速度更新及粒子更新
    			for (int k = 0; k<dim; k++)
    			{
    				// 速度更新
    				double rand1 = (double)rand() / RAND_MAX; //0到1之间的随机数
    				double rand2 = (double)rand() / RAND_MAX;
    				double w;
    				double Tmax = (double)maxgen;  //迭代次数
    				switch (n)
    				{
    				case 1:
    					w = 1;
    				case 2:
    					w = w_end + (w_start - w_end)*(Tmax - i) / Tmax;
    				case 3:
    					w = w_start - (w_start - w_end)*(i / Tmax)*(i / Tmax);
    				case 4:
    					w = w_start + (w_start - w_end)*(2 * i / Tmax - (i / Tmax)*(i / Tmax));
    				case 5:
    					w = w_end*(pow((w_start / w_end), (1 / (1 + 10 * i / Tmax))));
    				default:
    					w = 1;
    				}
    				V[j][k] = w*V[j][k] + c1*rand1*(pbest[j][k] - pop[j][k]) + c2*rand2*(gbest[k] - pop[j][k]);
    				//速度修正
    				if (V[j][k] > Vmax)
    					V[j][k] = Vmax;
    				if (V[j][k] < Vmin)
    					V[j][k] = Vmin;
    				// 粒子更新
    				pop[j][k] = pop[j][k] + V[j][k];
    				//位置修正
    				if (pop[j][k] > popmax)
    					pop[j][k] = popmax;
    				if (pop[j][k] < popmin)
    					pop[j][k] = popmin;
    			}
    			fitness[j] = func(pop[j]); //新粒子的适应度值
    		}
    		for (int j = 0; j<sizepop; j++)
    		{
    			// 个体极值更新
    			if (fitness[j] > fitnesspbest[j])
    			{
    				for (int k = 0; k<dim; k++)
    				{
    					pbest[j][k] = pop[j][k];
    				}
    				fitnesspbest[j] = fitness[j];
    			}
    			// 群体极值更新
    			if (fitness[j] > fitnessgbest)
    			{
    				for (int k = 0; k<dim; k++)
    					gbest[k] = pop[j][k];
    				fitnessgbest = fitness[j];
    			}
    		}
    		for (int k = 0; k<dim; k++)
    		{
    			genbest[i][k] = gbest[k]; // 每一代最优值取值粒子位置记录
    		}
    		result[i] = fitnessgbest; // 每代的最优值记录到数组
    	}
    }
    

    运行结果:

    在这里插入图片描述

    更多相关内容
  • 混合粒子群求解TSP问题,重新定义了离散粒子群算法DPSO的速度和位置公式,使其适宜求解离散问题.针对DPSO易早熟,收敛慢的缺陷,建立局部极小区域的扰动机制,在结合局部搜索算法PSEC后,提出了一种混合离散粒子群算法...
  • 包含多个速度更新公式粒子群算法.pdf
  • 设计了基于平均速度的切换模拟退火算法和退火温度的更新公式, 使得粒子群在保持较快的寻优速度条 件下, 仍能很容易地跳出局部极小点. 对3 个典型测试函数的寻优问题进行实验, 所得结果表明了该算法的有效性....
  • 第三章针对PSO算法求解组合优化问题时,速度迭代公式难以定义的问题,提出等值变换、异值变换和变换序列等概念的基础上,通过重新定义粒子的速度和位置迭代公式,设计随机自适应粒子群优化模型并用以求解0-1背包问题...
  • 针对分数阶达尔文粒子群算法收敛性能依赖于分数阶次α,易陷入局部最优的特点,提出了一种自适应的分数阶达尔文粒子群优化(AFO-DPSO)算法,利用粒子的位置和速度信息来动态调整分数阶次α,并引入自适应的加速系数...
  • 针对惯性权重改进策略大多采用同代粒子使用相同权重,忽略了粒子本身特点...通过对7个典型测试函数的测试结果表明,AWPSO在收敛速度,收敛精度,全局搜索能力方面比线性惯性权重粒子群算法(LDIWPSO)均有不同程度上的提高。
  • 基本的粒子群算法的单步更新位置,速度的算法,有详细的注释,可读性强
  • 粒子群优化 (PSO) 是一种计算方法,它通过迭代尝试改进与给定质量度量相关的候选解决方案来优化问题。 PSO 通过拥有一组候选解(这里称为粒子)并根据粒子位置和速度上的简单数学公式在搜索空间中移动这些粒子来优化...
  • 针对感应电机扩展卡尔曼滤波器转速估计中...仿真实验表明, 与试探法、标准粒子群算法及遗传算法比较, 改进粒子群算法优化的扩展卡尔曼滤波器能够有效提高转速估计的精度, 从而提高无速度传感器矢量控制系统的控制性能。
  • 最优化算法之粒子群算法(PSO)

    万次阅读 多人点赞 2018-08-03 10:26:45
    一、粒子群算法的概念   粒子群优化算法(PSO:Particle swarm optimization) 是一种进化计算技术(evolutionary computation)。源于对鸟群捕食的行为研究。粒子群优化算法的基本思想:是通过群体中个体之间的...

    一、粒子群算法的概念

      粒子群优化算法(PSO:Particle swarm optimization) 是一种进化计算技术(evolutionary computation)。源于对鸟群捕食的行为研究。粒子群优化算法的基本思想:是通过群体中个体之间的协作和信息共享来寻找最优解.
      PSO的优势:在于简单容易实现并且没有许多参数的调节。目前已被广泛应用于函数优化、神经网络训练、模糊系统控制以及其他遗传算法的应用领域。

    二、粒子群算法分析

    1、基本思想

      粒子群算法通过设计一种无质量的粒子来模拟鸟群中的鸟,粒子仅具有两个属性:速度和位置,速度代表移动的快慢,位置代表移动的方向。每个粒子在搜索空间中单独的搜寻最优解,并将其记为当前个体极值,并将个体极值与整个粒子群里的其他粒子共享,找到最优的那个个体极值作为整个粒子群的当前全局最优解,粒子群中的所有粒子根据自己找到的当前个体极值和整个粒子群共享的当前全局最优解来调整自己的速度和位置。下面的动图很形象地展示了PSO算法的过程:
    这里写图片描述

    2、更新规则

      PSO初始化为一群随机粒子(随机解)。然后通过迭代找到最优解。在每一次的迭代中,粒子通过跟踪两个“极值”(pbest,gbest)来更新自己。在找到这两个最优值后,粒子通过下面的公式来更新自己的速度和位置。
    这里写图片描述
    公式(1)的第一部分称为【记忆项】,表示上次速度大小和方向的影响;公式(1)的第二部分称为【自身认知项】,是从当前点指向粒子自身最好点的一个矢量,表示粒子的动作来源于自己经验的部分;公式(1)的第三部分称为【群体认知项】,是一个从当前点指向种群最好点的矢量,反映了粒子间的协同合作和知识共享。粒子就是通过自己的经验和同伴中最好的经验来决定下一步的运动。以上面两个公式为基础,形成了PSO的标准形式
    这里写图片描述
    公式(2)和 公式(3)被视为标准PSO算法

    3、PSO算法的流程和伪代码

    这里写图片描述

    4、PSO算法举例

    这里写图片描述
    这里写图片描述

    5、PSO算法的demo

    #include <iostream>
    #include <vector>
    #include <cmath>
    #include <map>
    #include <algorithm>
    #include <random>
    #include <ctime>
    #include <Eigen/Dense>
    using namespace Eigen;
    using namespace std;
    
    const int dim = 1;//维数
    const int p_num = 10;//粒子数量
    const int iters = 100;//迭代次数
    const int inf = 999999;//极大值
    const double pi = 3.1415;
    //定义粒子的位置和速度的范围
    const double v_max = 4;
    const double v_min = -2;
    const double pos_max = 2;
    const double pos_min = -1;
    //定义位置向量和速度向量
    vector<double> pos;
    vector<double> spd;
    //定义粒子的历史最优位置和全局最优位置
    vector<double> p_best;
    double g_best;
    //使用eigen库定义函数值矩阵和位置矩阵
    Matrix<double, iters, p_num> f_test;
    Matrix<double, iters, p_num> pos_mat;
    
    //定义适应度函数
    double fun_test(double x)
    {
        double res = x * x + 1;
        return res;
    }
    
    //初始化粒子群的位置和速度
    void init()
    {
        //矩阵中所有元素初始化为极大值
        f_test.fill(inf);
        pos_mat.fill(inf);
        //生成范围随机数
        static std::mt19937 rng;
        static std::uniform_real_distribution<double> distribution1(-1, 2);
        static std::uniform_real_distribution<double> distribution2(-2, 4);
        for (int i = 0; i < p_num; ++i)
        {
            pos.push_back(distribution1(rng));
            spd.push_back(distribution2(rng));
        }
        vector<double> vec;
        for (int i = 0; i < p_num; ++i)
        {
            auto temp = fun_test(pos[i]);//计算函数值
            //初始化函数值矩阵和位置矩阵
            f_test(0, i) = temp;
            pos_mat(0, i) = pos[i];
            p_best.push_back(pos[i]);//初始化粒子的历史最优位置
        }
        std::ptrdiff_t minRow, minCol;
        f_test.row(0).minCoeff(&minRow, &minCol);//返回函数值矩阵第一行中极小值对应的位置
        g_best = pos_mat(minRow, minCol);//初始化全局最优位置
    }
    
    void PSO()
    {
        static std::mt19937 rng;
        static std::uniform_real_distribution<double> distribution(0, 1);
        for (int step = 1; step < iters; ++step)
        {
            for (int i = 0; i < p_num; ++i)
            {
                //更新速度向量和位置向量
                spd[i] = 0.5 * spd[i] + 2 * distribution(rng) * (p_best[i] - pos[i]) +
                    2 * distribution(rng) * (g_best - pos[i]);
                pos[i] = pos[i] + spd[i];
                //如果越界则取边界值
                if (spd[i] < -2 || spd[i] > 4)
                    spd[i] = 4;
                if (pos[i] < -1 || pos[i] > 2)
                    pos[i] = -1;
                //更新位置矩阵
                pos_mat(step, i) = pos[i];
            }
            //更新函数值矩阵
            for (int i = 0; i < p_num; ++i)
            {
                auto temp = fun_test(pos[i]);
                f_test(step, i) = temp;
            }
            for (int i = 0; i < p_num; ++i)
            {
                MatrixXd temp_test;
                temp_test = f_test.col(i);//取函数值矩阵的每一列
                std::ptrdiff_t minRow, minCol;
                temp_test.minCoeff(&minRow, &minCol);//获取每一列的极小值对应的位置
                p_best[i] = pos_mat(minRow, i);//获取每一列的极小值,即每个粒子的历史最优位置
            }
            g_best = *min_element(p_best.begin(), p_best.end());//获取全局最优位置
        }
        cout << fun_test(g_best);
    }
    
    int main()
    {
        init();
        PSO();
        system("pause");
        return 0;
    }

    参考:https://blog.csdn.net/myarrow/article/details/51507671
    https://blog.csdn.net/google19890102/article/details/30044945
    https://wenku.baidu.com/view/65c600b9294ac850ad02de80d4d8d15abe230048.html
    https://blog.csdn.net/darin1997/article/details/80675933

    展开全文
  • 粒子群算法详解

    万次阅读 多人点赞 2016-12-02 16:44:35
    粒子群算法(particleswarm optimization,PSO)由Kennedy和Eberhart在1995年提出,该算法对于Hepper的模拟鸟群(鱼群)的模型进行修正,以使粒子能够飞向解空间,并在最好解处降落,从而得到了粒子群优化算法。...

    一.产生背景

       

    粒子群算法(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实现
    close all;
    clear all;
    
    PopSize=500;%种群大小
    CityNum = 14;%城市数
    
    OldBestFitness=0;%旧的最优适应度值
    
    Iteration=0;%迭代次数
    MaxIteration =2000;%最大迭代次数
    IsStop=0;%程序停止标志 
    Num=0;%取得相同适应度值的迭代次数
    
    c1=0.5;%认知系数
    c2=0.7;%社会学习系数
    w=0.96-Iteration/MaxIteration;%惯性系数,随迭代次数增加而递减
    
    %节点坐标
    node=[16.47 96.10; 16.47 94.44; 20.09 92.54; 22.39 93.37; 25.23 97.24;...
         22.00 96.05; 20.47 97.02; 17.20 96.29; 16.30 97.38; 14.05 98.12;...
         16.53 97.38; 21.52 95.59; 19.41 97.13; 20.09 94.55];
    
    %初始化各粒子,即产生路径种群
    Group=ones(CityNum,PopSize);   
    for i=1:PopSize
        Group(:,i)=randperm(CityNum)';
    end
    Group=Arrange(Group);
    
    %初始化粒子速度(即交换序)
    Velocity =zeros(CityNum,PopSize);   
    for i=1:PopSize
        Velocity(:,i)=round(rand(1,CityNum)'*CityNum); %round取整
    end
    
    %计算每个城市之间的距离
    CityBetweenDistance=zeros(CityNum,CityNum);   
    for i=1:CityNum
        for j=1:CityNum
            CityBetweenDistance(i,j)=sqrt((node(i,1)-node(j,1))^2+(node(i,2)-node(j,2))^2);
        end
    end
    
    %计算每条路径的距离
    for i=1:PopSize   
            EachPathDis(i) = PathDistance(Group(:,i)',CityBetweenDistance);
    end
    
    IndivdualBest=Group;%记录各粒子的个体极值点位置,即个体找到的最短路径
    IndivdualBestFitness=EachPathDis;%记录最佳适应度值,即个体找到的最短路径的长度
    [GlobalBestFitness,index]=min(EachPathDis);%找出全局最优值和相应序号 
    
    %初始随机解
    figure;
    subplot(2,2,1);
    PathPlot(node,CityNum,index,IndivdualBest);
    title('随机解');
    
    %寻优
    while(IsStop == 0) & (Iteration < MaxIteration) 
        %迭代次数递增
        Iteration = Iteration +1;  
        
        %更新全局极值点位置,这里指路径
        for i=1:PopSize   
            GlobalBest(:,i) = Group(:,index);
          
        end
        
        %求pij-xij ,pgj-xij交换序,并以概率c1,c2的保留交换序
        pij_xij=GenerateChangeNums(Group,IndivdualBest);  
        pij_xij=HoldByOdds(pij_xij,c1); 
        pgj_xij=GenerateChangeNums(Group,GlobalBest);
        pgj_xij=HoldByOdds(pgj_xij,c2);
        
        %以概率w保留上一代交换序
        Velocity=HoldByOdds(Velocity,w);
    
        Group = PathExchange(Group,Velocity); %根据交换序进行路径交换
        Group = PathExchange(Group,pij_xij);
        Group = PathExchange(Group,pgj_xij);
        for i = 1:PopSize    % 更新各路径总距离
              EachPathDis(i) = PathDistance(Group(:,i)',CityBetweenDistance);
        
        end
    
        IsChange = EachPathDis<IndivdualBestFitness;%更新后的距离优于更新前的,记录序号
        IndivdualBest(:, find(IsChange)) = Group(:, find(IsChange));%更新个体最佳路径
        IndivdualBestFitness = IndivdualBestFitness.*( ~IsChange) + EachPathDis.*IsChange;%更新个体最佳路径距离
        [GlobalBestFitness, index] = min(EachPathDis);%更新全局最佳路径,记录相应的序号
       
        if GlobalBestFitness==OldBestFitness %比较更新前和更新后的适应度值;
            Num=Num+1; %相等时记录加一;
        else
            OldBestFitness=GlobalBestFitness;%不相等时更新适应度值,并记录清零;
            Num=0;
        end    
        if Num >= 20 %多次迭代的适应度值相近时程序停止
            IsStop=1;
        end
    
         BestFitness(Iteration) =GlobalBestFitness;%每一代的最优适应度
    
    
    end
    
    %最优解
    subplot(2,2,2);
    PathPlot(node,CityNum,index,IndivdualBest);
    title('优化解');
    %进化曲线
    subplot(2,2,3);
    plot((1:Iteration),BestFitness(1:Iteration));
    grid on;
    title('进化曲线');
    %最小路径值
    GlobalBestFitness
    
    运行结果如下:

    2.java 实现
    package pso;
    import java.awt.*;
    import java.awt.event.*;
    import java.io.ByteArrayInputStream;
    import java.io.InputStream;
    
    import javax.swing.*;
    import javax.swing.event.*;
    public class Pso extends Frame implements Runnable
    {
        private static int particleNumber;  //粒子的数量
        private static int iterations;      //迭代的次数
        private static int k=1;             //记录迭代的次数
        final private static float C1=2;    //学习因子
        final private static float C2=2;
        final private static float WMIN=-200;
        final private static float WMAX=200;
        final private static float VMAX=200;
        private static float r1;           //随机数0-1之间
        private static float r2;
        private static float x[][];
        private static float v[][];
        private static float xpbest[][];
        private static float pbest[];      
        private static float gbest=0;
        private static float xgbest[];
        private static float w;           //惯性因子
        private static float s;
        private static float h;
        private static float fit[];
        public Sounds sound;
        
        //粒子群的迭代函数
    public void lzqjs()
    {
    	  
    		w=(float)(0.9-k*(0.9-0.4)/iterations);
            for(int i=0;i<particleNumber;i++)
            {
                       fit[i]= (float)(1/(Math.pow(x[i][0],2)+Math.pow(x[i][1],2))); //求适值函数最大值
                       System.out.print("粒子"+i+"本次适应值函数f为:" + fit[i]);
                       System.out.println();
                       if(fit[i]>pbest[i])
                       {
                       	pbest[i]=fit[i];
                       	xpbest[i][0]=x[i][0];
                       	xpbest[i][1]=x[i][1];
                       }
                       if(pbest[i]>gbest)
                       {
                       	gbest=pbest[i];
                       	xgbest[0]=xpbest[i][0];
                       	xgbest[1]=xpbest[i][1];
                       }
             }
             for(int i=0;i<particleNumber;i++)
             {
                       for(int j=0;j<2;j++)
                       {
                    	   //粒子速度和位置迭代方程:
                       	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]));
                       
                       	x[i][j]=(float)(x[i][j]+v[i][j]);
                       
                       }
                   	System.out.print("粒子"+i+"本次X1的速度变化幅度:"+v[i][0]+";本次X2的速度变化幅度:"+v[i][1]);
                    System.out.println();
                	System.out.print("粒子"+i+"本次X1为:"+x[i][0]+";本次X2为:"+x[i][1]);
                    System.out.println();
             }
    }
    	public static void main(String[] args)
    	{
    		
    		particleNumber=Integer.parseInt(JOptionPane.showInputDialog("请输入粒子个数1-500)"));
    		iterations=Integer.parseInt(JOptionPane.showInputDialog("请输入迭代次数"));
    		x=new float [particleNumber][2];
    		v=new float [particleNumber][2];
    		fit=new float [particleNumber];    //存储适值函数值
    		pbest=new float [particleNumber];  //存储整个粒子群的最有位置
    		xpbest=new float [particleNumber][2];
    		xgbest=new float [2];
    		for(int i=0;i<particleNumber;i++)
    		{
    			
    			//对数组的初始化操作
    			pbest[i]=0;
    			xpbest[i][0]=0;
    			xpbest[i][1]=0;
    		}
    		xgbest[0]=0;
    		xgbest[1]=0;
    		 System.out.println("开始初始化:");
    		for(int i=0;i<particleNumber;i++)
    		{
    			
    			for(int j=0;j<2;j++)
    			{
    				//任意给定每个位置一定的位置值和速度值
    				x[i][j]=(float)(WMAX*Math.random()+WMIN);
    				v[i][j]=(float)(VMAX*Math.random());
    			}
    			System.out.print("粒子"+i+"本次X1的变化幅度:"+v[i][0]+";本次X2的变化幅度:"+v[i][1]);
    		 	 System.out.println();
    		 	System.out.print("粒子"+i+"本次X1为:"+x[i][0]+";本次X2为:"+x[i][1]);
    			 System.out.println();
    		}
    		System.out.println("初始化数据结束,开始迭代.....");
    	Pso threada=new Pso();
    	threada.setTitle("基于粒子群的粒子位置动态显示");
    	threada.setSize(800,800);
    	threada.addWindowListener(new gbck());
    	threada.setVisible(true);
            Thread threadc=new Thread(threada);
            threadc.start();
    	}
    	static class gbck extends WindowAdapter
    	{
    		public void windowClosing(WindowEvent e)
    		{
    			System.exit(0);
    		}
    	}
    	
    	//开启的额外线程用于声音的播放
    	public void run()
    	{
           
    		repaint();
            
            for(int i=0;i<iterations;i++){
            	sound();
            }
    	}
    	public void paint(Graphics g)
    	{
    		 
    		   g.setColor(new Color(0,0,0));
    	       for(int i=0;i<particleNumber;i++)
    	       {
    	       	g.drawString("*",(int)(x[i][0]+200),(int)(x[i][1]+200));
    	       }
    	       g.setColor(new Color(255,0,0));
    	       g.drawString("全局最优适应度函数值:"+gbest+"      参数1:"+xgbest[0]+"     参数2:"+xgbest[1]+"    迭代次数:"+ k,50,725);
    
        try
    	{
    	lzqjs();  //开始迭代
    	
    	if(k>=iterations)
    	{
    		
    		Thread.sleep((int)(5000));
    		System.exit(0);
    	}
    	k=k+1;  //每次迭代一次加1操作
    	Thread.sleep((int)(1000));
    	}
        catch(InterruptedException e)
        {
    		 System.out.println(e.toString());
        }
        repaint();
    	}
    	public  void sound(){
    		  sound =new Sounds("050.wav");
    		  InputStream stream =new ByteArrayInputStream(sound.getSamples());
    		  // play the sound
    		  sound.play(stream);
    		  // exit
    
    	}
    }
    运行的结果如下:


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

    展开全文
  • 为了提高空气孔结构光子晶体生物传感器的归一化透射率,利用粒子群优化(PSO)算法对其结构参数进行多维空间全局优化。以散射空气孔、耦合空气孔和内部空气孔的半径作为被优化变量,并根据位置—速度更新公式进行优化...
  • 理解:假使一群鸟要找吃的,这时一群鸟就是粒子群,一只鸟就是个体。 初始化:最开始鸟在一定的范围内(已经知道了这个范围内是有食物的了)各自有自己的速度(所谓速度就是下一次迭代(或者说下一单位时间?与物理上...

    理解:假使一群鸟要找吃的,这时一群鸟就是粒子群,一只鸟就是个体。

     

    初始化:最开始鸟在一定的范围内(已经知道了这个范围内是有食物的了)各自有自己的速度(所谓速度就是下一次迭代(或者说下一单位时间?与物理上的意义一致)想要在这个维度上走的长度,也就是步长,多个维度的步长就会组成一个运动方向,所以这里的速度不仅有大小,而且有方向,因此是一个矢量)与位置;

     

    寻找机制:这时候鸟有个小雷达,可以食物信号的强度,强度越大,实物越近(比如要求解一个函数的最大值,那么信号最大值的位置就是食物所在的位置,然后计算当前位置到最大值的位置的距离,就是与食物的距离了),但是位置这个可说不准,所以用鸟鸣沟通,看看谁雷达信号最大,那么她身边更有可能具有食物。这样鸟群所有人都报了一下自己雷达强度,发现A小鸟身边强大最大,鸟群会议决定向A小鸟那里飞;但是每只鸟都有自己的小心思,虽然自己位置所在的雷达信号不是最大的,但是往自己曾经飞过信号最大的地方去,万一才是食物的所在地呢?但是鸟群会议的指令又不能不听,所以所有的小鸟最后飞的速度都是一个折衷的方案,也就是两个方向都要走,走个速度的合成,但是鸟还有惯性,转向不那么灵便,所以变成了自己原本的速度,往鸟群会议方向的速度,以及自己经验想要飞去的速度的合成。

     

    所以有公式:

     

     

    这里k表示第k轮,或者第k个单位时间。

    Vid表示第i只鸟个体在第d维的速度,ω表示惯性因子;c1为自我学习因子,c2为社会学习因子;r1与r2为两个随机数,区间在(0,1)上,(可以理解成鸟的意志很难捉摸,对于自己的经验与社会经验,有时候很相信,有时候又不是很相信,变成了一个概率事件);Pid表示第i个鸟个体在她自己走过的位置上的信号最强位置在d维度上的位置;Ppd是表示通过鸟会议得到的最佳信号位置在d维上位置;

     

    流程图:

     

    展开全文
  • 提出了一种新型的PSO算法——含速度变异算子的粒子群算法(PSOVMO)。该算法在进行变异时的变异对象是搜索速度(v),而不是通常情况下的位置(x)。其方法是,设置一个随迭代的进行按指数级数减小的临界速度。在...
  • 粒子群优化算法(PSO)

    千次阅读 2022-03-15 19:57:14
    粒子群优化算法(PSO) 粒子群优化算法(PSO)是一种进化计算技术,源于对鸟群捕食行为的研究。该算法最初是受到飞鸟集群活动的规律性启发,进而利用群体智能建立的一个简化模型。粒子群算法在对动物及群活动行为...
  • 智能优化及其应用课程设计详细讲解,粒子群算法在路径规划上的应用,python编写
  • 粒子群算法

    万次阅读 多人点赞 2018-06-22 00:22:16
    第二篇博客,为大家简单介绍粒子群算法(PSO)。粒子群算法同遗传算法相似,也是根据生物界中的
  • 粒子群算法(PSO)详解

    万次阅读 多人点赞 2020-01-10 16:17:27
    1 粒子群PSO算法简介 1.1 维基百科的解释 粒子群算法(Particle Swarm Optimization,简称PSO),或称粒子群优化,是属于人工智能算法,公元1995年由肯尼迪(Kennedy)与埃伯哈特(Eberhart)(1995)两位学者所提出...
  • 针对传统粒子群优化算法解决复杂问题时收敛速度太快、容易陷入局部最优解的问题,在全局—局部最优解粒子群算法的基础上,提出了一种改进学习因子和约束因子的混合粒子群优化算法。通过将粒子的邻域最优解加入到速度...
  • 粒子群优化算法及MATLAB实现

    千次阅读 多人点赞 2021-04-22 20:18:02
    1. 粒子群优化算法概述 2. 粒子群优化算法求解      2.1 连续解空间问题      2.2 构成要素      2.3 算法过程描述    ...
  • 001 粒子群算法

    2021-08-05 07:16:44
    粒子群(PSO)算法是依托群鸟觅食的模型寻找最优解。群体特征基于以下3个简单的行为准则: 冲突避免:群体在一定空间移动,个体有自己的移动意志,但不能影响影响其他个体移动,避免碰撞和争执。 速度匹配:个体...
  • 粒子群算法(PSO)初识

    千次阅读 2018-12-12 13:10:52
    粒子群算法PSO是模拟群体智能所建立起来的一种优化算法,用于解决各种优化问题。   抽象问题实例化: 假设一群 鸟在觅食,只有一个地方有 食物,所有鸟儿都看不见食物(不知道食物的具体位置,知道了就不无需...
  • 粒子群算法python(含例程代码与详解)

    千次阅读 多人点赞 2020-10-07 09:19:35
    1.粒子群算法简介 粒子群算法的思想源于对鸟类捕食行为的研究,模拟鸟集群飞行觅食的行为,鸟之间通过集体的协作使群体达到最优目的。 设想这样的一个场景,一群鸟在随机的搜索食物,在某块区域里有一块食物, 2....
  • 8.粒子群算法(理论部分)

    千次阅读 2020-09-22 22:27:02
    本文主要介绍基础粒子群算法的主要理论,并简单介绍自适应权重分配与压缩因子的用法(即速度更新公式的三个系数改进)。 实际上粒子群算法经历了数十年发展,衍生出的改进算法多种多样,这里就不再过多介绍。下面...
  • 贝叶斯网络结构学习是数据挖掘和知识发现领域的重要研究技术之一,在网络结构的搜索空间较大的情况下,传统的二值粒子群优化算法往往存在收敛速度慢,容易陷入局部最优,学习精度较差的缺陷。在传统二值粒子群优化算法...
  • 粒子群算法PSO入门代码火经典案例求Ackley函数附-PSO.zip 本帖最后由 当当的花生 于 2016-7-30 20:09 编辑 回帖获得更多 粒子群算法 遗传算法前面有人讲了,我来讲讲PSO。 1)先看看百度百科解释: 粒子群...
  • 粒子群优化

    2018-10-25 16:17:54
    优化程序,如何选择pbest ,如何选择gbest,根据位置和速度公式进行位置和速度的更新

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,312
精华内容 924
热门标签
关键字:

粒子群速度公式