精华内容
下载资源
问答
  • matlab中粒子群算法基础(-)

    千次阅读 2016-11-16 20:28:04
    算法描述:n个粒子在Q维(变量个数)空间进行搜索,每个粒子表示为xi=(xi1,xi2,xi3,xi4,xi5.......),对应的速度Vi=(vi1,vi2,vi3,vi4,vi5...),搜索时考虑两个因素:1自己历史最大值2全

    http://cn.mathworks.com/help/gads/examples/optimize-using-a-particle-swarm.html


    算法描述:n个粒子在Q维(变量个数)空间进行搜索,每个粒子表示为xi=(xi1,xi2,xi3,xi4,xi5.......),对应的速度Vi=(vi1,vi2,vi3,vi4,vi5...),搜索时考虑两个因素:1自己历史最大值2全部粒子最优值

    速度由3个因素改变;1惯性权重,2自身权重3种群权重

    可以通过plotobjective(@..,rang)画出函数图像。

    对于复杂的目标函数可能使用默认设置会找不到最优值。

    可进行一些自定义设置;

    1绑定搜索空间

     设置 lb=-10*ones(1,nvars);其中nvars为变量个数

           ub=-lb;

    [x,Fval.exitFlag,output]=particleswarm(fun,nvars,lb,ub);

    2.更待其他选项

    options=optimoptions('particleswarm','MinNeighborsFraction'1);

    [x,Fval.exitFlag,output]=particleswarm(fun,nvars,lb,ub,options);

    3.更改自身权重

    options.SelfAdjustmentWeight=1.9;

    [x,F

    展开全文
  • matlab代码粒子群算法粒子群选择 ParticleSwarmOpt是使用微粒群优化算法(由)开发的优化工具。 不需要工具箱。 将路径添加到您的Matlab,然后就可以使用它了。 该代码无法执行离散搜索,也不支持多目标优化。 对于...
  • MATLAB实现粒子群算法

    2018-11-13 10:53:24
    本资源是利用MATLAB实现粒子群优化算法的寻优算法。可以正确仿真。
  • 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(速度)。
    在粒子群算法的每次迭代中,每个粒子的位置和速度都会更新。

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

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

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

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

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

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

    在这里插入图片描述

    4.4 找到新位置

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

    在这里插入图片描述

    状态转移方程:

    v i j ⃗ ( t + 1 ) = w v i j ⃗ ( t ) + c 1 r 1 ( p i j ( t ) − x i j ⃗ ( t ) ) + c 2 r 2 ( g j ( t ) − x i j ⃗ ( 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} vij (t+1)=wvij (t)+c1r1(pij(t)xij (t))+c2r2(gj(t)xij (t))(4-1)

    x i j ⃗ ( t + 1 ) = x i j ⃗ ( t ) + v i j ⃗ ( t + 1 ) (4-2) \vec {x_{ij}}(t+1) = \vec{x_{ij}}(t)+\vec{v_{ij}}(t+1) \tag{4-2} xij (t+1)=xij (t)+vij (t+1)(4-2)

    其中, c 1 , c 2 c_1,c_2 c1,c2为学习因子,也称加速常数(acceleration constant);

    r 1 , r 2 r_1,r_2 r1,r2,[0,1]范围内的均匀随机数。

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

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

    5. 算法的运行参数

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

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

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

    6. 算法的基本流程

    1. 初始化粒子群,包括群体规模N,每个粒子的位置 x i x_i xi和速度 v i v_i vi
    2. 计算吗每一个粒子的适应度值 F i t [ i ] Fit[i] Fit[i]
    3. 计算每个粒子,用它的适应度值 F i t [ i ] Fit[i] Fit[i]和个体极值 p b e s t ( i ) p_{best}(i) pbest(i)比较,如果 F i t [ i ] > p b e s t ( i ) Fit[i]>p_{best}(i) Fit[i]>pbest(i),则用 F i t [ i ] Fit[i] Fit[i]替换掉 p b e s t ( i ) p_{best}(i) pbest(i)
    4. 计算每个粒子,用它的适应度值 F i t [ i ] Fit[i] Fit[i]和全局极值 g b e s t ( i ) g_{best}(i) gbest(i)比较,如果 F i t [ i ] > g b e s t ( i ) Fit[i]>g_{best}(i) Fit[i]>gbest(i),则用 F i t [ i ] Fit[i] Fit[i]替换掉 g b e s t ( i ) g_{best}(i) gbest(i)
    5. 根据式(4-1)和式(4-2)更新粒子的位置 x i x_i xi和速度 v i v_i vi
    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 = 1 30 x i 2 + x i − 6 f(x) = \sum^{30}_{i=1}x_i^2+x_i-6 f(x)=i=130xi2+xi6

    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 = ( ( s i n ( x 1 2 + x 2 2 ) ) 2 − c o s ( x 1 2 + x 2 2 ) + 1 ) ( ( 1 + 0.1 × ( x 1 2 + x 2 2 ) ) 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}} y=((1+0.1×(x12+x22))2)0.7((sin(x12+x22))2cos(x12+x22)+1)

    其中,粒子数为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 ∗ ( x − 2 ) 2 + 0.3 ∗ ( y − 4 ) 2 − 0.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] z=0.4(x2)2+0.3(y4)20.7,x[40,40],y[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——粒子群算法

    2011-06-20 17:23:53
    matlab——粒子群算法,比较好用。。。
  • MATLAB实现粒子群算法,可以看到寻优的过程。并且在每句后都有注解。
  • test-fun为定义的求解函数,test-funfun主函数调用MATLAB官方粒子群算法工具箱求解最大值
  • matlab代码粒子群算法
  • 粒子群算法PSO应用于神经网络优化matlab-粒子群算法(PSO)应用于神经网络优化[matlab].rar 粒子群算法(PSO)应用于神经网络优化[matlab]. 有程序 Overview p Introduction p Theory p Applications p ...
  • matlab代码粒子群算法PSO文件 粒子群优化算法基于Ali Mirjalilis matlab实现。 python实现需要两个依赖关系:matplotlib和numpy。 以下是将python,matplotlib和numpy下载到您的个人计算机上以运行代码的指南。 由...
  • matlab粒子群算法代码

    2020-12-24 20:19:12
    matlab代码 粒子群算法matlab代码
  • matlab代码粒子群算法粒子群最小化器 粒子群优化算法,用于查找两个函数的最小值。 该算法以及将要最小化的两个功能在此处进行了描述: 该代码是用Matlab编写的。 要运行它,只需键入PSO22a以最小化所描述的两个...
  • matlab代码粒子群算法自适应CLPSO Matlab代码用于宏观自适应综合学习粒子群优化器(MaPSO)和微观自适应综合学习粒子群优化器(MiPSO)算法。 抽象的 优化启发式算法(如粒子群优化器(PSO))的广泛使用对参数...
  • matlab代码粒子群算法遗传算法 GeneticAlgorithmOpt是由遗传算法开发的使用遗传算法的优化工具。 不需要工具箱。 将路径添加到您的Matlab,然后就可以使用它了。 此代码只能处理离散的优化问题。 对于连续变化的参数...
  • MATLAB代码 粒子群算法(PSO) 详细注释
  • MATLAB实现粒子群算法的进阶讲解(多维+约束条件)

    万次阅读 多人点赞 2019-11-12 18:46:53
    我们在之前的博客,对粒子群算法的实现进行了讲解,主要讲解了粒子群算法的产生,实现步骤,并且通过代码来实现了当输入变量为n维向量时的粒子群算法。 许多网友对之前的代码有些疑惑,并且提到了几个问题:1,...

    我们在之前的博客中,对粒子群算法的实现进行了讲解,主要讲解了粒子群算法的产生,实现步骤,并且通过代码来实现了当输入变量为n维向量时的粒子群算法。
    许多网友对之前的代码有些疑惑,并且提到了几个问题:
    1,对于之前的代码,觉得有些看不懂?
    2,如果输入变量不再是n维向量,而是n*n维的矩阵,甚至n*n*n…维的矩阵,该如何编写代码?
    3,如果目标函数存在约束条件,该如何编写代码?
    本节就基于之前博客的内容,出现的问题,以及这两天我的一些学习,来对上述问题进行一个解答。

    上一讲博客链接在此:(https://blog.csdn.net/DBLLLLLLLL/article/details/82965722)

    1.自变量为2维向量的粒子群算法

    首先还是从最简单的开始,关于自变量为2维的粒子群算法,其代码的实现过程可以参考上一讲的博客,这里我对于该代码进行了一些改进。主要改进就是增加了一个自适应变异机制,即每次算法计算周期,都有一定的概率随机改变某一个个体的数值,从而提高了整个粒子群的寻优能力。关于这个能力,感兴趣的人可以尝试将代码中的自适应变异的代码段注释掉,观察结果,可以有更直观的感受。

    %% 清空环境
    clc;clear all;close all;
    %% 目标函数
    %  下面这个函数叫做Schaffer函数,最小值在(0,0)处,为0
    fun= @(a,b)(0.5+(sin(sqrt(a.^2+b.^2)).^2-0.5)./((1+0.001.*(a.^2+b.^2)).^2));
    %  绘图函数,可舍弃
    figure(1);
    [x0_1, x0_2]=meshgrid(-5:0.1:5);
    y0=fun(x0_1,x0_2);
    mesh(x0_1, x0_2, y0);
    hold on;
    %% 设置种群参数
    %   需要自行配置
    sizepop = 500;                         % 初始种群个数
    dim = 2;                           % 空间维数
    ger = 300;                       % 最大迭代次数     
    xlimit = [ -5,5 ; -5 ,5 ];        % 设置位置参数限制(矩阵的形式可以多维)
    vlimit = [ -1.5,1.5 ; -1.5,1.5]; % 设置速度限制
    c_1 = 0.8;                       % 惯性权重
    c_2 = 0.5;                       % 自我学习因子
    c_3 = 0.5;                       % 群体学习因子 
    %% 生成初始种群
    %  首先随机生成初始种群位置
    %  然后随机生成初始种群速度
    %  然后初始化个体历史最佳位置,以及个体历史最佳适应度
    %  然后初始化群体历史最佳位置,以及群体历史最佳适应度
    %  绘图(可舍弃)
     for i = 1:dim
        pop_x(i,:) = xlimit(i, 1) + (xlimit(i, 2) - xlimit(i, 1)) * rand(1, sizepop);%初始种群的位置
    end    
    pop_v = rand(dim, sizepop);                   % 初始种群的速度
    gbest = pop_x;                                % 每个个体的历史最佳位置
    fitness_gbest = fun(pop_x(1,:),pop_x(2,:));   % 每个个体的历史最佳适应度
    zbest = pop_x(:,1);                          % 种群的历史最佳位置
    fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
    for j=1:sizepop
        if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = pop_x(:,j);
            fitness_zbest=fitness_gbest(j);
        end
    end
    
    plot3(gbest(1,:),gbest(2,:),fun(gbest(1,:),gbest(2,:)), 'ro');title('初始状态图');
    hold on;
    figure(2);
    mesh(x0_1, x0_2, y0);
    hold on;
    plot3(gbest(1,:),gbest(2,:),fun(gbest(1,:),gbest(2,:)), 'ro');
    hold on;
    
    %% 粒子群迭代
    %    更新速度并对速度进行边界处理    
    %    更新位置并对位置进行边界处理
    %    进行自适应变异
    %    计算新种群各个个体位置的适应度
    %    新适应度与个体历史最佳适应度做比较
    %    个体历史最佳适应度与种群历史最佳适应度做比较
    %    再次循环或结束
    
    iter = 1;                        %迭代次数
    times = 1;                       %用于显示,可舍弃
    record = zeros(ger, 1);          % 记录器
    while iter <= ger
        
        %    更新速度并对速度进行边界处理 
        pop_v =  c_1 * pop_v  + c_2 * rand *(gbest - pop_x) + c_3 * rand *(repmat(zbest, 1, sizepop) - pop_x);% 速度更新
        for i=1:dim 
            for j=1:sizepop
                if  pop_v(i,j)>vlimit(i,2)
                    pop_v(i,j)=vlimit(i,2);
                end
                if  pop_v(i,j) < vlimit(i,1)
                    pop_v(i,j)=vlimit(i,1);
                end
            end
        end 
        
        %    更新位置并对位置进行边界处理
        pop_x = pop_x + pop_v;% 位置更新
        % 边界位置处理
        for i=1:dim 
            for j=1:sizepop
                if  pop_x(i,j)>xlimit(i,2)
                    pop_x(i,j)=xlimit(i,2);
                end
                if  pop_x(i,j) < xlimit(i,1)
                    pop_x(i,j)=xlimit(i,1);
                end
            end
        end
        
        %    自适应变异
        for j=1:sizepop
            if rand > 0.85
                i=ceil(dim*rand);
                pop_x(i,j)=xlimit(i, 1) + (xlimit(i, 2) - xlimit(i, 1)) * rand;
            end
        end
        
        %    计算新种群各个个体位置的适应度
        fitness_pop = fun(pop_x(1,:),pop_x(2,:)) ; % 当前所有个体的适应度
        
        %    新适应度与个体历史最佳适应度做比较
        for j = 1:sizepop      
            if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
                gbest(:,j) = pop_x(:,j);               % 更新个体历史最佳位置            
                fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
            end 
        end
        
        %    个体历史最佳适应度与种群历史最佳适应度做比较
        for j = 1:sizepop  
            if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
                zbest = gbest(:,j);                    % 更新群体历史最佳位置  
                fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
            end
        end
        
        record(iter) = fitness_zbest;%最大值记录
        
        if times >= 10        %显示函数 可以舍去
            cla;
            mesh(x0_1, x0_2, y0);
            plot3(pop_x(1,:),pop_x(2,:),fun(pop_x(1,:),pop_x(2,:)), 'ro');title('状态位置变化');
            pause(0.5);
            times=0;
        end
        
        iter = iter+1;
        times=times+1;        %显示函数 可以舍去
    end
    %% 迭代结果输出
    
    figure(3);plot(record);title('收敛过程')
    figure(4);
    mesh(x0_1, x0_2, y0);
    hold on;
    plot3(pop_x(1,:),pop_x(2,:),fun(pop_x(1,:),pop_x(2,:)), 'ro');title('最终状态图');
    
    disp(['最优值:',num2str(fitness_zbest)]);
    disp('变量取值:');
    disp(zbest);
    
    

    2.自变量为n维向量的粒子群算法

    根据自变量为2位的粒子群算法的代码,我们可以很容易就类比出来自变量为n维的粒子群算法的代码。这里很多人对于这个类比过程不太擅长,那我把已经写好的5维的代码发出来供大家参考。

    %% 清空环境
    clc;clear all;close all;
    %% 目标函数
    %    下列函数为Rastrigin函数,是一个多峰值的函数,在0向量处取得全局最小值0
    fun= @(X)(sum((X.^2-10*cos(2*pi*X)+10),1));
    
    %% 设置种群参数
    %   需要自行配置
    sizepop = 500;                    % 初始种群个数
    dim = 5;                          % 空间维数
    ger = 200;                       % 最大迭代次数     
    xlimit_max = 5.12*ones(dim,1);    % 设置位置参数限制(矩阵的形式可以多维)
    xlimit_min = -5.12*ones(dim,1);
    vlimit_max = 1*ones(dim,1);       % 设置速度限制
    vlimit_min = -1*ones(dim,1);
    c_1 = 0.8;                        % 惯性权重
    c_2 = 0.5;                        % 自我学习因子
    c_3 = 0.5;                        % 群体学习因子 
    
    %% 生成初始种群
    %  首先随机生成初始种群位置
    %  然后随机生成初始种群速度
    %  然后初始化个体历史最佳位置,以及个体历史最佳适应度
    %  然后初始化群体历史最佳位置,以及群体历史最佳适应度
    for i=1:dim
        for j=1:sizepop
            pop_x(i,j) = xlimit_min(i)+(xlimit_max(i) - xlimit_min(i))*rand;
            pop_v(i,j) = vlimit_min(i)+(vlimit_max(i) - vlimit_min(i))*rand;  % 初始种群的速度
        end
    end    
    gbest = pop_x;                                % 每个个体的历史最佳位置
    fitness_gbest = fun(pop_x);                   % 每个个体的历史最佳适应度
    zbest = pop_x(:,1);                           % 种群的历史最佳位置
    fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
    for j=1:sizepop
        if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = pop_x(:,j);
            fitness_zbest=fitness_gbest(j);
        end
    end
    
    
    %% 粒子群迭代
    %    更新速度并对速度进行边界处理    
    %    更新位置并对位置进行边界处理
    %    进行自适应变异
    %    计算新种群各个个体位置的适应度
    %    新适应度与个体历史最佳适应度做比较
    %    个体历史最佳适应度与种群历史最佳适应度做比较
    %    再次循环或结束
    
    iter = 1;                        %迭代次数
    record = zeros(ger, 1);          % 记录器
    while iter <= ger
        for j=1:sizepop
            %    更新速度并对速度进行边界处理 
            pop_v(:,j)= c_1 * pop_v(:,j) + c_2*rand*(gbest(:,j)-pop_x(:,j))+c_3*rand*(zbest-pop_x(:,j));% 速度更新
            for i=1:dim
                if  pop_v(i,j) > vlimit_max(i)
                    pop_v(i,j) = vlimit_max(i);
                end
                if  pop_v(i,j) < vlimit_min(i)
                    pop_v(i,j) = vlimit_min(i);
                end
            end
            
            %    更新位置并对位置进行边界处理
            pop_x(:,j) = pop_x(:,j) + pop_v(:,j);% 位置更新
            for i=1:dim
                if  pop_x(i,j) > xlimit_max(i)
                    pop_x(i,j) = xlimit_max(i);
                end
                if  pop_x(i,j) < xlimit_min(i)
                    pop_x(i,j) = xlimit_min(i);
                end
            end
            
            %    进行自适应变异
            if rand > 0.85
                i=ceil(dim*rand);
                pop_x(i,j)=xlimit_min(i) + (xlimit_max(i) - xlimit_min(i)) * rand;
            end
      
            %    计算新种群各个个体位置的适应度
    
            fitness_pop(j) = fun(pop_x(:,j));                      % 当前个体的适应度
    
            
            %    新适应度与个体历史最佳适应度做比较
            if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
                gbest(:,j) = pop_x(:,j);               % 更新个体历史最佳位置            
                fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
            end   
            
            %    个体历史最佳适应度与种群历史最佳适应度做比较
            if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
                zbest = gbest(:,j);                    % 更新群体历史最佳位置  
                fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
            end    
        end
        
        record(iter) = fitness_zbest;%最大值记录
        
        iter = iter+1;
    
    end
    %% 迭代结果输出
    
    plot(record);title('收敛过程')
    disp(['最优值:',num2str(fitness_zbest)]);
    disp('变量取值:');
    disp(zbest);
    

    3.自变量为n维向量且存在约束条件的粒子群算法

    解决了输入为n维向量的粒子群算法的代码,接下来我们来看,当存在约束条件时,如何构造这个算法。这里采用的思想是,对每一个粒子进行判断,判断该粒子的取值是否满足约束条件,如果满足,则进行正常的适应度计算,如果不满足,则将该粒子的适应度直接赋值为一个很大的数(求最小值时赋值成大数,求最大值时应该赋值成小数)。具体代码实现如下:

    %% 清空环境
    clc;clear all;close all;
    %% 目标函数
    %    下列函数为:
    %    y=0.072*x1+0.063*x2+0.057*x3+0.05*x4+0.032*x5+0.0442*x6+0.0675*x7+7
    %    约束条件为:
    %    0.072*x1+0.063*x2+0.057*x3+0.05*x4+0.032*x5+0.0442*x6+0.0675*x7<=264.4
    %    128*x1+78.1*x2+64.1*x3+43*x4+58.1*x5+36.9*x6+50.5*x7<=67919
    a=[0.072,0.063,0.057,0.05,0.032,0.0442,0.0675];
    b=[0.072,0.063,0.057,0.005,0.032,0.0442,0.0675];
    c=[128,78.1,64.1,43,58.1,36.9,50.5];
    fun= @(X)(a*X+7);
    cons1= @(X)(b*X<=264.4);
    cons2= @(X)(c*X>=-20);
    %% 设置种群参数
    %   需要自行配置
    sizepop = 500;                         % 初始种群个数
    dim = 7;                           % 空间维数
    ger = 500;                       % 最大迭代次数    
    xlimit_max = 50*ones(dim,1);     % 设置位置参数限制(矩阵的形式可以多维)
    xlimit_min = -50*ones(dim,1);
    vlimit_max = 1*ones(dim,1);      % 设置速度限制
    vlimit_min = -1*ones(dim,1);
    c_1 = 0.8;                       % 惯性权重
    c_2 = 0.5;                       % 自我学习因子
    c_3 = 0.5;                       % 群体学习因子 
    
    %% 生成初始种群
    %  首先随机生成初始种群位置
    %  然后随机生成初始种群速度
    %  然后初始化个体历史最佳位置,以及个体历史最佳适应度
    %  然后初始化群体历史最佳位置,以及群体历史最佳适应度
    for i=1:dim
        for j=1:sizepop
            pop_x(i,j) = xlimit_min(i)+(xlimit_max(i) - xlimit_min(i))*rand;  % 初始种群的位置
            pop_v(i,j) = vlimit_min(i)+(vlimit_max(i) - vlimit_min(i))*rand;  % 初始种群的速度
        end
    end                 
    gbest = pop_x;                                % 每个个体的历史最佳位置
    for j=1:sizepop
        if cons1(pop_x(:,j))
            if cons2(pop_x(:,j))
                fitness_gbest(j) = fun(pop_x(:,j));                      % 每个个体的历史最佳适应度
            else
                fitness_gbest(j) = 10^10; 
            end
        else
            fitness_gbest(j) = 10^10; 
        end  
    end                  
    zbest = pop_x(:,1);                           % 种群的历史最佳位置
    fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
    for j=1:sizepop
        if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = pop_x(:,j);
            fitness_zbest=fitness_gbest(j);
        end
    end
    
    
    %% 粒子群迭代
    %    更新速度并对速度进行边界处理    
    %    更新位置并对位置进行边界处理
    %    进行自适应变异
    %    进行约束条件判断并计算新种群各个个体位置的适应度
    %    新适应度与个体历史最佳适应度做比较
    %    个体历史最佳适应度与种群历史最佳适应度做比较
    %    再次循环或结束
    
    iter = 1;                        %迭代次数
    record = zeros(ger, 1);          % 记录器
    while iter <= ger
        for j=1:sizepop
            %    更新速度并对速度进行边界处理 
            pop_v(:,j)= c_1 * pop_v(:,j) + c_2*rand*(gbest(:,j)-pop_x(:,j))+c_3*rand*(zbest-pop_x(:,j));% 速度更新
            for i=1:dim
                if  pop_v(i,j) > vlimit_max(i)
                    pop_v(i,j) = vlimit_max(i);
                end
                if  pop_v(i,j) < vlimit_min(i)
                    pop_v(i,j) = vlimit_min(i);
                end
            end
            
            %    更新位置并对位置进行边界处理
            pop_x(:,j) = pop_x(:,j) + pop_v(:,j);% 位置更新
            for i=1:dim
                if  pop_x(i,j) > xlimit_max(i)
                    pop_x(i,j) = xlimit_max(i);
                end
                if  pop_x(i,j) < xlimit_min(i)
                    pop_x(i,j) = xlimit_min(i);
                end
            end
            
            %    进行自适应变异
            if rand > 0.85
                i=ceil(dim*rand);
                pop_x(i,j)=xlimit_min(i) + (xlimit_max(i) - xlimit_min(i)) * rand;
            end
      
            %    进行约束条件判断并计算新种群各个个体位置的适应度
            if cons1(pop_x(:,j))
                if cons2(pop_x(:,j))
                    fitness_pop(j) = fun(pop_x(:,j));                      % 当前个体的适应度
                else
                    fitness_pop(j) = 10^10; 
                end
            else
                fitness_pop(j) = 10^10; 
            end
            
            %    新适应度与个体历史最佳适应度做比较
            if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
                gbest(:,j) = pop_x(:,j);               % 更新个体历史最佳位置            
                fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
            end   
            
            %    个体历史最佳适应度与种群历史最佳适应度做比较
            if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
                zbest = gbest(:,j);                    % 更新群体历史最佳位置  
                fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
            end    
        end
        
        record(iter) = fitness_zbest;%最大值记录
        
        iter = iter+1;
    
    end
    %% 迭代结果输出
    
    plot(record);title('收敛过程')
    disp(['最优值:',num2str(fitness_zbest)]);
    disp('变量取值:');
    disp(zbest);
    

    4.自变量为n*n维矩阵且存在约束条件的粒子群算法

    有些网友说,自己所要解决的情况,输入变量不仅仅是一个n维的向量,而是一个n*n维的矩阵,甚至n*n*n*…维的空间矩阵。想要采用粒子群算法,该如何实现呢?
    其实每一个n*n维矩阵,可以看成是n维向量,每个向量的元素又是一个向量,这样不断嵌套得到的。因此总的来说,整个代码的框架并没有太大的变化,仅仅是将原来的计算多嵌套几层就好。
    代码如下:

    %% 清空环境
    clc;clear all;close all;
    %% 目标函数
    %    该函数的变量是一个3*4的矩阵形式的变量
    %    cons1=@(X)(1);表示无约束条件
    %    cons1=@(X)(sum(sum(X))>=0);可以尝试添加约束条件
    a=[2.5,4.5,-2];
    b=[2;4.2;4;-4];
    c=[1,2,3,4;-4,-3,-2,-1;1,3,2,4];
    fun= @(X)(sum(sum(c.*X.^2))+a*X*b);
    cons1=@(X)(sum(sum(X))>=0);    
    %% 设置种群参数
    %   需要自行配置
    %   下文中所有出现dim2,或者:的地方,都需要根据实际的矩阵维度来进行更改
    sizepop = 500;                         % 初始种群个数
    dim1 = 3;                           % 空间维数
    dim2 = 4;
    ger = 500;                       % 最大迭代次数    
    xlimit_max = 50*ones(dim1,dim2,1);     % 设置位置参数限制(矩阵的形式可以多维)
    xlimit_min = -50*ones(dim1,dim2,1);
    vlimit_max = 1*ones(dim1,dim2,1);      % 设置速度限制
    vlimit_min = -1*ones(dim1,dim2,1);
    c_1 = 0.8;                       % 惯性权重
    c_2 = 0.5;                       % 自我学习因子
    c_3 = 0.5;                       % 群体学习因子 
    
    %% 生成初始种群
    %  首先随机生成初始种群位置
    %  然后随机生成初始种群速度
    %  然后初始化个体历史最佳位置,以及个体历史最佳适应度
    %  然后初始化群体历史最佳位置,以及群体历史最佳适应度
    for i_1=1:dim1
        for i_2=1:dim2      
            for j=1:sizepop
                pop_x(i_1,i_2,j) = xlimit_min(i_1,i_2)+(xlimit_max(i_1,i_2) - xlimit_min(i_1,i_2))*rand;  % 初始种群的位置
                pop_v(i_1,i_2,j) = vlimit_min(i_1,i_2)+(vlimit_max(i_1,i_2) - vlimit_min(i_1,i_2))*rand;  % 初始种群的速度
            end
        end
    end                 
    gbest = pop_x;                                % 每个个体的历史最佳位置
    for j=1:sizepop                               % 每个个体的历史最佳适应度
        if cons1(pop_x(:,:,j))                      % 约束条件       
            fitness_gbest(j)=fun(pop_x(:,:,j));                    
        else
            fitness_gbest(j) = 10^10; 
        end  
    end   
    zbest = pop_x(:,:,1);                           % 种群的历史最佳位置
    fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
    for j=1:sizepop
        if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = pop_x(:,:,j);
            fitness_zbest=fitness_gbest(j);
        end
    end
    
    
    %% 粒子群迭代
    %    更新速度并对速度进行边界处理    
    %    更新位置并对位置进行边界处理
    %    进行自适应变异
    %    进行约束条件判断并计算新种群各个个体位置的适应度
    %    新适应度与个体历史最佳适应度做比较
    %    个体历史最佳适应度与种群历史最佳适应度做比较
    %    再次循环或结束
    
    iter = 1;                        %迭代次数
    record = zeros(ger, 1);          % 记录器
    while iter <= ger
        for j=1:sizepop
            %    更新速度并对速度进行边界处理 
            pop_v(:,:,j)= c_1 * pop_v(:,:,j) + c_2*rand*(gbest(:,:,j)-pop_x(:,:,j))+c_3*rand*(zbest-pop_x(:,:,j));% 速度更新
            for i_1=1:dim1
                for i_2=1:dim2
                    if  pop_v(i_1,i_2,j) > vlimit_max(i_1,i_2)
                        pop_v(i_1,i_2,j) = vlimit_max(i_1,i_2);
                    end
                    if  pop_v(i_1,i_2,j) < vlimit_min(i_1,i_2)
                        pop_v(i_1,i_2,j) = vlimit_min(i_1,i_2);
                    end                
                end
            end
            
            %    更新位置并对位置进行边界处理
            pop_x(:,:,j) = pop_x(:,:,j) + pop_v(:,:,j);% 位置更新
            for i_1=1:dim1
                for i_2=1:dim2
                    if  pop_x(i_1,i_2,j) > xlimit_max(i_1,i_2)
                        pop_x(i_1,i_2,j) = xlimit_max(i_1,i_2);
                    end
                    if  pop_x(i_1,i_2,j) < xlimit_min(i_1,i_2)
                        pop_x(i_1,i_2,j) = xlimit_min(i_1,i_2);
                    end
                end
            end
            
            %    进行自适应变异
            if rand > 0.85
                i_1=ceil(dim1*rand);
                i_2=ceil(dim2*rand);
                pop_x(i_1,i_2,j)=xlimit_min(i_1,i_2) + (xlimit_max(i_1,i_2) - xlimit_min(i_1,i_2)) * rand;
            end
          
      
            %    进行约束条件判断并计算新种群各个个体位置的适应度
            if cons1(pop_x(:,:,j))                                       % 约束条件
                fitness_pop(j) = fun(pop_x(:,:,j));                      % 当前个体的适应度
            else
                fitness_pop(j) = 10^10; 
            end
            
            %    新适应度与个体历史最佳适应度做比较
            if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
                gbest(:,:,j) = pop_x(:,:,j);               % 更新个体历史最佳位置            
                fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
            end   
            
            %    个体历史最佳适应度与种群历史最佳适应度做比较
            if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
                zbest = gbest(:,:,j);                    % 更新群体历史最佳位置  
                fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
            end    
        end
        
        record(iter) = fitness_zbest;%最大值记录
        
        iter = iter+1;
    
    end
    %% 迭代结果输出
    
    plot(record);title('收敛过程')
    disp(['最优值:',num2str(fitness_zbest)]);
    disp('变量取值:');
    disp(zbest);
    
    展开全文
  • 粒子群算法matlab

    2017-10-31 20:32:44
    粒子群算法matlab粒子群算法matlab粒子群算法matlab
  • matlab 粒子群算法优化神经网络预测 直接使用 可用于流量预测等
  • matlab代码粒子群算法-FSAPSO发表在《应用软计算》上的论文“用于计算昂贵问题的快速替代辅助粒子群优化算法”的MATLAB代码。
  • matlab代码粒子群算法粒子群优化 这是用Matlab编写的基本PSO算法。 该代码是矢量化的,可以选择使用并行计算工具箱。 包括演示和示例。 这是学习如何实现PSO算法的一个很好的例子,适用于大规模非线性系统参数估计的...
  • MATLAB粒子群算法

    2018-03-31 10:10:30
    如何开发粒子群算法,运用改进粒子群算法解决规划问题,附带程序。
  • matlab代码粒子群算法粒子群优化:最新技术 [pso](使用python) PSO算法的基本变体是通过拥有一组候选解决方案(称为粒子)(称为“群”)来工作的。 群:这些粒子根据一些简单的公式在搜索空间移动。 粒子的运动...
  • matlab代码粒子群算法动态PSO-LA 基于三动作学习自动机(DPSOLA)算法的动态全局和局部组合粒子群优化算法的Matlab代码。 抽象的 最近已经开发了许多粒子群优化(PSO)算法的变体,其最大目的是摆脱局部极小值。 ...
  • matlab代码粒子群算法粒子群优化 PSO算法在MATLAB中进行了编码,并经过了Rosenbrock,Peaks和Drop Wave函数的测试。 每个文件都有3个不同的文件,以避免混淆。
  • matlab代码粒子群算法
  • matlab代码粒子群算法该存储库由各种基准问题(球形,Rastrigin,Ackley和其他函数)的Matlab源代码组成,这些源代码使用各种受生物启发的进化算法(例如PSO(粒子群优化),遗传算法,差异进化和TLBO(基于老师学习...
  • matlab代码粒子群算法
  • matlab代码粒子群算法FOA 森林优化算法-Matlab代码 土井: 网址: 文章摘要: 在本文,提出了一种适用于连续非线性优化问题的新进化算法,即森林优化算法(FOA)。 它的灵感来自森林几棵可以存活数十年的树木,...
  • matlab代码粒子群算法多网格等距再分析(MG-IGR) 论文的MATLAB代码“一种有效的基于辅助投影的多网格等距重新分析方法及其在优化框架的应用”。 安装说明 确保已安装用于MATLAB的CALFEM,请参见。 要安装IGA工具...
  • matlab粒子群算法教程

    2018-05-10 12:58:45
    matlab粒子群教程,详细介绍粒子群算法原理及matlab代码。

空空如也

空空如也

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

matlab中粒子群算法

matlab 订阅