1. 差分进化算法基础回顾
差分进化算法(Differential Evolution,简称DE)是一种基于群体智能的全局优化算法,由Storn和Price在1995年首次提出。它特别适合解决复杂的非线性、多模态优化问题。DE算法之所以受欢迎,主要得益于它结构简单、容易实现、收敛速度快等特点。
DE算法的核心思想是通过种群中个体之间的差异向量来产生新的解。整个过程可以分为四个基本步骤:初始化、变异、交叉和选择。首先,算法随机生成初始种群,每个个体代表搜索空间中的一个潜在解。然后,通过变异操作生成变异个体,常用的变异策略包括DE/rand/1、DE/best/1等。接下来,变异个体与目标个体进行交叉操作,产生试验个体。最后,通过选择操作决定哪些个体能够进入下一代种群。
在Matlab中实现基础DE算法非常简单。下面是一个基本的DE/rand/1/bin的实现代码示例:
function [best_solution, best_fitness] = DE(fitness_func, dim, lb, ub, pop_size, max_iter, F, CR)
% 初始化种群
population = lb + (ub - lb) .* rand(pop_size, dim);
fitness = arrayfun(@(i) fitness_func(population(i,:)), 1:pop_size);
[best_fitness, best_idx] = min(fitness);
best_solution = population(best_idx, :);
for iter = 1:max_iter
for i = 1:pop_size
% 变异:DE/rand/1
idxs = randperm(pop_size, 3);
mutant = population(idxs(1),:) + F * (population(idxs(2),:) - population(idxs(3),:));
% 交叉:二项式交叉
j_rand = randi(dim);
trial = population(i,:);
for j = 1:dim
if rand() < CR || j == j_rand
trial(j) = mutant(j);
end
end
% 边界处理
trial = min(max(trial, lb), ub);
% 选择
trial_fitness = fitness_func(trial);
if trial_fitness < fitness(i)
population(i,:) = trial;
fitness(i) = trial_fitness;
if trial_fitness < best_fitness
best_fitness = trial_fitness;
best_solution = trial;
end
end
end
end
end
这个基础版本虽然简单,但在很多问题上已经能表现出不错的性能。不过,它也存在一些局限性,比如固定的控制参数(F和CR)可能不适合不同阶段的搜索需求,简单的变异策略可能导致搜索效率不高等。这些局限性促使研究者们开发出了各种改进版本的DE算法。
2. 自适应差分进化算法SaDE
SaDE(Self-adaptive Differential Evolution)是差分进化算法的一个重要变体,由Qin和Suganthan在2005年提出。与基础DE算法不同,SaDE最大的特点是能够自适应地调整算法的控制参数和变异策略,这使得它能够更好地适应不同优化问题的特性。
SaDE的自适应机制主要体现在两个方面:参数自适应和策略自适应。在参数自适应方面,SaDE不再使用固定的F和CR值,而是让这些参数在进化过程中根据历史表现动态调整。具体来说,每个个体都有自己的F和CR值,这些值会在进化过程中不断更新。表现好的参数组合会被保留并传递给下一代,而表现差的参数组合则会被淘汰。
在策略自适应方面,SaDE维护了一个策略池,包含多种变异策略(如DE/rand/1、DE/current-to-best/1等)。算法会根据各策略的历史表现动态调整它们被选中的概率。表现好的策略会被更频繁地使用,而表现差的策略则会被较少使用。
下面是一个简化的SaDE实现示例:
function [best_solution, best_fitness] = SaDE(fitness_func, dim, lb, ub, pop_size, max_iter)
% 初始化种群和参数
population = lb + (ub - lb) .* rand(pop_size, dim);
fitness = arrayfun(@(i) fitness_func(population(i,:)), 1:pop_size);
% 初始化参数:每个个体有自己的F和CR
F = 0.5 * ones(pop_size, 1);
CR = 0.9 * ones(pop_size, 1);
% 策略池
strategies = {@strategy_rand1, @strategy_current_to_best};
strategy_success = zeros(size(strategies));
strategy_trials = zeros(size(strategies));
strategy_probs = ones(size(strategies)) / numel(strategies);
[best_fitness, best_idx] = min(fitness);
best_solution = population(best_idx, :);
for iter = 1:max_iter
for i = 1:pop_size
% 根据概率选择策略
strategy_idx = randsample(numel(strategies), 1, true, strategy_probs);
strategy = strategies{strategy_idx};
% 执行变异和交叉
[mutant, trial] = strategy(population, i, F(i), CR(i), best_solution);
% 边界处理
trial = min(max(trial, lb), ub);
% 选择
trial_fitness = fitness_func(trial);
if trial_fitness < fitness(i)
% 更新成功记录
strategy_success(strategy_idx) = strategy_success(strategy_idx) + 1;
population(i,:) = trial;
fitness(i) = trial_fitness;
if trial_fitness < best_fitness
best_fitness = trial_fitness;
best_solution = trial;
end
end
strategy_trials(strategy_idx) = strategy_trials(strategy_idx) + 1;
% 参数自适应更新
F(i) = F(i) + randn() * 0.1;
F(i) = min(max(F(i), 0.1), 1);
CR(i) = CR(i) + randn() * 0.1;
CR(i) = min(max(CR(i), 0), 1);
end
% 更新策略概率
if mod(iter, 50) == 0 && sum(strategy_trials) > 0
success_rates = strategy_success ./ (strategy_trials + eps);
strategy_probs = success_rates / sum(success_rates);
strategy_success(:) = 0;
strategy_trials(:) = 0;
end
end
end
function [mutant, trial] = strategy_rand1(population, i, F, CR, ~)
idxs = randperm(size(population,1), 3);
mutant = population(idxs(1),:) + F * (population(idxs(2),:) - population(idxs(3),:));
trial = crossover(population(i,:), mutant, CR);
end
function [mutant, trial] = strategy_current_to_best(population, i, F, CR, best)
idxs = randperm(size(population,1), 2);
mutant = population(i,:) + F * (best - population(i,:)) + F * (population(idxs(1),:) - population(idxs(2),:));
trial = crossover(population(i,:), mutant, CR);
end
function trial = crossover(target, mutant, CR)
dim = numel(target);
trial = target;
j_rand = randi(dim);
for j = 1:dim
if rand() < CR || j == j_rand
trial(j) = mutant(j);
end
end
end
SaDE在实际应用中表现优异,特别是在处理复杂多模态问题时。它的自适应机制使得算法能够在探索(exploration)和开发(exploitation)之间取得良好的平衡。不过,SaDE的实现相对复杂,计算开销也略大于基础DE算法。在实际使用时,需要根据具体问题的复杂度和计算资源进行权衡。
3. 基于外部存档的JADE算法
JADE(Adaptive Differential Evolution with Optional External Archive)是Zhang和Sanderson在2009年提出的另一种自适应DE变体。它在SaDE的基础上进一步改进,引入了两个关键创新点:基于成功历史的参数自适应和可选的外部存档机制。
JADE的参数自适应机制比SaDE更加精细。它不再为每个个体独立维护参数,而是使用基于成功历史的统计方法来更新参数。具体来说,JADE维护了两个参数μF和μCR,分别代表缩放因子F和交叉概率CR的均值。在每次迭代中,成功产生更优解的参数值会被记录下来,并用这些成功参数来更新μF和μCR。这种机制使得算法能够自动适应不同问题的特性,无需手动调整参数。
外部存档机制是JADE的另一个重要特点。在基础DE算法中,被淘汰的个体直接丢弃。而JADE将这些个体存入一个外部存档中,并在变异操作时从当前种群和存档中随机选择个体。这样做可以增加种群的多样性,防止算法过早收敛到局部最优解。
JADE还引入了"DE/current-to-pbest"变异策略,这是对传统"DE/current-to-best"策略的改进。它不仅仅使用当前最优个体,而是从表现最好的前p%个体中随机选择一个作为引导,这样既保持了算法的收敛性,又避免了过度贪婪导致的早熟收敛。
下面是一个JADE算法的Matlab实现:
function [best_solution, best_fitness] = JADE(fitness_func, dim, lb, ub, pop_size, max_iter, p)
% 初始化
population = lb + (ub - lb) .* rand(pop_size, dim);
fitness = arrayfun(@(i) fitness_func(population(i,:)), 1:pop_size);
archive = [];
% 参数初始化
mu_F = 0.5;
mu_CR = 0.5;
c = 0.1; % 学习率
p = max(p, 1/pop_size); % 确保p不是太小
[best_fitness, best_idx] = min(fitness);
best_solution = population(best_idx, :);
% 成功参数记录
S_F = [];
S_CR = [];
for iter = 1:max_iter
% 计算当前前p%个体的索引
[~, sorted_idx] = sort(fitness);
pbest_idx = sorted_idx(1:ceil(p*pop_size));
% 生成本代的F和CR
F = mu_F + 0.1 * tan(pi*(rand(pop_size,1)-0.5));
F(F<0) = 0; F(F>1) = 1;
CR = mu_CR + 0.1 * tan(pi*(rand(pop_size,1)-0.5));
CR(CR<0) = 0; CR(CR>1) = 1;
for i = 1:pop_size
% 选择pbest个体
pbest = population(pbest_idx(randi(numel(pbest_idx))), :);
% 从种群和存档中选择r1和r2
candidates = [population; archive];
idxs = randperm(size(candidates,1), 2);
r1 = candidates(idxs(1),:);
r2 = candidates(idxs(2),:);
% DE/current-to-pbest/1变异
mutant = population(i,:) + F(i)*(pbest - population(i,:)) + F(i)*(r1 - r2);
% 交叉
j_rand = randi(dim);
trial = population(i,:);
for j = 1:dim
if rand() < CR(i) || j == j_rand
trial(j) = mutant(j);
end
end
% 边界处理
trial = min(max(trial, lb), ub);
% 选择
trial_fitness = fitness_func(trial);
if trial_fitness < fitness(i)
% 将被替换的个体加入存档
if numel(archive) < pop_size
archive = [archive; population(i,:)];
else
archive(randi(size(archive,1)), :) = population(i,:);
end
% 记录成功参数
S_F = [S_F; F(i)];
S_CR = [S_CR; CR(i)];
population(i,:) = trial;
fitness(i) = trial_fitness;
if trial_fitness < best_fitness
best_fitness = trial_fitness;
best_solution = trial;
end
end
end
% 更新μF和μCR
if ~isempty(S_F)
% Lehmer均值更新μF
sum_F = sum(S_F.^2);
if sum_F > 0
mu_F = (1-c)*mu_F + c*(sum(S_F.^2)/sum(S_F));
end
% 算术均值更新μCR
mu_CR = (1-c)*mu_CR + c*mean(S_CR);
% 清空成功记录
S_F = [];
S_CR = [];
end
end
end
JADE算法在多个标准测试函数上表现出色,特别是在高维复杂问题上。它的自适应机制使得算法对初始参数设置不敏感,大大降低了使用门槛。外部存档机制则有效提高了种群的多样性,增强了算法的全局搜索能力。在实际应用中,JADE通常比基础DE和SaDE表现更好,尤其是当问题具有复杂的多模态特性时。
4. 基于成功历史记忆的SHADE算法
SHADE(Success-History based Adaptive Differential Evolution)是Tanabe和Fukunaga在2013年提出的DE变体,可以看作是JADE的增强版。SHADE在CEC2013竞赛中获得了第三名的好成绩,证明了其优异的性能。SHADE在JADE的基础上进一步改进了参数自适应机制,引入了更完善的历史记忆系统。
SHADE的核心创新是其历史记忆机制。与JADE只维护μF和μCR两个均值不同,SHADE使用两个固定大小的记忆数组MF和MCR来存储成功的参数值。这些记忆数组按照先进先出(FIFO)的原则更新,保存了最近几代的成功参数信息。当需要生成新的F和CR值时,SHADE不是简单地从固定分布中采样,而是从历史记忆数组中随机选择一个位置,然后在其附近生成新值。这种机制使得参数调整更加精细,能够更好地跟踪算法在不同搜索阶段的需求。
SHADE还改进了JADE的参数更新方式。在JADE中,所有成功参数对μF和μCR的贡献是相等的。而SHADE引入了基于适应度改进量的权重,改进量大的参数组合会获得更大的权重。这使得算法能够更重视那些带来显著改进的参数设置。
下面是一个SHADE算法的Matlab实现:
function [best_solution, best_fitness] = SHADE(fitness_func, dim, lb, ub, pop_size, max_iter, H, p)
% 初始化
population = lb + (ub - lb) .* rand(pop_size, dim);
fitness = arrayfun(@(i) fitness_func(population(i,:)), 1:pop_size);
archive = [];
% 历史记忆初始化
MF = 0.5 * ones(H, 1);
MCR = 0.5 * ones(H, 1);
k = 1; % 当前更新的记忆位置
% 其他参数
p = max(p, 1/pop_size);
c = 0.1;
[best_fitness, best_idx] = min(fitness);
best_solution = population(best_idx, :);
for iter = 1:max_iter
% 计算当前前p%个体的索引
[~, sorted_idx] = sort(fitness);
pbest_idx = sorted_idx(1:ceil(p*pop_size));
% 生成本代的F和CR
r = randi(H, pop_size, 1);
F = MF(r) + 0.1 * tan(pi*(rand(pop_size,1)-0.5));
F(F<0) = 0; F = min(F, 1);
CR = MCR(r) + 0.1 * tan(pi*(rand(pop_size,1)-0.5));
CR(CR<0) = 0; CR = min(CR, 1);
% 成功参数记录
S_F = [];
S_CR = [];
S_delta_f = [];
for i = 1:pop_size
% 选择pbest个体
pbest = population(pbest_idx(randi(numel(pbest_idx))), :);
% 从种群和存档中选择r1和r2
candidates = [population; archive];
idxs = randperm(size(candidates,1), 2);
r1 = candidates(idxs(1),:);
r2 = candidates(idxs(2),:);
% DE/current-to-pbest/1变异
mutant = population(i,:) + F(i)*(pbest - population(i,:)) + F(i)*(r1 - r2);
% 交叉
j_rand = randi(dim);
trial = population(i,:);
for j = 1:dim
if rand() < CR(i) || j == j_rand
trial(j) = mutant(j);
end
end
% 边界处理
trial = min(max(trial, lb), ub);
% 选择
trial_fitness = fitness_func(trial);
if trial_fitness < fitness(i)
% 记录成功参数
S_F = [S_F; F(i)];
S_CR = [S_CR; CR(i)];
S_delta_f = [S_delta_f; fitness(i) - trial_fitness];
% 将被替换的个体加入存档
if numel(archive) < pop_size
archive = [archive; population(i,:)];
else
archive(randi(size(archive,1)), :) = population(i,:);
end
population(i,:) = trial;
fitness(i) = trial_fitness;
if trial_fitness < best_fitness
best_fitness = trial_fitness;
best_solution = trial;
end
end
end
% 更新历史记忆
if ~isempty(S_F)
% 计算权重
weights = S_delta_f / sum(S_delta_f);
% 加权Lehmer均值更新MF
sum_F = sum(weights .* S_F.^2);
if sum_F > 0
new_MF = sum(weights .* S_F.^2) / sum(weights .* S_F);
else
new_MF = MF(k);
end
% 加权算术均值更新MCR
new_MCR = sum(weights .* S_CR);
% 更新记忆
MF(k) = new_MF;
MCR(k) = new_MCR;
% 更新记忆位置
k = mod(k, H) + 1;
end
end
end
SHADE算法在多个方面表现出色。它的历史记忆机制使得参数自适应更加精细和稳定,能够更好地适应不同优化问题的特性。基于改进量的权重分配则让算法能够更重视那些带来显著提升的参数设置。在实际应用中,SHADE通常比JADE表现更好,特别是在复杂的多模态问题上。不过,SHADE的实现相对复杂,计算开销也略大,这在处理超高维问题时可能需要考虑。
5. 线性种群缩减的LSHADE算法
LSHADE(Linear population size reduction SHADE)是SHADE算法的进一步扩展,由Tanabe和Fukunaga在2014年提出。LSHADE在CEC2014竞赛中获得了冠军,证明了其卓越的性能。LSHADE的核心创新是引入了线性种群缩减机制(Linear Population Size Reduction, LPSR),这使得算法能够在搜索过程中动态调整种群大小,提高计算效率。
LPSR机制的基本思想是:在优化初期保持较大的种群规模以增强全局探索能力,随着迭代的进行线性减小种群规模以集中计算资源进行局部开发。具体来说,LSHADE的种群大小按照以下公式更新:
N(g+1) = round([(N_min - N_init)/max_iter] * g + N_init)
其中N_init是初始种群大小,N_min是最小种群大小(通常设置为4),g是当前迭代次数,max_iter是最大迭代次数。这种线性缩减策略简单有效,能够在保持算法性能的同时显著减少计算开销。
LSHADE还继承了SHADE的所有优点,包括历史记忆机制和基于成功历史的参数自适应。这些特性与LPSR机制相结合,使得LSHADE能够在全局探索和局部开发之间取得更好的平衡,同时保持较高的计算效率。
下面是一个LSHADE算法的Matlab实现:
function [best_solution, best_fitness] = LSHADE(fitness_func, dim, lb, ub, N_init, max_iter, H, p)
% 初始化
population = lb + (ub - lb) .* rand(N_init, dim);
fitness = arrayfun(@(i) fitness_func(population(i,:)), 1:N_init);
archive = [];
% 历史记忆初始化
MF = 0.5 * ones(H, 1);
MCR = 0.5 * ones(H, 1);
k = 1;
% LPSR参数
N_min = 4;
N_current = N_init;
% 其他参数
p = max(p, 1/N_init);
c = 0.1;
[best_fitness, best_idx] = min(fitness);
best_solution = population(best_idx, :);
for iter = 1:max_iter
% 计算当前前p%个体的索引
[~, sorted_idx] = sort(fitness);
pbest_idx = sorted_idx(1:ceil(p*N_current));
% 生成本代的F和CR
r = randi(H, N_current, 1);
F = MF(r) + 0.1 * tan(pi*(rand(N_current,1)-0.5));
F(F<0) = 0; F = min(F, 1);
CR = MCR(r) + 0.1 * tan(pi*(rand(N_current,1)-0.5));
CR(CR<0) = 0; CR = min(CR, 1);
% 成功参数记录
S_F = [];
S_CR = [];
S_delta_f = [];
S_index = [];
for i = 1:N_current
% 选择pbest个体
pbest = population(pbest_idx(randi(numel(pbest_idx))), :);
% 从种群和存档中选择r1和r2
candidates = [population; archive];
idxs = randperm(size(candidates,1), 2);
r1 = candidates(idxs(1),:);
r2 = candidates(idxs(2),:);
% DE/current-to-pbest/1变异
mutant = population(i,:) + F(i)*(pbest - population(i,:)) + F(i)*(r1 - r2);
% 交叉
j_rand = randi(dim);
trial = population(i,:);
for j = 1:dim
if rand() < CR(i) || j == j_rand
trial(j) = mutant(j);
end
end
% 边界处理
trial = min(max(trial, lb), ub);
% 选择
trial_fitness = fitness_func(trial);
if trial_fitness < fitness(i)
% 记录成功参数和个体索引
S_F = [S_F; F(i)];
S_CR = [S_CR; CR(i)];
S_delta_f = [S_delta_f; fitness(i) - trial_fitness];
S_index = [S_index; i];
% 将被替换的个体加入存档
if numel(archive) < N_init
archive = [archive; population(i,:)];
else
archive(randi(size(archive,1)), :) = population(i,:);
end
population(i,:) = trial;
fitness(i) = trial_fitness;
if trial_fitness < best_fitness
best_fitness = trial_fitness;
best_solution = trial;
end
end
end
% 更新历史记忆
if ~isempty(S_F)
% 计算权重
weights = S_delta_f / sum(S_delta_f);
% 加权Lehmer均值更新MF
sum_F = sum(weights .* S_F.^2);
if sum_F > 0
new_MF = sum(weights .* S_F.^2) / sum(weights .* S_F);
else
new_MF = MF(k);
end
% 加权算术均值更新MCR
new_MCR = sum(weights .* S_CR);
% 更新记忆
MF(k) = new_MF;
MCR(k) = new_MCR;
% 更新记忆位置
k = mod(k, H) + 1;
end
% LPSR: 线性种群缩减
N_new = round(((N_min - N_init)/max_iter) * iter + N_init);
if N_new < N_current
% 移除最差的个体
[~, worst_idx] = maxk(fitness, N_current - N_new);
population(worst_idx, :) = [];
fitness(worst_idx) = [];
N_current = N_new;
end
end
end
LSHADE算法通过LPSR机制显著提高了计算效率,特别是在处理复杂优化问题时。在实际应用中,LSHADE通常能够在较少的函数评价次数内找到高质量的解,这使得它特别适合那些函数评价代价高昂的优化问题。不过,LPSR机制也引入了一个新的参数N_min(最小种群大小),需要根据问题特性进行适当设置。一般来说,对于大多数问题,N_min=4是一个合理的默认值。
6. 高级变体LSHADE_EpSin解析
LSHADE_EpSin是LSHADE算法的一个高级变体,由Awad等人提出。它在LSHADE的基础上引入了两种创新机制:基于正弦函数的参数自适应框架和基于高斯步行的局部搜索策略。这些改进使得LSHADE_EpSin在CEC2017竞赛中表现优异。
LSHADE_EpSin最显著的特点是它的正弦参数自适应框架。传统的DE变体通常使用固定或线性变化的参数控制策略,而LSHADE_EpSin采用了一种混合正弦调整策略。具体来说,它结合了两种正弦公式:
- 非自适应正弦递减调整:F = F_min + (F_max - F_min) * sin(π/2 * (1 - g/G)^k)
- 基于历史的自适应正弦递增调整:F = MF(r) + α * sin(π/2 * (g/G)) * randn()
其中,g是当前迭代次数,G是最大迭代次数,k是控制递减速度的参数,α是振幅系数。第一种公式在算法初期提供较大的F值以增强探索能力,随着迭代进行逐渐减小F值以增强开发能力。第二种公式则根据历史成功参数和当前迭代进度动态调整F值,增加了算法的适应性。
LSHADE_EpSin还在算法后期引入了基于高斯步行的局部搜索策略。当迭代次数超过一定阈值后,算法会以一定概率对当前最优解进行高斯扰动,生成新的试验个体。这种策略有助于算法跳出局部最优,特别是在复杂的多模态问题上。
下面是一个简化的LSHADE_EpSin实现:
function [best_solution, best_fitness] = LSHADE_EpSin(fitness_func, dim, lb, ub, N_init, max_iter, H, p)
% 初始化
population = lb + (ub - lb) .* rand(N_init, dim);
fitness = arrayfun(@(i) fitness_func(population(i,:)), 1:N_init);
archive = [];
% 历史记忆初始化
MF = 0.5 * ones(H, 1);
MCR = 0.5 * ones(H, 1);
k = 1;
% LPSR参数
N_min = 4;
N_current = N_init;
% EpSin参数
F_min = 0.1;
F_max = 0.9;
alpha = 0.1;
local_search_start = 0.8 * max_iter;
local_search_prob = 0.1;
[best_fitness, best_idx] = min(fitness);
best_solution = population(best_idx, :);
for iter = 1:max_iter
% 计算当前前p%个体的索引
[~, sorted_idx] = sort(fitness);
pbest_idx = sorted_idx(1:ceil(p*N_current));
% 生成本代的F和CR - EpSin混合策略
r = randi(H, N_current, 1);
% 非自适应正弦递减部分
F_sin1 = F_min + (F_max - F_min) * sin(pi/2 * (1 - iter/max_iter)^2);
% 自适应正弦递增部分
F_sin2 = MF(r) + alpha * sin(pi/2 * (iter/max_iter)) .* randn(N_current,1);
% 混合F
F = 0.5 * F_sin1 + 0.5 * F_sin2;
F(F<0) = 0; F = min(F, 1);
% CR生成
CR = MCR(r) + 0.1 * tan(pi*(rand(N_current,1)-0.5));
CR(CR<0) = 0; CR = min(CR, 1);
% 局部搜索: 高斯步行
if iter > local_search_start && rand() < local_search_prob
ls_solution = best_solution + 0.1 * (ub - lb) .* randn(1, dim);
ls_solution = min(max(ls_solution, lb), ub);
ls_fitness = fitness_func(ls_solution);
if ls_fitness < best_fitness
best_solution = ls_solution;
best_fitness = ls_fitness;
% 将局部搜索解加入种群
[~, worst_idx] = max(fitness);
population(worst_idx, :) = ls_solution;
fitness(worst_idx) = ls_fitness;
end
end
% 成功参数记录
S_F = [];
S_CR = [];
S_delta_f = [];
S_index = [];
for i = 1:N_current
% 选择pbest个体
pbest = population(pbest_idx(randi(numel(pbest_idx))), :);
% 从种群和存档中选择r1和r2
candidates = [population; archive];
idxs = randperm(size(candidates,1), 2);
r1 = candidates(idxs(1),:);
r2 = candidates(idxs(2),:);
% DE/current-to-pbest/1变异
mutant = population(i,:) + F(i)*(pbest - population(i,:)) + F(i)*(r1 - r2);
% 交叉
j_rand = randi(dim);
trial = population(i,:);
for j = 1:dim
if rand() < CR(i) || j == j_rand
trial(j) = mutant(j);
end
end
% 边界处理
trial = min(max(trial, lb), ub);
% 选择
trial_fitness = fitness_func(trial);
if trial_fitness < fitness(i)
% 记录成功参数和个体索引
S_F = [S_F; F(i)];
S_CR = [S_CR; CR(i)];
S_delta_f = [S_delta_f; fitness(i) - trial_fitness];
S_index = [S_index; i];
% 将被替换的个体加入存档
if numel(archive) < N_init
archive = [archive; population(i,:)];
else
archive(randi(size(archive,1)), :) = population(i,:);
end
population(i,:) = trial;
fitness(i) = trial_fitness;
if trial_fitness < best_fitness
best_fitness = trial_fitness;
best_solution = trial;
end
end
end
% 更新历史记忆
if ~isempty(S_F)
% 计算权重
weights = S_delta_f / sum(S_delta_f);
% 加权Lehmer均值更新MF
sum_F = sum(weights .* S_F.^2);
if sum_F > 0
new_MF = sum(weights .* S_F.^2) / sum(weights .* S_F);
else
new_MF = MF(k);
end
% 加权算术均值更新MCR
new_MCR = sum(weights .* S_CR);
% 更新记忆
MF(k) = new_MF;
MCR(k) = new_MCR;
% 更新记忆位置
k = mod(k, H) + 1;
end
% LPSR: 线性种群缩减
N_new = round(((N_min - N_init)/max_iter) * iter + N_init);
if N_new < N_current
% 移除最差的个体
[~, worst_idx] = maxk(fitness, N_current - N_new);
population(worst_idx, :) = [];
fitness(worst_idx) = [];
N_current = N_new;
end
end
end
LSHADE_EpSin通过其创新的正弦参数自适应框架,在探索和开发之间实现了更动态的平衡。非自适应部分确保算法遵循一个整体的搜索策略,而自适应部分则根据当前搜索情况动态调整。高斯步行局部搜索则增强了算法在后期跳出局部最优的能力。这些特性使得LSHADE_EpSin在处理复杂优化问题时表现出色,特别是那些具有欺骗性多模态特性的问题。不过,LSHADE_EpSin的实现相对复杂,参数也更多,需要更仔细的调参才能发挥最佳性能。
880



被折叠的 条评论
为什么被折叠?



