2025中科院2区SCI-状态优化算法Status-based Optimization-附Matlab免费代码

近年来，现实世界的优化问题变得越来越复杂，挑战了传统确定性方法的有效性。本文介绍了基于状态的优化（SBO），这是一种受人类对地位提升的渴望启发的高效算法。通过模拟个人如何接近、学习或从高地位人物那里获得资源，SBO将这些社会模式转化为一种强大的方法，以挑战优化任务。2025年在线发表在JCR 1区，中科院2区 SCI计算机类期刊 Neurocomputing 。

3. 提出的基于地位的优化

本文重点介绍了SBO算法的暴露，详细说明了其数学建模和计算复杂性。

3.1. SBO灵感

SBO算法模拟了人类攀登社会阶梯的基本驱动力——一种植根于我们自我提升需求的行为[43]。这种雄心壮志反映了优化的核心目标：迭代改进。像人们通过与成功的同伴联系获得优势一样[44]，SBO代理从表现良好的解决方案中学习以提高搜索效率。

认知科学和行为经济学的研究证实，从高地位个体中学习可以提高复杂场景中的问题解决能力。SBO将此转化为计算术语，创建了一种集体智能，其中：

• 代理共享知识（类似于人类网络）
• 多样化策略自然出现
• 系统平衡探索和开发

简而言之，我们可以这样说SBO的工作方式：

1. 精英参与（探索）：

   • 代理跟随表现最好的个体以发现有前景的区域
   • 类似于在社会等级中寻找导师

2. 资源阶段（开发）

   • 采集：从精英中收集信息
   • 评估：像专业人士一样改进解决方案以提高技能

几种受人类地位驱动的社会行为和教育互动启发的优化算法已经成功解决了复杂问题。基于人类行为的优化（HBBO）算法[45]模拟了合作、竞争、模仿和社会学习的集体人类行为。HBBO通过模仿、创新和协作等机制平衡社会学习与个体创造力，使其适用于动态或多目标问题。

同样，教育竞争优化器（ECO）[46]模拟了竞争学习环境，其中解决方案竞争并从表现最好的个体中学习，由最佳解决方案指导，类似于教师。这种方法促进了快速收敛和适应性，在受限优化场景中展示了其效率，例如学术性能建模和博弈论。

通过正式化地位寻求行为，SBO优于前身：

• 平衡全局/局部搜索
• 减少手动参数调整
• 扩展到高维问题

3.2. SBO的数学建模

从人类地位寻求行为中汲取灵感，SBO算法将优化框架为个人和社会发展过程。它首先生成两个不同的代理种群——代表来自不同社会背景的个体——然后通过模拟社会精英指导的过程来发展他们。

关键阶段如下：

1. 精英追求：代理识别并转向表现良好的解决方案（“导师”）
2. 资源采集：他们获得有价值的信息（社会资本）
3. 策略整合：代理批判性地评估并仅采用最有益的改进

这反映了人们如何：

• 通过向成功的同伴学习在社会上进步
• 选择性地采用增强他们地位的行为
• 通过积累优势系统地攀登等级

算法通过整合这些改进来提供最优解——数学上表示地位成就的顶峰。（后续部分将详细介绍完整的数学细节。）

3.2.1. 初始化

初始化阶段为SBO算法奠定了基础，通过生成两个种群$X^1$和$X^2$。在此模型中，每个索引$i$对应一个独特的家庭，其中$X^1$和$X^2$中的相同索引的个体代表具有不同知识水平和社会地位的家庭成员。这种双种群设计确保每个家庭至少由两个个体表示，从而捕获家族内多样性并使算法迭代时精英成员动态更新。

$${\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_N\end{array}\right]}_{N\times D}={\left[\begin{array}{cccc}{x}_{1,1}& x_{1,j}& \cdots & x_{1,N}\\ x_{i,1}& x_{i,j}& \cdots & x_{i,D}\\ x_{N,1}& x_{N,j}& \cdots & x_{N,D}\end{array}\right]}_{N\times D}\text{\hspace{1em}(1)}$$

每个个体的状态由公式(2)定义：

$$x_{i,j}=U(b_j,u_b)\text{\hspace{1em}(2)}$$

其中$x_{i,j}$是第$i$个个体的第$j$个决策变量，$D$是决策变量的数量，$b_j$和$u_b$分别是下界和上界。这种统一初始化在$N\times D$矩阵中为两个种群建立了问题的多维特性，并确保了多样化的起点。

在初始化之后，选择过程为每个家庭的精英种群$X^{\ast }$识别精英成员。具体来说，对于第$i$个家庭：

