差分进化算法DE(学习笔记_06)

最新推荐文章于 2024-03-15 15:51:15 发布
最新推荐文章于 2024-03-15 15:51:15 发布
阅读量1.7k 收藏 10
点赞数 6
分类专栏： 智能优化算法 文章标签： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49647278/article/details/122644722
版权

1. 特点

  • 采用概率转移规则，不需要确定性的规则。

  • 具有内在的并行性，利用个体局部信息、群体全局信息指导进一步搜索。

  • 算法操作简单，利于求解高维度的函数优化问题。

2. 基本参数

  • np: 种群规模，np >= 4

  • f: 变异算子，决定偏差向量的缩放比例。 f∈[0,2]

    • 大 (f>1)：差分向量的扰动过大，种群收敛性能差

    • 小：易陷入局部最优

  • cr: 交叉算子，控制一个实验向量参数来自于随机选择的变异向量而非原向量的概率。cr∈[0,1]

    • 大：加速收敛

3. 基本流程

  1. 初始化参数，随机产生初始种群，进化代数 i = 1

  2. 评价初始种群（计算每个个体的目标函数值）

  3. for i = 2：iter_max

    1. 变异操作

    2. 交叉操作

    3. 边界条件处理，得到临时种群

    4. 评价临时种群

    5. 选择操作（一对一），得到新种群

  4. end

  5. 输出结果

4. 差分进化算法的其他形式

  • 符号：DE/x/y/z

  • x ：当前被变异的向量是“随机的”或“最佳的”。

  • y : 所利用的差向量的个数

  • z ：交叉程序的操作方法 (bin、exp)

5. DE/rand/1/bin

  • r1 = randi([1,np]);
v(j,:) = x(r1,:) + f * (x(r2,:) - x(r3,:));

  • 源代码如下：

%% DE/rand/1/bin
% DE/被变异的向量是随机的/差向量1个/交叉操作bin

clear;
close all;
clc;

np = 30;  %种群数量
d = 2;  %维度
iter_max = 200;  %最大迭代次数
f = 0.5;  %变异算子
cr = 0.1;  %交叉算子

x_max = 5;
x_min = -5;

x = zeros(np,d);  %初始种群
u = zeros(np,d);  %变异后的种群
v = zeros(np,d);  %交叉后的种群

%% 1.初始化种群
x = rand(np,d) * (x_max - x_min) + x_min;

%% 2.评价初始种群
for i = 1:np
    ob(i) = func(x(i,:));
end
trace(1) = min(ob);

for i = 1:iter_max-1
    %% 3.变异操作
    for j = 1:np
        r1 = randi([1,np]);
        while(r1 == j)
            r1 = randi([1,np]);
        end
        r2 = randi([1,np]);
        while(r2 == j)
            r2 = randi([1,np]);
        end
        r3 = randi([1,np]);
        while(r3 == j)
            r3 = randi([1,np]);
        end
        v(j,:) = x(r1,:) + f * (x(r2,:) - x(r3,:));
    end
    
    %% 4.交叉操作
    r = randi([1,np]);
    for j = 1:d
        cr_t = rand(1);
        if (cr_t <= cr) | (j == r)
            u(j,:) = v(j,:);
        else
            u(j,:) = x(j,:);
        end
    end
    
    %% 5.边界处理(边界吸收)
    for j = 1:d
        for k = 1:np
            if u(k,j) < x_min
                u(k,j) = x_min;
            end
            if u(k,j) > x_max
                u(k,j) = x_max;
            end
        end
    end
    
    %% 6.选择操作
    %计算变异、交叉、边界处理后的种群的适应度值
    for j = 1:np
        f1(j) = func(u(j,:));
    end
    for j = 1:np
        if f1(j) < ob(j)
            x(j,:) = u(j,:);
        end
    end
    %重新计算适应度值
    for j = 1:np
        ob(j) = func(x(j,:));
    end
    trace(i + 1) = min(ob);
end

%% 6.输出
disp( '最小值位置为:');
[sortf,index] = sort(ob);
x = x(index,:);
x = x(1,:);
x
disp( '最小值为:');
min(ob)

figure
plot(trace);
hold on;
legend_str = {'DE/rand/1/bin','DE/best/2/bin','自适应的DE/best/2/bin'};
xlabel('迭代次数');
ylabel('适应度值');
title("适应度进化曲线")

function results = func(x)
    results = 5 * cos(x(1) * x(2))+ x(1) * x(2) + x(2) * x(2) * x(2);
end

6. DE/best/2/bin

  • v(j,:) = x(best,:) - f * (x(r1,:) - x(r2,:) + x(r3,:) - x(r4,:));

  • 源代码如下：

