2024年最新优化算法——莲花效应算法，MATLAB代码免费获取

注：该算法已按照智能优化算法APP标准格式进行整改，可直接集成到APP中，方便大家与自己的算法进行对比。

莲花效应算法（Lotus Effect Algorithm，LAE）是一种新的进化算法，它将蜻蜓算法中的高效算子与叶子上的水的自清洁特征(莲花效应)相结合，进行提取和局部搜索操作。荷叶的效果表明荷叶具有超疏水和自洁特性。植物叶子的特性导致水分在叶子上收集土壤，然后顺着叶子滑下而不被吸收。这种情况可以被认为是根据水滴在叶子上的运动进行的局部搜索，下图以最好的方式描述了这一特性。

该成果于2024年发表在计算机科学领域3区SCI期刊“The Journal of Supercomputing”上。

1.原理详解

（1）LEA勘探阶段

在LEA中，由蜻蜓进行生物传粉，这与本文算法的探索阶段相同。蜻蜓算法考虑了昆虫群体的分离、对齐和内聚三个基本原则，以及食物和敌人两个概念，模拟了蜻蜓的智能行为。分离表示防止个体与相邻个体发生碰撞。对准指的是个体与邻域内其他个体的速度匹配。凝聚力指的是个体向社区整体中心靠拢的趋势。每个蜻蜓群的主要目标是生存。因此，个体必须都被食物来源吸引，并从敌人那里分散注意力。考虑到这两种行为，更新个体在群体中的位置有五个因素，每个因素都可以被数学建模。分离计算公式为:

式中Xi表示当前索引为i的个体在进化迭代t中的位置，Xj表示进化迭代t中第j个个体在邻域中的位置，N为该邻域中的个体个数。

对齐的计算方法如下:

式中，Xj表示进化迭代t中邻域第j个个体的速度。

内聚力计算公式如下:

式中Xi表示当前索引为i的个体在进化迭代t中的位置，N为邻居个数，Xj表示进化迭代t中第j个个体在该邻居中的位置。

对食物来源的吸引力计算如下:

其中Xi表示当前个体在进化迭代t中索引i的位置，Xt +表示当前进化迭代t产生的食物源位置。

敌人分心的计算方法如下:

其中，Xt i表示当前个体在进化迭代t中索引为i的位置，Xt -表示当前进化迭代t产生的敌人位置。

蜻蜓的行为是这五种假设模式的结合。为了更新蜻蜓在搜索空间中的位置并模拟其运动，考虑了步长和位置两个向量。步长(简称步长)类似于粒子群算法中的速度矢量，蜻蜓算法是在粒子群算法框架的基础上发展起来的。步长矢量或速度矢量表示蜻蜓的运动方向，定义如下:

式中s为分离系数，St i为进化迭代i中第i个个体的分离度，a为对齐系数，At i为第i个个体的对齐度，c为内聚系数，Ct i为第i个个体的内聚度，f为食物因子，Ft i为第i个个体的食物来源，e为敌人因子，Et i为第i个个体的敌人，w为惯性权重，最后t为算法的迭代计数器。

步长矢量计算完成后，位置矢量计算如下:

其中t为算法的迭代计数器。

利用分离(s)、对齐(a)、内聚(c)、食物(f)和敌人(e)等因素，在优化过程中可以进行各种探索和利用行为。食物来源的位置和敌人的位置是从整个群体中找到的最佳和最差的答案中获得的。这导致收敛到搜索空间中有希望的位置，而偏离搜索空间中不希望的位置。为了改善蜻蜓在探索过程中的随机/随机行为，需要在其邻域无解的情况下，以随机步长在搜索空间中飞行。在这种情况下，蜻蜓的位置使用以下关系更新:

其中t是当前迭代计数器，d是位置向量的维数。Levy是按下列关系计算:

其中r1和r2是0到1之间的两个随机数，β是一个常数，σ的计算关系如下:

其中， 

（2）LEA开发阶段

局部授粉(自花受精)是该算法的提取阶段。在这种授粉中，一个系数指定了每朵花在最容易找到的花周围生长面积的大小。最佳解决方案是运动的基础，其他解决方案也会向它移动。在移动算法开始时，所用的步骤较长，在结束时所用的步骤较短。

其中Xt+1为第(t +1)次迭代中花粉的位置，g *为迄今为止所有进化迭代中找到的最佳花粉位置。R是增长区域，随着算法迭代而缩小。实际上，在算法开始时，移动步骤较长，在算法结束时，移动步骤变短，直到收敛到最优。

式中，t为算法当前的进化迭代，L为最终迭代次数。

