精华内容
下载资源
问答
  • 有约束的基于适应度和连续世代策略的混沌自适应粒子群算法,利用混沌系统产生混沌粒子群,利用混合自适应策略调节每个粒子的惯性因子和种群规模,利用惩罚函数法去处理约束条件,融合多种改进方案,实现了收敛速度和...
  • 自适应粒子群算法

    2018-07-24 19:09:02
    关于自适应粒子群算法MATLAB代码,过程很详细,适合初学者学习。
  • 一些关于粒子群算法的文献-一种动态改变惯性权的自适应粒子群算法.pdf 关于粒子群算法的一些期刊论文
  • 为了实现启发式优化算法的自适应参数调整, 避免算法陷入局部最优,提高算法的精度为解决参数辨识问题,采用自适应模糊粒子群算法(AFPSO)提出了从自动调整的三个方面对基本算法进行改进的建议参数,种群拓扑和突变...
  • 一、粒子群算法 粒子群算法是在1995年由Eberhart博士和Kennedy博士一起提出的,它源于对鸟群捕食行为的研究。它的基本核心是利用群体中的个体对信息的共享从而使整个群体的运动在问题求解空间中产生从无序到有序的...

     一、粒子群算法

    粒子群算法是在1995年由Eberhart博士和Kennedy博士一起提出的,它源于对鸟群捕食行为的研究。它的基本核心是利用群体中的个体对信息的共享从而使整个群体的运动在问题求解空间中产生从无序到有序的演化过程,从而获得问题的最优解。设想这么一个场景:一群鸟进行觅食,而远处有一片玉米地,所有的鸟都不知道玉米地到底在哪里,但是它们知道自己当前的位置距离玉米地有多远。那么找到玉米地的最佳策略,也是最简单有效的策略就是搜寻目前距离玉米地最近的鸟群的周围区域。

    在PSO中,每个优化问题的解都是搜索空间中的一只鸟,称之为"粒子",而问题的最优解就对应于鸟群中寻找的"玉米地"。所有的粒子都具有一个位置向量(粒子在解空间的位置)和速度向量(决定下次飞行的方向和速度),并可以根据目标函数来计算当前的所在位置的适应值(fitness value),可以将其理解为距离"玉米地"的距离。在每次的迭代中,种群中的例子除了根据自身的经验(历史位置)进行学习以外,还可以根据种群中最优粒子的"经验"来学习,从而确定下一次迭代时需要如何调整和改变飞行的方向和速度。就这样逐步迭代,最终整个种群的例子就会逐步趋于最优解。

    上面的解释可能还比较抽象,下面通过一个简单的例子来进行说明

    在一个湖中有两个人他们之间可以通信,并且可以探测到自己所在位置的最低点。初始位置如上图所示,由于右边比较深,因此左边的人会往右边移动一下小船。

    现在左边比较深,因此右边的人会往左边移动一下小船

    一直重复该过程,最后两个小船会相遇

    得到一个局部的最优解

    将每个个体表示为粒子。每个个体在某一时刻的位置表示为,x(t),方向表示为v(t)

    p(t)为在t时刻x个体的自己的最优解,g(t)为在t时刻所有个体的最优解,v(t)为个体在t时刻的方向,x(t)为个体在t时刻的位置

    下一个位置为上图所示由x,p,g共同决定了

    种群中的粒子通过不断地向自身和种群的历史信息进行学习,从而可以找到问题的最优解。

    但是,在后续的研究中表表明,上述原始的公式中存在一个问题:公式中V的更新太具有随机性,从而使整个PSO算法的全局优化能力很强,但是局部搜索能力较差。而实际上,我们需要在算法迭代初期PSO有着较强的全局优化能力,而在算法的后期,整个种群应该具有更强的局部搜索能力。所以根据上述的弊端,shi和Eberhart通过引入惯性权重修改了公式,从而提出了PSO的惯性权重模型:

    每一个向量的分量表示如下

    其中w称为是PSO的惯性权重,它的取值介于【0,1】区间,一般应用中均采用自适应的取值方法,即一开始令w=0.9,使得PSO全局优化能力较强,随着迭代的深入,参数w进行递减,从而使的PSO具有较强的局部优化能力,当迭代结束时,w=0.1。参数c1和c2称为学习因子,一般设置为1,4961;而r1和r2为介于[0,1]之间的随机概率值。

    整个粒子群优化算法的算法框架如下:

    step1种群初始化,可以进行随机初始化或者根据被优化的问题设计特定的初始化方法,然后计算个体的适应值,从而选择出个体的局部最优位置向量和种群的全局最优位置向量。

    step2 迭代设置:设置迭代次数,并令当前迭代次数为1

    step3 速度更新:更新每个个体的速度向量

    step4 位置更新:更新每个个体的位置向量

    step5 局部位置和全局位置向量更新:更新每个个体的局部最优解和种群的全局最优解

    step6 终止条件判断:判断迭代次数时都达到最大迭代次数,如果满足,输出全局最优解,否则继续进行迭代,跳转至step 3。

      对于粒子群优化算法的运用,主要是对速度和位置向量迭代算子的设计。迭代算子是否有效将决定整个PSO算法性能的优劣,所以如何设计PSO的迭代算子是PSO算法应用的研究重点和难点。

    二、曲线递增策略的自适应粒子群算法研究(CIPSO)

           群智能算法以其动态寻优能力强、实现途径简单等特点不断成为进化算法领域的研究热点。控参的选择对算法寻优性能有着极大影响,首先从数学推导角度对粒子群参数进行深入研究,接着提出一种契合粒子本身进化公式的,且具有反向思维的曲线递增策略的改进算法。最后验证该算法具备以下两点突出优势:a)有效避免早熟问题,在处理维度灾难问题上,寻优性能更强,且具备良好的平衡全局与局部寻优性能; b)算法控参简单,可有效解决鲁棒性低且繁琐的人工调参问题。 

    三、部分代码

    function [gbest,gbestval,fitcount]= CLPSO_new_func(fhd,Max_Gen,Max_FES,Particle_Number,Dimension,VRmin,VRmax,varargin)
    %[gbest,gbestval,fitcount]= CLPSO_new_func('f8',3500,200000,30,30,-5.12,5.12)
    rand('state',sum(100*clock));
    me=Max_Gen;
    ps=Particle_Number;
    D=Dimension;
    cc=[1 1];   %acceleration constants
    t=0:1/(ps-1):1;t=5.*t;
    Pc=0.0+(0.5-0.0).*(exp(t)-exp(t(1)))./(exp(t(ps))-exp(t(1)));
    % Pc=0.5.*ones(1,ps);
    m=0.*ones(ps,1);
    iwt=0.9-(1:me)*(0.7/me);
    % iwt=0.729-(1:me)*(0.0/me);
    cc=[1.49445 1.49445];
    if length(VRmin)==1
        VRmin=repmat(VRmin,1,D);
        VRmax=repmat(VRmax,1,D);
    end
    mv=0.2*(VRmax-VRmin);
    VRmin=repmat(VRmin,ps,1);
    VRmax=repmat(VRmax,ps,1);
    Vmin=repmat(-mv,ps,1);
    Vmax=-Vmin;
    pos=VRmin+(VRmax-VRmin).*rand(ps,D);
    
    for i=1:ps;
        e(i,1)=feval(fhd,pos(i,:),varargin{:});
    end
    
    fitcount=ps;
    vel=Vmin+2.*Vmax.*rand(ps,D);%initialize the velocity of the particles
    pbest=pos;
    pbestval=e; %initialize the pbest and the pbest's fitness value
    [gbestval,gbestid]=min(pbestval);
    gbest=pbest(gbestid,:);%initialize the gbest and the gbest's fitness value
    gbestrep=repmat(gbest,ps,1);
    
    stay_num=zeros(ps,1);
    
    ai=zeros(ps,D);
    f_pbest=1:ps;f_pbest=repmat(f_pbest',1,D);
    for k=1:ps
        ar=randperm(D);
        ai(k,ar(1:m(k)))=1;
        fi1=ceil(ps*rand(1,D));
        fi2=ceil(ps*rand(1,D));
        fi=(pbestval(fi1)<pbestval(fi2))'.*fi1+(pbestval(fi1)>=pbestval(fi2))'.*fi2;
        bi=ceil(rand(1,D)-1+Pc(k));
        if bi==zeros(1,D),rc=randperm(D);bi(rc(1))=1;end
        f_pbest(k,:)=bi.*fi+(1-bi).*f_pbest(k,:);
    end
    
    stop_num=0;
    i=1;
    
    
    while i<=me&fitcount<=Max_FES
        i=i+1;
        for k=1:ps
            
            if stay_num(k)>=5
                %     if round(i/10)==i/10%|stay_num(k)>=5
                stay_num(k)=0;
                ai(k,:)=zeros(1,D);
                f_pbest(k,:)=k.*ones(1,D);
                ar=randperm(D);
                ai(k,ar(1:m(k)))=1;
                fi1=ceil(ps*rand(1,D));
                fi2=ceil(ps*rand(1,D));
                fi=(pbestval(fi1)<pbestval(fi2))'.*fi1+(pbestval(fi1)>=pbestval(fi2))'.*fi2;
                bi=ceil(rand(1,D)-1+Pc(k));
                if bi==zeros(1,D),rc=randperm(D);bi(rc(1))=1;end
                f_pbest(k,:)=bi.*fi+(1-bi).*f_pbest(k,:);
            end
            
            for dimcnt=1:D
                pbest_f(k,dimcnt)=pbest(f_pbest(k,dimcnt),dimcnt);
            end
            aa(k,:)=cc(1).*(1-ai(k,:)).*rand(1,D).*(pbest_f(k,:)-pos(k,:))+cc(2).*ai(k,:).*rand(1,D).*(gbestrep(k,:)-pos(k,:));%~~~~~~~~~~~~~~~~~~~~~~
            vel(k,:)=iwt(i).*vel(k,:)+aa(k,:);
            vel(k,:)=(vel(k,:)>mv).*mv+(vel(k,:)<=mv).*vel(k,:);
            vel(k,:)=(vel(k,:)<(-mv)).*(-mv)+(vel(k,:)>=(-mv)).*vel(k,:);
            pos(k,:)=pos(k,:)+vel(k,:);
            
            if (sum(pos(k,:)>VRmax(k,:))+sum(pos(k,:)<VRmin(k,:)))==0;
                e(k,1)=feval(fhd,pos(k,:),varargin{:});
                fitcount=fitcount+1;
                tmp=(pbestval(k)<=e(k));
                if tmp==1
                    stay_num(k)=stay_num(k)+1;
                end
                temp=repmat(tmp,1,D);
                pbest(k,:)=temp.*pbest(k,:)+(1-temp).*pos(k,:);
                pbestval(k)=tmp.*pbestval(k)+(1-tmp).*e(k);%update the pbest
                if pbestval(k)<gbestval
                    gbest=pbest(k,:);
                    gbestval=pbestval(k);
                    gbestrep=repmat(gbest,ps,1);%update the gbest
                end
            end
            
        end
        
        % if round(i/100)==i/100
        %     plot(pos(:,D-1),pos(:,D),'b*');hold on;
        %     for k=1:floor(D/2)
        %         plot(gbest(:,2*k-1),gbest(:,2*k),'r*');
        %     end
        %     hold off
        %     title(['PSO: ',num2str(i),' generations, Gbestval=',num2str(gbestval)]);
        %     axis([VRmin(1,D-1),VRmax(1,D-1),VRmin(1,D),VRmax(1,D)])
        %     drawnow
        % end
        
        if fitcount>=Max_FES
            break;
        end
        if (i==me)&(fitcount<Max_FES)
            i=i-1;
        end
    end
    gbestval
    
    
    

    四、仿真结果 

     五、参考文献

     [1]吴凡,洪思,杨冰,胡贤夫.一种曲线递增策略的自适应粒子群算法研究[J/OL].计算机应用研究,{3},{4}{5}:1-6[2021-07-14].https://doi.org/10.19734/j.issn.1001-3695.2020.09.0235.

     》》  喜欢可以关注我

    展开全文
  • % 改进的快速粒子群优化算法 (APSO):function apsoLb=[0.1 0.10.10.1]; %下边界Ub=[2.0 10.0 10.0 2.0]; %上边界% 默认参数para=[25 150 0.95]; %[粒子数,迭代次数,gama参数]% APSO 优化求解函数[gbest,fmin]=pso_...

    % 改进的快速粒子群优化算法 (APSO):

    function apso

    Lb=[0.1 0.1  0.1  0.1]; %下边界

    Ub=[2.0 10.0 10.0 2.0]; %上边界

    % 默认参数

    para=[25 150 0.95]; %[粒子数,迭代次数,gama参数]

    % APSO 优化求解函数

    [gbest,fmin]=pso_mincon(@cost,@constraint,Lb,Ub,para);

    % 输出结果

    Bestsolution=gbest % 全局最优个体

    fmin

    %% 目标函数

    function f=cost(x)

    f=1.10471*x(1)^2*x(2)+0.04811*x(3)*x(4)*(14.0+x(2));

    % 非线性约束

    function [g,geq]=constraint(x)

    % 不等式限制条件

    Q=6000*(14+x(2)/2);

    D=sqrt(x(2)^2/4+(x(1)+x(3))^2/4);

    J=2*(x(1)*x(2)*sqrt(2)*(x(2)^2/12+(x(1)+x(3))^2/4));

    alpha=6000/(sqrt(2)*x(1)*x(2));

    beta=Q*D/J;

    tau=sqrt(alpha^2+2*alpha*beta*x(2)/(2*D)+beta^2);

    sigma=504000/(x(4)*x(3)^2);

    delta=65856000/(30*10^6*x(4)*x(3)^3);

    F=4.013*(30*10^6)/196*sqrt(x(3)^2*x(4)^6/36)*(1-x(3)*sqrt(30/48)/28);

    g(1)=tau-13600;

    g(2)=sigma-30000;

    g(3)=x(1)-x(4);

    g(4)=0.10471*x(1)^2+0.04811*x(3)*x(4)*(14+x(2))-5.0;

    g(5)=0.125-x(1);

    g(6)=delta-0.25;

    g(7)=6000-F;

    % 如果没有等式约束,则置geq=[];

    geq=[];

    %%  APSO Solver

    function [gbest,fbest]=pso_mincon(fhandle,fnonlin,Lb,Ub,para)

    if nargin<=4,

    para=[20 150 0.95];

    end

    n=para(1);% 粒子种群大小

    time=para(2); %时间步长,迭代次数

    gamma=para(3); %gama参数

    scale=abs(Ub-Lb); %取值区间

    % 验证约束条件是否合乎条件

    if abs(length(Lb)-length(Ub))>0,

    disp('Constraints must have equal size');

    return

    end

    alpha=0.2; % alpha=[0,1]粒子随机衰减因子

    beta=0.5;  % 收敛速度(0->1)=(slow->fast);

    % 初始化粒子群

    best=init_pso(n,Lb,Ub);

    fbest=1.0e+100;

    % 迭代开始

    for t=1:time,

    %寻找全局最优个体

    for i=1:n,

    fval=Fun(fhandle,fnonlin,best(i,:));

    % 更新最有个体

    if fval<=fbest,

    gbest=best(i,:);

    fbest=fval;

    end

    end

    % 随机性衰减因子

    alpha=newPara(alpha,gamma);

    % 更新粒子位置

    best=pso_move(best,gbest,alpha,beta,Lb,Ub);

    % 结果显示

    str=strcat('Best estimates: gbest=',num2str(gbest));

    str=strcat(str,'  iteration='); str=strcat(str,num2str(t));

    disp(str);

    fitness1(t)=fbest;

    plot(fitness1,'r','Linewidth',2)

    grid on

    hold on

    title('适应度')

    end

    % 初始化粒子函数

    function [guess]=init_pso(n,Lb,Ub)

    ndim=length(Lb);

    for i=1:n,

    guess(i,1:ndim)=Lb+rand(1,ndim).*(Ub-Lb);

    end

    %更新所有的粒子 toward (xo,yo)

    function ns=pso_move(best,gbest,alpha,beta,Lb,Ub)

    % 增加粒子在上下边界区间内的随机性

    n=size(best,1); ndim=size(best,2);

    scale=(Ub-Lb);

    for i=1:n,

    ns(i,:)=best(i,:)+beta*(gbest-best(i,:))+alpha.*randn(1,ndim).*scale;

    end

    ns=findrange(ns,Lb,Ub);

    % 边界函数

    function ns=findrange(ns,Lb,Ub)

    n=length(ns);

    for i=1:n,

    % 下边界约束

    ns_tmp=ns(i,:);

    I=ns_tmp

    ns_tmp(I)=Lb(I);

    % 上边界约束

    J=ns_tmp>Ub;

    ns_tmp(J)=Ub(J);

    %更新粒子

    ns(i,:)=ns_tmp;

    end

    % 随机性衰减因子

    function alpha=newPara(alpha,gamma);

    alpha=alpha*gamma;

    % 带约束的d维目标函数的求解

    function z=Fun(fhandle,fnonlin,u)

    % 目标

    z=fhandle(u);

    z=z+getconstraints(fnonlin,u); % 非线性约束

    function Z=getconstraints(fnonlin,u)

    % 罚常数 >> 1

    PEN=10^15;

    lam=PEN; lameq=PEN;

    Z=0;

    % 非线性约束

    [g,geq]=fnonlin(u);

    %通过不等式约束建立罚函数

    for k=1:length(g),

    Z=Z+ lam*g(k)^2*getH(g(k));

    end

    % 等式条件约束

    for k=1:length(geq),

    Z=Z+lameq*geq(k)^2*geteqH(geq(k));

    end

    % Test if inequalities

    function H=getH(g)

    if g<=0,

    H=0;

    else

    H=1;

    end

    % Test if equalities hold

    function H=geteqH(g)

    if g==0,

    H=0;

    else

    H=1;

    end

    展开全文
  • 本人最近写了一篇以信噪比为适应度函数的自适应粒子群优化算法Matlab Code,但是运行总是出错误,恳求哪位Matlab大神帮忙看看 修改修改,谢谢。信噪比SNR适应度函数:function SNR=fitness(x)N=20000;fs=20;h=1/fs;T...

    本人最近写了一篇以信噪比为适应度函数的自适应粒子群优化算法Matlab Code,但是运行总是出错误,恳求哪位Matlab大神帮忙看看 修改修改,谢谢。

    信噪比SNR适应度函数:

    function SNR=fitness(x)

    N=20000;

    fs=20;

    h=1/fs;

    T=(0:N-1)*h;

    AL=0.1;

    fL=0.01;

    u=AL*sin(2*pi*fL.*T);

    D=0.5;   %噪声强度

    ff=fs*(0:N/100-1)/N;

    sz=sqrt(2*D).*randn(1,N);   %产生的白噪声序列

    s=u+sz;         %信号

    xx(1,:)=sr(x(1),x(2),h,s);

    Yf=fft(xx(1,:));

    P=Yf.*conj(Yf)/N;   %功率谱

    G=sum(P);

    H=P(11);

    GG=(G-H)/10;

    SNR=10*log(H/GG)/log(10);  %以SNR作为适应度函数

    非线性微分方程离散并求解的数值算法:

    function x=sr(a,b,h,x1)

    x=zeros(1,length(x1));

    for i=1:length(x1)-1

    k1=h*(x(1)*x(i)-x(2)*x(i).^3+x1(i));

    k2=h*(x(1)*(x(i)+k1/2)-x(2)*(x(i)+k1/2).^3+x1(i));

    k3=h*(x(1)*(x(i)+k2/2)-x(2)*(x(i)+(sqrt(2)-1)*k1/2+(2-sqrt(2))*k2/2).^3+x1(i+1));

    k4=h*(x(1)*(x(i)+k3)-x(2)*(x(i)-sqrt(2)*k2/2+(2+sqrt(2))*k3/2).^3+x1(i+1));

    x(i+1)=x(i)+(1/6)*(k1+(2-sqrt(2))*k2+(2+sqrt(2))*k3+k4);

    end

    主函数:

    clear all;

    clc;

    format long;

    %------给定初始化条件-------------------

    c1=2;             %学习因子1

    c2=2;             %学习因子2

    wmax=0.9;              %惯性权重

    wmin=0.6;              %惯性权重

    MaxDT=100;            %最大迭代次数

    D=2;                  %搜索空间维数(未知数个数)

    N=40;                  %初始化群体个体数目

    eps=10^(-6);           %设置精度(在已知最小值时候用)

    %------初始化种群的个体(可以在这里限定位置和速度的范围)------------

    for i=1:N

    for j=1:D

    x(i,j)=rand(1);  %随机初始化位置

    v(i,j)=rand(1);  %随机初始化速度

    end

    end

    for i=1:N

    p(i)=fitness(x(i,:));

    y(i,:)=x(i,:);

    end

    pg=x(1,:);             %Pg为全局最优

    for i=2:N

    if fitness(x(i,:))

    pg=x(i,:);

    end

    end

    for t=1:MaxDT

    for j=1:N

    fv(j)=fitness(x(j,:));

    end

    fvag=sum(fv)/N;

    fmin=min(fv);

    for i=1:N

    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 x(i,1)>1||x(i,1)<0

    x(i,1)=rand(1);

    end

    if x(i,2)>1||x(i,2)<0

    x(i,2)=rand(1);

    end

    if fitness(x(i,:))

    p(i)=fitness(x(i,:));

    y(i,:)=x(i,:);

    end

    if p(i)

    pg=y(i,:);

    end

    end

    Pbest(t)=fitness(pg);

    end

    %------最后从所得到的结果中取出最优的解

    disp('*************************************************************')

    disp('函数的全局最优位置为:')

    Solution=pg'

    disp('最后得到的优化极值为:')

    Result=fitness(pg)

    disp('*************************************************************')

    figure(1)

    r=[1:1:100];

    plot(r,Pbest,'r--','linewidth',1);

    xlabel('迭代次数')

    ylabel('适应度值')

    title('自适应权重PSO算法')

    hold on

    Solution=pg'

    Result=fitness(pg)

    figure(2)

    plot(x,'DisplayName','x')

    axis([0,40,-5,5])

    %------算法结束---DreamSun GL & HF,适应度函数源程序(fitness.m)------------

    展开全文
  • 粒子群算法,又称粒子群优化算法(Partical Swarm Optimization),缩写为 PSO, 是近年来发展起来的一种新的进化算法(Evolutionary Algorithm - EA),由Eberhart 博士和kennedy 博士于1995年提出,其源于对鸟群...
  • 针对基本粒子群优化算法稳定性较差和易陷入局部收敛的缺点,提出了一种基于群体适应度方差的自适应粒子群优化算法。一方面,在可行域中采用混沌初始化生成均匀分布的粒群,提高了初始解的质量;另一方面,构造了基于...
  • Matlab自适应协同粒子群优化算法(ACPSO)算法。 抽象的 介绍了一种自适应合作粒子群优化器(ACPSO),它通过学习自动机(LA)算法为合作技术提供了便利。 ACPSO的合作学习策略可以协同优化问题,并在不同情况下对...
  • matlab代码粒子群算法自适应CLPSO Matlab代码用于宏观自适应综合学习粒子群优化器(MaPSO)和微观自适应综合学习粒子群优化器(MiPSO)算法。 抽象的 优化启发式算法(如粒子群优化器(PSO))的广泛使用对参数...
  • 粒子群算法matlab以求解函数最优解为例 clear; clc; close all; N=100; %粒子个数 D=2; %粒子维数 MaxIter=500; %最大迭代次数 C1max=1.8; %权重参数,自适应 C2max=1.8; C1=1.2; C2=1.2; w=0.79; Wmax=0.8; %对...

    粒子群算法matlab以求解函数最优解为例

    clear; clc; close all;
    N=100; %粒子个数
    D=2; %粒子维数
    MaxIter=500; %最大迭代次数
    C1max=1.8;  %权重参数,自适应
    C2max=1.8;  
    C1=1.2;  
    C2=1.2;
    w=0.79;
    Wmax=0.8;  %对自己速度的记忆
    Wmin=0.4;
    Xmax=4; Xmin=-4;  %自变量的范围
    Vmax=1; Vmin=-1;  %速度的范围
    
    x=rand(N,D)*(Xmax-Xmin)+Xmin; %初始化N个粒子的D维空间位置
    v=rand(N,D)*(Vmax-Vmin)+Vmin; %初始化N个粒子的D维空间速度
    
    p=x;
    pbest=ones(N,1);
    for i=1:N
        pbest(i)=func(p(i,:));  %计算适应度,此处求的优化目标是最小值
    end
    
    g=ones(1,D);
    gbest=min(pbest);      %全局最小值
    index=find(pbest==gbest);
    g=p(index(1),:);   %全局最小位置
    gb=ones(1,MaxIter); %记录历史的全局最小
    
    for i=1:MaxIter
        for j=1:N
            if func(x(j,:))<pbest(j)
                pbest(j)=func(x(j,:)); %记录对应粒子的局部最小
                p(j,:)=x(j,:);
            end
            if pbest(j)<gbest
                gbest=pbest(j);   %记录对应粒子的全局最小
                g=p(j,:);
            end
            w=Wmax-(Wmax-Wmin)*i/MaxIter; %自适应更新记忆度
            C1=(C1max-C1)*i/MaxIter+C1; %自适应更新权重
            C2=(C2max-C2)*i/MaxIter+C2;
            
            v(j,:)=w*v(j,:)+C1*rand*(p(j,:)-x(j,:))+C2*rand*(g-x(j,:)); %速度调整
            x(j,:)=x(j,:)+v(j,:);                                                            %位置更新
            for ii=1:D
                if v(j,ii)>Vmax | v(j,ii)<Vmin                                    %边界调整
                    v(j,ii)=rand*(Vmax-Vmin)+Vmin;
                end
                if x(j,ii)>Xmax | x(j,ii)<Xmin
                    x(j,ii)=rand*(Xmax-Xmin)+Xmin;
                end
            end
        end
        gb(i)=gbest;
    end
    g
    gb(end)
    figure(1)
    plot(gb);
    xlabel('迭代次数');
    ylabel('适应度值');
    figure(2);
    k1=-4:0.02:4;
    k2=-4:0.02:4;
    z=3*cos(k1'*k2)+k1+k2.^2;
    mesh(k1,k2,z);
    hold on;
    scatter(g(:,1),g(:,2),func(g),'*')
                
            
        
    

    在这里插入图片描述

    展开全文
  • 一些关于粒子群算法的文献-自适应变异的粒子群优化算法.pdf 关于粒子群算法的一些期刊论文
  • MATLAB 粒子群算法,例题与常用模版

    万次阅读 多人点赞 2018-09-06 18:09:18
    MATLAB 粒子群算法 本文学习自:Particle Swarm Optimization in MATLAB - Yarpiz Video Tutorial 与《精通MATLAB智能算法》 1. 简介: Particle Swarm Optimization ,粒子群优化算法,常用来找到方程...
  • 代码利用粒子群算法对带时间窗的车辆路径规划问题进行了求解,代码进行了详细的注释,易于理解和进行修改,内置了一组数据,为可执行的代码。
  • 粒子群算法matlab实现(一)

    万次阅读 多人点赞 2017-07-04 15:45:39
    粒子群算法(Particle Swarm Optimization,PSO)是20世纪90年代兴起的一门学科,因其概念简明、实现方便、收敛速度快而为人所知。粒子群算法的基本思想是模拟鸟群随机搜寻食物的捕食行为,鸟群通过自身经验和种群...
  • 该算法将粒子群算法作为全局搜索算法,序列二次规划算法作为局部搜索算法,将粒子群算法的全局性和序列二次算法的精确性二者有效结合起来,实现对目标模型的求解。通过MATLAB仿真实验的结果可以看出,该算法能够有效...
  • 为避免粒子群算法后期出现早熟收敛,提出一种基于Tent映射的自适应混沌嵌入式粒子群算法。将混沌变量嵌入到标准粒子群算法中,且对参数进行自适应调整。算法采用Tent映射生成的混沌序列来取代基本粒子群算法中的...
  • 一、粒子群算法 粒子群算法是在1995年由Eberhart博士和Kennedy博士一起提出的,它源于对鸟群捕食行为的研究。它的基本核心是利用群体中的个体对信息的共享从而使整个群体的运动在问题求解空间中产生从无序到有序的...
  • 基于logistic映射的自适应变尺度混沌粒子群算法
  • 一些关于粒子群算法的文献-自适应变邻域混沌搜索微粒群算法.pdf 关于粒子群算法的一些期刊论文
  • 支持向量机是机器学习中常见的一种算法,特别是软间隔的支持向量机在解决非线性的分类与回归问题时特别常见,其相比硬间隔的支持向量机而言,增添了松弛变量,能够允许一些错误的发生,通过参数惩罚因子c衡量松弛...
  • matlab代码粒子群算法形状 SHAPES(基于群体启发式样条曲线的自适应和惩罚估计)自适应样条曲线拟合方法的代码,描述如下: Soumya D. Mohanty和Ethan Fahnestock。 “带有粒子群优化的自适应样条拟合。” arXiv预印...
  • 一些关于粒子群算法的文献-一种基于离散粒子群的自适应径向基网络模型.pdf 关于粒子群算法的一些期刊论文
  • 自适应的蝙蝠算法 用粒子群算法改进的蝙蝠算法 由于遗传算法和粒子群算法
  • MATLAB实现粒子群算法的进阶讲解(多维+约束条件)

    万次阅读 多人点赞 2019-11-12 18:46:53
    我们在之前的博客中,对粒子群算法的实现进行了讲解,主要讲解了粒子群算法的产生,实现步骤,并且通过代码来实现了当输入变量为n维向量时的粒子群算法。 许多网友对之前的代码有些疑惑,并且提到了几个问题:1,...
  • 采用自加速遗传粒子群算法(SPSO-GA)对温室物理模型中难以确定的参数进行辨识,建立半封闭式温室能耗预测模型。根据上海半封闭式玻璃试验温室的气象数据和测量的能耗值,分别采用遗传算法(GA)、粒子群算法(PSO)和SPSO...
  • MATLAB】混合粒子群算法原理、代码及详解

    千次阅读 多人点赞 2020-01-19 13:12:35
    本博主的一篇粒子群整定PID算法的文章介绍了全局粒子群算法的原理及其在PID参数自整定上的应用。这篇文章则是介绍了在全局粒子群算法的改进算法——混合粒子群算法。该算法相比全局粒子群算法收敛速度更慢,但可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 416
精华内容 166
关键字:

自适应粒子群算法matlab

matlab 订阅