%% DE/best/2/bin
% DE/被变异的向量是最佳的/差向量2个/交叉操作bin

np = 20;  %种群数量
d = 2;  %维度
iter_max = 200;  %最大迭代次数
f = 0.5;  %变异算子
cr = 0.1;  %交叉算子

x_max = 5;
x_min = -5;

x = zeros(np,d);  %初始种群
u = zeros(np,d);  %变异后的种群
v = zeros(np,d);  %交叉后的种群

%% 1.初始化种群
x = rand(np,d) * (x_max - x_min) + x_min;

%% 2.评价初始种群
for i = 1:np
    ob(i) = func(x(i,:));
end
trace(1) = min(ob);
for i = 1:np
    if ob(i) == trace(1)
        best = i;
        break;
    end
end
    

for i = 1:iter_max-1
    %% 3.变异操作
    for j = 1:np
        r1 = randi([1,np]);
        while(r1 == j)
            r1 = randi([1,np]);
        end
        r2 = randi([1,np]);
        while(r2 == j | r2 == r1)
            r2 = randi([1,np]);
        end
        r3 = randi([1,np]);
        while(r3 == j | r3 == r1 | r3 == r2)
            r3 = randi([1,np]);
        end
        r4 = randi([1,np]);
        while(r4 == j | r4 == r1 | r4 == r2 | r4 == r3)
            r4 = randi([1,np]);
        end
        v(j,:) = x(best,:) - f * (x(r1,:) - x(r2,:) + x(r3,:) - x(r4,:));
    end
    
    %% 4.交叉操作
    r = randi([1,np]);
    for j = 1:d
        cr_t = rand(1);
        if (cr_t <= cr) | (j == r)
            u(j,:) = v(j,:);
        else
            u(j,:) = x(j,:);
        end
    end
    
    %% 5.边界处理(边界吸收)
    for j = 1:d
        for k = 1:np
            if u(k,j) < x_min
                u(k,j) = x_min;
            end
            if u(k,j) > x_max
                u(k,j) = x_max;
            end
        end
    end
    
    %% 6.选择操作
    %计算变异、交叉、边界处理后的种群的适应度值
    for j = 1:np
        f1(j) = func(u(j,:));
    end
    for j = 1:np
        if f1(j) < ob(j)
            x(j,:) = u(j,:);
        end
    end
    %重新计算适应度值
    for j = 1:np
        ob(j) = func(x(j,:));
    end
    trace(i + 1) = min(ob);
    
    for pos = 1:np
        if ob(pos) == trace(i + 1)
            best = pos;
            break;
        end
    end
end

%% 6.输出
disp( '最小值位置为:');
[sortf,index] = sort(ob);
x = x(index,:);
x = x(1,:);
x
disp( '最小值为:');
min(ob)

plot(trace);
hold on;
xlabel('迭代次数');
ylabel('适应度值');
title("适应度进化曲线")

function results = func(x)
    results = 5 * cos(x(1) * x(2))+ x(1) * x(2) + x(2) * x(2) * x(2);
end

7. 自适应差分进化算法( DE/best/2/bin基础上改进 )

  • 自适应的变异算子

  • lamuda = exp(1)^(1 - iter_max/(iter_max + 1 - i));
f = f0 * 2^lamuda;
v(j,:) = x(best,:) - f * (x(r1,:) - x(r2,:) + x(r3,:) - x(r4,:));

  • 随机范围的交叉算子(平均值0.75)，有助于保持群体的多样性

  • cr = 0.5 * (1 + rand);

  • 源代码如下：

%% 自适应机制 DE/best/2/bin
% DE/被变异的向量是最佳的/差向量1个/交叉操作bin
% 自适应变异算子 + 平均值为0.75的随机交叉算子

np = 30;  %种群数量
d = 2;  %维度
iter_max = 200;  %最大迭代次数
f0 = 2;  %变异算子
cr = 0.75;  %交叉算子

x_max = 5;
x_min = -5;

x = zeros(np,d);  %初始种群
u = zeros(np,d);  %变异后的种群
v = zeros(np,d);  %交叉后的种群

%% 1.初始化种群
x = rand(np,d) * (x_max - x_min) + x_min;

%% 2.评价初始种群
for i = 1:np
    ob(i) = func(x(i,:));
end
trace(1) = min(ob);
for i = 1:np
    if ob(i) == trace(1)
        best = i;
        break;
    end
end
    
