2023年最新智能优化算法之——IBI逻辑优化算法(IBL)，附MATLAB代码

企业开发 2023-06-24 21:53:30 阅读次数: 0

今天给大家带来一个有意思的智能优化算法，IBL算法。

先说效果：在CEC2005函数集测试，基本上毫无压力，把把都能预测的很准确，而且速度极快。大家可以自行尝试哈。

为啥说这个算法有意思呢，大家看IBL的英文全称是：Incomprehensible but Intelligible-in-time logics，我在这里给大家直译成中文就是：难以理解但又能及时理解的逻辑。可能我翻译的不太准确啊，但是我又结合他的摘要，大概的理解就是：人类的思维不像计算机那样，人类的思维是可以随着时间、事物的变化而变化的，在之前看起来毫无逻辑的事情，在经过人类学习一段时间后，这个事情就会变得很有逻辑了。不得不说老外这个思维是真的奇特哈，根据这个也能提出一个新算法，而且效果还很不错。大家感兴趣的可以去看看原文。

参考文献：

Mirrashid, M.; Naderpour, H. Incomprehensible but Intelligible-in-time logics: Theory and optimization algorithm. Knowl.-Based Syst. 2023, 264, 110305. doi点击链接跳转原文 

废话不多说，依旧是2005函数集的测试，附上2005函数集的理论范围：

 大部分优化函数在F8上的表现是不太好的，也就寻优到-4000多，咱们试一下这个IBL：

WOW，直接就干到-9700多去了，看样子不错呀，回头了我会将2023年最新的算法做一个对比，决一雌雄一下。

再试一个F14的，理论值是1，能找到0.998004，还阔以

 

 最后再来一个：

上核心代码！

function [Bests_Results,n_it_phase1,n_it_phase2,n_it_phase3,costs1,costs2,costs3] = ILA (CostFunction,Vmin,Vmax,nV,nNL,nModel,nIt,mIt_Phase1,mIt_Phase2,Bmin,Bmax,nRep,nIt_classification)

%% Initialization
Empty.NL = [];                                % Current NL
Empty.NLprevious = [];                        % Previous NL
Empty.Cost = inf;
Empty1.NL = [];                               % Current NL
Empty1.Average = [];                          % Previous NL
Empty1.Cost = inf;
Empty1.Members = [];
Experts = repmat (Empty, nNL, 1);             % Experts
n_it_phase1 = round(nIt*mIt_Phase1);          % Number of iterations in phase 1
n_it_phase2 = round(nIt*mIt_Phase2);          % Number of iterations in phase 2
n_it_phase3 = nIt-n_it_phase1-n_it_phase2;    % Number of iterations in phase 3
costs1 = zeros(n_it_phase1,1);                        % Costs of the phase 1
costs2 = zeros(n_it_phase2,1);                        % Costs of the phase 2
costs3 = zeros(n_it_phase3,1);                        % Costs of the phase 3
n_Groups = zeros(nModel,1);
Em.NL = [];
Em1.NL = [];
Em1.Cost = inf;
Expert_IbI = repmat (Em1, 1, 1);            % The best solution of the current generation
Logic = repmat (Em1, 1, 1);                 % The best solution before the current generation
Expert_new = repmat (Em1, 1, 1);
K0 = repmat (Em, nNL, 1);                   % Knowledge 0
K1 = repmat (Em, nNL, 1);                   % Knowledge 1
Expert_new.NL = [];
Expert_new.Cost = inf;
Knowledge_Phase1 = K0;
Knowledge_Phase2 = K0;
Knowledge_Phase3 = K0;
GroupNumber = ones(nNL,1);
Em2.NL = [];
Em2.Cost = inf;
Bests_Results = repmat (Em2, nIt, 1);

if length(Vmin) ~= (nV)
    Vmin=Vmin.*ones(1,nV);
    Vmax=Vmax.*ones(1,nV);
end

for i = 1:nNL
    Experts(i).NL = unifrnd(Vmin,Vmax,1,nV);
    Experts(i).NLprevious = unifrnd(Vmin,Vmax,1,nV);
    Experts(i).Cost = CostFunction(Experts(i).NL);
end

% Extract the Logic (Best NL in the previous solutions)
for i = 1:nNL
    if CostFunction(Experts(i).NLprevious) <= Logic.Cost
        Logic.Cost = CostFunction(Experts(i).NLprevious); % The best solution of before the current generation
        Logic.NL = Experts(i).NLprevious;
    end
    if Experts(i).Cost <= Expert_IbI.Cost
        Expert_IbI.Cost = Experts(i).Cost;    % The best solution of the current generation
        Expert_IbI.NL = Experts(i).NL;
    end
