精华内容
下载资源
问答
  • 用基于模拟退火的粒子群优化算法求解无约束优化问题用随机权重粒子群优化算法求解无约束优化问题 用学习因子同步变化的粒子群优化算法求解无约束优化问题 用学习因子异步变化的粒子群优化算法求解无约束优化问题
  • 视频讲解+粒子群优化算法PPT+演讲稿+matlab算法实例
  • 使用粒子群算法求解一个简单地二元函数最小值!解决函数最值问题!
  • 粒子群算法是智能优化算法中的一个重要的组成部分,本代码是其在多目标领域一个重要的应用。看了此代码对多目标优化是及其重要的!
  • 优化算法粒子群算法(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

    展开全文
  • 用于布局参数的优化, 提出了适合粒子群优化的约束处理, 并通过与直接搜索算法的混合, 加强了算法在局部区域 的搜索能力. 通过实例将该算法与乘子法以及基于遗传算法的布局优化方法进行了比较. 仿真结果表明, 该...
  • 为有效避免粒子群优化算法后期...实例仿真结果表明:弹性粒子群优化算法是有效的;相比基本粒子群优化算法和自适应粒子群优化算法,弹性粒子群优化算法求解水电优化调度问题具有更强的全局寻优能力和更快的收敛速度.
  • 粒子群优化算法

    2018-11-02 10:42:45
    寻找最有解的智能算法,属于优化控制,可以作为学术汇报PPT,内有实例程序
  • 针对粒子群优化算法搜索空间有限、容易出现早熟现象的缺陷,提出将量子粒子群优化算法用于求解作业车间...仿真实例结果证明,该算法具有良好的全局收敛性能和快捷的收敛速度,调度效果优于遗传算法和粒子群优化算法
  • 应用粒子群优化(PSO)算法对电力系统的机组优化组合问题进行研究,介绍了算法原理,分析了算法中各个参数的不同取值对算法搜索能力和收敛速度的影响,并以常用的测试函数进行验证,建立了相应的数学模型,并以IEEE3机6节点...
  • 粒子群优化算法的简单例子,实现对非线性函数的极值寻优
  • 针对元件可靠性为区间值的系统可靠性优化问题, 提出一种区间多目标粒子群优化方法. 首先, 建立问题的区间多目标优化模型; 然后, 利用粒子群算法优化该模型, 定义一种不精确Pareto 支配关系, 并给出编码、约束处理、...
  • 粒子群优化算法原理参考: 如何直观形象地理解粒子群算法? 最优化算法之粒子群算法(PSO) 参数设置 关于粒子群算法的两种惯性权重 粒子群优化实现思路: 1、知道粒子群优化原理后,首先需要设置初始参数:粒子个数...

    粒子群优化算法原理参考:
    如何直观形象地理解粒子群算法?
    最优化算法之粒子群算法(PSO)
    参数设置
    关于粒子群算法的两种惯性权重

    粒子群优化实现思路:
    1、知道粒子群优化原理后,首先需要设置初始参数:粒子个数n社会学习因子c1个体学习因子c2收敛条件loss惯性因子w
    2、确定需要优化函数的维度,给出每个维度下参数的取值范围
    例如:
    在这里插入图片描述
    对于该函数有三个维度x,y,z,在进行粒子群优化时需要给出每个维度的取值区间x=[-10, 10], y=[-80, 20], z=[-9, 2]
    3、在步骤2中给出取值范围后,先随机初始化每个粒子的初始位置Position(每个粒子初始化的位置都在步骤2给的范围内),将每个粒子的初始速度V0设为0,将每个粒子的个体最优解Pbest设为与初始化位置Position相等,Pbest=Position。
    4、计算每一个粒子当前位置下目标函数f的值Value,记录最小值所对应的粒子index
    5、更新个体最优解Pbest。将4中算出的当前时刻的Value,与上一时刻计算的Value记为lastValue进行比较,看哪一个粒子的lastValue大于Value,那么就将这个粒子的当前时刻坐标设为这个粒子的Pbest,否则不变。即:(如果当上一步值比当前值大,那么就将Pbest的坐标值改变,也就是每一个粒子Pbest的值等于该粒子当前时刻历史数据中所处位置对应目标函数最小值的位置)
    6、更新全局最优解Pz。全局最优解为4中index对应的粒子的位置
    7、根据下面两个公式更新粒子的速度与位置
    该公式引用于https://blog.csdn.net/daaikuaichuan/article/details/81382794
    8、重复4-8直到loss收敛为止。

    粒子群优化Python实现:

    import numpy as np
    import random
    
    
    class ParticleSwarmOptimization:
        """粒子群优化算法"""
        def __init__(self, n=20, c1=2, c2=2, loss=0.001, w=0.6):
            """
            :param n: 粒子个数 一般为[10, 40]个粒子。根据实际情况而定可以取更多
            :param c1: 社会学习因子 通常在[0, 4]区间范围,一般取2
            :param c2: 个体学习因子 通常在[0, 4]区间范围,一般取2
            :param loss: 判断是否收敛条件
            :param w:惯性因子 较大时全局搜索能力强,较小时局部搜索能力强(本文为定值) 参考:https://blog.csdn.net/qq_38883271/article/details/101538704
            """
            self.n = n
            self.c1 = c1
            self.c2 = c2
            self.loss = loss
            self.w = w
    
        def fit(self, region):
            """
            初始化变量
            :param region: 每个维度的可行域,该变量的格式为字典
            例如:region = {0:[20, 50], 1:[30, 100],....}
                其中0为第一个维度,其可行域为[20, 50]
                其中1为第二个维度,其可行域为[30, 100]
            """
            self.partical = {}  # 存储每个粒子初始化的位置结果
            # 为每个粒子进行初始化位置
            for num in range(self.n):  # 初始化self.n个粒子
                init = []  # 用于存储每个粒子的初始化参数
                for ndim in range(len(region)):  # 每个粒子初始化len(region)个维度
                    init.append(random.uniform(region[ndim][0], region[ndim][1]))
                self.partical[num] = init
    
            # 初始化每个粒子的初始速度V为0。
            self.V = {}
            for temp in range(self.n):
                self.V[temp] = 0
    
            # 设每个粒子的个体最优解Pb为当前初始化的位置(也可以设为随机位置)
            self.Pb = self.partical.copy()
    
        def predict(self, callback):
            """
            计算最终最优结果
            :param callback: 回调函数,用于优化的目标函数
            :return:
            """
            # 存储上一步的位置信息
            last_position = self.partical.copy()
            last_value = []  # 存储上一步目标函数值,value的上一步值
            # 存储位置变化绝对值
            loss = 100
            # 循环更新每个粒子的位置,直到位置变化小于某一值
            loop = 0  # 循环次数
            while True:
                # 计算每一个粒子当前位置下目标函数的值,并将最小值所对应的粒子记录下来index
                min = callback(self.partical[0])  # 设最小值为min
                index = 0  # 最小值所对应的粒子索引
                value = []  # 存储每个粒子所处位置对应目标函数的值
                for temp in range(self.n):  # 对每一个粒子进行遍历
                    value.append(callback(self.partical[temp]))  # 计算每一个粒子当前时刻位置所对应目标函数的值,存储到value中
                    if min > value[temp]:
                        min = value[temp]
                        index = temp
                if loop == 0:
                    last_value = value.copy()
                else:
                    # 更新个体最优解Pb
                    for temp in range(self.n):
                        if last_value[temp] > value[temp]:  # 如果当上一步值比当前值大,那么就将self.Pb的坐标值改变,也就是每一个粒子self.Pb的值等于该粒子当前时刻历史数据中所处位置对应目标函数最小值的位置
                            last_value[temp] = value[temp]
                            self.Pb[temp] = self.partical[temp]
                # 将全局最优解设为index粒子对应的坐标
                Pz = self.partical[index]
                # 更新每个粒子的坐标
                for temp in range(self.n):
                    # 更新速度
                    if temp != index:
                        self.V[temp] = self.w*np.array(self.V[temp]) + self.c1*random.random()*(np.array(Pz) - np.array(self.partical[temp]))\
                                       + self.c2*random.random()*(np.array(self.Pb[temp]) - np.array(self.partical[temp]))  # 这个地方谁减谁不能搞反, 不然出错
                        # 更新位置
                        self.partical[temp] = np.array(self.partical[temp]) + np.array(self.V[temp])
                        # 计算更新前后位置变化
                        if loss > np.sqrt(np.mean(np.square(np.array(self.partical[temp]) - np.array(last_position[temp])))):
                            loss = np.sqrt(np.mean(np.square(np.array(self.partical[temp]) - np.array(last_position[temp]))))
    
                # 判断位置变化,是否跳出循环,是否收敛
                print(f"loop:{loop}  loss:{loss}")
                if loss < self.loss:
                    break
                last_position = self.partical.copy()
                loop += 1
    
            return Pz
    
    
    

    粒子群优化算法实例分析:
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210322151500922.png
    对于上图目标函数进行参数寻优:

    def callback(x):
        """回调函数"""
        sum = 0
        for i in range(len(x)):
            sum += (x[i]-i)*(x[i]-i)
        sum /= 100
    
        return sum
    
    
    def run():
        # 实例化粒子群优化算法
        pso = ParticleSwarmOptimization(n=10, c1=2, c2=2, loss=0.001, w=0.6)
        # 定义变量取值范围
        region = {0:[-50, 50], 1:[-50, 50], 2:[-40, 100]}
        pso.fit(region)
        result = pso.predict(callback)
        print(result)
    
    
    if __name__ == "__main__":
        run()
    

    运行结果:

    [2.00528254e-03 9.99545977e-01 2.00752164e+00]
    

    由上面运行结果可以看出:实际结果应该为:[0, 1, 2],运行结果为[0.002005, 0.9995, 2.0075],结果相差不大

    展开全文
  • 粒子群优化算法

    2019-01-08 15:51:39
    粒子群算法的各种matlab代码,有多种function实例。包括解决约束类问题
  • 求解二次规划的粒子群优化算法,李响,曹德欣,二次规划是一类基本而又重要的非线性规划问题. 粒子群是一种通过群体中个体间的相互作用寻找复杂空间中最优区域的一种算法,本文讨
  • 遗传算法简单实例: 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-

    展开全文
  • 详细、透彻介绍粒子群算法比较好的PPT课件,适合初学者透彻理解粒子群算法的概念、原理和流程
  • 粒子群算法是一门新兴算法,此算法与遗传算法有很多相似之处,其收敛于全局最优解的概率很大。 ①相较于传统算法计算速度非常快,全局搜索能力也很强; ②PSO对于种群大小不十分敏感,所以初始种群设为500-1000,...

    粒子群算法是一门新兴算法,此算法与遗传算法有很多相似之处,其收敛于全局最优解的概率很大。
    ①相较于传统算法计算速度非常快,全局搜索能力也很强;
    ②PSO对于种群大小不十分敏感,所以初始种群设为500-1000,速度影响也不大;
    ③粒子群算法适用于连续函数极值问题,对于非线性多峰问题均有较强的全局搜索能力。

    作为举例说明,本文将用粒子群算法,求解Rastrigin函数f(x)=x²-10*cos(2πx)+10在区间[-6,6]的极小值。
    先用matlab画出这个函数的图像,便于我们直观地观察:
    Matlab函数图像
    该函数的全局最小值为0,在x=0处取得

    下面,用C#实现求极值。测试环境VS2015

    using System;
    using System.Linq;
    using System.Threading;
    
    namespace PSO_FunctionTest
    {
    
        class Program
        {
            public static double[] xlimit = new double[2] { -6, 6 };       //位置边界设置
            public static double[] vlimit = new double[2] { -2, 2 };       //速度边界设置
            
            public static int generation;             //迭代次数
    
             static void Main(string[] args)
            {
                int popsize;                  //种群规模         
                double Wmax=0.95;             //惯性权重设置
                double Wmin = 0.45;
                double C1 = 2;                //自我学习因子
                double C2 = 2;                //群体学习因子
                Random rand = new Random();
                
                Console.WriteLine("请输入种群规模大小:");
                popsize = Convert.ToInt32(Console.ReadLine());
                Console.WriteLine("请输入迭代次数:");
                generation = Convert.ToInt32(Console.ReadLine());
                Console.WriteLine("算法运行中,请稍后......");
    
                //参数初始化           
                double[] x0 = new double[popsize];                  //种群位置初始化
                double[] V = new double[popsize];                    //粒子速度初始化
                double[] x_pbest = new double[popsize];         //个体历史最好位置
                double[] p_fitness = new double[popsize];       //个体历史最佳适应度
                double x_gbest = new double();                        //群体历史最好位置
                double g_fitness = new double();                      //群体历史最佳适应度
                Initialize(popsize,out x0,out x_pbest, out p_fitness, out x_gbest, out g_fitness,out V);
    
                Thread.Sleep(3000);                                            //延时
    
                //算法运行
                for (int i = 0; i < generation; i++)
                {
                    double[] fitness = new double[popsize];
                    for (int j = 0; j < popsize; j++)
                    {
                        fitness[j] =func(x0[j]);
                    }
                    //遍历每个粒子
                    for (int j = 0; j < popsize; j++)
                    {
                        if (fitness[j]<p_fitness[j])             //将当前个体适应度与个体历史最佳适应度比较,符合条件则替换
                        {
                            p_fitness[j] = fitness[j];            //更新个体历史最佳适应度
                            x_pbest[j] = x0[j];                     //更新对应位置
                        }
                    }
                    if (g_fitness>p_fitness.Min())
                    {
                        g_fitness = p_fitness.Min();             //更新全局最优值
                        int index = new int();                      //在个体历史适应度中找到最小值的索引号
                        index = p_fitness.ToList().IndexOf(p_fitness.Min());      //索引值
                        x_gbest = x0[index];               //更新全局最好位置
                    }
                    double W = new double();
                    W= Wmax - (Wmax - Wmin) * i / generation;     //线性递减惯性权重
                    
                    for (int j = 0; j < popsize; j++)
                    {
                        //速度更新
                        V[j] = W * V[j] + C1 * rand.NextDouble() * (x_pbest[j] - x0[j]) + C2 * rand.NextDouble() * (x_gbest - x0[j]);
                        //速度限制
                        if (V[j]>vlimit[1])
                        {
                            V[j] = vlimit[1];
                        }
                        if (V[j]<vlimit[0])
                        {
                            V[j] = vlimit[0];
                        }
                        //位置更新
                        x0[j] = x0[j] + V[j];
                        //位置限制
                        if (x0[j]>xlimit[1])
                        {
                            x0[j] = xlimit[1];
                        }
                        if (x0[j] < xlimit[0])
                        {
                            x0[j] = xlimit[0];
                        }
                    }
                }
                Console.WriteLine("目标函数的全局最小值是:{0}\n出现在x={1}处", g_fitness.ToString("f3"), x_gbest.ToString("f3"));
                Console.ReadKey();
    
            }
            /// <summary>
            /// 函数表达式
            /// </summary>
            /// <param name="variable">自变量</param>
            /// <returns>函数值</returns>
            public static double func(double variable)
            {
                double x = variable;
                double f;
                f = x * x - 10 * Math.Cos(2 * Math.PI * x) + 10;
                return f;
            }
    
            //初始化参数
            public static void Initialize(int popsize,out double[] x0,out double[] x_pbest,out double[] p_fitness,out double x_gbest,out double g_fitness,out double[] V )
            {
                Random rand = new Random();
                double[] x = new double[popsize];                     //种群位置
                double[] v0 = new double[popsize];                   //粒子速度
                //double[][] pbest = new double[popsize][];      //个体历史最好位置
                double[] p_fit = new double[popsize];                //个体历史最优值
                double gbest = rand.Next(0, 1);                          //群体历史最佳位置
                double g_fit = double.PositiveInfinity;                //群体历史最佳适应度
    
                for (int i = 0; i < popsize; i++)
                {                              
                    x[i] = xlimit[0] + rand.NextDouble() * (xlimit[1] - xlimit[0]);
                    v0[i] = rand.NextDouble();                
                    p_fit[i] = rand.Next(1,2);              //个体历史最佳适应度初始化选取,需额外注意!!!!
                }           
                x0 = x;
                V = v0;
                x_pbest = x;
                p_fitness = p_fit;
                x_gbest = gbest;
                g_fitness = g_fit;
            }      
        }
    }
    
    

    调试运行,得到如下结果:
    在这里插入图片描述

    算法运行结果基本正确
    本人初学,欢迎各位指正!!!

    展开全文
  • 基本粒子群优化算法(PSO)的matlab实现

    万次阅读 多人点赞 2016-11-01 16:25:08
    粒子群优化算法是一种模拟鸟群社会行为的群体搜素算法。它分为全局最佳粒子优化和局部最佳粒子优化,对于全局最佳PSO,或者叫做gbest PSO,每个粒子的邻域都是整个群,其算法伪代码如下: 创建并初始化一个n维的...
  • 将新的基于粒子群优化的方法应用于布局参数的优化,提出了适合粒子群优化的约束处理,并通过与直接搜索算法的混合,加强了算法在局部区域的搜索能力。通过实例将该算法与乘子法以及墓于遗传算法的布局优化方法进行了...

空空如也

空空如也

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

粒子群优化算法实例