精华内容
下载资源
问答
  • 基于matlab的差分进化算法 可以测试一些函数的最小值
  • 差分进化算法(Differential Evolution Algorithm,DE)是一种高效全局优化算法。是一种模拟生物进化随机模型,通过反复迭代,使得那些适应环境个体被保存了下来。它进化流程则与遗传算法非常类似,都包括变异...

    差分进化算法(Differential Evolution Algorithm,DE)是一种高效的全局优化算法。是一种模拟生物进化的随机模型,通过反复迭代,使得那些适应环境的个体被保存了下来。它的进化流程则与遗传算法非常类似,都包括变异、杂交和选择操作,但这些操作的具体定义与遗传算法有所不同。

    9ab9b92a3feb6abf426153525c5eafd0.png

    DE的基本原理

    基本思想是从某一组随机产生的初始种群开始,随机选择两个不同的个体向量相减产生差分向量,将差分向量赋予权值后与第三个随机选择的个体向量相加,产生变异向量。然后将变异向量与预先确定的父代个体向量按一定的规则交叉产生试验向量。

    402353b50e8bd187598eedccad1679aa.png

    若试验向量的适应度值优于父代个体的向量的适应度值,则选用试验的向量进入下一代,否则保留父代个体向量。通过不断的进化,保留优胜的个体,引导搜索过程向最优解逼近。

    37cda4641274c6574d6e34d524e47511.png

    DE的算法流程

    1、基本参数的设置,包括种群规模(NP), 缩放因子(F), 交叉概率(CR)。

    2、初始化种群。

    3、计算种群适应度值。

    4、终止条件不满足时,依次执行变异、交叉、选择运算进行循环,直到终止运算。

    b41176a8cb5b2a25eb42983619740057.png

    DE的特点

    进化计算是一种具有鲁棒性的方法,能适应不同的环境不同的问题,而且在大多数情况下都能得到比较满意的有效解。他对问题的整个参数空间给出一种编码方案,而不是直接对问题的具体参数进行处理,不是从某个单一的初始点开始搜索,而是从一组初始点搜索。因而进化算法具有广泛的应用性,高度的非线性,易修改性和可并行性。

    409d9ea59b67012984196e6e2870425a.png

    DE代码实现

    fc61f86cb8dff45eac76e55ac7edd06c.png

    DE的经验规则

    控制参数对一个全局优化算法的影响是很大的,DE的控制变量选择也有一些经验规则。

    1、种群数量。根据经验,种群数量必须满足NP≥4以确保DE具有足够的不同的变异向量。

    2、变异算子。变异算子决定偏差向量的放大比例。F = 0.5通常是一个较好的初始选择。若种群过早收敛,那么 F 或 NP 应该增加。

    e2afb0c81015f9c679126c3c2f243b6c.png

    3、交叉算子。交叉算子是控制一个试验向量来自随机选择的变异向量,而不是原来向量的概率的参数,CR 的一个较好的选择是0.1,但较大的CR 通常加速收敛。

    4、最大进化代数。DE算法运行到指定的进化代数之后就停止运行,并将当前群体中的最佳个体作为所求问题的最优解输出。

    5、终止条件。除最大进化代数可作为DE的终止条件,还需要其它判定准则。

    1a08d644631d47e5e4ebf39ab67517c0.png

    DE的优缺点

    DE算法最新颖的特征是它的变异操作。算法迭代初期,种群中个体差异大,变异操作会使算法具有较强全局搜索能力;到迭代后期,当趋于收敛,使得算法具有较强局部搜索能力。这种新颖特征优点有:待定参数少、不易陷入局部最优、收敛速度快。

    be985aa380028e67e0dc625bab192a72.png

    但是DE也有不足之处:当种群个体较少,且生成新一代个体的适应值比原种群个体适应值差,导致个体难以更新,没有收敛到极值点。如果求解的参数设置不当,收敛过快,产生局部最优问题。

    15060a62a5324e097153d82a387780e9.png
    展开全文
  • 一、差分进化算法理论 差分进化算法是基于群体智能理论优化算法,通过群体内个体间合作与竞争而产生智能优化搜索算法。1.1 差分进化特点(1)结构简单,容易使用。主要通过差分变异算子来进行遗传操作。(2)...

    这个就当是自己学习的整理总结吧。

    一、差分进化算法理论

    差分进化算法是基于群体智能理论的优化算法,通过群体内个体间的合作与竞争而产生的智能优化搜索算法。

    1.1 差分进化特点

    (1)结构简单,容易使用。主要通过差分变异算子来进行遗传操作。

    (2)性能优越。具有较好的可靠性,鲁棒性,高效性。

    (3)自适应性。差分变异算子可以是一个常数,也可以是一个具有变异步长和搜索方向的自适应能力。

    (4)具有内在并行性,可协同搜索。在同一要求下,差分进化算法拥有更快的收敛速度。

    1.2 差分进化算法操作

    (1)初始化

    差分进化算法利用NP个维数为D的实数值参数向量,作为每一代的种群。一般初始化种群符合均匀概率分布。

    (2)变异

    基本变异向量由下式产生

    0b6155f1fffc0170cc0386866fe0be30.png

    要求r1,r2,r3,i互不相同,所以NP必须大于4,F是变异算子通常在0-2之间,它控制偏差向量的放大作用。

    通俗的理解就是把两个向量的差值乘上变异算子加给第三个向量作为新的变异向量。

    (3)交叉

    为了增加干扰向量的多样性,引入交叉操作。

    49d88b3aa2e3a97b7969ff75e4fb68ce.png

    randb(j)表示产生[0,1]之间随机数第j个估计值,rnbr表示一个随机选择的序列。CR是交叉算子。

    通俗理解就是如果随机产生的randb(j)小于CR或者j=r,那么就将变异后的种群放入选择群体中,如果不是就就将原来的种群放入选择种群中。

    (4)选择

    为了决定选择种群中的向量是否能成为下一代的一员,试验向量与当前的目标向量进行比较,如果出现目标函数被最小化,那么具有最小目标函数的向量将在下一代出现。试验向量只与一个个体进行比较,而不是所有个体。

    (5)边界条件处理

    一种方法是将超过边界的向量使用可行域中随机产生的参数向量代替。

    例如:u(n,m)=rand*(Xs-Xx)+Xx;

    另一种方法是,进行边界吸收处理,直接放栗子好理解

                if u(n,m)<Xx
                    u(n,m)=Xx;
                end
                if u(n,m)>Xs
                    u(n,m)=Xs;
                end

    二、改进的差分进化算法

    (1)自适应差分进化算法

    主要是使用了自适应算子。在基本的差分进化算法中,变异算子经常取常数,比较难准确确定,变异率太大,全局最优解低,变异率小,群体多样性下降,易出现‘早熟’的现象。我们可以设计这样的变异算子:

    621affed0c402e16cfb7b5b48ed4987c.png

    这样开始的时候变异算子为2F0,在初期可以保持多样性,防止早熟。随着进展,变异算子降低最后变为F0,避免最优解遭到破坏。

    还可以设计一个随机范围的交叉算子:

    dd9380bab06832a8b288c66cf4803b15.png

    这样交叉算子的均值就在0.75,保持了群体多样性。

    (2)离散差分进化算法

    采用的是浮点数编码,用到了floor这个函数向下取整即可。

    三、差分进化算法流程

    93496c3f77e5c2cbba4376c2aa6f94b3.png

    四、参数说明

    种群数量NP:规模越大多样性越好,但是增加计算难度,一般在5D~10D之间,而且必须大于4。

    变异算子F:

    equation?tex=F%5Csubseteq%5B0%2C2%5D ,决定偏差向量的放大比例。F=0.5是一个比较好的初始选择,如果过早收敛可以增大F或者NP

    交叉算子CR:

    equation?tex=CR%5Csubseteq%5B0%2C1%5D ,CR越大,发生交叉的可能性就越大,一般CR=0.1,较大的CR会加速收敛。

    终止条件:一般当目标函数值小于阈值时程序终止,一般取

    equation?tex=10%5E%7B-6%7D

    五、实例练习

    (1)计算函数

    equation?tex=f%28x%29%3D%5Csum_%7Bi%3D1%7D%5E%7Bn%7D%7Bx_%7Bi%7D%5E%7B2%7D%7D+%28-20%5Cleq+x_%7Bi%7D%5Cleq20%29 的最小值,其中个体x的维数n=10,这是一个简单的平方和函数,只有一个极小点x=(0,0,...,0),理论上最小值分f(0,0,...,0)=0。

    解:使用的是自适应进化算法,所以变异算子和变异算子不是常数

    clear all;
    close all;
    clc;
    NP=50;                               %种群数量
    D=10;                                %变量的维数
    G=200;                               %最大进化代数
    F0=0.4;                              %初始变异算子
    CR=0.1;                              %交叉算子
    Xs=20;                               %上限
    Xx=-20;                              %下限
    yz=10^-6;                            %阈值
    %赋初值
    x=zeros(D,NP);                       %初始种群
    v=zeros(D,NP);                       %变异种群
    u=zeros(D,NP);                       %选择种群
    x=rand(D,NP)*(Xs-Xx)+Xx;             %赋初值
    %计算目标函数
    for m=1:NP
        Ob(m)=func1(x(:,m));
    end
    trace(1)=min(Ob);
    %差分进化循环
    for gen=1:G
        %变异操作
        %自适应变异算子
        lamda=exp(1-G/(G+1-gen));
        F=F0*2^lamda;
        %r1,r2,r3,m互不相同
        for m=1:NP
            r1=randi([1,NP],1,1);
            while (r1==m)
                r1=randi([1,NP],1,1);
            end
            r2=randi([1,NP],1,1);
            while (r2==m)||(r1==r2)
                r2=randi([1,NP],1,1);
            end
            r3=randi([1,NP],1,1);
            while (r3==m)||(r2==r3)||(r1==r3)
                r3=randi([1,NP],1,1);
            end
            v(:,m)=x(:,r1)+F*(x(:,r2)-x(:,r3));
        end
        %交叉操作
        r=randi([1,D],1,1);
        for n=1:D
            cr=rand(1);
            if (cr<=CR)||(n==r)
                u(n,:)=v(n,:);
            else
                u(n,:)=x(n,:);
            end
        end
        %边界条件处理
        for n=1:D
            for m=1:NP
                if (u(n,m)<Xx)||(u(n,m)>Xs)
                    u(n,m)=rand*(Xs-Xx)+Xx;
                end
            end
        end
        %选择操作
        for m=1:NP
            Ob1(m)=func1(u(:,m));
        end
        for m=1:NP
            if Ob1(m)<Ob(m)
                x(:,m)=u(:,m);
            end
        end
        for m=1:NP
            Ob(m)=func1(x(:,m));
        end
        trace(gen+1)=min(Ob);
        if min(Ob)<yz
            break
        end
    end
    [SortOb,Index]=sort(Ob);
    x=x(:,Index);
    X=x(:,1);                                       %最优变量
    Y=min(Ob);                                      %最优值
    %画图
    figure
    plot(trace);
    xlabel('迭代次数')
    ylabel('目标函数值')
    title('DE目标函数曲线')
    %适应度函数
    function result=func1(x)
    summ=sum(x.^2);
    result=summ;
    end                    

    提示一下size 函数的用法,size(x,1)返回行数,size(x,2)返回列数。

    b7e42ae9d7330e2abeab3f7114431977.png

    (2)求函数

    equation?tex=f%28x%2Cy%29%3D3cos%28xy%29%2Bx%2By 的最小值,其中x的范围是[-4,4],y的取值范围是[-4,4],这是一个有多个局部极值的函数,函数图形如图所示。

    c0f7bbc0f02ce55f50c92f257add4853.png

    解:

    clear all;
    close all;
    clc;
    NP=20;                                %种群数量
    D=2;                                  %变量的维数
    G=100;                                %最大进化代数
    F=0.5;                                %变异算子
    CR=0.1;                               %交叉算子
    Xs=4;                                 %上限
    Xx=-4;                                %下限
    %赋初值
    x=zeros(D,NP);                        %初始种群
    v=zeros(D,NP);                        %变异种群
    u=zeros(D,NP);                        %选择种群
    x=rand(D,NP)*(Xs-Xx)+Xx;              %赋初值
    %计算目标函数
    for m=1:NP
        Ob(m)=func2(x(:,m));
    end
    trace(1)=min(Ob);
    %差分进化循环
    for gen=1:G
        %变异操作
        %r1,r2,r3,m各不相同
        for m=1:NP
            r1=randi([1,NP],1,1);
            while (r1==m)
                r1=randi([1,NP],1,1);
            end
            r2=randi([1,NP],1,1);
            while (r1==r2)||(r2==m)
                r2=randi([1,NP],1,1);
            end
            r3=randi([1,NP],1,1);
            while (r1==r3)||(r2==r3)||(r3==m)
                r3=randi([1,NP],1,1);
            end
             v(:,m)=x(:,r1)+F*(x(:,r2)-x(:,r3));
        end
        %交叉操作
        r=randi([1,D],1,1);
        for n=1:D
            cr=rand(1);
            if(cr<CR)||(n==r)
                u(n,:)=v(n,:);
            else
                u(n,:)=x(n,:);
            end
        end
        %边界处理,边界吸收
        for n=1:D
            for m=1:NP
                if u(n,m)<Xx
                    u(n,m)=Xx;
                end
                if u(n,m)>Xs
                    u(n,m)=Xs;
                end
            end
        end
        %选择操作
        for m=1:NP
            Ob1(m)=func2(u(:,m));
        end
        for m=1:NP
            if Ob1(m)<Ob(m)
                x(:,m)=u(:,m);
            end
        end
        for m=1:NP
            Ob(m)=func2(x(:,m));
        end
        trace(gen+1)=min(Ob);
        
    end
    [SortOb,Index]=sort(Ob);
    x=x(:,Index);
    X=x(:,1);                                      %最优变量
    Y=min(Ob);                                     %最优值
    %画图
    figure
    plot(trace);
    xlabel('迭代次数')
    ylabel('目标函数值')
    title('DE目标函数曲线')
    %适应度函数
    function value=func2(x)
    value=3*cos(x(1)*x(2))+x(1)+x(2);
    end

    8c67e76ab332f7d47407bc9fc64f50cf.png

    结果:当x=-4,y=-3.9478时取到最小值-10.9734

    (3)用离散差分算法求函数

    equation?tex=f%28x%2Cy%29%3D-%28%28x%5E%7B2%7D%2By-1%29%5E%7B2%7D%2B%28x%2By%5E%7B2%7D-7%29%5E%7B2%7D%29%2F200%2B10 的最大值,其中x取-100~100之间的整数,y取-100~100之间的整数,其函数图像如图所示:

    d6b31561f232d27ef35dc22d4fd4189a.png

    解:

    clear all;
    close all;
    clc;
    NP=20;                                  %种群数量
    D=2;                                    %变量的维数
    G=100;                                  %最大进化代数
    F=0.5;                                  %变异算子
    CR=0.1;                                 %交叉算子
    Xs=100;                                 %上限
    Xx=-100;                                %下限
    %赋初值
    x=zeros(D,NP);                          %初始种群
    v=zeros(D,NP);                          %变异种群
    u=zeros(D,NP);                          %选择种群
    x=randi([Xx,Xs],D,NP);                  %赋初值
    %计算目标函数
    for m=1:NP
        Ob(m)=func3(x(:,m));
    end
    trace(1)=max(Ob);
    %差分进化循环
    for gen=1:G
        for m=1:NP
            r1=randi([1,NP],1,1);
            while (r1==m)
                r1=randi([1,NP],1,1);
            end
            r2=randi([1,NP],1,1);
            while (r1==r2)||(r2==m)
                r2=randi([1,NP],1,1);
            end
            r3=randi([1,NP],1,1);
            while (r3==m)||(r3==r2)||(r3==r1)
                r3=randi([1,NP],1,1);
            end
            v(:,m)=floor(x(:,r1)+F*(x(:,r2)-x(:,r3)));            %floor向下取整   
        end
        %交叉操作
        r=randi([1,D],1,1);
        for n=1:D
            cr=rand(1);
            if (cr<=CR)||(n==r)
                u(n,:)=v(n,:);
            else
                u(n,:)=x(n,:);
            end
        end
        %边界吸收
        for n=1:D
            for m=1:NP
                if u(n,m)<Xx
                    u(n,m)=Xx;
                end
                if u(n,m)>Xs
                    u(n,m)=Xs;
                end
            end
        end
        %选择操作
        for m=1:NP
            Ob1(m)=func3(u(:,m));
        end
        for m=1:NP
            if Ob1(m)>Ob(m)
                x(:,m)=u(:,m);
            end
        end
        for m=1:NP
            Ob(m)=func3(x(:,m));
        end
        trace(gen+1)=max(Ob);
    end
    [SortOb,Index]=sort(Ob);
    X=x(:,Index);
    XBest=x(:,end);                           %最优变量
    Y=max(Ob);                                %最优
    %画图
    figure
    plot(trace)
    xlabel('迭代次数')
    ylabel('目标函数值')
    title('DE目标函数曲线')
    %%适应度函数
    function y=func3(x)
    y=-((x(1).^2+x(2)-1).^2+(x(1)+x(2).^2-7).^2)/200+10;
    end
        

    22b82a4ab73860e8837b6ef2cbb49dc2.png

    通过这三个例子我们可以发现如果把遗传算法部分学好了,差分进化这块也特别好理解,这两种算法虽然交叉的变异的方法不一样,但是思想上很相近。

    展开全文
  • 差分进化算法是一种全局最优算法,在差分演化算法当中需要注意几个点为变异率F、交叉率Cr、基向量选择r0,r1,r2选择等问题。在研究差分演化算法过程之中有许多改进,对基向量改进、变异概率、交叉概率...

    差分进化算法是一种全局最优算法,在差分演化算法当中需要注意的几个点为变异率F、交叉率Cr、基向量的选择r0,r1,r2的选择等问题。在研究差分演化算法的过程之中有许多的改进,对基向量的改进、变异概率、交叉概率的改进。这里提供的是经典的差分演化算法,利用经典差分演化算法解决一元函数的最优值问题。
    经典的差分演化算法步骤:
    (1)初始化:x[i][j]=xmin+(xmax-xmin)*rand(D,Np);
    xmin–变量的上界;xmax–变量的下界;D–种群数;Np–个体数;
    (2)变异:v[i][j]=x[r0][j]+(x[r1][j]-x[r2][j])*F
    通常F取0.5–09;但是对于函数的不同去<0.5也可以;
    (3)交叉:u[i][j]=v[i][j]----Cr<rand()
    u[i][j]=x[i][j]-----else
    (4)选择:x[i][j]=u[i][j]—f(u)<f(x);
    xg[i][j]=x[i][j]—else;g指的是子代数
    -----这里是决定选最大值还是最小值
    下面给出利用差分演化算法求解一元函数最小值的案列:

    % DE算法的应用----针对一元函数
    % 求解函数的最大值/最小值
    % 解决问题:求解函数f(x)=x.*sin(10*x.*pi)+2
    % 时间:2020.12.23
    % 工具:matlab2018a
    % 注意点:对于循环最好采用分步循环,最好做一个大循环,原因在于多次子循环将导致部分精度丢失
     clc
     clear
    % 定义初始值
     D=50;
     Np=1;
     Ft=0.5;   %后期对其进行改进
     Cr=0.8;
     xmax=2;
     xmin=-1;
     K=100;    %迭代次数
     
     %种群初始化
     x=xmin+(xmax-xmin)*rand(D,1);
     F=Ft+0.001*(rand(D,1)-0.5);  %改进后的变异因子
     best=x(1,:);  %选取其中一个最为最优值,为后面选取最优值做准备
     tx=[xmin:0.01:xmax];
     f=fun_DE(tx);
     figure(1)
     plot(tx,f,'b')
     hold on
     f0=fun_DE(best);
     plot(best,f0,'ro','linewidth',2);
     
     
    %保存最优子代
     for i=2:D
     if fun_DE(best)>fun_DE(x(i,:))
           best=x(i,:);
       end
     end
     fi=fun_DE(best);   %把最优值传递给fi
     
    % 进行变异、交叉、选择
     for n=1:K
        time(n)=n;  %做这一步的原因在于显示在哪个位置进行收敛
        
        % %变异
        for i=1:D
            r0=0;r1=0;r2=0;
           while( r0==i||r1==i||r2==i||r0==r1||r0==r2||r1==r2)
                r0=ceil(D*rand(1));
                r1=ceil(D*rand(1));
                r2=ceil(D*rand(1));
           end
           
            v(i,:)=x(r0,:)+F(i,:)*(x(r1,:)-x(r2,:));
      
           for j=1:Np                      %检查是否越界
                  if(v(i,j)<xmin(j))
                      v(i,j)=xmin(j);
                  elseif(v(i,j)>xmax(j)) 
                       v(i,j)=xmax(j);
                   end
           end
        
           
       %交叉
      for j=1:Np
         if rand(1)<Cr
                u(i,j)=v(i,j);
            else
               u(i,j)=x(i,j);
            end
      end
      
      
        %选择
        if fun_DE(u(i,:))<fun_DE(x(i,:))
               x(i,:)=u(i,:);
        end
         if fun_DE(x(i,:))<fi
                % fi=fun_DE1(x(i,:));
          end
            best=x(i,:);
       best_f(n)=fun_DE(best);
      
     end
     end
     
    plot(best,best_f(n),'ro','linewidth',2)
    xlabel('x');ylabel('J');
    title('函数最小值');
    fprintf('最优解结果为%f,%f',best);
    fprintf('最小函数值为%f',best_f(n));   %打印最优
    figure(2)
    plot(time,best_f(time),'r-');
    xlabel('迭代次数');ylabel('最优值');
    title('迭代后的最优结果')     
    
    输出结果:
    最优解结果为1.950519,最小函数值为0.049740>> 
    

    结果图形展示:

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

    展开全文
  • 对于刚基础差分演化算法来说,自己要首先根据算法原理写出解决一元函数最优化问题,再次写出解决多元函数代码,只要能把这两部分代码弄清楚了,那么对于改进差分演化算法差分演化算法的应用问题将会轻松许多...

    3741176ebd328f0c2d7c489ed1dae9ee.png

    差分演化算法是一种基于全局最优的算法,它可以应用到我们的多目标、粒子滤波器、工程等问题。对于刚基础差分演化算法来说,自己要首先根据算法原理写出解决一元函数的最优化问题,再次写出解决多元函数的代码,只要能把这两部分的代码弄清楚了,那么对于改进差分演化算法和差分演化算法的应用问题将会轻松许多。

    对于算法的学习推荐下面几本书!

    差分演化算法的代码最重要的是对于最优值保存这里,设置最优值让其等于一个初始值的第一个位置,之后不断从其中选取最优值,依此下去就可以得到最优值。下面是采用matlab写的差分演化算法应用在多元函数上的最优化代码。

    程序:

    function f=fun_DE1(x)

    for i=1:2 %这里的i是1:Np.

    f=0;

    f=f+x(:,i).*2.^(i-1);

    end

    clc

    clear

    % DE算法应用---多元函数

    %需求:DE算法求解多维函数--以超椭球题函数f(x)=sum(x(i)*2^(i-1)),i=1,2,...

    %求解超椭球体函数的最优值---最大值/最小值

    %matlab与java写的程序,所要的评价次数来说,matlab需要的更多

    %时间:2020.12.18

    D=50;%群体个数

    Np=2;%所求的变量个数,这里相当于个体数,根据自己的需要调整个体数

    xmin=-1;

    xmax=2;

    K=300; %迭代次数

    F=0.5; %变异因子[0 2]

    Cr=0.8; %交叉因子[0.6 0.9]

    %第一步 初始化种群

    x=xmin+(xmax-xmin)*rand(D,Np);

    for i=1:Np

    best(1,i)=x(1,i);%全局最优个体 ---之后不断更新

    end

    for i=2:D

    if(fun_DE1(x(i,:))>fun_DE1(best(1,:))) %编写函数有问题,下去思考

    best(1,:)=x(i,:);

    end

    end

    fi=fun_DE1(best); %保证个体全局最优

    %%进入循环直到满足精度要求或者迭代次数达到

    for n=1:K %做迭代

    time(n)=n;

    %第二步 变异

    for i=1:D

    for j=1:Np %检查是否越界

    r1=1;r2=1;r3=1;%使得个体满足变异条件.此处与Java有点不一样,他是从1开始

    while(r1==r2||r1==r3||r2==r3||r1==i||r2==i||r3==i)

    r1=ceil(D*rand(1)); %保持其中的r1,r2,r3互异,这样做的目的是为了防止种群的单一性

    r2=ceil(D*rand(1));

    r3=ceil(D*rand(1));

    end

    v(i,j)=x(r1,j)+F*(x(r2,j)-x(r3,j));

    %做一个防止越界

    if v(i,j)<xmin

    v(i,j)=xmin;

    elseif x(i,j) >xmax

    x(i,j)=xmax;

    end

    end

    %交叉

    for j=1:Np

    temper=rand(1); %随机产生一个数,用于进行多点交叉

    if(temper<Cr)

    u(i,j)=v(i,j);

    else

    u(i,j)=x(i,j);

    end

    end

    %选择

    if(fun_DE1(u(i,:))>fun_DE1(x(i,:)))

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

    end

    if(fun_DE1(x(i,:))<fi)

    %fi=fun_DE1(x(i,:));

    x(i,:)=best;

    end

    Best_f(n)=fun_DE1(x(i,:));

    end

    end

    fprintf('最优解结果为%f,%f,%f,%f,%f',x(1,:));

    fprintf('最大函数值为%f',Best_f(n));

    plot(time,Best_f(time),'k-');

    运行结果:

    最优解结果为2.000000,2.000000,最大函数值为4.000000>>

    40dccca21ffe498a9828db238d2d9a86.png

    以上就是matlab差分演化算法求解多元函数最优化问题的代码,如果有想要用java的差分演化算法求解多元目标函数的代码的私信!

    其实只要能把多元函数的代码写出,那么一元的就出来了,只需要把对应的种群个体数改为1即可!

    只需0.01元,点击下方获取编程资料!

    欢迎关注知乎,留言交流!

    展开全文
  •  差分算法是一种随机启发式、自组织最小化算法。2、查分算法的特点:(1)结构简单、容易使用;(2)性能优越;(3)自适应性;(4)具有内在并行性,可协同搜索;(5)算法通用;3、操作程序:初始化——变异...
  • 差分进化算法

    2018-05-31 11:11:13
    基于MATLAB的差分进化算法,一个简单的代码供大家交流学习
  • 差分进化算法框架下,借鉴闭环控制思想,设计状态评价因子,通过计算种群个体进化状态估计值,实现变异策略自适应切换,指导下一代种群进化,以提高算法搜索性能。王柳静, 张贵军, 周晓根. 基于状态估计反馈...
  • 差分进化:一种快速高效的Matlab代码,实现了差分进化算法
  • 差分进化算法的Matlab代码,可运行,注释清楚 差分进化算法的Matlab代码,可运行,注释清楚
  • 差分进化算法的matlab程序,可用于优化问题求解。
  • 差分进化算法的函数优化程序 适合于初学者 matlab 差分进化算法的函数优化程序 适合于初学者 matlab
  •  差分算法是一种随机启发式、自组织最小化算法。2、查分算法的特点:(1)结构简单、容易使用;(2)性能优越;(3)自适应性;(4)具有内在并行性,可协同搜索;(5)算法通用;3、操作程序:初始化——变异...
  • 人工智能 车间调度 函数优化 参数自适应的差分进化算法 JADE matlab源代码
  • 【DE算法】差分进化算法原理及matlab代码

    万次阅读 多人点赞 2017-11-03 10:51:14
    差分进化算法DE与遗传算法GA非常类似,下面是差分进化算法的步骤。算法步骤如下:初始化变异交叉d.选择测试函数:Rastrigr函数 全局最优点: , matlab代码如下:[plain] view plain copyfunction DE(Gm,F0) t0...
  • 差分进化算法Matlab实现

    千次阅读 多人点赞 2019-03-25 18:04:24
    一、介绍 ...同时,差分进化算法独特记忆能力使其可以动态跟踪当前搜索情况,及时调整搜索测量,因此具有较强全局收敛能力。 目前为止,差分进化算法已经成为一种求解非线性,不可微,多极...
  • 标准差分进化算法matlab程序实现 自适应差分演化算法方面的Matlab和C++代码及论文 差分进化算法 DE-Differential Evolution matlab练习程序(差异演化DE) 【DE算法】差分进化算法原理及matlab代码 差分进化...
  • 自适应调节的差分进化算法matlab程序(原创)——RD-DE 算法在优化初期需要搜索能力更强的阶段采用[0,1]之间随机选择变异因子 F 以及交叉概率因子 CR 的策略;而在后期需要开发能力 更强的阶段则采用令 F 和 CR 单调...
  • 差分进化算法原理及matlab代码实现

    万次阅读 多人点赞 2019-04-23 19:40:08
    差分进化算法介绍: 在自然界中,遗传,...差分进化算法是基于群体只能理论优化算法,与进化算法相比,保留了基于种群全局搜索策略,采用实数编码,基于差分简单变异操作操作和“一对一”竞争生存策略...
  • 作为进化算法一类,差分进化算法能够有效对社会系统进行只能模拟,更好地演化社会系统进化状态,同时能够进行一定改进,进而优化进化性能。
  • 差分进化算法的MatLab源代码,可供研究者和编程者参考 差分进化算法的MatLab源代码,可供研究者和编程者参考
  • 很实用的差分进化算法程序,对初学者很有参考价值
  • 同时,差分进化算法独特记忆能力使其可以动态跟踪当前搜索情况,及时调整搜索测量,因此具有较强全局收敛能力。 目前为止,差分进化算法已经成为一种求解非线性,不可微,多极值和高维复杂函数一种极其...
  • 标准差分进化算法多目标线性规划若干解法及MATLAB实现
  • 提出了一种新进化搜索算法,即加权差分进化算法(WDE)。 在本文中,提出了加权差分演化算法(WDE)来解决实数值优化问题。实际上,当随机确定WDE所有参数时,WDE没有控制参数,只有模式大小。WDE可以...
  • matlab代码,详细的matlab代码,可以放心使用,包含三个源文件
  • 标准差分进化算法matlab程序实现

    千次阅读 热门讨论 2018-09-10 14:41:35
    终于开始了研究生阶段学习...从6号到9号,我用三天时间看完了两篇关于标准差分进化算法的英文文献,虽然在完成本科毕业设计时候也简单接触了差分进化算法,但是并没有自己动手实现,只是粗略地了解了算法流程,...
  • 使用带有球修剪多目标差分进化算法设计连续控制器。进化计算应用。 2)RunTutorial.m 运行并以html格式发布Tutorial.m文件。 3)Tutorial.m spMODE算法快速参考教程。 4)spMODEparam.m 生成运行spMODE...
  • 差分进化算法的matlab源码,这里只对单目标连续问题做研究,离散问题目前没有涉及,下面是标准差分进化算法的matlab源码,里面函数是单目标sphere函数。这份代码只是更好理解差分进化算法(DE)原理和迭代...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 123
精华内容 49
关键字:

matlab的差分进化算法

matlab 订阅