在本算法中，使用蜻蜓的邻域半径(在探索阶段)和R(在开发阶段)的值来平衡探索和开发。蜻蜓的半径是一个增量值，最终使它们凝聚在一起，变量R根据算法的重复次数进行调整，控制运动步数由长到小。

（3）LEA开发阶段强化

考虑使用水滴进行局部搜索，以模拟水在莲花叶子上的运动。通过将水滴移动到叶子上的第一个坑，它们就会被填满，水就会溢出叶子。每一个群个体，即解被称为具有位置(Xi)和初始速度(Vi)的drop，在问题搜索空间中移动以寻找最优解。水滴在叶子上形成后，被放置在离它最近的局部最优位置。这种局部最优被称为坑。每个坑都有一个容纳水滴的能力，这取决于它的深度(适合度)。下图展示了一些具有不同容量的凹坑。

在每次迭代中，最深的凹坑被认为是具有最佳适应度的坑。在局部搜索建模中，对每个水滴考虑一个速度矢量，每次迭代后，运动矢量加到速度矢量上，再加到速度矢量上。水滴运动方程如式所示。这些阶段重复β次，β系数从输入端接收。

在这个模型中，每个坑都有一个容量，其深度决定了它的适合度，越深，容量越大。在每次迭代中，所有坑的容量计算如下:

式中， 为进化迭代t中第i个坑的容量， 为进化迭代t中第i个坑的大小，fMax为坑中最大适应度的大小，fMin为坑中最小适应度的大小。Const是一个常数，表示一个目标函数凹坑的最大容量。下图说明了算法执行的第一次迭代中的五个凹坑。在每次迭代中，将凹坑的平均容量随机添加到每个凹坑中。

其中Selectt i是在演化迭代t中选择凹坑的概率，ct i是在演化迭代t中第i个凹坑的容量，k是容量高于溢出凹坑的凹坑的数量。

选择一个坑后，溢出的水向那个坑移动。当沿着遇到一个比源坑容量大的坑时，溢出的水会注入容量大的坑中，运动停止；否则，它会继续到达选定的坑，并注入溢出的水。源坑在运动结束时被移除。坑的容量越大，在算法执行过程中重用它的概率就越大；它更有可能被选中来捕获流向它的溢出的水。在这种运动中，与PSO算法不同，液滴在搜索过程中没有保持最佳位置的记忆。合理解决方案的知识不会保持任何下降。一个液滴可以定位其他液滴的当前位置，并且在任何时刻都知道最佳液滴的位置。

以下公式表示局部搜索时液滴运动的速度和位置并表示表面上一个坑溢出的液滴运动的速度和位置。

在公式中，Xt deeppit为演化迭代t中最深坑的当前位置，Vt i为演化迭代t中水滴i的当前速度，Xt i为水滴i在演化迭代t中的当前位置，q为速度增量系数。

在迭代过程中，为了改善群体体验，通过评估它们的能力和适合度标准，水滴之间会发生两种互动：一个坑候选接收从其他坑溢出的水；增加滴的能力。

LEA算法所对应的伪代码如下所示

2.结果展示

老规矩，采用作者独创的智能优化算法APP轻松对比一下本期算法。

在23个经典函数上的表现：

再浅浅对比一下：

发现本期的莲花效应算法，效果不是很理想。不过本期莲花效应算法的公式倒是很新颖，或许可以借鉴他的公式对自己的算法进行改进。

3.MATLAB核心代码

%微信公众号搜索：淘个代码，获取更多免费代码
function [Best_score,Best_pos,cg_curve]=LEA(SearchAgents_no,Max_iteration,lb,ub,dim,fobj)
% display('optimizing your problem');
cg_curve=zeros(1,Max_iteration);


if size(ub,2)==1
    ub=ones(1,dim)*ub;
    lb=ones(1,dim)*lb;
end


r=(ub-lb)/10;
Delta_max=(ub-lb)/10;


Food_fitness=inf;
Food_pos=zeros(dim,1);


Enemy_fitness=-inf;
Enemy_pos=zeros(dim,1);


X=initialization(SearchAgents_no,dim,ub,lb);
Fitness=zeros(1,SearchAgents_no);


DeltaX=initialization(SearchAgents_no,dim,ub,lb);


