基于自适应适应度-距离平衡的随机分形搜索算法(Matlab代码实现)

简介: 基于自适应适应度-距离平衡的随机分形搜索算法(Matlab代码实现)

💥1 概述

参考文献:

提出了基于自适应适应度-距离平衡选择的随机分形搜索(FDB-SFS)算法。对实验研究中提出的方法的结果进行了统计评估,并与文献中竞争优化算法的结果进行了比较。对比表明,所提出的FDB-SFS算法在寻找最优解方面优于其他算法,并且收敛速度更快达到最优解。根据实验研究结果,所提出的FDB-SFS算法在OPF问题中的优化成本比AO、GBO、GPC、HGS、HHO、RUN、TSO、LSHADE、LSHADE-EPSIN、LSHADE-CNEPSIN、LSHADE-SPACMA和MadDE优化算法好5.7362%、0.0954%、7.6244、0.1785%、2.4329%、1.7408%、1.95317%、3.5486%、2.2007%和1.5203%。  


📚2 运行结果

部分代码:

function []=case_1()
[nPop, dimension, maxIteration, lbArray, ubArray] = problem_terminate();
S.Start_Point = nPop;            
S.Maximum_Diffusion = 0;
S.Walk = 1; % *Important
S.Ndim = dimension;
S.Lband = lbArray;
S.Uband = ubArray;
S.Maximum_Generation  = maxIteration;
    P = zeros(S.Start_Point,S.Ndim);
%Creating random points in considered search space=========================
    point = repmat(S.Lband,S.Start_Point,1) + rand(S.Start_Point, S.Ndim).* ...
        (repmat(S.Uband - S.Lband,S.Start_Point,1));
%==========================================================================
%Calculating the fitness of first created points=========================== 
    FirstFit = zeros(1,S.Start_Point);
    for i = 1 : size(point,1)
        FirstFit(i) = problem(point(i,:)); 
    end
    [Sorted_FitVector, Indecis] = sort(FirstFit);
    point = point(Indecis,:);%sorting the points based on obtaind result
%==========================================================================
%Finding the Best point in the group=======================================
    BestPoint = point(1, :);
    fbest = Sorted_FitVector(1);%saving the first best fitness
%==========================================================================
nfeval = 1;
%Starting Optimizer========================================================
while ( ( nfeval < S.Maximum_Generation) )
    New_Point = point;
    FitVector = Sorted_FitVector;
    %diffusion process occurs for all points in the group
    if S.Maximum_Diffusion>0
        for i = 1 : S.Start_Point
            %creating new points based on diffusion process
            [NP, fit] = Diffusion_Process(point(i,:),Sorted_FitVector(i),S,nfeval,BestPoint,fhd, fNumber);
            New_Point(i,:) = NP; FitVector(i) = fit;
            nfeval = nfeval + 1;
           if nfeval >= S.Maximum_Generation
               S.Start_Point = 0;
               break;
           end
        end  
    end
    fit = FitVector';
    [~, sortIndex] = sort(fit);
    Pa = zeros(1,S.Start_Point);
    %Starting The First Updating Process====================================
    for i=1:1:S.Start_Point     
        Pa(sortIndex(i)) = (S.Start_Point - i + 1) / S.Start_Point; 
    end
    RandVec1 = randperm(S.Start_Point);
    RandVec2 = randperm(S.Start_Point);
    FDBIndex = fitnessDistanceBalance( point, fit);
    for i = 1 : S.Start_Point
        for j = 1 : size(New_Point,2)
            if rand > Pa(i)
                if Sigmoid_Func_1_Increase(S.Maximum_Generation, nfeval)
                    P(i,j) = New_Point(FDBIndex,j) - rand*(New_Point(RandVec2(i),j) - New_Point(i,j)); 
                else
                    P(i,j) = New_Point(RandVec1(i),j) - rand*(New_Point(RandVec2(i),j) - New_Point(i,j)); 
                end
            else
                P(i,j)= New_Point(i,j);
            end
        end
    end
    P = Bound_Checking(P,S.Lband,S.Uband);%for checking bounds
    for i = 1 : S.Start_Point
        Fit_FirstProcess = problem(P(i,:)); 
        if Fit_FirstProcess<=fit(i)
            New_Point(i,:)=P(i,:);
            fit(i)=Fit_FirstProcess;
        end
        nfeval = nfeval + 1;
       if nfeval >= S.Maximum_Generation
           S.Start_Point = 0;
           break;
       end
    end
    FitVector = fit;
    %======================================================================    
    [Sorted_FitVector,SortedIndex] = sort(FitVector);
    New_Point = New_Point(SortedIndex,:);
    BestPoint = New_Point(1,:);%first point is the best  
    pbest = New_Point(1,:);
    fbest = FitVector(1);
    point = New_Point;
    %Starting The Second Updating Process==================================
    Pa = sort(SortedIndex/S.Start_Point, 'descend');
    for i = 1 : S.Start_Point
       if rand > Pa(i)
           %selecting two different points in the group
           R1 = ceil(rand*size(point,1));
           R2 = ceil(rand*size(point,1));
            while R1 == R2
                R2 = ceil(rand*size(point,1));
            end
            if rand < .5
                ReplacePoint = point(i,:) - rand * (point(R2,:) - BestPoint); 
            else
                ReplacePoint = point(i,:) + rand * (point(R2,:) - point(R1,:)); 
            end
            ReplacePoint = Bound_Checking(ReplacePoint,S.Lband,S.Uband);
            replaceFit =  problem(ReplacePoint); 
            if replaceFit < Sorted_FitVector(i)
                point(i,:) = ReplacePoint;
                Sorted_FitVector(i) = replaceFit;
            end
            if replaceFit < fbest
                pbest = ReplacePoint;
                fbest = replaceFit;
                BestPoint = pbest;
            end
            nfeval = nfeval + 1;
            if nfeval >= S.Maximum_Generation
               break;
            end
       end
    end