$$x_i^e=\{\begin{array}{ll}{x}_i^1& \text{if }fobj(x_i^1)<fobj(x_i^2)\\ x_i^2& \text{otherwise}\end{array}\text{\hspace{1em}(3)}$$

其中$fobj(\cdot )$是目标函数。

$$x_i^{\text{new}}=\{\begin{array}{ll}{x}_i+K_f\left[(x_{i-1}-x_{i+1})+(x_r-x_i)\right]& \text{if }f(x_i)>f(x_r)\\ x_i& \text{otherwise}\end{array}\text{\hspace{1em}(4)}$$

这种双种群方法不仅仅是在每个组中找到表现最好的个体——它反映了现实世界的社交流动性，其中进步取决于个人优点和战略联系。普通个体$x_i$与其精英对应物$x_i^e$之间的互动模拟了现实世界中的地位导向社交网络，说明了精英如何促进进步和在家庭内部及跨家庭单位的知识共享。

3.2.2. 精英参与

在精英参与阶段，SBO算法复制了人类社会结构的复杂动态，以增强对最优解的搜索。此阶段模拟了寻求高地位导师指导的个体——算法中的精英代理——以加快他们的进步。与孤立的家庭框架不同，这种进展通过建立不同社会单位之间的联系，创建了更具适应性和鲁棒性的搜索空间。

为了模拟这种行为，SBO算法使用轮盘赌选择方法[47]从种群中选择个体。此子集代表种群中不同家庭中最成功的成员。这种子集选择过程确保个体不仅仅依赖于单一的主导同伴，而是考虑多个有影响力的代理，反映了人类网络不可预测但战略性的本质。

选定的个体，表示为$x_i^e$，以及种群中的最佳个体$x_a$，共同定义了一个高地位圈——一个在解决方案空间中具有象征意义但计算上重要的区域，代理旨在融入其中。这种动态表示的社会流动性确保个体系统地过渡到搜索空间中更有希望的区域。

为了数学上阐明这种行为，公式(4)和图2描述了个体$x_i$在高地位圈内的生成。这个高地位圈代表了一个自适应区域，其中个体导航到更好的解决方案，平衡了结构化进展和探索性随机性。个体的运动由以下公式控制：

$$x_i=\{\begin{array}{ll}(1-w_1-w_2)\times x_i+w_1\times x_a+w_2\times z_b& \text{if }\text{rand}<w_3\\ w_4\times ((1-w_1-w_2)\times x_i+w_1\times x_a^e+w_2\times z_b)& \text{otherwise}\end{array}\text{\hspace{1em}(4)}$$

其中$x_i$表示种群中的第$i$个个体，$x_a^e$表示通过$X^e$种群的轮盘赌方法选择的下一个时间步的精英个体，$z_b$是迄今为止找到的最佳个体。公式(4)中的运动策略确保个体受到其自身位置、表现良好的同伴和最佳已知解决方案的影响。

$$x_{i,j}^e=x_{i,j}^e,\text{if }{m}_j=1\text{\hspace{1em}(5)}$$

其中行向量$m$最初为零，并在社交互动之前更新为：

$$m((1:ceil(\text{rand}\times D)))=1\text{\hspace{1em}(6)}$$

其中$u=\text{randperm}(D)$提供对决策变量索引的随机排列。

如图3所示，此阶段将种群引导至解决方案空间中更有希望的区域，以最大化探索。

图3(a)：成功个体通过使用高地位代理的资源来改进其位置。

图3(b)：挣扎的个体通过使用资源来自我改进。

图2. SBO的精英参与阶段。

参数$w_1$和$w_2$使用$\text{randn}$生成，提供正态分布的随机性以加权$x_i$、$x_a^e$和$z_b$的贡献。这些值引入了随机性，同时确保运动保持在逻辑范围内，促进了受控且多样化的搜索。

相比之下，$w_3$和$w_4$是设计参数，动态调整高地位圈对探索和开发的影响。$w_3$的计算如下：

$$w_3=\tanh \left({\left(\frac{\sqrt{\text{MaxFEs}-\text{randn}\times \text{FEs}}}{i}\right)}^{\frac{\text{FEs}}{\text{MaxFEs}}}\right)\text{\hspace{1em}(7)}$$

其中$\text{MaxFEs}$表示函数评估的最大数量，$\text{FEs}$是当前评估数量，$i$是个体的索引。这种公式允许$w_3$根据优化进展进行调整，决定是否应用标准更新规则或更随机的搜索模式。

如果$\text{rand}\ge w_3$，则使用公式(4)中的第二个公式，其中$w_2$作为缩放因子，生成在$[-w_3,w_3]$之间的均匀分布随机数。这种机制增加了探索多样性，通过启用步进大小调整，特别是在逃避局部最优时。

$$w_4=\text{uni\_frmd}(-w_3,w_3)\text{\hspace{1em}(8)}$$

通过整合这些组件，SBO算法模拟了现实世界的决策——个体在战略性地探索非常规路径以优化结果的同时，追求成功的同伴。公式(4)中的战略计算了高地位圈内的最佳位置，反映了个体如何获得有影响力的网络以获得更好的前景。通过进化计算，代理逐渐改进，向搜索空间中更有希望的区域移动。

相比之下，第二个公式引入了一个随机缩放因子，范围从$[-w_3,w_3]$，允许算法探索超出直接有希望区域的区域。这种特征防止了过早收敛，同时使SBO能够发现未探索区域中潜在优越的解决方案。这种平衡反映了人类决策。人们有时会偏离既定路径，无论是通过职业变化还是创新冒险，以找到传统方法错过的机会。

通过结合结构化学习和探索灵活性，SBO在探索和开发之间实现了最佳平衡。这使算法能够有效地适应复杂的优化景观。由此产生的方法是提高解决方案质量，同时在多样化问题中保持鲁棒性，证明了SBO在高性能计算中的能力。

3.2.3. 资源采集

资源采集阶段对于从探索过渡到开发至关重要，通过获取和利用有价值的见解——类似于人类网络中的社会资本。在此阶段，在$X$种群中的所有个体中创建一个标志向量，最初设置为1以表示初步的地位相关成功。此标志在资源评估阶段更新，作为个体地位改进的动态指标。

资源采集机制根据地位相关成功而变化。对于社会上成功的个体，资源通过从同一家庭单元中的精英个体和种群中的整体最佳个体平均输入来选择性地获取。这种资源更新如下：

$$x_{i,j}^e=x_{i,j}^e+\frac{x_{a,j}^e+x_{b,j}^e}{2}\text{\hspace{1em}(9)}$$

其中$i,j=\text{randi}(D)$对于$i,d=1,2,3,...,D$，反映了家庭和外部精英影响的融合。

$$x_{i,j}^e=x_{i,j}^e,\text{if }{m}_j=1\text{\hspace{1em}(10)}$$

其中行向量$m$最初为零，并在社交互动之前更新为：

$$m((1:ceil(\text{rand}\times D)))=1\text{\hspace{1em}(11)}$$

其中$u=\text{randperm}(D)$提供对决策变量索引的随机排列。

如图3所示，此阶段将种群引导至解决方案空间中更有希望的区域，以最大化探索。

图3(a)：成功个体通过使用高地位代理的资源来改进其位置。

图3(b)：挣扎的个体通过使用资源来自我改进。

3.2.4. 资源评估

在资源评估阶段，算法评估所获得的资源是否增强了个体的适应度。使用之前建立的标志向量，它跟踪进展：

• 1 = 适应度改进（成功）
• 0 = 无改进（失败）

实际上，如果更新后的个体$x_i^e$的目标函数值优于原始$x_i$，则保留新状态：

$$x_i=x_i^e\text{if }fobj(x_i^e)<fobj(x_i)\text{\hspace{1em}(10)}$$

同时，标志向量刷新如下：

$${\text{flag}}_i=\{\begin{array}{ll}1& \text{if }fobj(x_i^e)<fobj(x_i)\\ 0& \text{otherwise}\end{array}\text{\hspace{1em}(11)}$$

表现无改进的个体保持当前位置，而成功的个体则转移到更优越的位置。这种选择性过程反映了现实世界的社交进步，其中只有有价值的资源，那些明显提高代理地位的资源，才会被保留。这种改进逐步引导搜索朝着最优解的方向发展。

3.2.5. 整合

当满足终止标准时，整合阶段激活，无论是在达到最大函数评估次数或实现足够优化的解决方案（通过增强指标验证）。在此之前，算法通过其核心阶段反复循环：

• 精英参与
• 资源采集
• 资源评估

每个阶段模拟地位驱动的互动，逐步改进解决方案。

实现细节：

• 算法1提供了伪代码。
• 图4显示了工作流程。
  

图4显示了SBO的工作流程。

在整合期间，算法：

• 编译并评估结果是否符合目标
• 生成一个体现基于地位的启发式的最终解决方案
• 确保高效的资源使用和详细的文档记录用于分析/应用
• 

3.3 完整代码

% 📜 Status-based Optimization (SBO) source codes (version 1.0)
% 🌐 Website and codes of SBO:  The Status-based Optimization: Algorithm and comprehensive performance analysis:
 
% 🔗 https://aliasgharheidari.com/SBO.html

% 👥 Jian Wang, Yi Chen, Ali Asghar Heidari, Zongda Wu, Huiling Chen

% 📅 Last update: 06 10 2025

% 📧 E-Mail: jona.wzu@gmail.com, aliasghar68@gmail.com, chenhuiling.jlu@gmail.com
  
% 📜 After use of code, please users cite the main paper on SBO: 
% The Status-based Optimization: Algorithm and comprehensive performance analysis
% Jian Wang, Yi Chen, Ali Asghar Heidari, Zongda Wu, Huiling Chen
% Neurocomputing, 2025

%----------------------------------------------------------------------------------------------------------------------------------------------------%
% 📊 You can use and compare with other optimization methods developed recently:
%     - (SBO) 2025: 🔗 https://aliasgharheidari.com/SBO.html
%     - (ESC) 2024: 🔗 https://aliasgharheidari.com/ESC.html
%     - (MGO) 2024: 🔗 https://aliasgharheidari.com/MGO.html
%     - (PLO) 2024: 🔗 https://aliasgharheidari.com/PLO.html
%     - (FATA) 2024: 🔗 https://aliasgharheidari.com/FATA.html
%     - (ECO) 2024: 🔗 https://aliasgharheidari.com/ECO.html
%     - (AO) 2024: 🔗 https://aliasgharheidari.com/AO.html
%     - (PO) 2024: 🔗 https://aliasgharheidari.com/PO.html
%     - (RIME) 2023: 🔗 https://aliasgharheidari.com/RIME.html
%     - (INFO) 2022: 🔗 https://aliasgharheidari.com/INFO.html
%     - (RUN) 2021: 🔗 https://aliasgharheidari.com/RUN.html
%     - (HGS) 2021: 🔗 https://aliasgharheidari.com/HGS.html
%     - (SMA) 2020: 🔗 https://aliasgharheidari.com/SMA.html
%     - (HHO) 2019: 🔗 https://aliasgharheidari.com/HHO.html
%----------------------------------------------------------------------------------------------------------------------------------------------------%

function [bestFitness, best_pos, Convergence_curve] = SBO(N, MaxFEs, lb, ub, dim, fobj)
    
    %% INITIALIZATION
    FEs = 0;
    bestFitness = inf; % Change to -inf for maximization problems
    best_pos = zeros(1, dim);
    
    Convergence_curve = [];
    iter = 1;

    % Initialize populations
    current_X = initialization(N, dim, ub, lb);
    localElite_X = initialization(N, dim, ub, lb);
        
    % Initialize fitness values
    current_Fitness = inf * ones(N, 1);
    localElite_Fitness = inf * ones(N, 1);
    
    % Calculate initial fitness and determine initial best solutions (local and global)
    for i = 1:N
        current_Fitness(i, 1) = fobj(current_X(i, :));
        FEs = FEs + 1;
        
        temp_localElite_Fitness = fobj(localElite_X(i ,:));
        FEs = FEs + 1;
        
        % Determine the initial local elite
        if current_Fitness(i, 1) < temp_localElite_Fitness
            localElite_X(i, :) = current_X(i, :);
            localElite_Fitness(i, 1) = current_Fitness(i, 1);
        else
            localElite_Fitness(i, 1) = temp_localElite_Fitness;
        end
        
        % Update the initial global best
        if localElite_Fitness(i, 1) < bestFitness
            bestFitness = localElite_Fitness(i, 1);
            best_pos = localElite_X(i, :);
        end
    end
    
    %% Sort the local elite fitness for the first Roulette Wheel Selection
    [sorted_localElite_Fitness, ~] = sort(localElite_Fitness);
    
    %% Social success flag and social fitness initialization
    flag = ones(N, 1);
    social_Fitness = inf * ones(N, 1);
    
    %% MAIN LOOP
    while FEs < MaxFEs
        
        %% Select an individual from the localElite population based on Roulette selection
        Roulette_index = RouletteWheelSelection(1./(sorted_localElite_Fitness + eps));
        if Roulette_index == -1  
            Roulette_index = 1; % Default to the best if selection fails
        end
        
        %% Update the current population
        for i = 1:N
            w1 = randn;
            w2 = randn;
            w3 = tanh((sqrt(abs(MaxFEs - randn * FEs))/i)^(FEs/MaxFEs));
            w4 = unifrnd(-w3, w3);
            if rand < w3
                for j = 1:dim
                    current_X(i, j) = (1 - w1 - w2) * current_X(i, j) + w1 * localElite_X(Roulette_index, j) + w2 * best_pos(j);
                end
            else
                for j = 1:dim
                    current_X(i, j) = w4 * ((1 - w1 - w2) * current_X(i, j) + w1 * localElite_X(Roulette_index, j) + w2 * best_pos(j));
                end
            end
        end
        
        %% Boundary control
        current_X = BoundaryControl(current_X, lb, ub);
        
        %% Upward social strategy
        social_X = current_X;
        
        % One-dimension source exchange for socially successful individuals
        for i = 1:N
            if flag(i) == 1
                social_X1_val = localElite_X(i, randi(dim));
                social_X2_val = best_pos(randi(dim));
                social_X(i, randi(dim)) = (social_X1_val + social_X2_val) / 2;
            end
        end
        
        % Multi-dimension source exchange for socially failed individuals
        m = zeros(1, dim);
        u = randperm(dim);
        m(u(1:ceil(rand * dim))) = 1;
        for i = 1:N
            if flag(i) == 0
                for j = 1:dim
                    if m(j)
                        social_X(i, j) = localElite_X(i, j);
                    end
                end
            end
        end
        
        %% Greedy selection and current population update
        for i = 1:N
            % Evaluate new and social positions
            if FEs < MaxFEs
                current_Fitness(i, 1) = fobj(current_X(i, :));
                FEs = FEs + 1;
            end
            if FEs < MaxFEs
                social_Fitness(i, 1) = fobj(social_X(i, :));
                FEs = FEs + 1;
            end
            
            % Greedy selection
            if social_Fitness(i, 1) < current_Fitness(i, 1)
                % Social success: update position and set flag
                flag(i, 1) = 1;
                current_X(i, :) = social_X(i, :);
                current_Fitness(i, 1) = social_Fitness(i, 1);
            else
                % Social fail: keep current position and set flag
                flag(i, 1) = 0;
            end
        end
        
        %% Update local elite population
        for i = 1:N
            if current_Fitness(i, 1) < localElite_Fitness(i, 1)
                localElite_Fitness(i, 1) = current_Fitness(i, 1);
                localElite_X(i, :) = current_X(i, :);
            end
        end
        
        %% Sort local elite fitness and update the global best position
        [sorted_localElite_Fitness, idx] = sort(localElite_Fitness);
        if sorted_localElite_Fitness(1) < bestFitness
            bestFitness = sorted_localElite_Fitness(1);
            best_pos = localElite_X(idx(1), :);
        end
    
        %% Record the best fitness for the convergence curve
        Convergence_curve(iter) = bestFitness;
        iter = iter + 1;
    end
end  

%% Helper Functions

% Enforce boundary constraints on agent positions
function X = BoundaryControl(X, low, up)
    [N, dim] = size(X);
    
    if isscalar(low)
        low = repmat(low, 1, dim);
    end
    if isscalar(up)
        up = repmat(up, 1, dim);
    end
    
    for i = 1:N
        for j = 1:dim                
            k = rand < rand; % 50% chance for either clipping or re-initializing
            
            if X(i,j) < low(j) 
                if k
                    X(i,j) = low(j); % Clipping to the boundary
                else
                    X(i,j) = rand * (up(j) - low(j)) + low(j); % Re-initializing
                end 
            end        
            
            if X(i,j) > up(j)  
                if k
                    X(i,j) = up(j); % Clipping to the boundary
                else
                    X(i,j) = rand * (up(j) - low(j)) + low(j); % Re-initializing
                end 
            end
        end
    end
end
    
% Roulette wheel selection mechanism
function choice = RouletteWheelSelection(weights)
    % Normalize weights to handle negative values if any, although 1/fitness should be positive
    if any(weights<0)
        weights = weights + min(weights);
    end
    accumulation = cumsum(weights);
    if accumulation(end) == 0
        choice = -1;
        return;
    end
    p = rand() * accumulation(end);
    chosen_index = -1;
    for index = 1:length(accumulation)
        if (accumulation(index) > p)
            chosen_index = index;
            break;
        end
    end
    choice = chosen_index;
end

Jian Wang, Yi Chen, Chenglang Lu, Ali Asghar Heidari, Zongda Wu, Huiling Chen,The Status-based Optimization: Algorithm and comprehensive performance analysis,Neurocomputing,2025,130603,https://doi.org/10.1016/j.neucom.2025.130603.