end

n_t = zeros(nModel,1);
nt = round((n_it_phase1)/nModel);
for m = 1:nModel
    n_t(m,1) = nt;
end
n_t(nModel,1) = (n_it_phase1)-(nModel-1)*nt;

for m = 1:nModel
    n_Groups(m,1) = randi(round(nNL/2));     % Number of workgropus in each model
end

%% Phase 0: Grouping (Clustering)

for m = 1:nModel
    
    % Clustering
    MAT = zeros(nNL,nV);
    for i = 1:nNL
        MAT(i,:) = Experts(i).NL;
    end
    opts = statset('MaxIter',nIt_classification);
    lastwarn('Success');
    GroupNumber0 = GroupNumber;
    GroupNumber = kmeans(MAT,n_Groups(m,1),'Distance','sqeuclidean','Replicates',nRep,'Options',opts);
    [warningMessage, warningMessageID] = lastwarn;
    if contains(warningMessage, 'Failed to converge')
        warnStruct = warning('off');
        GroupNumber = GroupNumber0;
        if m ==1
            n_Groups(m,1) = 1;
        else
            n_Groups(m,1) = n_Groups(m-1,1);
        end
    end
    Experts_Groups = repmat (Empty1, n_Groups(m,1),1);
    n_members = zeros(n_Groups(m,1),1);
    
    for c = 1:n_Groups(m,1)
        nn=0;
        for i = 1:nNL
            if GroupNumber(i,1) == c
                nn = nn+1;
            end
        end
        n_members(c,1) = nn;
        Experts_Groups(c).Members = repmat (Em, n_members(c,1), 1);
    end
    
    %% Phase 1: Workgropus
    for it_phase1 = 1:n_t(m,1)
        
        for c = 1:n_Groups(m,1)
            SUM = 0;
            num = 0;
            for i = 1:nNL
                if GroupNumber(i,1) == c
                    num = num+1;
                    SUM = Experts(i).NL + SUM;
                    Experts_Groups(c).Members(num).NL = Experts(i).NL;
                    if Experts(i).Cost <= Experts_Groups(c).Cost
                        Experts_Groups(c).NL = Experts(i).NL;
                        Experts_Groups(c).Cost = Experts(i).Cost;
                    end
                end
            end
            Experts_Groups(c).Average = SUM./n_members(c,1);
        end
        
        % Calculate the ratios
        D = zeros(nNL,1);
        P = zeros(nNL,1);
        C = zeros(nNL,1);
        for i = 1:nNL
            C(i,1) = sqrt(sum((Experts(i).NL-Logic.NL).^2));
            D(i,1) = sqrt(sum((Experts(i).NL-Experts(i).NLprevious).^2));
            P(i,1) = sqrt(sum((Experts(i).NL-Experts_Groups(GroupNumber(i,1)).NL).^2));
        end
        min_D = min(D); max_D = max(D);
        min_P = min(P); max_P = max(P);
        min_C = min(C); max_C = max(C);
        
        Rc = (C-min_C)./(max_C-min_C);
        Rp = (P-min_P)./(max_P-min_P);
        RD = (D-min_D)./(max_D-min_D);
        Bc = Bmin + (Bmax-Bmin)*rand();
        Bp = Bmin + (Bmax-Bmin)*rand();
        BD = Bmin + (Bmax-Bmin)*rand();
        
        for i = 1:nNL
            B = Bmin + (Bmax-Bmin)*rand();
            if (Rc(i,1) <= Bc) && (Rp(i,1) <= Bp)
                random_member = randi (n_members(GroupNumber(i,1),1));
                K0(i).NL = Rp(i,1).*(Experts(i).NL + Experts_Groups(GroupNumber(i,1)).Members(random_member).NL)./2;
            elseif (Rc(i,1) <= Bc) && (Rp(i,1) > Bp)
                K0(i).NL = Rp(i,1).*(Experts(i).NL + Experts_Groups(GroupNumber(i,1)).Average)./2;
            elseif (Rc(i,1) > Bc) && (Rp(i,1) <= Bp)
                random_member = randi (n_members(GroupNumber(i,1),1));
                K0(i).NL = Rp(i,1).*(Experts_Groups(GroupNumber(i,1)).NL + Experts_Groups(GroupNumber(i,1)).Members(random_member).NL)./2;
            elseif (Rc(i,1) > Bc) && (Rp(i,1) > Bp)
                K0(i).NL = Rp(i,1).*(Experts_Groups(GroupNumber(i,1)).NL + Experts_Groups(GroupNumber(i,1)).Average)./2;
            end
            
            if RD(i,1)<= BD
                K1(i).NL = (rand()).*(Experts_Groups(GroupNumber(i,1)).Average);
            else
                K1(i).NL = (rand()).*(unifrnd(Vmin,Vmax,1,nV));
            end
            
            Knowledge_Phase1(i).NL = abs(K0(i).NL + K1(i).NL)./2;
            
            % Update the NL
            alpha1 = -1.5+3.*rand(1,nV);
            Expert_new.NL = Experts(i).NL + alpha1.*(Knowledge_Phase1(i).NL);
            Expert_new.NL = max(Expert_new.NL, Vmin);
            Expert_new.NL = min(Expert_new.NL, Vmax);
            E1 = Experts(i).NL;
            Expert_new.Cost = CostFunction(Expert_new.NL);
            
            COEF = -1.5+3*rand();
            K = rand().*Experts_Groups(GroupNumber(i,1)).NL;
            NEW.NL = COEF.*(Expert_new.NL) + K;
            NEW.NL = max(NEW.NL, Vmin);
            NEW.NL = min(NEW.NL, Vmax);
            NEW.Cost = CostFunction(NEW.NL);
            if NEW.Cost < Expert_new.Cost
                Expert_new = NEW;
            end
            
            
            if Expert_new.Cost < Experts(i).Cost
                Experts(i).NL = Expert_new.NL;
                Experts(i).Cost = Expert_new.Cost;
            end
            if Experts(i).NL ~= E1
                Experts(i).NLprevious = E1;
            end
            E1 = Expert_IbI.NL;
            if Experts(i).Cost < Expert_IbI.Cost
                Expert_IbI.Cost = Experts(i).Cost;
                Expert_IbI.NL = Experts(i).NL;
            end
            if Expert_IbI.NL ~= E1
                Logic.NL = E1;
            end
        end
        
        costs1((m-1)*(n_t(1,1))+it_phase1,1) = Expert_IbI.Cost;
        Bests_Results((m-1)*(n_t(1,1))+it_phase1).NL = Expert_IbI.NL;
        Bests_Results((m-1)*(n_t(1,1))+it_phase1).Cost = Expert_IbI.Cost;
        
    end
