精华内容
下载资源
问答
  • 列举了蚁群算法与粒子群算法优缺点,以及对比,提供了一个较为完善的优化思路
  • 粒子群算法简介优缺点及其的应用.ppt
  • 粒子群算法简介优缺点及其应用 2020-10-25 2 粒子群算法的研究背景 粒子群算法(Particle Swarm Optimization简称PSO)是一种基于群体智能的进化计算方法PSO由Kennedy和Eberhart博士于1995年提出 粒子群算法源于复杂...
  • 粒子群算法 2016/6/5 粒子群算法的研究背景 粒子群算法( Particle Swarm Optimization,简称PSO,是一种基 于群体智能的进化计算方法PSO由 Kennedy和 Eberhart博士于 1995年提出 粒子群算法源于复杂适应系统( Complex ...
  • 粒子群算法简介优缺点及其的应用.ppt
  • 【寻算法】量子粒子群算法(QPSO) 参数寻的python实现一、粒子群算法缺点二、量子粒子群算法三、QPSO算法的python实现参考资料 一、粒子群算法缺点 本人之前的博文(参考资料【1】)已经详细介绍了PSO...

    【超参数寻优】量子粒子群算法(QPSO) 超参数寻优的python实现

    一、粒子群算法的缺点

    本人之前的博文(参考资料【1】)已经详细介绍了PSO算法,学习本博文前需要先学习PSO算法。

    PSO算法的缺点:
    1、需要设定的参数(惯性因子ww,局部学习因子c1{c_1}和全局学习因子c2{c_2})太多,不利于找到待优化模型的最优参数。
    2、粒子位置变化缺少随机性,容易陷入局部最优的陷阱。

    二、量子粒子群算法

    量子粒子群优化(Quantum Particle Swarm Optimization,QPSO)算法取消了粒子的移动方向属性,粒子位置的更新跟该粒子之前的运动没有任何关系,这样就增加了粒子位置的随机性(参考资料【2】)。
    量子粒子群算法中引入的新名词:
    mbest:表示pbest的平均值,即平均的粒子历史最好位置。
    量子粒子群算法的粒子更新步骤:
    步骤一:计算mbest

    Mbest=1Mi=1Mpbest_i{M_{best}} = \frac{1}{M}\sum\limits_{i = 1}^M {{p_{best\_i}}}

    其中MM表示粒子群的大小,pbest_i{p_{best\_i}}表示当前迭代中的第iipbestpbest

    步骤二:粒子位置更新

    Pi=ϕpbest_i+(1ϕ)gbest{P_i} = \phi \cdot {p_{best\_i}} + (1 - \phi )gbest

    其中gbestgbest表示当前全局最优粒子,Pi{P_i}用于第ii个粒子位置的更新。
    粒子位置更新公式为:

    xi=Pi±αMbestxiln(1u){x_i} = {P_i} \pm \alpha \left| {{M_{best}} - {x_i}} \right|\ln \left( {\frac{1}{u}} \right)

    其中xi{x_i}表示第ii个粒子的位置,α\alpha为创新参数,ϕ\phiuu0,1(0,1)上的均匀分布数值。取++-的概率为0.5。

    由上所示,QPSO算法中只有一个创新参数α\alpha设置,一般α\alpha不大于1。

    三、QPSO算法的python实现

    完整python代码和样本地址:https://github.com/shiluqiang/QPSO_python
    本博文以非线性SVM为待优化模型,待优化参数为正则化参数CC和核参数 σ\sigma,适应度函数值为3-fold交叉验证平均值。

    ## 2. QPSO算法
    class QPSO(object):
        def __init__(self,particle_num,particle_dim,alpha,iter_num,max_value,min_value):
            '''定义类参数
            particle_num(int):粒子群大小
            particle_dim(int):粒子维度,对应待寻优参数的个数
            alpha(float):控制系数
            iter_num(int):最大迭代次数
            max_value(float):参数的最大值
            min_value(float):参数的最小值
            '''
            self.particle_num = particle_num
            self.particle_dim = particle_dim
            self.iter_num = iter_num
            self.alpha = alpha
            self.max_value = max_value
            self.min_value = min_value
    
    ### 2.1 粒子群初始化
        def swarm_origin(self):
            '''初始化粒子群中的粒子位置
            input:self(object):QPSO类
            output:particle_loc(list):粒子群位置列表
            '''
            particle_loc = []
            for i in range(self.particle_num):
                tmp1 = []
                for j in range(self.particle_dim):
                    a = random.random()
                    tmp1.append(a * (self.max_value - self.min_value) + self.min_value)
                particle_loc.append(tmp1)
            
            return particle_loc
    
    ### 2.2 计算适应度函数数值列表
        def fitness(self,particle_loc):
            '''计算适应度函数值
            input:self(object):PSOparticle_loc(list):粒子群位置列表
            output:fitness_value(list):适应度函数值列表
            '''
            fitness_value = []
            ### 1.适应度函数为RBF_SVM3_fold交叉校验平均值
            for i in range(self.particle_num):
                rbf_svm = svm.SVC(kernel = 'rbf', C = particle_loc[i][0], gamma = particle_loc[i][1])
                cv_scores = cross_validation.cross_val_score(rbf_svm,trainX,trainY,cv =3,scoring = 'accuracy')
                fitness_value.append(cv_scores.mean())
            ### 2. 当前粒子群最优适应度函数值和对应的参数
            current_fitness = 0.0
            current_parameter = []
            for i in range(self.particle_num):
                if current_fitness < fitness_value[i]:
                    current_fitness = fitness_value[i]
                    current_parameter = particle_loc[i]
    
            return fitness_value,current_fitness,current_parameter
    
    ### 2.3 粒子位置更新    
        def updata(self,particle_loc,gbest_parameter,pbest_parameters):
            '''粒子位置更新
            input:self(object):QPSOparticle_loc(list):粒子群位置列表
                  gbest_parameter(list):全局最优参数
                  pbest_parameters(list):每个粒子的历史最优值
            output:particle_loc(list):新的粒子群位置列表
            '''
            Pbest_list = pbest_parameters
            #### 2.3.1 计算mbest
            mbest = []
            total = []
            for l in range(self.particle_dim):
                total.append(0.0)
            total = np.array(total)
            
            for i in range(self.particle_num):
                total += np.array(Pbest_list[i])
            for j in range(self.particle_dim):
                mbest.append(list(total)[j] / self.particle_num)
            
            #### 2.3.2 位置更新
            ##### Pbest_list更新
            for i in range(self.particle_num):
                a = random.uniform(0,1)
                Pbest_list[i] = list(np.array([x * a for x in Pbest_list[i]]) + np.array([y * (1 - a) for y in gbest_parameter]))
            ##### particle_loc更新
            for j in range(self.particle_num):
                mbest_x = []  ## 存储mbest与粒子位置差的绝对值
                for m in range(self.particle_dim):
                    mbest_x.append(abs(mbest[m] - particle_loc[j][m]))
                u = random.uniform(0,1)
                if random.random() > 0.5:
                    particle_loc[j] = list(np.array(Pbest_list[j]) + np.array([self.alpha * math.log(1 / u) * x for x in mbest_x]))
                else:
                    particle_loc[j] = list(np.array(Pbest_list[j]) - np.array([self.alpha * math.log(1 / u) * x for x in mbest_x]))
                    
            #### 2.3.3 将更新后的量子位置参数固定在[min_value,max_value]内 
            ### 每个参数的取值列表
            parameter_list = []
            for i in range(self.particle_dim):
                tmp1 = []
                for j in range(self.particle_num):
                    tmp1.append(particle_loc[j][i])
                parameter_list.append(tmp1)
            ### 每个参数取值的最大值、最小值、平均值   
            value = []
            for i in range(self.particle_dim):
                tmp2 = []
                tmp2.append(max(parameter_list[i]))
                tmp2.append(min(parameter_list[i]))
                value.append(tmp2)
            
            for i in range(self.particle_num):
                for j in range(self.particle_dim):
                    particle_loc[i][j] = (particle_loc[i][j] - value[j][1])/(value[j][0] - value[j][1]) * (self.max_value - self.min_value) + self.min_value
                    
            return particle_loc
    
    ## 2.4 画出适应度函数值变化图
        def plot(self,results):
            '''画图
            '''
            X = []
            Y = []
            for i in range(self.iter_num):
                X.append(i + 1)
                Y.append(results[i])
            plt.plot(X,Y)
            plt.xlabel('Number of iteration',size = 15)
            plt.ylabel('Value of CV',size = 15)
            plt.title('QPSO_RBF_SVM parameter optimization')
            plt.show()         
    
    ## 2.5 主函数
        def main(self):
            results = []
            best_fitness = 0.0 
            ## 1、粒子群初始化
            particle_loc = self.swarm_origin()
            ## 2、初始化gbest_parameter、pbest_parameters、fitness_value列表
            ### 2.1 gbest_parameter
            gbest_parameter = []
            for i in range(self.particle_dim):
                gbest_parameter.append(0.0)
            ### 2.2 pbest_parameters
            pbest_parameters = []
            for i in range(self.particle_num):
                tmp1 = []
                for j in range(self.particle_dim):
                    tmp1.append(0.0)
                pbest_parameters.append(tmp1)
            ### 2.3 fitness_value
            fitness_value = []
            for i in range(self.particle_num):
                fitness_value.append(0.0)
            
            ## 3、迭代
            for i in range(self.iter_num):
                ### 3.1 计算当前适应度函数值列表
                current_fitness_value,current_best_fitness,current_best_parameter = self.fitness(particle_loc)
                ### 3.2 求当前的gbest_parameter、pbest_parameters和best_fitness
                for j in range(self.particle_num):
                    if current_fitness_value[j] > fitness_value[j]:
                        pbest_parameters[j] = particle_loc[j]
                if current_best_fitness > best_fitness:
                    best_fitness = current_best_fitness
                    gbest_parameter = current_best_parameter
                
                print('iteration is :',i+1,';Best parameters:',gbest_parameter,';Best fitness',best_fitness)
                results.append(best_fitness)
                ### 3.3 更新fitness_value
                fitness_value = current_fitness_value
                ### 3.4 更新粒子群
                particle_loc = self.updata(particle_loc,gbest_parameter,pbest_parameters)
            ## 4.结果展示
            results.sort()
            self.plot(results)
            print('Final parameters are :',gbest_parameter)
    

    最优适应度函数值随迭代次数的变化如下图:
    在这里插入图片描述

    参考资料

    1、https://blog.csdn.net/Luqiang_Shi/article/details/84720738
    2、郑伟博. 粒子群优化算法的改进及其应用研究[D]. 2016.

    展开全文
  • 粒子群算法主要分为4个大的分支: (1)标准粒子群算法的变形  在这个分支中,主要是对标准粒子群算法的惯性因子、收敛因子(约束因子)、“认知”部分的c1,“社会”部分的c2进行变化与调节,希望获得好的效果。 ...

       粒子群算法主要分为4个大的分支:

    (1)标准粒子群算法的变形

           在这个分支中,主要是对标准粒子群算法的惯性因子、收敛因子(约束因子)、“认知”部分的c1,“社会”部分的c2进行变化与调节,希望获得好的效果。

          惯性因子的原始版本是保持不变的,后来有人提出随着算法迭代的进行,惯性因子需要逐渐减小的思想。算法开始阶段,大的惯性因子可以是算法不容易陷入局部最优,到算法的后期,小的惯性因子可以使收敛速度加快,使收敛更加平稳,不至于出现振荡现象。经过本人测试动态的减小惯性因子w,的确可以使算法更加稳定,效果比较好。但是递减惯性因子采用什么样的方法呢?人们首先想到的是线型递减,这种策略的确很好,但是是不是最优的呢?于是有人对递减的策略作了研究,研究结果指出:线型函数的递减优于凸函数的递减策略,但是凹函数的递减策略又优于线型的递减,经过本人测试,实验结果基本符合这个结论,但是效果不是很明显。

       对于收敛因子,经过证明如果收敛因子取0.729,可以确保算法的收敛,但是不能保证算法收敛到全局最优,经过本人测试,取收敛因子为0.729效果较好。对于社会与认知的系数c2,c1也有人提出:c1先大后小,而c2先小后大的思想,因为在算法运行初期,每个鸟要有大的自己的认知部分而又比较小的社会部分,这个与我们自己一群人找东西的情形比较接近,因为在我们找东西的初期,我们基本依靠自己的知识取寻找,而后来,我们积累的经验越来越丰富,于是大家开始逐渐达成共识(社会知识),这样我们就开始依靠社会知识来寻找东西了。

        2007年希腊的两位学者提出将收敛速度比较快的全局版本的粒子群算法与不容易陷入局部最优的局部版本的粒子群算法相结合的办法,利用的公式是

        v=n*v(全局版本)+(1-n)*v(局部版本)       速度更新公式,v代表速度

       w(k+1)=w(k)+v                     位置更新公式

    该算法在文献中讨论了系数n取各种不同情况的情况,并且运行来了20000次来分析各种系数的结果。

    (2)粒子群算法的混合

            这个分支主要是将粒子群算法与各种算法相混合,有人将它与模拟退火算法相混合,有些人将它与单纯形方法相混合。但是最多的是将它与遗传算法的混合。根据遗传算法的三种不同算子可以生成3中不同的混合算法。

            粒子群算法与选择算子的结合,这里相混合的思想是:在原来的粒子群算法中,我们选择粒子群群体的最优值作为pg,但是相结合的版本是根据所有粒子的适应度的大小给每个粒子赋予一个被选中的概率,然后依据概率对这些粒子进行选择,被选中的粒子作为pg,其它的情况都不变。这样的算法可以在算法运行过程中保持粒子群的多样性,但是致命的缺点是收敛速度缓慢。

            粒子群算法与杂交算子的结合,结合的思想与遗传算法的基本一样,在算法运行过程中根据适应度的大小,粒子之间可以两两杂交,比如用一个很简单的公式

         w(新)=n×w1+(1-n)×w2;

    w1与w2就是这个新粒子的父辈粒子。这种算法可以在算法的运行过程中引入新的粒子,但是算法一旦陷入局部最优,那么粒子群算法将很难摆脱局部最优。

         粒子群算法与变异算子的结合,结合的思想:测试所有粒子与当前最优的距离,当距离小于一定的数值的时候,可以拿出所有粒子的一个百分比(如10%)的粒子进行随机初始化,让这些粒子重新寻找最优值。

       (3)二进制粒子群算法

          最初的PSO是从解决连续优化问题发展起来的.Eberhart等又提出了PSO的离散二进制版.用来解决工程实际中的组合优化问题。他们在提出的模型中将粒子的每一维及粒子本身的历史最优、全局最优限制为1或0,而速度不作这种限制。用速度更新位置时,设定一个阈值,当速度高于该阈值时,粒子的位置取1,否则取0。二进制PSO与遗传算法在形式上很相似,但实验结果显示,在大多数测试函数中,二进制PSO比遗传算法速度快,尤其在问题的维数增加时

      (4)协同粒子群算法

       协同PSO,该方法将粒子的D维分到D个粒子群中,每个粒子群优化一维向量,评价适应度时将这些分量合并为一个完整的向量。例如第i个粒子群,除第i个分量外,其他D-1个分量都设为最优值,不断用第i个粒子群中的粒子替换第i个分量,直到得到第i维的最优值,其他维相同。为将有联系的分量划分在一个群,可将D维向量分配到m个粒子群优化,则前D mod m个粒子群的维数是D/m的向上取整。后m-(D mod m)个粒子群的维数是D/m的向下取整。协同PSO在某些问题上有更快的收敛速度,但该算法容易被欺骗。

       基本的粒子群算法的分支就着4个,大部分的粒子群算法都围绕着这4个分支在变化,其中粒子群算法的变形居多,从根本上来说,几乎没有什么新的思想的提出。

     

     

    注:本文系转载文章,欢迎交流。
    原文出处:http://blog.csdn.net/niuyongjie/article/details/1596181

    展开全文
  • 粒子群算法

    千次阅读 2020-11-27 11:18:01
    文章目录粒子群优化算法(PSO)前言一、粒子群算法的起源二、问题描述和问题抽象1.问题描述2.问题抽象1、位置信息总结 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这...

    粒子群优化算法(PSO)

    学习记录,欢迎大家前来讨论,另外文章中有部分引用内容后期我会把链接补充上去。



    一、粒子群算法的起源

    粒子群优化算法(PSO:Particle swarm optimization)是一种进化计算技术(evolutionary computation),1995 年由Eberhart 博士和kennedy 博士提出,源于对鸟群捕食的行为研究 。该算法最初是受到飞鸟集群活动的规律性启发,进而利用群体智能建立的一个简化模型。粒子群算法在对动物集群活动行为观察基础上,利用群体中的个体对信息的共享使整个群体的运动在问题求解空间中产生从无序到有序的演化过程,从而获得最优解。

    粒子群优化算法的基本思想:是通过群体中个体之间的协作和信息共享来寻找最优解.

    二、问题描述和问题抽象

    1.问题描述

    一群鸟在一片固定的区域中搜索食物,该地区只有一块食物,所有鸟都不知道食物在哪里,但是他们可以感知到自己离食物还有多远,他们通过相互交流来搜索食物。
    小鸟们在微信群里公布自己的位置信息,发现鸟A离得食物最近,然后鸟儿们就向着鸟A的方向移动进行搜寻,鸟B突然发现,哦!刚才我经过的某个位置离得食物好像也很近,我也要到那附近去搜寻一下。就是这么一个过程

    在这里插入图片描述

    2.问题抽象

    在这里插入图片描述

    将每个小鸟抽象成一个粒子,而每个粒子对应于解集中的一个解。
    在一个D维空间中,有N个粒子组成一个群落。每个粒子就有以下结果参数

    1、位置信息

    在这里插入图片描述

    2、 速度表示

    在这里插入图片描述

    3、 适应值

    在这里插入图片描述

    4、最优值

    (1)个体最优pbest

    在这里插入图片描述

    (2)全局最优pbest

    在这里插入图片描述

    该处使用的url网络请求的数据。


    三、算法原理

    3.1更新规则

    PSO初始化为一群随机粒子(随机解)。然后通过迭代找到最优解。每一次迭代中,粒子通过跟踪两个“极值”(pbest,gbest)来更新自己。在找到这两个最优值后,粒子通过下面的下面的公式来更新自己的速度和位置。

    基础标准式

    在这里插入图片描述
    设置Vmax是为了控制每次的步长,以防搜索步长过大错过最优解。
    在这里插入图片描述
    第一部分记忆项是惯性保持部分,粒子沿着当前的速度和方向惯性飞行,不偏移的趋势,
    第二部分是自我认知部分,粒子受到自身历史最好位置的吸引力,有回到自身历史最好位置的意愿。
    第三部分是社会认知部分,粒子处在一个社会中(种群中),社会上有更好的粒子,粒子受到最佳位置的吸引力,有去社会最佳位置的意愿。

    两种极端情况

    在这里插入图片描述

    3.2 更新示意图

    1、步骤示意图
    在这里插入图片描述
    2、全局直观示意图(引用别人的博客的图)
    在这里插入图片描述

    3.2 算法流程图

    在这里插入图片描述

    四、算法的小优化

    标准的PSO算法存在一定的局限性,在实际问题中的应用效果不太理想,比较难以兼顾局部搜索和全局搜索,也很难保证收敛的速度 。针对这个问题,演化出两种改进措施:
    (1)引入惯性权重因子𝝎
    (2)引入收缩因子𝝋

    4.1 引入惯性权重因子

    在这里插入图片描述
    ·𝝎称为惯性权重因子,其值非负
    𝝎较大时,全局寻优能力强,局部寻优能力弱
    𝝎较小时,全局寻优能力弱,局部寻优能力强
    对𝝎进行动态化处理可以获得比固定值更好的寻优结果,动态化𝝎
    可以在PSO搜索过程中动态变化,或者根据PSO性能的某个测度函数动态改变。
    𝝎的引入,使得PSO算法性能有了很大的提高,针对不同的搜索问题可以调整全局和局部搜索的能力。

    个人理解:就是当𝝎变大的时候,下一步的位置更新中惯性的权重变大,那么该粒子就较小的偏离原来的方向,下一步搜索的随机性降低。

    权重因子动态变化(这里的ini和end好像有的搞反了 我后期再改改)

    动态变化主要按照以下四种函数进行,权重因子递减:
    在这里插入图片描述
    下面是这几个函数的图像
    在这里插入图片描述
    最后一个公式中的c值,我取了一个较大的数这个具体是多少我还不知道。
    一般𝝎最初取0…9,终值取0.4

    线性权值递减

    一般最常用最方便的是线性权值递减
    由于较大的权重因子有利于跳出局部最小点,便于全局搜索,而较小的惯性因子则有利于对当前的搜索区域进行精确局部搜索,以利于算法收敛,因此针对PSO算法容易早熟以及算法后期易在全局最优解附近产生振荡现象,可以采用线性变化的权重,
    在这里插入图片描述

    4.2 收缩因子

    在这里插入图片描述
    学习因子cl和c2决定了微粒本身经验信息和其他微粒的经验信息对微粒运行轨迹的影响,反映了微粒群之间的信息交流。设置c1较大的值,会使微粒过多地在局部范围内徘徊,而较大的c2的值,则又会促使微粒过早收敛到局部最小值。微粒有效地控制微粒的飞行速度,使算法达到全局探测与局部开采两者间的有效平衡,Clerc构造了引入收缩因子的PSO模型,采用了压缩因子,这种调整方法通过合适选取参数,可确保PSO算法的收敛性,并可取消对速度的边界限制
    此函数在C大于四之后呈现单调递减的趋势,所以C越大收缩的约厉害,但是这个是不是没单独考虑到C1和C2呢???

    五、评价标准

    目前评价(改进)粒子群算法的标准已经非常成熟。业内已经整理出了许多不同维度的标准测试函数。需要从准确率(与最优解的偏差),成功率(计算到最优解的概率),计算速度以及稳定性(均值,中位数,方差)等方面对算法进行考量。
    用于测试的几个函数如下(图是引用过来的 后期我再把网址添加上去)
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    七 、优缺点

    优点

    1. 收敛速度较快
    2. 需要调整的参数少,原理简单,容易实现,这是PSO的最大优点。
    3. 协同搜索,同时利用个体局部信息和群体全局信息进行指导搜索

    缺点

    1. 算法局部搜索能力较差,搜索精度不高。

    2. 算法不能保证搜索到全局最优解,主要有一下两个方面:
      有时粒子群在俯冲过程中会错失全局最优解。
      应用PSO算法处理高位复杂问题是,算法可能过早收敛。

    3. PSO算法是一种概率算法

      八、小例子(参考代码后期放他的链接)

      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      可以看到有时候并不稳定会陷入局部最优值

    代码

    import numpy as np
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    import time
    
    class PSO(object):
        def __init__(self):
            self.iter=300 #迭代次数
    #         self.w=1 #惯性权重
            self.lr = (2, 2)  #粒子群个体和社会的学习因子,即加速常数
            self.sizepop=20 #种群规模
            self.rangepop=(-2,2) #粒子的位置的范围限制,x、y方向的限制相同
            self.rangespeed=(-0.5,0.5) #速度限制
            self.px=[]  #当前全局最优解
            self.py=[]
     
        def func(self, x):
            # x输入粒子位置
            # y 粒子适应度值
            if (x[0] == 0) & (x[1] == 0):
                y = np.exp((np.cos(2 * np.pi * x[0]) + np.cos(2 * np.pi * x[1])) / 2) - 2.71289
            else:
                y = np.sin(np.sqrt(x[0] ** 2 + x[1] ** 2)) / np.sqrt(x[0] ** 2 + x[1] ** 2) + np.exp(
                    (np.cos(2 * np.pi * x[0]) + np.cos(2 * np.pi * x[1])) / 2) - 2.71289
            return y
     
        def initpopvfit(self, sizepop):
            pop = np.zeros((sizepop, 2))
            v = np.zeros((sizepop, 2))
            fitness = np.zeros(sizepop)
     
            for i in range(sizepop):
                pop[i] = [(np.random.rand() - 0.5) * self.rangepop[0] * 2, (np.random.rand() - 0.5) * self.rangepop[1] * 2]
                v[i] = [(np.random.rand() - 0.5) * self.rangepop[0] * 2, (np.random.rand() - 0.5) * self.rangepop[1] * 2]
                fitness[i] = self.func(pop[i])
            return pop, v, fitness
     
        def getinitbest(self, fitness, pop):
            # 群体最优的粒子位置及其适应度值
            gbestpop, gbestfitness = pop[fitness.argmax()].copy(), fitness.max()
            # 个体最优的粒子位置及其适应度值,使用copy()使得对pop的改变不影响pbestpop,pbestfitness类似
     
            pbestpop, pbestfitness = pop.copy(), fitness.copy()
     
            return gbestpop, gbestfitness, pbestpop, pbestfitness
     
        def run(self):
            """
            通过循环迭代,不断的更新粒子的位置和速度,根据新粒子的适应度值更新个体和群体的极值
            :return:
            """
            pop, v, fitness = self.initpopvfit(self.sizepop)
            gbestpop, gbestfitness, pbestpop, pbestfitness = self.getinitbest(fitness, pop)
     
            result = np.zeros(self.iter)
            for i in range(self.iter):
                # 速度更新
                for j in range(self.sizepop):
                    v[j] = (0.5*(100-i)/100+0.4) * v[j] + self.lr[0] * np.random.rand() * (pbestpop[j] - pop[j]) + self.lr[
                                                                                                        1] * np.random.rand() * (
                                                                                                        gbestpop - pop[j])
                v[v < self.rangespeed[0]] = self.rangespeed[0]
                v[v > self.rangespeed[1]] = self.rangespeed[1]
     
                # 粒子位置更新
                for j in range(self.sizepop):
                    pop[j] += v[j]
                pop[pop < self.rangepop[0]] = self.rangepop[0]
                pop[pop > self.rangepop[1]] = self.rangepop[1]
     
                # 适应度更新
                for j in range(self.sizepop):
                    fitness[j] = self.func(pop[j])
     
                for j in range(self.sizepop):
                    if fitness[j] > pbestfitness[j]:
                        pbestfitness[j] = fitness[j]
                        pbestpop[j] = pop[j].copy()
     
                if pbestfitness.max() > gbestfitness:
                    gbestfitness = pbestfitness.max()
                    gbestpop = pop[pbestfitness.argmax()].copy()
     
                result[i] = gbestfitness
                self.px.append(gbestpop[0])
                self.py.append(gbestpop[1])
            return result, self.px, self.py
     
        def drawPaht(self,X, Y, Z, px, py, pz):
            """
            绘图
            """
            fig = plt.figure()
            ax = Axes3D(fig)
            plt.title("PSO")
            ax.plot_surface(X, Y, Z, rstride=1, cstride=1, color='b', )
            ax.set_xlabel('x label', color='r')
            ax.set_ylabel('y label', color='g')
            ax.set_zlabel('z label', color='b')
            ax.plot(px, py, pz, 'r.')  # 绘点x
            plt.show()
            
    def f(X, Y):
        return np.sin(np.sqrt(X ** 2 + Y ** 2)) / np.sqrt(X ** 2 + Y ** 2) + np.exp(
            (np.cos(2 * np.pi * X) + np.cos(2 * np.pi * Y)) / 2) - 2.71289
    a=0
    b=0
    for i in range(1000):
        pso = PSO()
        result, px, py = pso.run()
        print(max(result), result.argmax())
        if max(result)>1:
            a+=1
        else :
            b+=1
    print(a,b)
    
    
    plt.plot(result)
    
    X = np.arange(-2, 2, 0.05)
    Y = np.arange(-2, 2, 0.05)
    X, Y = np.meshgrid(X, Y)
    Z = f(X, Y)
    pso.drawPaht(X, Y, Z, px, py, f(np.array(px), np.array(py)))
    plt.show()
    
    展开全文
  • 概述 智能理论算法的优点是无需先验知识,不需要分析数据内部的规律和内在关联,只需要对数据本身进行学习,自组织、自适应的完成优化问题的求解,缺点是采用这种模型的收敛速度往往极慢,处理...粒子群算法 产生早熟

    概述

    算法本质

    优化算法是一种给定方向的遍历

    定义

    群体智能优化算法主要模拟了昆虫、兽群、鸟群和鱼群的群体行为,这些群体按照一种合作的方式寻找食物,群体中的每个成员通过学习它自身的经验和其他成员的经验来不断地改变搜索的方向。任何一种由昆虫群体或者其他动物社会行为机制而激发设计出的算法或分布式解决问题的策略均属于群体智能(Swarm Intelligence)

    白话解释

    模仿昆虫或者一些动物的觅食或者其他行为,这些动物群体按照一中合作的方式寻找食物,不断的交流食物信息,能够很快的找到更多的食物。通过对他们的行为的研究抽象出来的一种算法,就是群体智能优化算法。(例如,一个个体找到了食物,就会通知其他个体来这个有食物的地方,这就是一种行为)

    算法原则

    1. 邻近原则:群体能够进行简单的空间和时间计算;
    2. 品质原则:群体能够响应环境中的品质因子;
    3. 多样性反应原则:群体的行动范围不应该太窄;
    4. 稳定性原则:群体不应在每次环境变化时都改变自身的行为;
    5. 适应性原则:在所需代价不太高的情况下,群体能够在适当的时候改变自身的行为。

    1、遗传算法(GA)

    全局搜索能力强,局部搜索能力较弱,往往只能得到次优解而不是最优解。

    研究发现,遗传算法可以用极快的速度达到最优解的90%以上,但是要达到真正的最优解需要花费很长时间,即局部搜索能力不足。

    2、粒子群算法(PSO)

    产生早熟收敛并被证明算法不是全局收敛
    未加权重——收敛速度快但容易陷入局部最优解

    3、 蚁群算法

    参数设置复杂,如果参数设置不当,容易偏离优质解

    4、 模拟退火算法

    全局寻优,适合搭配粒子群、鲸鱼优化算法等容易陷入局部最优解的

    5、 鱼群算法

    参数设置复杂,如果参数设置不当,容易偏离优质解.(同蚁群)

    6、鲸鱼优化算法

    6.1问题

    算法陷入局部极值和收敛速度问题
    陷入局部最优解
    结合模拟退火算法,通过接受较差点来提升全局寻优能力
    收敛速度慢
    引入自适应权重,提升算法的局部寻优能力

    展开全文
  • 粒子群算法(也称PSO算法),也是一种进化算法,模拟生物群体的觅食行为,是一种群体智能算法,类似的算法有遗传算法,模拟退火算法等等。PSO是通过当前已知种群寻找到的所有解来决定新的解的寻找方向,也就是新解的...
  • 粒子群优算法

    2019-12-03 20:44:38
    粒子群算法的流程三 ,代码实现%% 清空环境%% 参数初始化%% 产生初始粒子和速度%% 个体极值和群体极值%% 迭代寻%种群更新%% 结果分析四 ,运行结果4.1改变c1,c2,w值多次迭代结果4.2改变maxgen,dim值多次迭代结果五 ,...
  • 作者:莫石 ...来源:知乎 著作权归作者所有,转载请联系作者获得...基本思想都是模拟自然界生物群体行为来构造随机优化算法的,不同的是粒子群算法模拟鸟类群体行为,而蚁群算法模拟蚂蚁觅食原理。 1.相同点 (1)都是
  • 群体智能算法之粒子群算法

    千次阅读 2020-04-21 23:18:54
    智能算法:粒子群算法 1. 简介2. 粒子群算法(PSO)算法过程3. PSO算法的优缺点4. 具体应用5. 小结 1. 简介 2. 粒子群算法(PSO)算法过程 3. PSO算法的优缺点 4. 具体应用 5. 小结 ...
  • 粒子群算法(1)----粒子群算法简介 2011年07月08日 17:16:32 xljiulong 阅读数:28543 ...
  • 粒子群算法求解旅行商问题,实现离散与连续的转化,充分发挥粒子群算法优势!!!!!!!!!!!!!!!!!!
  • 针对基本粒子群算法精度较低,结果易发散的缺点,提出了一种参数自适应调整和边界条件约束的粒子群算法,惯性权重,学习因子随着迭代过程线性递加或递减,从而在算法初期个体能搜索整个空间,后期能够朝着全局最...
  • 粒子群算法(1)----粒子群算法简介

    千次阅读 2015-07-16 11:04:46
    一、粒子群算法的历史  粒子群算法源于复杂适应系统(Complex Adaptive System,CAS)。CAS理论于1994年正式提出,CAS中的成员称为主体。比如研究鸟群系统,每个鸟在这个系统中就称为主体。主体有适应性,它能够...
  • 一、粒子群算法 1.定义 粒子群优化算法是通过模拟鸟群觅食行为而发展起来的一种基于群体协作的随机搜索算法。 2.模拟捕食 PSO模拟鸟群的捕食行为。一群鸟在随机搜索食物,在这个区域里只有一块食物。所有的鸟都...
  • 粒子群算法介绍

    2021-03-25 15:18:39
    优化算法——粒子群优化介绍 1. 基本概念 粒子群优化算法(PSO:Particle swarm ...粒子群算法通过设计一种无质量的粒子来模拟鸟群中的鸟,粒子仅具有两个属性:速度和位置,速度代表移动的快慢,位置代表移动的方
  • 为了克服这个缺点,提出了一种新的粒子群算法,算法对粒子的速度和位置更新公式进行了改进,使粒子在其最优位置的基础上进行位置更新,增强了算法的寻能力; 通过对 " 个基准函数的仿真实验,表明了改进算法的有效...
  • 模拟退火算子能够很好地提高粒子群算法的局部搜索能力和克服粒子群算法易于陷入局部最解的缺点。测试算例结果表明,利用所提方法能够获得更好、更完备的船舶电力系统重构方案,算法具有较好的优化性能。
  • 一、粒子群算法的历史  粒子群算法源于复杂适应系统(ComplexAdaptiveSystem,CAS)。CAS理论于1994年正式提出,CAS中的成员称为主体。比如研究鸟群系统,每个鸟在这个系统中就称为主体。主体有适应性,它能够与...
  • 针对传统离散粒子群算法求解背包问题早熟收敛、精度低等缺点提出一种解决背包问题的双尺度变异离散粒子群算法。利用对当前最解进行双尺度速度变异,可以实现提高算法局部最解搜索能力的同时,保持算法的全局搜索...
  • 粒子群算法解决TSP问题

    千次阅读 2018-12-17 21:29:13
    1. 粒子群算法简介 **粒子群算法(particle swarm optimization,PSO)**由Kennedy和Eberhart在1995年提出,属于进化算法的一种,是通过对模拟鸟群扑食行为设计的。 基本思想: 从随机解出发,通过迭代寻找最解,...
  • 一、粒子群算法的历史 粒子群算法源于复杂适应系统(ComplexAdaptiveSystem,CAS)。CAS理论于1994年正式提出,CAS中的成员称为主体。比方研究鸟群系统,每一个鸟在这个系统中就称为主体。主体有适应性,它能够与...

空空如也

空空如也

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

粒子群算法的优缺点