精华内容
下载资源
问答
  • MATLAB 粒子群算法,例题与常用模版

    万次阅读 多人点赞 2018-09-06 18:09:18
    MATLAB 粒子群算法 本文学习自:Particle Swarm Optimization in MATLAB - Yarpiz Video Tutorial 与《精通MATLAB智能算法》 1. 简介: Particle Swarm Optimization ,粒子群优化算法,常用来找到方程...

    本文学习自:Particle Swarm Optimization in MATLAB - Yarpiz Video Tutorial 与《精通MATLAB智能算法》

    1. 简介:

    Particle Swarm Optimization ,粒子群优化算法,常用来找到方程的最优解。

    2. 算法概述:

    每次搜寻都会根据自身经验(自身历史搜寻的最优地点)和种群交流(种群历史搜寻的最优地点)调整自身搜寻方向速度

    3. 算法优势:

    • 相较于传统算法计算速度非常快,全局搜索能力也很强;
    • PSO对于种群大小不十分敏感,所以初始种群往往设为500-1000,不同初值速度影响也不大;
    • 粒子群算法适用于连续函数极值问题,对于非线性、多峰问题均有较强的全局搜索能力。

    4. 算法基本原理

    一个形象的例子:

    A与B两个小粒子初始时在河的两侧,他们想要找到河最深处。如果A某时刻所在位置的深度比B的浅,A就会像B的方向走,反之亦然。 当A到达Global Minimum(全局最小值)时,B会一直向着A前进,直到在optimum solution(全剧最优解)处汇合。
    在这里插入图片描述

    4.1 概述

    从上面的示例中我们得到两个准则,也可以说是每个粒子的必要特性:

    1. Communication : 彼此互相通知
    2. Learning : 不停地学习以达最优解

    数量众多的粒子通过相互的交流与学习,全部粒子最终将汇聚到一点,即问题的解。粒子间相互交流与学习的过程用数学或计算机语言描述为迭代

    迭代的意义在于不断寻找更优的值,从理论上来说,如果我们掌握了一种可以不停寻找到更优解答的方法,通过不停的迭代,我们就能够找到最优的答案

    Learning the concept of better is the main problem that an optimizer should solve. Then an optimizer learns the concept of better, it is able to solve any kind of optimuzation.Because the solution of optimization problem is to find the best one . So if we know what is the better, we actually can discover the concept of best.

    4.2 粒子的基本信息

    回顾粒子群算法概述:
    每次搜寻都会根据自身经验(自身历史搜寻的最优地点)和种群交流(种群历史搜寻的最优地点)调整自身搜寻方向和速度

    我们首先聚焦与粒子本身,或许全部粒子研究起来很复杂,但单个粒子的属性是很简单的。

    首先,每个粒子包含两个基本信息,Position(位置) & Velocity(速度)。
    在粒子群算法的每次迭代中,每个粒子的位置和速度都会更新。

    • 我们用Xi(t)\vec {X_i(t)}记录位置
    • Vi(t)\vec { V_i (t)}记录方向与速度
      在这里插入图片描述
    4.3 粒子的个体极值与全局极值

    回顾粒子群算法概述:
    每次搜寻都会根据自身经验(自身历史搜寻的最优地点)种群交流(种群历史搜寻的最优地点)调整自身搜寻方向和速度。

    仅有上述位置与速度两个信息还不够,我们之前提到过,每一个粒子是会学习的。 每个粒子还拥有下面两个信息(每个信息都是一个向量):

    • 每一个粒子有它自己的记忆,会记住自己的best position , best experience,即个体极值 (personal best), 标记为Pi(t)\vec { P_i (t)}

    • 当前时刻全局的最优解,即全局极值(Common best experience among the members),标记为 gi(t)\vec { g_i (t)}

      总结:PSO初始化为一群随机粒子,然后通过迭代找到最优解。在每一次迭代过程中,粒子通过跟踪两个极值来更新自己,一个是粒子本身所找到的最优解,这个解称为个体极值Pi(t)\vec { P_i (t)};另一个极值是整个种群目前找到的最优解,这个极值是全局极值 gi(t)\vec { g_i (t)}

    在这里插入图片描述

    4.4 找到新位置

    根据平行四边形法则,已知个体极值与整体极值,有了新时刻的速度Vi(t+1)\vec {V_i}(t+1) ,会得到新的位置Xi(t+1)\vec {X_i}(t+1)

    在这里插入图片描述

    状态转移方程:

    vij(t+1)=wvij(t)+c1r1(pij(t)xij(t))+c2r2(gj(t)xij(t))(4-1)\vec {v_{ij}}(t+1) = w\vec{v_{i j}} (t) + c_1r_1(p_{ij} (t) - \vec{x_{ij}}(t))+c_2r_2(g_j(t)-\vec{x_{ij}}(t)) \tag{4-1}

    xij(t+1)=xij(t)+vij(t+1)(4-2)\vec {x_{ij}}(t+1) = \vec{x_{ij}}(t)+\vec{v_{ij}}(t+1) \tag{4-2}

    其中,c1,c2c_1,c_2为学习因子,也称加速常数(acceleration constant);

    r1,r2r_1,r_2,[0,1]范围内的均匀随机数。

    式(1)右边由三部分组成:

    • 第一部分为“惯性(inertia)”或“动量(MOMENTUM)”部分,反映了粒子的运动习惯,代表粒子有维持自己先前速度的趋势。
    • 第二部分为“认知(cognition)”部分,反映了粒子对自身历史经验的记忆,代表粒子由向自身历史最佳位置逼近的趋势。
    • 第三部分为“社会(social)”部分,反映了粒子间协同合作与知识共享的群体历史经验,代表粒子有向群体或领域历史最佳位置逼近的趋势。

    5. 算法的运行参数

    PSO算法一个最大的优点是不需要调节太多的参数,但是算法中少数几个参数却直接影响着算法的性能和收敛性。

    基本粒子群算法有下述7个运行参数需要提前设定:

    1. rr:粒子群算法的种子数,对粒子群算法中种子数值可以随机生成也可以固定位一个初始的数值,要求能涵盖目标函数的范围内。
    2. mm:粒子群群体大小,即群体中所含个体的数量,一般取为20~40。在变两年比较多的时候可以取100以上较大的数。
    3. maxdmax_d:一般为最大迭代次数以最小误差的要求满足的。粒子群算法的最大迭代次数,也是终止条件数。
    4. r1,r2r_1,r_2:两个在[0,1]之间变化的加速度权重系数随机产生。
    5. c1,c2c_1,c_2:加速常数,取随机2左右的值。
    6. ww:惯性权重产生的。
    7. vk,xkv_k,x_k:一个粒子的速度和位移数值,用粒子群算法迭代出每一组的数值。

    6. 算法的基本流程

    1. 初始化粒子群,包括群体规模N,每个粒子的位置xix_i和速度viv_i
    2. 计算吗每一个粒子的适应度值Fit[i]Fit[i]
    3. 计算每个粒子,用它的适应度值Fit[i]Fit[i]和个体极值pbest(i)p_{best}(i)比较,如果Fit[i]>pbest(i)Fit[i]>p_{best}(i),则用Fit[i]Fit[i]替换掉pbest(i)p_{best}(i)
    4. 计算每个粒子,用它的适应度值Fit[i]Fit[i]和全局极值gbest(i)g_{best}(i)比较,如果Fit[i]>gbest(i)Fit[i]>g_{best}(i),则用Fit[i]Fit[i]替换掉gbest(i)g_{best}(i)
    5. 根据式(4-1)和式(4-2)更新粒子的位置xix_i和速度viv_i
    6. 如果满足结束条件(误差足够好或到达最大循环次数)退出,否则返回步骤2.

    7. 手动实现PSO

    function[xm,fv] = PSO(fitness,N,c1,c2,w,M,D)
    % c1,c2:学习因子
    % w:惯性权重
    % M:最大迭代次数
    % D:搜索空间维数
    % N:初始化群体个体数目
    
    
    % 初始化种群的个体(可以在这里限定位置和速度的范围)
    format long;
    for i = 1:N
        for j=1:D
            x(i,j) = randn; % 随机初始化位置
            v(i,j) = randn; % 随即初始化速度
        end
    end
    
    
    % 先计算各个粒子的适应度,并初始化pi和pg
    for i=1:N
        p(i) = fitness(x(i,:));
        y(i,:) = x(i,:);
    end 
    pg = x(N,:);  % pg为全局最优
    for i=1:(N-1)
        if(fitness(x(i,:))<fitness(pg))
            pg = x(i,:);
        end
    end
    
    
    % 进入主要循环,按照公式依次迭代,直到满足精度要求
    for t=1:M
        for i=1:N  % 更新速度、位移
            v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
            x(i,:)=x(i,:)+v(i,:);
            if fitness(x(i,:)) < p(i)
                p(i)=fitness(x(i,:));
                y(i,:)=x(i,:);
            end
            if p(i) < fitness(pg)
                pg=y(i,:);
            end
        end
        Pbest(t)=fitness(pg);
    end
    
    
    % 输出结果
    disp('目标函数取最小值时的自变量:')
    xm=pg';
    disp('目标函数的最小值为:')
    fv=fitness(pg);
    
    例1:求解下列函数的最小值:

    f(x)=i=130xi2+xi6f(x) = \sum^{30}_{i=1}x_i^2+x_i-6

    function F=fitness(x)
    F = 0;
    for i = 1:30
        F = F+x(i)^2+x(i)-6;
    end
    

    输入:

    x = zeros(1,30);
    [xm1,fv1] = PSO(@fitness,50,1.5,2.5,0.5,100,30)
    

    后记:拜托 还有人问显示fitness未定义怎么办,找不到输出结果怎么办?? 软件入门都没搞定就不要急于求成好吗?
    补入门知识:把手动实现PSO的代码保存为PSO.m,把function F=fitness(x)和后面4行代码保存为fitness.m。 然后再在命令行输入内容。

    9. 自适应权重法

    function[xm,fv] = PSO_adaptation(fitness,N,c1,c2,wmax,wmin,M,D)
    % c1,c2:学习因子
    % wmax:惯性权重最大值
    % wmin:惯性权重最小值
    % M:最大迭代次数
    % D:搜索空间维数
    % N:初始化群体个体数目
    
    
    % 初始化种群的个体(可以在这里限定位置和速度的范围)
    for i = 1:N
        for j=1:D
            x(i,j) = randn; % 随机初始化位置
            v(i,j) = randn; % 随即初始化速度
        end
    end
    
    
    %先计算各个粒子的适应度,并初始化个体最优解pi和整体最优解pg %
    %初始化pi %
    for i = 1:N
        p(i) = fitness(x(i,:)) ;
        y(i,:) = x(i,:) ;
    end
    %初始化pg %
    pg = x(N,:) ;
    %得到初始的全局最优pg %
    for i = 1:(N-1)
        if fitness(x(i,:)) < fitness(pg)
            pg = x(i,:) ;
        end
    end
     
    %主循环函数,进行迭代,直到达到精度的要求 %
    for t = 1:M
        for j = 1:N
            fv(j) = fitness(x(j,:)) ;
        end
        fvag = sum(fv)/N ;
        fmin = min(fv);
        for i = 1:N    %更新函数,其中v是速度向量,x为位置,i为迭代特征
            if fv(i) <= fvag
                w = wmin+(fv(i)-fmin)*(wmax-wmin)/(fvag-fmin) ;   %依据早熟收敛程度和适应度值进行调整
            else
                w = wmax ;
            end
            v(i,:) = w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:)) ;
            x(i,:) = x(i,:)+v(i,:) ;
            if fitness(x(i,:)) < p(i)
                p(i) = fitness(x(i,:)) ;
                y(i,:) = x(i,:) ;
            end
            if p(i) < fitness(pg)
                pg = y(i,:) ;
            end
        end
         Pbest(t) = fitness(pg) ;
    end
     
    %给出最后的计算结果 %
    xm = pg' ;
    fv = fitness(pg) ;
     
    plot(Pbest)
    xlabel('进化次数') ;
    ylabel('适应度值') ;
    

    例2:用自适应权重法求解函数

    y=((sin(x12+x22))2cos(x12+x22)+1)((1+0.1×(x12+x22))2)0.7\large{y = \frac {((sin(x_1^2+x_2^2))^2-cos(x_1^2+x_2^2)+1)} {((1+0.1\times (x_1^2+x_2^2))^2)-0.7}}

    其中,粒子数为50,学习因子均为2,惯性权重取值[0.6,0.8],迭代步数为100.

    建立目标函数:

    function y = AdaptFunc(x)
        y = ((sin(x(1)^2+x(2)^2))^2-cos(x(1)^2+x(2)^2)+1)/((1+0.1*(x(1)^2+x(2)^2))^2)-0.7;
    end
    

    运行:

    [xm,fv] = PSO_adaptation(@AdaptFunc,50,2,2,0.8,0.6,100,2)
    

    在这里插入图片描述

    10.线性递减权重法

     function [ xm,fv ] = PSO_lin(fitness,N,c1,c2,wmax,wmin,M,D)
    format long ;
    %给定初始化条件
    % fitness:适应度函数
    % N:       初始化种群数目
    % c1:      个体最优化学习因子
    % c2:      整体最优化学习因子
    % wmax:    惯性权重最大值
    % wmin:    惯性权重最小值
    % M:       最大迭代次数      
    % D:       搜索空间的维数
    % xm:      最佳个体
    % fv:      适应度值
     
    %初始化种群个体%
    for i = 1:N
        for j = 1:D
            x(i,j) = randn ;  %随机初始化位置
            v(i,j) = randn ;  %随机初始化速度
        end
    end
     
    %先计算各个粒子的适应度,并初始化个体最优解pi和整体最优解pg %
    %初始化pi %
    for i = 1:N
        p(i) = fitness(x(i,:)) ;
        y(i,:) = x(i,:) ;
    end
    %初始化pg %
    pg = x(N,:) ;
    %得到初始的全局最优pg %
    for i = 1:(N-1)
        if fitness(x(i,:)) < fitness(pg)
            pg = x(i,:) ;
        end
    end
     
    %主循环函数,进行迭代,直到达到精度的要求 %
    for t = 1:M
        for i = 1:N    %更新函数,其中v是速度向量,x为位置,i为迭代特征
            w = wmax-(t-1)*(wmax-wmin)/(M-1)
            v(i,:) = w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:)) ;
            x(i,:) = x(i,:)+v(i,:) ;
            if fitness(x(i,:)) < p(i)
                p(i) = fitness(x(i,:)) ;
                y(i,:) = x(i,:) ;
            end
            if p(i) < fitness(pg)
                pg = y(i,:) ;
            end
        end
        Pbest(t) = fitness(pg) ;
    end
     
    %给出最后的计算结果 %
    xm = pg' ;
    fv = fitness(pg) ;
    

    11. 基于杂交(遗传算法)的算法

     function [ xm,fv ] = PSO_breed(fitness,N,c1,c2,w,bc,bs,M,D)
    format long ;
    %给定初始化条件
    % fitness:适应度函数
    % N:       初始化种群数目
    % c1:      个体最优化学习因子
    % c2:      整体最优化学习因子
    % w:       惯性权重
    % bc:      杂交概率
    % bs:      杂交池的大小比率
    % M:       最大迭代次数      
    % D:       搜索空间的维数
    % xm:      最佳个体
    % fv:      适应度值
     
    %初始化种群个体%
    for i = 1:N
        for j = 1:D
            x(i,j) = randn ;  %随机初始化位置
            v(i,j) = randn ;  %随机初始化速度
        end
    end
     
    %先计算各个粒子的适应度,并初始化个体最优解pi和整体最优解pg %
    %初始化pi %
    for i = 1:N
        p(i) = fitness(x(i,:)) ;
        y(i,:) = x(i,:) ;
    end
    %初始化pg %
    pg = x(N,:) ;
    %得到初始的全局最优pg %
    for i = 1:(N-1)
        if fitness(x(i,:)) < fitness(pg)
            pg = x(i,:) ;
        end
    end
     
    %主循环函数,进行迭代,直到达到精度的要求 %
    for t = 1:M
        for i = 1:N    %更新函数,其中v是速度向量,x为位置,i为迭代特征
            v(i,:) = w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:)) ;
            x(i,:) = x(i,:)+v(i,:) ;
            if fitness(x(i,:)) < p(i)
                p(i) = fitness(x(i,:)) ;
                y(i,:) = x(i,:) ;
            end
            if p(i) < fitness(pg)
                pg = y(i,:) ;
            end
            r1 = rand() ;
            if r1 < bc
                numPool = round(bs*N) ;    %杂交池中随机选取numPool个种群%
                PoolX = x(1:numPool,:) ;   %杂交池中的初始杂交父辈位置%
                PoolVX = v(1:numPool,:) ;  %杂交池中的初始杂交父辈速度%
                for i = 1:numPool
                    seed1 = floor(rand()*(numPool-1))+1 ;   %得到速度和位置的初始种子%
                    seed2 = floor(rand()*(numPool-1))+1 ;
                    pb = rand() ;
                    childxl(i,:) = pb*PoolX(seed1,:)+(1-pb)*PoolX(seed2,:) ;   %子代的速度和位置计算
                    childvl(i,:) = (pb*PoolVX(seed1,:)+pb*PoolVX(seed2,:))*norm(pb*PoolVX(seed1,:))/norm(pb*PoolVX(seed1,:)+pb*PoolVX(seed2,:)) ;
                end
                x(1:numPool,:) = childxl ;
                v(1:numPool,:) = childvl ;
            end
        end
    end
     
    %给出最后的计算结果 %
    xm = pg' ;
    fv = fitness(pg) ;
    

    12. 基于自然选择

     function [xm,fv]=PSO_nature(fitness,N,c1,c2,w,M,D)
    % fitness:待优化的目标函数;
    % N:粒子数目;
    % c1:学习因子1;
    % c2:学习因子2;
    % w:惯性权重;
    % M:最大迭代次数;
    % D:自变量的个数;
    % xm:目标函数取最小值时的自变量值;
    % fv:目标函数的最小值。
    format long;
    for i=1:N
        for j=1:D
            x(i,j)=randn;   %随机初始化位置
            v(i,j)=randn;   %随机初始化速度
        end
    end
    for i=1:N
        p(i)=fitness(x(i,:));
        y(i,:)=x(i,:);
    end
    pg=x(N,:);    %pg为全局最优
    for i=1:(N-1)
        if fitness(x(i,:))
            pg=x(i,:);
        end
    end
    for t=1:M
        for i=1:N   %速度、位移更新
            v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
            x(i,:)=x(i,:)+v(i,:);
            fx(i)=fitness(x(i,:));
            if fx(i)
                p(i)=fx(i);
                y(i,:)=x(i,:);
            end
            if p(i)
                pg=y(i,:);
            end
        end
        [sortf,sortx]=sort(fx);     %将所有的粒子按适应值排序
        exIndex=round((N-1)/2);
        x(sortx((N-exIndex+1):N))=x(sortx(1:exIndex));%将最好的一半粒子的位置替换掉最差的一半
        v(sortx((N-exIndex+1):N))=v(sortx(1:exIndex));%将最好的一半粒子的速度替换掉最差的一半
    end
    xm=pg';
    fv=fitness(pg);
    

    13.基于模拟退火

    function [xm,fv]=PSO_lamda(fitness,N,c1,c2,lamda,M,D)
    % fitness:待优化的目标函数;
    % N:粒子数目;
    % c1:学习因子1;
    % c2:学习因子2;
    % lamda:退火常数;
    % M:最大迭代次数;
    % D:自变量的个数;
    % xm:目标函数取最小值时的自变量值;
    % fv:目标函数的最小值。
    format long;
    for i=1:N
        for j=1:D
            x(i,j)=randn;   %随机初始化位置
            v(i,j)=randn;   %随机初始化速度
        end
    end
    for i=1:N
        p(i)=fitness(x(i,:));
        y(i,:)=x(i,:);
    end
    pg=x(N,:);    %pg为全局最优
    for i=1:(N-1)
        if fitness(x(i,:))
            pg=x(i,:);
        end
    end
    T=-fitness(pg)/log(0.2);    %初始温度
    for t=1:M
        groupFit=fitness(pg);
        for i=1:N           %当前温度下各个pi的适应值
            Tfit(i)=exp(-(p(i)-groupFit)/T);
        end
        SumTfit=sum(Tfit);
        Tfit=Tfit/SumTfit;
        pBet=rand();
        for i=1:N   %用轮盘赌策略确定全局最优的某个替代值
            ComFit(i)=sum(Tfit(1:i));
            if pBet<=ComFit(i)
                pg_plus=x(i,:);
                break;
            end
        end
        C=c1+c2;
       ksi=2/abs(2-C-sqrt(C^2-4*C));  %速度压缩因子
       for i=1:N
           v(i,:)=ksi*(v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg_plus-x(i,:)));
           x(i,:)=x(i,:)+v(i,:);
           if fitness(x(i,:))
               p(i)=fitness(x(i,:));
               y(i,:)=x(i,:);
           end
           if p(i)
               pg=y(i,:);
           end
       end
       T=T*lamda;
       Pbest(t) = fitness(pg) ;
    end   
    xm=pg';
    fv=fitness(pg);
    

    14. MATLAB粒子群工具箱

    添加工具箱的具体步骤就不在这里说了,网上有很多。

    例3:计算如下函数的最小值:

    z=0.4(x2)2+0.3(y4)20.7,x[40,40],y[40,40]z = 0.4*(x-2)^2 + 0.3 * (y-4)^2 -0.7, x\in[-40,40] , y\in[-40,40]

    • 定义待优化的MATLAB代码:

      function z = pso_func(in)
      n = size(in);
      x = in(:,1);
      y = in(:,2);
      nx = n(1);
      for i=1:nx
          temp = 0.4*(x(i)-2)^2+0.3*(y(i)-4)^2-0.7;
          z(i,:) = temp;
      end
      
    • 调用PSO算法的核心函数:pso_Trelea_vectorized

      clear
      clc
      x_range = [-40,40];
      y_range = [-40,40];
      range = [x_range;y_range];
      Max_V = 0.2*(range(:,2)-range(:,1));
      n = 2;
      pso_Trelea_vectorized('pso_func',n,Max_V,range)
      

    执行即可得到答案。

    在PSO算法函数pso_Trelea_vectorized173行中,PSO参数设置如下:

    Pdef = [100 2000 24 2 2 0.9 0.4 1500 1e-25 250 NaN 0 1];
    
    • 100:MATLAB命令窗口进行显示的间隔数
    • 2000:最大迭代次数
    • 24:初始化种子数,种子数越多,越有可能收敛到全局最优值,但算法收敛速度慢
    • 2:算法的加速度参数,分别影响局部最优值和全局最优值,一般不需要修改
    • 0.9和0.4为初始时刻和收敛时刻的加权值,一般不需要修改
    • 1500:迭代次数超过此值时,加权值取其最小
    • 1e-25:算法终止条件之一,当两次迭代中对应的种群最优值小于此阈值时,算法停止
    • 250:算法终止条件之一,取NaN时表示为非约束下的优化问题(即没有附加约束方程)
    • 0:制定采用何种PSO类型,0表示通常的PSO算法
    • 1:说明是否指定种子,0表示随机产生种子,1表示用户自行产生种子
    展开全文
  • Matlab粒子群优化算法-粒子群优化算法.rar 粒子群优化算法
  • matlab粒子群算法教程

    2018-05-10 12:58:45
    matlab粒子群教程,详细介绍粒子群算法原理及matlab代码。
  • 路径规划 matlab 粒子群算法 室内路径规划
  • matlab粒子群算法代码

    2020-12-24 20:19:12
    matlab代码 粒子群算法matlab代码
  • matlab粒子群算法

    2010-12-13 22:04:46
    matlab粒子群算法,运行结果无误。。适合初学研究者试验。。。
  • 基于MATLAB粒子群算法的切削用量优化.pdf
  • MATLAB粒子群优化算法(PSO)一、介绍粒子群优化算法(Particle Swarm Optimization Algorithm)是一种群智能算法,为了寻求全局最优。群体迭代,粒子在解空间追随最优的粒子进行搜索。粒子群算法的思想源于对鸟群捕食...

    MATLAB粒子群优化算法(PSO)

    一、介绍

    粒子群优化算法(Particle Swarm Optimization Algorithm)是一种群智能算法,为了寻求全局最优。群体迭代,粒子在解空间追随最优的粒子进行搜索。

    粒子群算法的思想源于对鸟群捕食行为的研究,模拟鸟集群飞行觅食的行为,鸟之间通过集体的协作使群体达到最优目的,是一种基于Swarm Intelligence的优化方法。

    马良教授在他的著作《蚁群优化算法》一书的前言中写到:“自然界的蚁群、鸟群、鱼群、羊群、牛群、蜂群等,其实时时刻刻都在给予我们以某种启示,只不过我们常常忽略了大自然对我们的最大恩赐!”

    设想这样一个场景:一群鸟在随机搜索食物,已知

    (1)在这块区域里只有一块食物;(2)所有的鸟都不知道食物在哪里;(3)但它们能感受到当前的位置离食物还有多远.

    那么:找到食物的最优策略是什么呢?

    搜寻目前离食物最近的鸟的周围区域,根据自己飞行的经验判断食物的所在。

    c4c85b02c07de0976a9c3e38d5c18368.gif

    PSO的基础: 信息的社会共享

    二、算法思路

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

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

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

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

    三、算法流程与伪代码

    8fa92fe6880fe84809ceff09c4c89cbd.png

    a49e49f7e3d40546df8c9e7d962e1713.png

    c1: weight of local information

    c2: weight of global information

    p: particle's position

    v: path direction

    rand: random variable, 0

    number of particles: 10~50

    c1+c2=4

    v=v+c1*rand*(pbest-p)+c2*rand*(gbest-p);中右边第一项v: inertia, c1*rand*(pbest-p): personal influence, c2*rand*(gbest-p): social influence.

    四、MATLAB程序

    粒子群优化算法求解函数y=x+x*sin(x)在[-10, 10]的最大值.

    pso.m

    function [best_x, best_y]=pso()

    %find the max value of a function

    %Author: kailugaji https://www.cnblogs.com/kailugaji/

    posMax=10;posMin=-10; %range of feasible solution

    x=posMin:0.1:posMax;

    y=my_fun(x); %object function

    plot(x,y);hold on; %plot function

    popsize=30; %number of particles

    max_iter=100; %maximum number of iterations

    position=rand(popsize,1);

    position=position*20-ones(popsize,1)*10; %particle's position

    vMax=1;vMin=-1; %range of velocity

    velosity=2*rand(popsize,1)-1; %path direction

    pbest=position; %current optimum

    gbest=position(1); %global optimum

    wBegin=1;wEnd=0.05;

    c1=2; %weight of local information

    c2=2; %weight of global information

    for i=1:max_iter

    position_new=position+velosity; %change direction of each particle

    velosity_new=(wEnd+(wBegin-wEnd)*(100-i)/100).*velosity+c1*rand().*(position-pbest.*ones(popsize,1))+c2*rand().*(position-gbest.*ones(popsize,1)); %inertia+personal influence+social influence

    for j=1:popsize

    if(position_new(j)>posMax)

    position_new(j)=posMax;

    end

    if(position_new(j)

    position_new(j)=posMin;

    end

    if(velosity_new(j)>vMax)

    velosity_new(j)=vMax;

    end

    if(velosity_new(j)

    velosity_new(j)=vMin;

    end

    if(my_fun(position_new(j))>my_fun(pbest(j)))

    pbest(j)=position_new(j);

    end

    if(my_fun(position_new(j))>my_fun(gbest))

    gbest=position_new(j);

    end

    end

    position=position_new;

    velosity=velosity_new;

    end

    plot(gbest,my_fun(gbest),'or');

    best_x=gbest;

    best_y=my_fun(gbest);

    my_fun.m

    function y=my_fun(x)

    y=x+x.*sin(x);

    五、实验结果

    >> [best_x, best_y]=pso()

    best_x =

    8.0051

    best_y =

    15.9190

    33712b5b04b37fab34bca01d977af2ea.png

    当x=8.0051时,粒子群优化算法终止迭代,此时获得的最大值为y=15.9190。

    六、参考文献

    展开全文
  • MATLAB粒子群算法

    2018-03-31 10:10:30
    如何开发粒子群算法,运用改进粒子群算法解决规划问题,附带程序。
  • Matlab粒子群算法源码

    2018-12-19 11:48:21
    粒子群算法的Matlab源码,可用于在Matlab上实现粒子群算法
  • Matlab粒子群算法工具箱使用方法及实例演示.ppt》由会员分享,可在线阅读,更多相关《Matlab粒子群算法工具箱使用方法及实例演示.ppt(22页珍藏版)》请在人人文库网上搜索。1、粒子群算法工具箱应用简介,1。引言,...

    《Matlab粒子群算法工具箱使用方法及实例演示.ppt》由会员分享,可在线阅读,更多相关《Matlab粒子群算法工具箱使用方法及实例演示.ppt(22页珍藏版)》请在人人文库网上搜索。

    1、粒子群算法工具箱应用简介,1。引言,粒子群算法(PSO算法) 定义:粒子群算法,又称粒子群优化算法(Partical Swarm Optimization),缩写为 PSO, 是近年来发展起来的一种新的进化算法(Evolutionary Algorithm - EA),由Eberhart 博士和kennedy 博士于1995年提出,其源于对鸟群捕食的行为研究。,2。算法思想,PSO模拟鸟群的捕食行为。 设想这样一个场景:一群鸟在随机搜索食物,在这个区域里只有一块食物,所有的鸟都不知道食物在那里,但是它们知道当前的位置离食物还有多远,那么找到食物的最优策略是什么呢? 最简单有效的就是搜寻目前离食。

    2、物最近的鸟的周围区域。都向这片区域靠拢。,3。抽象,PSO中,将问题的搜索空间类比于鸟类的飞行空间,将每只鸟抽象为一个无质量无体积的微粒,用以表征优化问题的一个候选解,我们称之为“粒子”,优化所需要寻找的最优解则等同于要寻找的食物。 所有的粒子都有一个由被优化的函数决定的适应值(fitness value),每个粒子还有一个速度决定他们飞翔的方向和距离,然后粒子们就追随当前的最优粒子在解空间中搜索。,3。抽象,PSO初始化为一群随机粒子(随机解、一群鸟),然后通过迭代找到最优解。在每一次迭代中,粒子(鸟)通过跟踪两个“极值”来更新自己的位置。一个就是粒子本身所找到的最优解,这个解叫做个体极值p。

    3、Best,另一个极值是整个种群目前找到的最优解,这个极值是全局极值gBest。(gBest是pBest中最好值),3。算法介绍,在找到这两个最优值时,粒子根据如下的公式来更新自己的速度和位置: 其中 ,V 是粒子的速度,Present 是粒子的当前位置 ,pBest 与 gBest见前面定义。rand ( )是(0 ,1)之间的随机数 ,c1和c2被称作学习因子。通常 ,c1 = c2 = 2。w 是加权系数(惯性权重),取值在 0. 1到0. 9之间。粒子通过不断学习更新 ,最终飞至解空间中最优解所在的位置 ,搜索过程结束。最后输出的 gBest 就是全局最优解。在更新过程中 ,粒子每一维的。

    4、最大速率限被限制为 Vmax ,如果某一维更新后的速度超过设定的Vmax,那么这一维的速度就被限定为Vmax。,3。算法介绍,将粒子延伸到N维空间,粒子i在N维空间里的位置表示为一个矢量,每个粒子的飞行速度也表示为一个矢量。 粒子数(鸟的个数): 一般取 140. 其实对于大部分的问题10个粒子已经足够可以取得好的结果; 粒子的长度(维度): 这是由优化问题决定, 就是问题解的长度(决策变量个数); 粒子的范围: 由优化问题决定,每一维可以设定不同的范围;,Vmax: 最大速度,决定粒子在一个循环中最大的移动距离, 通常设定为粒子的范围宽度,例如,粒子 (x1, x2, x3) ,x1 属于 。

    5、-10, 10, 那么 Vmax 的大小就是 20。 学习因子: 使粒子具有自我总结和向群体中优秀个体学习的能力,从而向群体内或邻域内最优点靠近,c1 和 c2 通常等于2,并且范围在 0 和 4 之间。 中止条件: 最大循环数以及最小错误要求。 惯性权重w :决定了对粒子当前速度继承多少,合适的选择可以使粒子具有均衡的探索能力和开发能力,惯性权重的取法有常数法、线性递减法、自适应法等。,3。算法介绍,例:对于问题 f(x) = x12 + x22+x32 求解,粒子可以直接编码为 (x1, x2, x3),而适应度函数就是f(x),接着我们就可以利用前面的过程去寻优,寻优过程是一个迭代过程,。

    6、 中止条件一般为设置为达到最大循环数或者最小错误要求。,3。算法介绍,PSO框架图,粒子群优化算法Matlab工具箱简介,Matlab粒子群工具箱(PSOt)提供了非常先进的粒子群优化算法 ,可指定惯性因子的起始值和中止值 ,可约定各维变量的取值范围 、粒子在遇到边界时是否反弹等各种参数 。除此以外 ,粒子群工具箱既可以在用户约定的范围内自动随机生成指定群体规模的初始粒子群 ,也可人工输入小于群体规模的任意数目的初始粒子 ,具备非常强的灵活性 。,粒子群优化算法Matlab工具箱简介,粒子群优化算法Matlab工具箱简介,PSOt具有非常强的灵活性,在实际计算中,用户只要根据需求编写好目标函数。

    7、,并设置好函数自变量的取值范围和每步迭代允许的最大变化量,PSOt即可自动进行优化计算。,该工具箱的使用方法主要分为一下几个步骤: (1)在MATLAB的命令窗口中点击“File”,“Set Path”,设置工具箱的路径。 (2)编写待优化的函数(test_func),保存为同名m文件,粒子群优化算法Matlab工具箱简介,(3)调用粒子群算法的核心模块:pso_Trelea_vectorized.m,其调用格式为: pso_Trelea_vectorized(functname, D, mv, VarRange , minmax, PSOparams, plotfcn, PSOseedVal。

    8、ue),pso_Trelea_vectorized(functname, D, mv, VarRange, minmax, PSOparams, plotfcn, PSOseedValue) Functname:目标函数名 D:待优化问题的维数; mv:粒子飞行的最大速度; VarRange:参数变化范围矩阵; Minmax:寻优类型,取0代表求目标函数最小值,取1代表求目 标函数最大值); PSOparams:参数矩阵,包括最大迭代次数、粒子群规模、惯性因子、学习因子、终止迭代条件等; Plotfcn:寻优过程中用于展示寻优过程的画图函数; PSOseedValue:可允许用户输入任意多组初。

    9、始粒子。,求非线性函数极大值,工具箱应用实例,工具箱应用实例,(1)编写待优化函数程序 function z = test_func(in) nn=size(in); %输入的是矩阵 ,即算法中随机产生一组x和y ,按x(nn, 1), y(nn, 1)排列 x=in(:,1); y=in(:,2); nx=nn(1); for i=1:nx temp=sin(sqrt(x(i)2+y(i)2)/sqrt(x(i)2+y(i)2)+exp(cos(2*pi*x(i)+cos(2*pi*y(i)/2)-2.71289; z(i,:)=temp; end,工具箱应用实例,(2)编写调用函数 x_range=-2,2; y_range=-2,2; range=x_range; y_range; Max_V=0.2* (range(:,2) - range(:,1); %最大速度取范围的 10 20% n=2; %粒子维数 PSOparams=10 300 20 2 2 0.9 0.4 1500 1e-25 250 NaN 0 0 %个体数目 20 ,进化次数 300 PSO_Trelea_vectorized(test_func, n, Max_V, range, 1, PSOparams),工具箱应用实例。

    展开全文
  • matlab粒子群算法 .zip

    2020-07-27 18:21:37
    该zip文件中包括了matlab实现的粒子群算法以及改进版本的粒子群算法的程序,所有文件程序都带有注释,欢迎大家下载学习。
  • MATLAB粒子群算法仿真

    2017-12-05 15:25:15
    关于粒子群算法一个Demo 寻找高斯函数的极值点。Matlab代码
  • Matlab粒子群算法遗传算法优化RBF径向基神经网络-粒子群算法、遗传算法优化RBF径向基神经网络.rar 粒子群算法、遗传算法优化RBF径向基神经网络
  • 基于Matlab粒子群算法的铣削用量优化及齿轮齿条接触分析.pdf
  • Matlab粒子群优化算法

    2018-04-07 13:08:45
    利用matlab写了粒子群优化算法的一个脚本文件,每行代码都有详细注释,可以根据代码内容自行修改,实现自己需要的功能
  • matlab粒子群适应度函数代码粒子群优化(PSO) 该存储库包含用于优化基准功能的标准粒子群优化代码(matlab M文件): . ├── img | ├── benchmark.gif | ├── convergence-2d.png | ├── convergence-30d....
  • Matlab粒子群神经网络的预测编程实现电力负荷预测-粒子群神经网络的预测编程实现,电力负荷预测本人已实现.rar 粒子群神经网络的预测编程实现,电力负荷预测本人已实现
  • matlab实现粒子群算法(PSO) 极值优化的程序代码 matlab实现粒子群算法(PSO) 极值优化的程序代码
  • matlab粒子群算法程序

    2014-04-21 22:00:39
    matlab软件开发 粒子群优化算法程序 格式为m文件
  • MATLAB粒子群算法工具箱求解的实例分析
  • 利用粒子群算法做水下机器人的路径规划,障碍物在此文件中设为圆形,并绘制出路径图和收敛曲线图
  • 使用matlab软件,解决背包问题,粒子群算法求取最优解
  • MATLAB粒子群入门例程

    2018-08-30 11:45:42
    简单的粒子群程序,适合新手学习使用,本例程为一个三元三次函数优化
  • Matlab粒子群算法神经网络泰坦尼克号介绍实验步骤初始化参数初始化种群计算适应度函数速度、位置更新极值更新实验结果总代码 介绍 这里用粒子群算法优化神经网络的参数,使其得到更好的训练效果。 粒子群算法是个很...

    介绍

    这里用粒子群算法优化神经网络的参数,使其得到更好的训练效果。
    粒子群算法是个很简单的算法,写这篇文章当做复习复习过去学过的内容了。
    粒子群算法流程图:
    在这里插入图片描述
    其中重要的是位置更新和速度更新公式
    在这里插入图片描述
    在这里那些参数都简单地取固定值

    实验步骤

    初始化参数

    %% 参数初始化
    %粒子群算法中的两个参数
    c1 = 2;
    c2 = 2;
    
    w=0.5; %权重
    
    maxgen=200;   % 进化次数  
    sizepop=20;   %种群规模
    
    Vmax=0.5;
    Vmin=-0.5;
    popmax=4;
    popmin=-4;
    

    初始化种群

    二进制编码,通过自变量的范围与精度来确定染色体编码长度。

    %% 产生初始粒子和速度
    for i=1:sizepop
        %随机产生一个种群
        pop(i,:)=4*rands(1,N)-2;    %初始种群
        V(i,:)=0.5*rands(1,N);  %初始化速度
        %计算适应度
        %fitness(i)=fun1(pop(i,:));   %染色体的适应度
        [err,fitness(i)]=Bpfun(pop(i,:),x1',y1',hiddennum1,hiddennum2,x2',y2');
    end
    

    计算适应度函数

    神经网络的测试集准确率作为适应度函数,用matlab自带的神经网络函数搭建BP神经网络。

    function [err,ac]=Bpfun(x,P,T,hiddennum1,hiddennum2,P_test,T_test)
    %% 训练&测试BP网络
    %% 输入
    % x:一个个体的初始权值和阈值
    % P:训练样本输入
    % T:训练样本输出
    % hiddennum:隐含层神经元数
    % P_test:测试样本输入
    % T_test:测试样本期望输出
    %% 输出
    % err:预测样本的预测误差的范数
    
    inputnum=size(P,1);       % 输入层神经元个数
    outputnum=size(T,1);      % 输出层神经元个数
    %% 新建BP网络
    net=newff(minmax(P),[hiddennum1,hiddennum2,outputnum],{'tansig','satlins','logsig'},'trainlm');
    %% 设置网络参数:训练次数为1000,训练目标为0.01,学习速率为0.1
    net.trainParam.epochs=10;
    net.trainParam.goal=0.01;
    LP.lr=0.1;
    net.trainParam.show=NaN;
    %net.trainParam.showwindow=false;  %高版MATLAB
    %% BP神经网络初始权值和阈值
    w1num=inputnum*hiddennum1; % 输入层到隐层1的权值个数
    w2num=hiddennum1*hiddennum2;% 隐层1到隐层2的权值个数
    w3num=outputnum*hiddennum2;% 隐层2到输出层的权值个数
    w1=x(1:w1num);   %初始输入层到隐层的权值
    B1=x(w1num+1:w1num+hiddennum1);  %初始隐层阈值
    w2=x(w1num+hiddennum1+1:w1num+hiddennum1+w2num); %初始隐层到输出层的阈值
    B2=x(w1num+hiddennum1+w2num+1:w1num+hiddennum1+w2num+hiddennum2); %输出层阈值
    w3=x(w1num+hiddennum1+w2num+hiddennum2+1:w1num+hiddennum1+w2num+hiddennum2+w3num); %初始隐层到输出层的阈值
    B3=x(w1num+hiddennum1+w2num+hiddennum2+w3num+1:w1num+hiddennum1+w2num+hiddennum2+w3num+outputnum); %输出层阈值
    net.iw{1,1}=reshape(w1,hiddennum1,inputnum);
    net.lw{2,1}=reshape(w2,hiddennum2,hiddennum1);
    net.lw{3,2}=reshape(w3,outputnum,hiddennum2);
    net.b{1}=reshape(B1,hiddennum1,1);
    net.b{2}=reshape(B2,hiddennum2,1);
    net.b{3}=reshape(B3,outputnum,1);
    %% 训练网络以
    net=train(net,P,T);
    %% 测试网络
    Y=sim(net,P_test);
    err=norm(Y-T_test);
    for i=1:length(Y)
        if Y(i)<0.5
            Y(i)=0;
        else
            Y(i)=1;
        end
    end
    ac=1-sum(abs(Y-T_test))/length(Y);
    

    速度、位置更新

    超范围的设为边界值

    for j=1:sizepop
            
            %速度更新
            V(j,:) = w*V(j,:) + c1*rand*(gbest(j,:) - pop(j,:)) + c2*rand*(zbest - pop(j,:));
            V(j,find(V(j,:)>Vmax))=Vmax;
            V(j,find(V(j,:)<Vmin))=Vmin;
            
            %种群更新
            pop(j,:)=pop(j,:)+V(j,:);
            pop(j,find(pop(j,:)>popmax))=popmax;
            pop(j,find(pop(j,:)<popmin))=popmin;
            
            %适应度值
            %fitness(j)=fun1(pop(j,:)); 
            [err,fitness(j)]=Bpfun(pop(j,:),x1',y1',hiddennum1,hiddennum2,x2',y2');
       
        end
    

    极值更新

        for j=1:sizepop
            
            %个体最优更新
            if fitness(j) > fitnessgbest(j)
                gbest(j,:) = pop(j,:);
                fitnessgbest(j) = fitness(j);
            end
            
            %群体最优更新
            if fitness(j) > fitnesszbest
                zbest = pop(j,:);
                fitnesszbest = fitness(j);
            end
        end 
        yy(i)=fitnesszbest;    
    

    实验结果

    寻优曲线:
    在这里插入图片描述
    最优初始权值和阈值:
    zbest =

    1 至 12 列

    -1.3909 0.4211 -4.0000 -4.0000 -3.0747 0.7278 0.2609 0.5257 0.3035 -4.0000 -1.7539 1.4606

    13 至 24 列

    -0.6466 -1.1569 -4.0000 -4.0000 -0.0353 -2.2010 -1.4103 -0.5082 -3.3560 -4.0000 -3.2423 1.0365

    25 至 36 列

    0.8485    0.8189   -3.7687   -4.0000   -1.9942   -4.0000   -4.0000    1.1625    0.9775   -4.0000   -3.5533    0.8062
    

    37 至 48 列

    -4.0000 1.4416 -3.1999 1.1774 -3.1303 -4.0000 -0.2201 -4.0000 0.0039 0.2402 -3.6992 -4.0000

    49 至 60 列

    -2.4385 0.2102 -2.2919 -1.8557 -1.4834 0.1662 -4.0000 -4.0000 -2.2281 -1.2947 -4.0000 -2.7338

    61 至 72 列

    0.9059   -4.0000   -0.9322   -4.0000   -3.4940   -3.3672   -2.7645   -4.0000   -1.7928    0.2071   -4.0000    1.4712
    

    73 至 84 列

    1.2638    0.6005   -2.6439   -3.7701   -2.3721   -4.0000   -2.9139   -0.8094   -2.6147    0.1717   -2.6738   -3.1668
    

    85 至 96 列

    1.6297   -3.1846   -3.1394   -3.7566    0.6721   -4.0000   -1.9135   -3.8827    0.3824   -4.0000   -4.0000   -3.5148
    

    97 至 108 列

    -4.0000 0.3533 -0.0105 -1.6206 -3.1942 -4.0000 -4.0000 -3.4977 -2.2151 -2.0006 -3.3219 -0.0998

    109 至 120 列

    -1.8840 -3.9514 0.8863 0.5666 1.2084 -3.8815 -2.5561 -2.1463 0.8396 -4.0000 -4.0000 -3.5560

    121 至 132 列

    -4.0000 -2.7513 -2.5226 1.2854 -2.9356 -2.7046 0.0803 -2.6269 0.8959 -0.1088 -4.0000 1.3314

    133 至 144 列

    -4.0000 -2.9946 -4.0000 1.1231 -3.0665 -2.0246 1.4080 -4.0000 -4.0000 -1.3666 -4.0000 0.3398

    145 至 156 列

    0.2099   -0.5329   -4.0000   -4.0000    1.4131   -1.9708   -0.5725   -3.7010   -4.0000    0.1608   -0.8834   -3.1611
    

    157 至 168 列

    1.5639   -3.9535   -2.2949   -4.0000   -2.6633    0.7295   -3.8275   -0.1578   -2.3034   -0.4336   -1.9277   -2.4596
    

    169 至 180 列

    -0.1329 1.2473 -4.0000 1.2027 -2.3681 -1.5221 -4.0000 0.6484 -4.0000 -1.8994 1.2410 0.7832

    181 至 192 列

    -3.5839 0.4650 0.9777 -3.6067 -2.1450 -1.2591 -0.3171 -4.0000 1.2079 -4.0000 -2.2733 -4.0000

    193 至 204 列

    -0.0869 -3.5696 -3.6571 -3.0560 -4.0000 -4.0000 -3.9686 -1.4987 0.8207 0.8795 -2.7175 -2.2507

    205 至 206 列

    -1.7657 1.1905

    fitnesszbest =

    0.8350
    

    总代码

    %% 清空环境
    clc
    clear
    %%
    %样本数据就是前面问题描述中列出的数据
    [x,y]=date_inscet();
    randIndex=randperm(size(x,1));%打乱顺序
    x=x(randIndex,:);y=y(randIndex,:);
    x1=x(1:1000,:);y1=y(1:1000,:);x2=x(1001:end,:);y2=y(1001:end,:);
    % 初始隐层神经元个数
    hiddennum1=15;hiddennum2=5;
    % 输入向量的最大值和最小值
    inputnum=size(x,2);       % 输入层神经元个数
    outputnum=size(y,2);      % 输出层神经元个数
    w1num=inputnum*hiddennum1; % 输入层到隐层1的权值个数
    w2num=hiddennum2*hiddennum1;% 隐层1到隐层2的权值个数
    w3num=outputnum*hiddennum2;% 隐层2到输出层的权值个数
    N=w1num+hiddennum1+w2num+hiddennum2+w3num+outputnum; %待优化的变量的个数
    %% 参数初始化
    %粒子群算法中的两个参数
    c1 = 2;
    c2 = 2;
    
    w=0.5; %权重
    
    maxgen=200;   % 进化次数  
    sizepop=20;   %种群规模
    
    Vmax=0.5;
    Vmin=-0.5;
    popmax=4;
    popmin=-4;
    
    %% 产生初始粒子和速度
    for i=1:sizepop
        %随机产生一个种群
        pop(i,:)=4*rands(1,N)-2;    %初始种群
        V(i,:)=0.5*rands(1,N);  %初始化速度
        %计算适应度
        %fitness(i)=fun1(pop(i,:));   %染色体的适应度
        [err,fitness(i)]=Bpfun(pop(i,:),x1',y1',hiddennum1,hiddennum2,x2',y2');
    end
    
    %% 个体极值和群体极值
    [bestfitness bestindex]=max(fitness);
    zbest=pop(bestindex,:);   %全局最佳
    gbest=pop;    %个体最佳
    fitnessgbest=fitness;   %个体最佳适应度值
    fitnesszbest=bestfitness;   %全局最佳适应度值
    
    %% 迭代寻优
    for i=1:maxgen
        
        for j=1:sizepop
            
            %速度更新
            V(j,:) = w*V(j,:) + c1*rand*(gbest(j,:) - pop(j,:)) + c2*rand*(zbest - pop(j,:));
            V(j,find(V(j,:)>Vmax))=Vmax;
            V(j,find(V(j,:)<Vmin))=Vmin;
            
            %种群更新
            pop(j,:)=pop(j,:)+V(j,:);
            pop(j,find(pop(j,:)>popmax))=popmax;
            pop(j,find(pop(j,:)<popmin))=popmin;
            
            %适应度值
            %fitness(j)=fun1(pop(j,:)); 
            [err,fitness(j)]=Bpfun(pop(j,:),x1',y1',hiddennum1,hiddennum2,x2',y2');
       
        end
        
        for j=1:sizepop
            
            %个体最优更新
            if fitness(j) > fitnessgbest(j)
                gbest(j,:) = pop(j,:);
                fitnessgbest(j) = fitness(j);
            end
            
            %群体最优更新
            if fitness(j) > fitnesszbest
                zbest = pop(j,:);
                fitnesszbest = fitness(j);
            end
        end 
        yy(i)=fitnesszbest;    
            
    end
    %% 结果分析
    hold on
    plot(yy)
    title('最优个体适应度','fontsize',12);
    xlabel('进化代数','fontsize',12);ylabel('适应度','fontsize',12);
    zbest
    fitnesszbest
    
    展开全文
  • 粒子群matlab源代码,对多维度的最大目标值进行求解, 迭代效果好https://blog.csdn.net/weixin_45746836/article/details/108954998

空空如也

空空如也

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

matlab粒子群

matlab 订阅