An Adaptive Coevolutionary Differential Evolution Algorithm for Large-scale Optimization

0、论文背景

本文在JADE和DECC_G的基础上，提出了JACC_G算法。在新的JACC-G算法中：采用带有lpbest的JADE作为子组件优化器；自适应加权仅在部分周期工作，添加检测模块以防止任意应用；在自适应加权过程中使用JADE优化权重向量。

Yang Z, Zhang J, Tang K, et al. An adaptive coevolutionary differential evolution algorithm for large-scale optimization[C]//2009 IEEE Congress on Evolutionary Computation. IEEE, 2009: 102-109.

1、 JACC_G

JACC_G是改自DECC_G，只不过优化器用了带有lpbest的JADE；自适应加权仅在部分周期工作；以及采用JADE优化权重向量。因此本文主要讲解这变化的三个部分，着重前面两个部分。有关DECC_G，请参见博客：DECC_G。有关JADE，请参见博客：JADE。

1.1 lpbest 的 JADE

pbest下的JADE，前100p%的个体总是被选择为pbest成员，导致后续差的个体被选择概率为0。随着迭代的进行，慢慢趋近于收敛，pbest成员几乎不怎么变动。为了提高JADE的探索能力，提出了lpbest下的JADE，lpbest选择的值更具多样性，就是差的个体，被选择的概率也不为0。

• 首先将所有的个体(NS个)随机均分为K组，，每组有 NS / K 个个体。
• 将每组的最佳值取出来放到 lpbest 中，lpbest中成员就有K个了。
• 每次突变中，随机从 lpbest 中去一个值作为。

从以上过程中不难发现，除了最差的K-1个值被选择的概率为0，其他个体均有选择成为的概率。

1.2 何时应用自适应加权的检测

在每个周期中，如果子控件10个，EACC-G必须优化10个子组件，并执行3次的自适应加权操作。在这种情况下，自适应加权大约需要总计算工作量的，计算量是相当大的。

为了防止任意使用自适应加权，我们引入了一个概率wp，它被初始化为wp = 1，来控制何时应用自适应加权策略。当自适应加权失效时，概率wp将迅速降低；因此，避免在无价值的自适应加权过程上浪费计算工作量是有用的。

 2、算法的复现以及简单实验

JACC_G的代码如下：

function sub_x = JADE1(sub_x, sample_y, best_x, index1, maxIteration,dim, LB, UB, Fun)

muCR = 0.5;    % 相关变量的初始化
muF = 0.5;
A = [];
p = 0.05;
c = 0.2;
popsize = size(sub_x,1);

for time = 1 : maxIteration
    SF = [];
    SCR = [];
    for i = 1 : popsize

        CR = normrnd(muCR, 0.1);    % 正太随机数   
        F = Cauchy_rand(muF, 0.1);    % 柯西随机数

        index = randperm(popsize);
        lpbest = [];
        k = p * popsize;
        subSizeIndex = popsize / k;
        for i0 = 1 : k
            index0 = ((i0 - 1) * subSizeIndex + 1) : i0 * subSizeIndex;
            eachLevelFitness = sample_y(index(index0));
            eachLevelSol = sub_x(index(index0), :);
            [~,ind1] = min(eachLevelFitness);
            lpbest = [lpbest; eachLevelSol(ind1, :)];    % 获得lpbest
        end
        xPBest = lpbest(randi(k), :);

        r1 = randi(popsize);
        while r1 == i
            r1 = randi(popsize);
        end
        SolA = [sub_x; A];
        r2 = randi(size(SolA, 1));
        while r2 == r1 || r2 == i
            r2 = randi(size(SolA, 1));
        end
        mutantPos = sub_x(i, :) + F * (xPBest - sub_x(i, :)) + F * (sub_x(r1, :) - SolA(r2, :));    % 突变

        jj = randi(dim);  % 选择至少一维发生交叉
        for d = 1:dim
            if rand() < CR || d == jj
                crossoverPos(d) = mutantPos(d);
            else
                crossoverPos(d) = sub_x(i,d);
            end
        end
        
        crossoverPos(crossoverPos>UB) = UB;     % 检查是否越界
        crossoverPos(crossoverPos<LB) = LB;

        best_x(:,index1) = crossoverPos;
        evalNewPos = Fun(best_x);    % 将突变和交叉后的变量重新评估
        if evalNewPos < sample_y(i)    % 小于原有值就更新
            A = [A; sub_x(i,:)];
            if size(A, 1) > popsize
                A(randi(size(A, 1)), :) = [];    % 保持A的数目不超过popsize
            end
            SCR = [SCR; CR];
            SF = [SF; F];
            sub_x(i,:) = crossoverPos;
            sample_y(i) = evalNewPos;
        end
    end

    muCR = (1 - c) * muCR + c * mean(SCR);
    muF = (1 - c) * muF + c * (sum(SF .* SF) / sum(SF));