end
NUM = n_it_phase1;
for it_phase2 = 1:n_it_phase2
NUM = NUM+1;    
    % Calculate the ratios
    for i = 1:nNL
        C(i,1) = sqrt(sum((Experts(i).NL-Logic.NL).^2));
        D(i,1) = sqrt(sum((Experts(i).NL-Experts(i).NLprevious).^2));
        P(i,1) = sqrt(sum((Experts(i).NL-Expert_IbI.NL).^2));
    end
    min_D = min(D); max_D = max(D);
    min_P = min(P); max_P = max(P);
    min_C = min(C); max_C = max(C);
    
    Rc = (C-min_C)./(max_C-min_C);
    Rp = (P-min_P)./(max_P-min_P);
    RD = (D-min_D)./(max_D-min_D);
    Bc = Bmin + (Bmax-Bmin)*rand();
    Bp = Bmin + (Bmax-Bmin)*rand();
    BD = Bmin + (Bmax-Bmin)*rand();
    
    for i = 1:nNL
        B = Bmin + (Bmax-Bmin)*rand();
        if (Rc(i,1) <= Bc) && (Rp(i,1) <= Bp)
            random_member = randi (nNL);
            K0(i).NL = Rp(i,1).*(Experts(i).NL + Experts(random_member).NL)./2;
        elseif (Rc(i,1) <= Bc) && (Rp(i,1) > Bp)
            SUM = 0;
            for ii = 1:nNL
                SUM = Experts(ii).NL + SUM;
            end
            Average = SUM./nNL;
            K0(i).NL = Rp(i,1).*(Experts(i).NL + Average)./2;
        elseif (Rc(i,1) > Bc) && (Rp(i,1) <= Bp)
            random_member = randi (nNL);
            K0(i).NL = Rp(i,1).*(Expert_IbI.NL + Experts(random_member).NL)./2;
        elseif (Rc(i,1) > Bc) && (Rp(i,1) > Bp)
            SUM = 0;
            for ii = 1:nNL
                SUM = Experts(ii).NL + SUM;
            end
            Average = SUM./nNL;
            K0(i).NL = Rp(i,1).*(Expert_IbI.NL + Average)./2;
        end
        
        if RD(i,1)<= BD
            SUM = 0;
            for ii = 1:nNL
                SUM = Experts(ii).NL + SUM;
            end
            Average = SUM./nNL;
            K1(i).NL = (rand()).*(Average);
        else
            K1(i).NL = (rand()).*(unifrnd(Vmin,Vmax,1,nV));
        end
        
        % Update the NL
        Knowledge_Phase2(i).NL = abs(K0(i).NL + K1(i).NL)./2;
        alpha2 = -0.75+1.5.*rand(1,nV);
        Expert_new.NL = Experts(i).NL + alpha2.*(Knowledge_Phase2(i).NL);
        Expert_new.NL = max(Expert_new.NL, Vmin);
        Expert_new.NL = min(Expert_new.NL, Vmax);
        E1 = Experts(i).NL;
        Expert_new.Cost = CostFunction(Expert_new.NL);
        
        COEF = -0.75+1.5*rand();
        K = rand().*(Expert_IbI.NL);
        NEW.NL = COEF.*(Expert_new.NL) + K;
        NEW.NL = max(NEW.NL, Vmin);
        NEW.NL = min(NEW.NL, Vmax);
        NEW.Cost = CostFunction(NEW.NL);
        
        if NEW.Cost < Expert_new.Cost
            Expert_new = NEW;
        end
        
        if Expert_new.Cost < Experts(i).Cost
            Experts(i).NL = Expert_new.NL;
            Experts(i).Cost = Expert_new.Cost;
        end
        if Experts(i).NL ~= E1
            Experts(i).NLprevious = E1;
        end
        E1 = Expert_IbI.NL;
        if Experts(i).Cost < Expert_IbI.Cost
            Expert_IbI.Cost = Experts(i).Cost;
            Expert_IbI.NL = Experts(i).NL;
        end
        if Expert_IbI.NL ~= E1
            Logic.NL = E1;
        end
    end
    
    costs2(it_phase2,1) = Expert_IbI.Cost;
    Bests_Results(NUM).NL = Expert_IbI.NL;
    Bests_Results(NUM).Cost = Expert_IbI.Cost;