for i = 1:iter_max-1
    %% 3.变异操作
    for j = 1:np
        r1 = randi([1,np]);
        while(r1 == j)
            r1 = randi([1,np]);
        end
        r2 = randi([1,np]);
        while(r2 == j | r2 == r1)
            r2 = randi([1,np]);
        end
        r3 = randi([1,np]);
        while(r3 == j | r3 == r1 | r3 == r2)
            r3 = randi([1,np]);
        end
        r4 = randi([1,np]);
        while(r4 == j | r4 == r1 | r4 == r2 | r4 == r3)
            r4 = randi([1,np]);
        end
        %自适应变异算子
        lamuda = exp(1)^(1 - iter_max/(iter_max + 1 - i));
        f = f0 * 2^lamuda;
        v(j,:) = x(best,:) - f * (x(r1,:) - x(r2,:) + x(r3,:) - x(r4,:));
    end
    
    %% 4.交叉操作
    r = randi([1,np]);
    cr = 0.5 * (1 + rand);  %平均值为0.75的随机交叉算子
    for j = 1:d
        cr_t = rand(1);
        if (cr_t <= cr) | (j == r)
            u(j,:) = v(j,:);
        else
            u(j,:) = x(j,:);
        end
    end
    
    %% 5.边界处理(边界吸收)
    for j = 1:d
        for k = 1:np
            if u(k,j) < x_min
                u(k,j) = x_min;
            end
            if u(k,j) > x_max
                u(k,j) = x_max;
            end
        end
    end
    
    %% 6.选择操作
    %计算变异、交叉、边界处理后的种群的适应度值
    for j = 1:np
        f1(j) = func(u(j,:));
    end
    for j = 1:np
        if f1(j) < ob(j)
            x(j,:) = u(j,:);
        end
    end
    %重新计算适应度值
    for j = 1:np
        ob(j) = func(x(j,:));
    end
    trace(i + 1) = min(ob);
    
    for pos = 1:np
        if ob(pos) == trace(i + 1)
            best = pos;
            break;
        end
    end
end

%% 6.输出
disp( '最小值位置为:');
[sortf,index] = sort(ob);
x = x(index,:);
x = x(1,:);
x
disp( '最小值为:');
min(ob)

plot(trace);
xlabel('迭代次数');
ylabel('适应度值');
title("适应度进化曲线");
legend(legend_str);

function results = func(x)
    results = 5 * cos(x(1) * x(2))+ x(1) * x(2) + x(2) * x(2) * x(2);
end

  8. 对比

 