end
end

clc;clear;clearvars;
addpath('CEC2008\');
global initial_flag

NS = 100;   % 种群数
dim = 500;   % 种群维度
s = 5;    % 子空间的数目,设定为5,10
upper_bound = [100,100,100,5,600,32,1];
lower_bound = [-100,-100,-100,-5,-600,-32,-1];
bestYhistory = [];    % 保存每次迭代的最佳值

for func_num = 1

    initial_flag = 0;    % 换一个函数initial_flag重置为0
    sample_x = lhsdesign(NS, dim).*(upper_bound(func_num) - lower_bound(func_num)) + lower_bound(func_num).*ones(NS, dim);    % 生成NS个种群,并获得其评估值
    sample_y = benchmark_func(sample_x,func_num);
    [best_y, bestIndex] = min(sample_y);    % 获取全局最小值以及对应的种群
    best_x = sample_x(bestIndex,:);
    wp = 1;    % 自适应加权的概率

    for i0 = 1 : 50     % 迭代50次

        index = randperm(dim);      % 随机划分子空间
        for i1 = 1 : s
            index1 = index(((i1 - 1) * (dim / s) + 1) : (i1 * (dim / s)));
            sub_x = sample_x(:,index1);
            sub_x = JADE1(sub_x, sample_y, best_x, index1, 70, dim / s, lower_bound(func_num), upper_bound(func_num), @(x)benchmark_func(x,func_num));%100*70
            sample_x(:,index1) = sub_x;
            sample_y = benchmark_func(sample_x,func_num);   %100
            [best_y, bestIndex] = min(sample_y);    % 获取全局最小值以及对应的种群
            best_x = sample_x(bestIndex,:);
        end

        [worse_y, worseIndex] = max(sample_y);    % 获取全局最大值以及对应的种群
        randIndex = randi(NS);
        while randIndex == bestIndex || randIndex == worseIndex
            randIndex = randi(NS);     % 随机获取一个值
        end
        if rand() < wp
            [worseX,worseY] = JADE2(sample_x(worseIndex,:), NS, 50, s, -2, 2, @(x)benchmark_func(x,func_num));% 50*100
            [bestX,bestY] = JADE2(sample_x(bestIndex,:), NS, 50, s, -2, 2, @(x)benchmark_func(x,func_num));% 权重向量在[-2,2]之间搜寻
            [randX,randY] = JADE2(sample_x(randIndex,:), NS, 50, s, -2, 2, @(x)benchmark_func(x,func_num));
            if worseY < best_y || bestY < best_y || randY < best_y    % wp自适应
                wp = min(1, wp * 2);
            else
                wp = wp / 2;
            end
            if worseY < best_y
                sample_x(worseIndex,:) = worseX;
                sample_y(worseIndex,:) = worseY;
            end
            if bestY < best_y
                sample_x(bestIndex,:) = bestX;
                sample_y(bestIndex,:) = bestY;
            end
            if randY < best_y
                sample_x(randIndex,:) = randX;
                sample_y(randIndex,:) = randY;
            end
        end

        [best_y, bestIndex] = min(sample_y);    % 获取全局最小值以及对应的种群
        best_x = sample_x(bestIndex,:);
        bestYhistory = [bestYhistory;best_y];
    end
end
plot(bestYhistory);

f1DECC_G：

f1JACC_G:

f2DECC_G：

f2JACC_G:

f3DECC_G：

f3JACC_G:

 可以发现，无论在收敛速度上还是在结果上，JACC_G均优于DECC_G。而且自适应加权的检测的存在，使得JACC_G的计算工作量是少于DECC_G的。