end
bestFitness=fbest;
bestSolution=pbest;
    fprintf('Best Fitness: %d\n', bestFitness);
    disp('Best Solution:'); 
    disp(bestSolution);
end
function p = Bound_Checking(p,lowB,upB)
    for i = 1 : size(p,1)
        upper = double(gt(p(i,:),upB));
        lower = double(lt(p(i,:),lowB));
        up = find(upper == 1);
        lo = find(lower == 1);
        if (size(up,2)+ size(lo,2) > 0 )
            for j = 1 : size(up,2)
                p(i, up(j)) = (upB(up(j)) - lowB(up(j)))*rand()...
                    + lowB(up(j));
            end
            for j = 1 : size(lo,2)
                p(i, lo(j)) = (upB(lo(j)) - lowB(lo(j)))*rand()...
                    + lowB(lo(j));
            end
        end
    end
end
function [createPoint, fitness] = Diffusion_Process(Point,Fitness,S,g,BestPoint, fhd, fNumber)
    %calculating the maximum diffusion for each point
    NumDiffiusion = S.Maximum_Diffusion;
    New_Point = zeros(S.Maximum_Diffusion+1,S.Ndim);
    fitness = zeros(1,S.Maximum_Diffusion+1);
    New_Point(1,:) = Point;
    fitness(1) = Fitness;
    %Diffiusing Part*******************************************************
    for i = 1 : NumDiffiusion
        %consider which walks should be selected.
        if rand < S.Walk 
            GeneratePoint = normrnd(BestPoint, (log(g)/g)*(abs((Point - BestPoint))), [1 size(Point,2)]) + (randn*BestPoint - randn*Point); % E艧itlik (11)
        else
            GeneratePoint = normrnd(Point, (log(g)/g)*(abs((Point - BestPoint))),[1 size(Point,2)]); % E艧itlik (12) 
        end
        New_Point(i+1,:) = GeneratePoint;
    end
    %check bounds of New Point
    New_Point = Bound_Checking(New_Point,S.Lband,S.Uband);
    %sorting fitness
    for i = 2 : size(New_Point,1)
        fitness(i) = problem(New_Point(i,:)); 
    end
    [fit_value,fit_index] = sort(fitness);
    fitness = fit_value(1,1);
    New_Point = New_Point(fit_index,:);
    createPoint = New_Point(1,:);
    %======================================================================
end


🌈3 Matlab代码实现

🎉4 参考文献

部分理论来源于网络,如有侵权请联系删除。


[1]Duman, S., Kahraman, H. T., Kati, M., "Economical operation of modern power grids incorporating uncertainties of renewable energy sources and load demand using the adaptive fitness-distance balance-based stochastic fractal search algorithm", Engineering Applications of Artificial Intelligence, Volume 117, Part A, 2023, 105501,https://doi.org/10.1016/j.engappai.2022.105501.  

