智能优化算法之郊狼算法(COA)，原理公式详解，附matlab代码

郊狼优化算法(Coyote Optimization Algorithm,COA)是一种新的仿生智能算法，该算法主要模拟了北美郊狼的社会组织及其生活状态，该算法不仅具有独特的搜索结构以及出色的优化能力，而且在求解全局优化问题时优势明显。该成果于2018年发表在知名SCI期刊IEEE Congress on Evolutionary Computation (CEC)上。目前谷歌学术上查询被引476次。

COA算法通过初始化种群、郊狼的成长、郊狼的生死、郊狼的驱逐和接纳四个主要操作模拟了郊狼群体行为，最后选取最优解。

算法原理

（1）初始化种群

令总种群的数量为N,Np为郊狼子种群的数量，每个郊狼子种群中郊狼的数量为Nc。随机初始化每个郊狼个体，每个郊狼个体以向量形式表示，因此第p个郊狼子种群中第c个郊狼个体的初始位置表示为  其中r为[0,1]之间的随机数；uj.、lj分别为第j维的上限、下限，设维度为D,则j=1,2,…,D。每个郊狼个体对社会的适应能力被称为适应度，适应度用目标函数表示为：

（2）郊狼的成长

在郊狼成长过程中,令每个郊狼子种群都由一只头狼和(Nc-1)只普通郊狼组成,头狼用a表示,其适应环境能力最强。郊狼成长过程不仅受到头狼影响还受到组内文化趋势的影响，定义组内文化趋势为u，其表示为: 

为偶数其他。 式中Rp为每个郊狼子种群中郊狼的社会地位排名

（3)郊狼的生与死

COA算法中郊狼的出生与死亡由郊狼的父母和社会环境共同决定，每组郊狼子种群中每只郊狼年龄，记为apc(t)，郊狼的生与死表示如下： 其他 式中y'3、y'4表示从第p组郊狼子群体中任意选择２只郊狼为其父母郊狼；j1、j2表示２个随机的维度；r'j为[0,1]之间的随机数;Rj表示为第j维度的随机数并受到上、下限的约束。

（4）

组内驱逐和接纳

COA算法中存在子群体的驱逐和接纳现象,每个子群体中的郊狼有一定概率被驱逐到其他子群体中，这是为了保证子群体之间的信息共享，因此驱逐发生的概率为: 

 结果展示

以为CEC2005函数集为例，进行结果展示：

 MATLAB核心代码

function [GlobalParams,GlobalMin,crgy] = COA(FOBJ, lu, nfevalMAX,n_packs,n_coy)
%% ------------------------------------------------------------------------
% Coyote Optimization Algorithm (COA) for Global Optimization.
% A nature-inspired metaheuristic proposed by Juliano Pierezan and 
% Leandro dos Santos Coelho (2018).
%
% Pierezan, J. and Coelho, L. S. "Coyote Optimization Algorithm: A new 
% metaheuristic for global optimization problems", Proceedings of the IEEE 
% Congress on Evolutionary Computation (CEC), Rio de Janeiro, Brazil, July 
% 2018, pages 2633-2640.
%
% Example:
% FOBJ        = @(x) sum(x.^2);         % Optimization problem
% D           = 30;                     % Problem dimension
% lu          = [zeros(1,D);ones(1,D)]; % Seach space
% nfevalMAX   = 10000*D;                % Stopping criteria
% Np          = 10;                     % Number of packs
% Nc          = 10;                     % Number of coyotes
% [GlobalParams,GlobalMin] = COA(FOBJ, lu, nfevalMAX,Np,Nc);
%
% Federal University of Parana (UFPR), Curitiba, Parana, Brazil.
% juliano.pierezan@ufpr.br
%% ------------------------------------------------------------------------


%% Optimization problem variables
D           = size(lu,2);
VarMin      = lu(1,:);
VarMax      = lu(2,:);


%% Algorithm parameters
if nargin < 5, n_coy = 5; 
elseif n_coy < 3, error('At least 3 coyotes per pack!'); end
if nargin < 4, n_packs = 20; end


% Probability of leaving a pack
p_leave     = 0.005*n_coy^2;
Ps          = 1/D;


%% Packs initialization (Eq. 2)
pop_total   = n_packs*n_coy;
costs       = zeros(pop_total,1);
coyotes     = repmat(VarMin,pop_total,1) + rand(pop_total,D).*(repmat(VarMax,pop_total,1) - repmat(VarMin,pop_total,1));
ages        = zeros(pop_total,1);
packs       = reshape(randperm(pop_total),n_packs,[]);
coypack     = repmat(n_coy,n_packs,1);


%% Evaluate coyotes adaptation (Eq. 3)
for c=1:pop_total
    costs(c,1) = FOBJ(coyotes(c,:));