Cloud-Lii
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DE.rar_DE进化算法_Fitness function_变异_差分进化_差分进化算法
07-15
标准差分进化算法，适应度函数，变异，交叉，选择，生成迭代图
de_差分进化算法_althoughonc_DE_
09-29
差分进化算法是一种高效的全局优化算法。它也是基于群体的启发式搜索算法，群中的每个个体对应一个解向量
免费：差分进化算法（Differential Evolution, DE）原理及其Matlab代码，详细中文版！
最新发布
2301_82017165的博客
03-15 533
差分进化算法（Differential Evolution, DE）原理及其Matlab代码，详细中文版！
DE_机器学习_差分进化算法_
10-04
机器学习经典算法matlab实现，差分进化算法
基于差分进化算法求解最优问题
04-08
基于差分进化算法，求解函数最优值问题，并画出曲线。
机器学习之算法优化—Geatpy工具中案例分析
ex_6450的博客
08-16 2393
问题1：如何用多种群来进行单目标优化 下面代码是通过加multi来构建SEGA进化算法来进行多种群进化优化： 上述代码输出为： 差分进化DE_rand_1_bin算法 算法描述:差分进化DE_rand_1_bin算法构造函数： 主要参数说明：代码为： 输出为： 2.2例2是展示了一个带约束的单目标旅行商问题的求解。 问题2： 代码如下： 输出为： matplotlib绘制路线图为： 问题3：代码为： 输出为： 问题4：模型：分析： 该问题可以单纯用实整数编码’RI’来实现，但由于有一个”x3,
DE：差分进化算法简单介绍
guangda_cargod的博客
12-14 2105
DE:differential evolution，差分进化算法
差分进化（DE）学习笔记
hulk的博客
04-09 501
差分进化（DE）学习笔记标准DE 标准DE 选择一个目标个体Xi，和随机三个个体Xr1, Xr2, Xr3(r1,r2,r3≠i)，变异得到Vi，给定的CR∈[0,1]为交叉概率，作为阈值使能随机选取变异个体Vi和目标个体Xi(父代解)中的基因(决策变量)组成新个体。 Irand是在区间［１，Ｄ(决策变量个数)］中随机选择的整数，保证Ui至少要从Vi中获得一个值，以确保试验向量(Ui,i.e....
差分进化算法——1
weixin_45890771的博客
10-02 5995
1、差分进化算法 差分进化算法是基于群体智能理论的优化算法，是通过群体内个体间的合作与竞争而产生的智能优化搜索算法。但相比于进化计算，它保留了基于种群的全局的搜索策略，采用实数编码、基于差分的简单变异操作和“一对一”的竞争生存策略，降低了进化计算操作的复杂性。同时，差分进化算法特有的记忆能力能使其可以动态跟踪当前的搜索情况，以调整其搜索策略，它具有较强的全局收敛能力和稳健性，且不需要借助问题的特征信息，适用于求解一些利用常规的数学规划方法很难求解甚至无法求解的复杂优化问题。 差分进化算法是一种自组织最小
DE算法代码学习
m0_49556086的博客
09-27 571
DE算法，代码分析
DE_差分进化算法matlab代码_源码
10-02
标准差分进化算法，多种不同的交叉策略供选择，代码添加注释，供初学者学习使用。
DE.rar_DE进化算法_corng91_差分进化_差分进化算法
07-14
使用matlab编程语言实现标准差分进化算法
差分进化算法DE
qq_51165184的博客
12-13 184
差分进化算法是一种基于贪心的并行直接搜索算法。
【转载】差分进化算法 (Differential Evolution)
Uuujuutdfu的博客
02-25 1572
原文：https://www.cnblogs.com/tsingke/p/5809453.html Differential Evolution（DE）是由Storn等人于1995年提出的，和其它演化算法一样，DE是一种模拟生物进化的随机模型，通过反复迭代，使得那些适应环境的个体被保存了下来。但相比于进化算法，DE保留了基于种群的全局搜索策略，采用实数编码、基于差分的简单变异操作和一对一的竞争生存...
差分进化算法
qq_30142403的博客
12-02 5285
1.算法提出及思想来源 差分进化算法（Differential Evolution，DE)于1997年由Rainer Storn和Kenneth Price在遗传算法等进化思想的基础上提出的，本质是一种多目标（连续变量）优化算法（MOEAs），用于求解多维空间中整体最优解。 差分进化思想来源即是早期提出的遗传算法（GeneticAlgorithm，GA），模拟遗传学中的杂交(crossover)...
差分进化算法（Differential Evolution)概述
weixin_45813276的博客
01-27 9497
差分进化算法（Differential Evolution)概述 1 引言 ​最优化方法分为传统优化方法和启发式优化方法两大类。传统优化方法大多利用目标函数的梯度 (或导数)信息实现单可行解的惯序、确定性搜索；启发式优化方法以仿生算法为主，通过启发式搜索策略实现多可行解的并行、随机优化。启发式搜索算法不要求目标函数连续、可微等信息，具有较好的全局寻优能力。 ​在众多启发式优化方法中，差分进化算法是一种基于群体差异的启发式随机搜索算法，该算法是R．Store和K．Price为求解Chebyshev多项式而提
关于差分进化算法(Differential Evolution)
遗世独立的乌托邦
11-14 4168
差分进化算法最具有特色的是它的自适应变异操作，在演化的初期阶段，因为种群中个体的差异较大，因此用来作为变异扰动的差向量也较大，个体的扰动就较大，有利于算法的全局搜索；随着演化的进行，当算法趋于收敛的时候，种群中个体的差异随之较小，因此用来变异扰动的差向量也随之自适应地变小，较小的扰动有利于局部搜索。正是由于这种简单又独具特色的变异操作有效地平衡了差分演化算法的全局搜索能力和局部搜索能力。
DE算法理解与实验
m0_49556086的博客
09-26 1041
DE
反向学习自适应差分进化算法
06-10
反向学习自适应差分进化算法（Reverse Learning Adaptive Differential Evolution, RL-Adaptive-DE）是一种基于自适应控制参数和差分进化算法的优化算法，用于解决函数优化问题。与传统的差分进化算法不同的是，RL-Adaptive-DE算法采用“反向学习”方式来更新种群，以提高算法的全局搜索能力，并且采用自适应控制参数方法来提高算法的收敛速度和搜索能力。 在RL-Adaptive-DE算法中，控制参数被视为可变的，通过自适应地调整控制参数来实现算法的自适应性。具体来说，RL-Adaptive-DE算法采用多种自适应方法来动态地调整控制参数，如F值的自适应调整、交叉概率的自适应调整和种群大小的自适应调整等，以适应不同的搜索环境。此外，RL-Adaptive-DE算法还采用混沌序列来产生随机数，从而增加算法的随机性，提高算法的全局搜索能力。 总之，RL-Adaptive-DE算法是一种高效、自适应、全局搜索能力强的优化算法，适用于各种函数优化问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值