相关文章
|
4天前
|
机器学习/深度学习 存储 算法
近端策略优化(PPO)算法的理论基础与PyTorch代码详解
近端策略优化(PPO)是深度强化学习中高效的策略优化方法,广泛应用于大语言模型的RLHF训练。PPO通过引入策略更新约束机制,平衡了更新幅度,提升了训练稳定性。其核心思想是在优势演员-评论家方法的基础上,采用裁剪和非裁剪项组成的替代目标函数,限制策略比率在[1-ϵ, 1+ϵ]区间内,防止过大的策略更新。本文详细探讨了PPO的基本原理、损失函数设计及PyTorch实现流程,提供了完整的代码示例。
100 10
近端策略优化(PPO)算法的理论基础与PyTorch代码详解
|
2月前
|
存储 算法 程序员
C 语言递归算法:以简洁代码驾驭复杂逻辑
C语言递归算法简介:通过简洁的代码实现复杂的逻辑处理,递归函数自我调用解决分层问题,高效而优雅。适用于树形结构遍历、数学计算等领域。
|
3月前
|
并行计算 算法 测试技术
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略,涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略,涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面,旨在通过综合策略提升程序性能,满足实际需求。
99 1
|
3月前
|
存储 缓存 算法
通过优化算法和代码结构来提升易语言程序的执行效率
通过优化算法和代码结构来提升易语言程序的执行效率
|
3月前
|
算法
分享一些提高二叉树遍历算法效率的代码示例
这只是简单的示例代码,实际应用中可能还需要根据具体需求进行更多的优化和处理。你可以根据自己的需求对代码进行修改和扩展。
|
3月前
|
算法 测试技术 开发者
在Python开发中,性能优化和代码审查至关重要。性能优化通过改进代码结构和算法提高程序运行速度,减少资源消耗
在Python开发中,性能优化和代码审查至关重要。性能优化通过改进代码结构和算法提高程序运行速度,减少资源消耗;代码审查通过检查源代码发现潜在问题,提高代码质量和团队协作效率。本文介绍了一些实用的技巧和工具,帮助开发者提升开发效率。
67 3
|
3月前
|
分布式计算 Java 开发工具
阿里云MaxCompute-XGBoost on Spark 极限梯度提升算法的分布式训练与模型持久化oss的实现与代码浅析
本文介绍了XGBoost在MaxCompute+OSS架构下模型持久化遇到的问题及其解决方案。首先简要介绍了XGBoost的特点和应用场景,随后详细描述了客户在将XGBoost on Spark任务从HDFS迁移到OSS时遇到的异常情况。通过分析异常堆栈和源代码,发现使用的`nativeBooster.saveModel`方法不支持OSS路径,而使用`write.overwrite().save`方法则能成功保存模型。最后提供了完整的Scala代码示例、Maven配置和提交命令,帮助用户顺利迁移模型存储路径。
|
6月前
|
安全
【2023高教社杯】D题 圈养湖羊的空间利用率 问题分析、数学模型及MATLAB代码
本文介绍了2023年高教社杯数学建模竞赛D题的圈养湖羊空间利用率问题,包括问题分析、数学模型建立和MATLAB代码实现,旨在优化养殖场的生产计划和空间利用效率。
272 6
【2023高教社杯】D题 圈养湖羊的空间利用率 问题分析、数学模型及MATLAB代码
|
6月前
|
存储 算法 搜索推荐
【2022年华为杯数学建模】B题 方形件组批优化问题 方案及MATLAB代码实现
本文提供了2022年华为杯数学建模竞赛B题的详细方案和MATLAB代码实现,包括方形件组批优化问题和排样优化问题,以及相关数学模型的建立和求解方法。
162 3
【2022年华为杯数学建模】B题 方形件组批优化问题 方案及MATLAB代码实现
|
6月前
|
数据采集 存储 移动开发
【2023五一杯数学建模】 B题 快递需求分析问题 建模方案及MATLAB实现代码
本文介绍了2023年五一杯数学建模竞赛B题的解题方法,详细阐述了如何通过数学建模和MATLAB编程来分析快递需求、预测运输数量、优化运输成本,并估计固定和非固定需求,提供了完整的建模方案和代码实现。
138 0
【2023五一杯数学建模】 B题 快递需求分析问题 建模方案及MATLAB实现代码

热门文章

最新文章