end
nfeval = pop_total;


%% Output variables
[GlobalMin,ibest]   = min(costs);
GlobalParams        = coyotes(ibest,:); 
    
%% Main loop
year=0;
while nfeval<nfevalMAX % Stopping criteria
    
    %% Update the years counter
    year = year + 1;


    %% Execute the operations inside each pack
    for p=1:n_packs
        % Get the coyotes that belong to each pack
        coyotes_aux = coyotes(packs(p,:),:);
        costs_aux   = costs(packs(p,:),:);
        ages_aux    = ages(packs(p,:),1);
        n_coy_aux   = coypack(p,1);
        
        % Detect alphas according to the costs (Eq. 5)
        [costs_aux,inds] = sort(costs_aux,'ascend');
        coyotes_aux      = coyotes_aux(inds,:);
        ages_aux         = ages_aux(inds,:);
        c_alpha          = coyotes_aux(1,:);
        
        % Compute the social tendency of the pack (Eq. 6)
        tendency         = median(coyotes_aux,1);
        
        % Update coyotes' social condition
        new_coyotes      = zeros(n_coy_aux,D);
        for c=1:n_coy_aux
            rc1 = c;
            while rc1==c
                rc1 = randi(n_coy_aux);
            end
            rc2 = c;
            while rc2==c || rc2 == rc1
                rc2 = randi(n_coy_aux);
            end
            
            % Try to update the social condition according to the alpha and
            % the pack tendency (Eq. 12)
            new_c = coyotes_aux(c,:) + rand*(c_alpha - coyotes_aux(rc1,:))+ ...
                                       rand*(tendency  - coyotes_aux(rc2,:));
            
            % Keep the coyotes in the search space (optimization problem
            % constraint)
            new_coyotes(c,:) = min(max(new_c,VarMin),VarMax);
            
            % Evaluate the new social condition (Eq. 13)
            new_cost = FOBJ(new_coyotes(c,:));
            nfeval   = nfeval+1;
            
            % Adaptation (Eq. 14)
            if new_cost < costs_aux(c,1)
                costs_aux(c,1)      = new_cost;
                coyotes_aux(c,:)    = new_coyotes(c,:);
            end
        end
        
        %% Birth of a new coyote from random parents (Eq. 7 and Alg. 1)
        parents         = randperm(n_coy_aux,2);
        prob1           = (1-Ps)/2;
        prob2           = prob1;
        pdr             = randperm(D);
        p1              = zeros(1,D);
        p2              = zeros(1,D);
        p1(pdr(1))      = 1; % Guarantee 1 charac. per individual
        p2(pdr(2))      = 1; % Guarantee 1 charac. per individual
        r               = rand(1,D-2);
        p1(pdr(3:end))  = r < prob1;
        p2(pdr(3:end))  = r > 1-prob2;
        
        % Eventual noise 
        n  = ~(p1|p2);
        
        % Generate the pup considering intrinsic and extrinsic influence
        pup =   p1.*coyotes_aux(parents(1),:) + ...
                p2.*coyotes_aux(parents(2),:) + ...
                n.*(VarMin + rand(1,D).*(VarMax-VarMin));
        
        % Verify if the pup will survive
        pup_cost    = FOBJ(pup);
        nfeval      = nfeval + 1;
        worst       = find(pup_cost<costs_aux==1);
        if ~isempty(worst)
            [~,older]               = sort(ages_aux(worst),'descend');
            which                   = worst(older);
            coyotes_aux(which(1),:) = pup;
            costs_aux(which(1),1)   = pup_cost;
            ages_aux(which(1),1)    = 0;
        end
        
        %% Update the pack information
        coyotes(packs(p,:),:) = coyotes_aux;
        costs(packs(p,:),:)   = costs_aux;
        ages(packs(p,:),1)    = ages_aux;
    end
    
    %% A coyote can leave a pack and enter in another pack (Eq. 4)
    if n_packs>1
        if rand < p_leave
            rp                  = randperm(n_packs,2);
            rc                  = randi(n_coy,1,2);
            aux                 = packs(rp(1),rc(1));
            packs(rp(1),rc(1))  = packs(rp(2),rc(2));
            packs(rp(2),rc(2))  = aux;
        end
    end
    
    %% Update coyotes ages
    ages = ages + 1;
    
    %% Output variables (best alpha coyote among all alphas)
    [GlobalMin,ibest]   = min(costs);
    GlobalParams        = coyotes(ibest,:);    
    crgy(year) =  GlobalMin;


end
end

参考文献

1] Pierezan J, Coelho L D S. Coyote optimization algorithm: a new metaheuristic for global optimization problems[C]//2018 IEEE congress on evolutionary computation (CEC). IEEE, 2018: 1-8.

完整代码获取方式：后台回复关键字：

TGDM880