for iter=1:Max_iteration
    
    r=(ub-lb)/4+((ub-lb)*(iter/Max_iteration)*2);
    
    w=0.9-iter*((0.9-0.4)/Max_iteration);
       
    my_c=0.1-iter*((0.1-0)/(Max_iteration/2));
    if my_c<0
        my_c=0;
    end
    
    s=2*rand*my_c; 
    a=2*rand*my_c; 
    c=2*rand*my_c; 
    f=2*rand;      
    e=my_c;        
    
    for i=1:SearchAgents_no
        Fitness(1,i)=fobj(X(:,i)');
        if Fitness(1,i)<Food_fitness
            Food_fitness=Fitness(1,i);
            Food_pos=X(:,i);
        end
        
        if Fitness(1,i)>Enemy_fitness
            if all(X(:,i)<ub') && all( X(:,i)>lb')
                Enemy_fitness=Fitness(1,i);
                Enemy_pos=X(:,i);
            end
        end
    end
    
    for i=1:SearchAgents_no
        index=0;
        neighbours_no=0;
        
        clear Neighbours_DeltaX
        clear Neighbours_X
        %find the neighbouring solutions
        for j=1:SearchAgents_no
            Dist2Enemy=distance(X(:,i),X(:,j));
            if (all(Dist2Enemy<=r) && all(Dist2Enemy~=0))
                index=index+1;
                neighbours_no=neighbours_no+1;
                Neighbours_DeltaX(:,index)=DeltaX(:,j);
                Neighbours_X(:,index)=X(:,j);
            end
        end
        
    
        S=zeros(dim,1);
        if neighbours_no>1
            for k=1:neighbours_no
                S=S+(Neighbours_X(:,k)-X(:,i));
            end
            S=-S;
        else
            S=zeros(dim,1);
        end
        
         if neighbours_no>1
            A=(sum(Neighbours_DeltaX')')/neighbours_no;
        else
            A=DeltaX(:,i);
        end
    
        if neighbours_no>1
            C_temp=(sum(Neighbours_X')')/neighbours_no;
        else
            C_temp=X(:,i);
        end
        
        C=C_temp-X(:,i);


        Dist2Food=distance(X(:,i),Food_pos(:,1));
        if all(Dist2Food<=r)
            F=Food_pos-X(:,i);
        else
            F=0;
        end
   
        Dist2Enemy=distance(X(:,i),Enemy_pos(:,1));
        if all(Dist2Enemy<=r)
            Enemy=Enemy_pos+X(:,i);
        else
            Enemy=zeros(dim,1);
        end
        
        for tt=1:dim
            if X(tt,i)>ub(tt)
                X(tt,i)=lb(tt);
                DeltaX(tt,i)=rand;
            end
            if X(tt,i)<lb(tt)
                X(tt,i)=ub(tt);
                DeltaX(tt,i)=rand;
            end
        end
        
        if any(Dist2Food>r)
            if neighbours_no>1
                for j=1:dim
                    DeltaX(j,i)=w*DeltaX(j,i)+rand*A(j,1)+rand*C(j,1)+rand*S(j,1);
                    if DeltaX(j,i)>Delta_max(j)
                        DeltaX(j,i)=Delta_max(j);
                    end
                    if DeltaX(j,i)<-Delta_max(j)
                        DeltaX(j,i)=-Delta_max(j);
                    end
                    X(j,i)=X(j,i)+DeltaX(j,i);
                end
            else
                % Eq. (3.8)
                X(:,i)=X(:,i)+Levy(dim)'.*X(:,i);
                DeltaX(:,i)=0;
            end
        else
            for j=1:dim
                % Eq. (3.6)
                DeltaX(j,i)=(a*A(j,1)+c*C(j,1)+s*S(j,1)+f*F(j,1)+e*Enemy(j,1)) + w*DeltaX(j,i);
                if DeltaX(j,i)>Delta_max(j)
                    DeltaX(j,i)=Delta_max(j);
                end
                if DeltaX(j,i)<-Delta_max(j)
                    DeltaX(j,i)=-Delta_max(j);
                end
                X(j,i)=X(j,i)+DeltaX(j,i);
            end 
        end
        
        Flag4ub=X(:,i)>ub';
        Flag4lb=X(:,i)<lb';
        X(:,i)=(X(:,i).*(~(Flag4ub+Flag4lb)))+ub'.*Flag4ub+lb'.*Flag4lb;
        
    end
    Best_score=Food_fitness;
    Best_pos=Food_pos';
    
    cg_curve(iter)=Best_score;
end
end


function o=Levy(d)


beta=3/2;
%Eq. (3.10)
sigma=(gamma(1+beta)*sin(pi*beta/2)/(gamma((1+beta)/2)*beta*2^((beta-1)/2)))^(1/beta);
u=randn(1,d)*sigma;
v=randn(1,d);
step=u./abs(v).^(1/beta);


% Eq. (3.9)
o=0.01*step;
end

4.参考文献

[1]Dalirinia E, Jalali M, Yaghoobi M, et al. Lotus effect optimization algorithm (LEA): a lotus nature-inspired algorithm for engineering design optimization[J]. The Journal of Supercomputing, 2024, 80(1): 761-799.

点击下方卡片获取完整代码