end

%% Phase 3: IbI Logic Search

for it_phase3 = 1:n_it_phase3
NUM = NUM+1;    
    for i = 1:nNL
        SUM = 0;
        for ii = 1:nNL
            SUM = SUM + Experts(ii).NL;
        end
        Average = SUM./nNL;
        
        factor = randi(2);
        if factor == 1
            Knowledge_Phase3(i).NL = abs(Average - Experts(randi(nNL)).NL);
        else
            Knowledge_Phase3(i).NL = abs(Average - Expert_IbI.NL);
        end
        alpha3 = -0.25+0.5.*rand(1,nV);
        Expert_new.NL = Experts(i).NL + alpha3.*(Knowledge_Phase3(i).NL);
        
        Expert_new.NL = max(Expert_new.NL, Vmin);
        Expert_new.NL = min(Expert_new.NL, Vmax);
        Expert_new.Cost = CostFunction(Expert_new.NL);
        
        COEF = -0.25+0.5*rand();
        K = rand().*(Expert_IbI.NL);
        NEW.NL = COEF.*(Expert_new.NL) + K;
        NEW.NL = max(NEW.NL, Vmin);
        NEW.NL = min(NEW.NL, Vmax);
        NEW.Cost = CostFunction(NEW.NL);
        if NEW.Cost < Expert_new.Cost
            Expert_new = NEW;
        end
        
        if Expert_new.Cost < Experts(i).Cost
            Experts(i).NL = Expert_new.NL;
            Experts(i).Cost = Expert_new.Cost;
        end
        if Experts(i).Cost < Expert_IbI.Cost
            Expert_IbI.Cost = Experts(i).Cost;
            Expert_IbI.NL = Experts(i).NL;
        end
    end
    costs3(it_phase3,1) = Expert_IbI.Cost;
    Bests_Results(NUM).NL = Expert_IbI.NL;
    Bests_Results(NUM).Cost = Expert_IbI.Cost;
end

%% Extract the results
Expert_IbI.Cost = CostFunction(Expert_IbI.NL);

end

 下方小卡片回复关键词：2023，免费获取2023年智能优化算法合集matlab代码。

后续会继续发布2023年其他最新优化算法，敬请关注。

猜你喜欢

转载自blog.csdn.net/woaipythonmeme/article/details/131322393
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022