查分进化算法DE

Posted 2020-08-27

% 差分进化算法程序 
function DE   
    t0 = cputime;  %计时
    %% 种群初始化
    T = 1000;               % 最大迭代次数 
    F0 = 0.5;               % 变异率 
    N = 100;                % 种群大小 
    D = 10;                 % 每个个体染色体的个数，即所求问题的维数 
    CR = 0.3;               % 交叉率  
    Tmin = zeros(1,T);      % 各代适应度函数的的最优值  
    bestX = zeros(T,D);     % 各代的最优解  
    value = zeros(1,N);  
    %% 适用度函数：Rastrigr 函数最小值
    function y = f(x) 
        y = sum(x.^2 - 10.*cos(2.*pi.*x) + 10);  
    end  
    %% 产生初始种群  
    % 设置界限  
    xMin = -5.12;  
    xMax = 5.12;  
    X0 = (xMax-xMin)*rand(N,D) + xMin;  % N-by-D  
    XG = X0;  
    XG_next_1= zeros(N,D);      %初始化，存储变异操作中间值N-by-D    
    XG_next_2 = zeros(N,D);     %初始化，存储交叉操作中间值N-by-D    
    for t=1:T
        %% 变异操作
        for i = 1:N  % 表示第i个个体
            %产生j,k,p三个不同的数
            dx = randperm(N);  
            r1 = dx(1);  
            r2 = dx(2);  
            r3 = dx(3); 
            %要保证与i不同  
            if r1 == i  
                r1  = dx(4);  
                else if r2 == i  
                     r2 = dx(4);  
                    else if r3 == i  
                        r3 = dx(4);  
                    end  
                end  
             end  
            % 自适用变异算子  
            suanzi = exp(1-T/(T + 1-t));  
            F = F0*2.^suanzi;  
            % 变异的个体来自三个随机父代 
            H = XG(r1,:) + F*(XG(r2,:) - XG(r3,:)); 
            % 检查个体变异，防止变异超出边界
            for j = 1: D
                if H(j) >xMin  & H(j) < xMax    % 在边界范围内    
                    XG_next_1(i,j) = H(j);  
                else  %超出边界范围
                    XG_next_1(i,j) = (xMax - xMin)*rand + xMin;  
                end  
            end  
        end  
       %% 交叉操作
        for i = 1: N  
            dx = randperm(D);    % [1,2,3,...D]的随机序列     
            for j = 1: D  
                if rand < CR  % & dx(1) ~= j % CR = 0.9   
                      XG_next_2(i,j) = XG_next_1(i,j);
                else  
                    XG_next_2(i,j) = XG(i,j);                  
                end  
            end  
        end  
       %% 选择操作 
        for i = 1:N  
            if f(XG_next_2(i,:)) <= f(XG(i,:)) 
                XG(i,:) = XG_next_2(i,:);
            end
        end
        %% 查找每代最优值
        for i = 1:N  
            value(i) = f(XG(i,:));  
        end 
        [value_min,pos_min] = min(value);
        %第G代中的目标函数的最小值  
        Tmin(t) = value_min;     
        %保存最优的个体  
        bestX(t,:) = XG(pos_min,:); 
        trace(t,1) = t;  
        trace(t,2) = value_min;  
        t = t + 1;  
    end
    %% 全局最优值：输出结果
    [value_min,pos_min] = min(Tmin);  
    best_value = value_min  
    best_vector =  bestX(pos_min,:)    
    fprintf(‘DE所耗的时间为：%f \n‘,cputime - t0);  
    %画出代数跟最优函数值之间的关系图    
    plot(trace(:,1),trace(:,2)); 
end

输出结果：

best_value =

     0

best_vector =

   1.0e-08 *

   -0.1568   -0.1476   -0.0155    0.0578   -0.0721   -0.1532    0.1067    0.0799   -0.0818   -0.0518

DE所耗的时间为：2.640625 

本文出自 “IT技术学习与交流” 博客，谢绝转载！