Automated Generation of Hybrid Metaheuristics Using Learning-to-Rank

Abstract

Metaheuristic algorithms, due to their superior global exploration capabilities and applicability, have emerged as critical tools for addressing complicated optimization tasks. However, these algorithms commonly depend on expert knowledge to configure parameters and design strategies. As a result, they frequently lack appropriate automatic behavior adjustment methods for dealing with changing problem features or dynamic search phases, limiting their adaptability, search efficiency, and solution quality. To address these limitations, this paper proposes an automated hybrid metaheuristic algorithm generation method based on Learning to Rank (LTR-MHA). The LTR-MHA aims to achieve adaptive optimization of algorithm combination strategies by dynamically fusing the search behaviors of Whale Optimization (WOA), Harris Hawks Optimization (HHO), and the Genetic Algorithm (GA). At the core of the LTR-MHA is the utilization of Learning-to-Rank techniques to model the mapping between problem features and algorithmic behaviors, to assess the potential of candidate solutions in real-time, and to guide the algorithm to make better decisions in the search process, thereby achieving a well-adjusted balance between the exploration and exploitation stages. The effectiveness and efficiency of the LTR-MHA method are evaluated using the CEC2017 benchmark functions. The experiments confirm the effectiveness of the proposed method. It delivers superior results compared to individual metaheuristic algorithms and random combinatorial strategies. Notable improvements are seen in average fitness, solution precision, and overall stability. Our approach offers a promising direction for efficient search capabilities and adaptive mechanisms in automated algorithm design.

1. Introduction

Metaheuristic algorithms have attracted crucial attention due to their ability to obtain high-quality solutions within reasonable computational costs [1]. By simulating behaviors from nature or evolutionary mechanisms, these algorithms can effectively explore complex solution spaces and, to some extent, avoid the local optima that traditional methods are prone to [2]. However, despite demonstrating strong robustness and adaptability, metaheuristic algorithms still face critical limitations, such as their reliance on human expertise and insufficient flexibility when applied to diverse problem scenarios, which remains a major bottleneck to their broader application.

Metaheuristic algorithms are usually designed to handle two primary tasks: exploration and exploitation. Ensuring a balanced transition between these tasks is essential. Such equilibrium plays a key role in determining the algorithm’s success. As stated by the “No Free Lunch” theorem [3], no metaheuristics can guarantee optimal results for every optimization task. Moreover, studies have shown [4] that a single algorithm struggles to effectively handle high-dimensional and non-convex optimization problems, making algorithm hybridization one of the key strategies for performance enhancement. This opens up broad avenues for research and application in hybrid algorithm strategies and machine learning-driven improvements to metaheuristic algorithms.

Recent research has increasingly emphasized fused and hybrid algorithms to boost efficiency and adaptability. Currently, common approaches involve integrating and optimizing classical algorithms such as the Genetic Algorithm (GA), Particle Swarm Optimization (PSO), and Differential Evolution (DE) [4]. The combination of genetic algorithms with simulated annealing has been applied to optimization tasks within complex search spaces, successfully achieving heuristic approximations of near-optimal solutions [5]. The Whale Optimization Algorithm (WOA) faces challenges due to the imbalance between exploration and exploitation. To mitigate this, the enhanced ESWOA [6], which embeds the hawk strategy, has been designed. Furthermore, research on the emerging “Dwarf Mongoose Optimization Algorithm” (DMOA) has demonstrated that algorithm hybridization strategies can effectively improve search efficiency and global convergence [7]. Bian et al. [8] recently proposed an Improved Snow Geese Algorithm (ISGA) that integrates adaptive migration and clustering strategies to enhance exploration in engineering applications and clustering optimization.

With the advancement of research on algorithm automation, hyper-heuristic algorithms and automated algorithm portfolio frameworks have emerged as new trends driving the development of intelligent algorithms [9]. By employing higher-level heuristic search and learning mechanisms, the dynamic selection and combination of multiple underlying heuristic algorithms have become effective approaches to enhancing algorithm generalization capabilities. Existing studies have proposed a unified classification system based on search components, promoting the deep integration of machine learning and metaheuristic algorithms [10]. Reinforcement learning methods have been applied to algorithmic behavior selection, utilizing historical search information to guide search strategies and thus improve solution efficiency [11]. To better balance algorithm convergence and diversity, approaches based on interactive learning frameworks and Learning-to-Rank models that significantly enhance solution performance by periodically collecting feedback and dynamically optimizing the search direction have been introduced [12]. Similarly, researchers have merged reinforcement learning with proximal policy optimization approaches to provide a general algorithm search framework, automating the design of metaheuristic algorithms across varied circumstances [1]. In addition, Seyyedabbasi [13] introduced an RL-based metaheuristic (RLWOA) that leverages a deep Q-learning agent to adjust WOA parameters online, resulting in marked improvements in convergence rate and solution quality on a suite of global optimization problems.

Drawing on these insights, developing metaheuristic algorithms can be regarded as tackling a combinatorial optimization task, with the solution space including factors such as algorithm parameters, algorithm composition, and algorithmic components. Related research can be divided into three categories: automated algorithm configuration, selection, and composition [1]. Algorithm configuration focuses on optimizing parameters for specific algorithms, while algorithm selection involves choosing algorithms based on problem characteristics. Although both configuration and selection offer distinct advantages, they require a certain degree of prior knowledge or accurate identification of problem features. In contrast, algorithm composition provides greater flexibility by generating new algorithms through the combination of basic components, thereby eliminating dependence on original algorithm structures. Furthermore, Learning-to-Rank (LTR) techniques, owing to their lightweight nature and strong interpretability, have demonstrated significant potential in automated algorithm composition and generation. LTR can directly model the mapping between candidate update behaviors and solution quality through supervised or weakly supervised learning, enabling dynamic algorithm selection and the optimization of combinatorial strategies.

This research attempts to address the limits of existing algorithm designs by investigating an automated algorithm generation strategy that incorporates Learning-to-Rank techniques. The goal is to achieve dynamic decision-making and adaptive adjustment within the algorithm generation process, thereby enhancing the generalization capability and solution efficiency of algorithms for various complex problems. By dynamically evaluating and ranking candidate solutions, LTR not only optimizes the algorithm’s search strategies but also effectively guides the algorithm in avoiding local optima and accelerating global convergence. Consequently, it offers a solution that is both theoretically innovative and practically valuable. This work focuses on validating the feasibility of the multi-algorithm generation strategy in enhancing single metaheuristic methods, rather than aiming to identify an optimal combination. To this goal, three exemplary classical metaheuristic algorithms (the GA, WOA, and HHO) are selected for the study. The key contributions of this work are the following:

• An automated hybrid metaheuristic algorithm design method based on Learning to Rank, called the LTR-MHA, is proposed. The method uses LTR to integrate different metaheuristic algorithms, such as the WOA, HHO, and the GA, allowing for dynamic algorithm selection and collaborative optimization. The LTR-MHA can flexibly integrate the update strategies of different algorithms based on problem features and dynamic feedback during the search process, considerably improving search capability and solution quality. This approach offers a novel and effective pathway for automated algorithm design and optimization.
• The LTR-MHA constructs a training dataset by extracting key feature information from historical search processes and trains a predictive model to capture the mapping between candidate update behaviors and solution quality. During the search process, the feature vectors of search agents are fed into the trained model in real time to dynamically evaluate and rank candidate update behaviors. This enables the algorithm to prioritize more promising update actions, thereby enhancing the specificity and scientific basis of its search decisions.
• The LTR-MHA method is empirically evaluated on four representative function categories from the CEC2017 benchmark. The results indicate that the approach achieves significant improvements in efficiency, solution precision, and overall stability when compared with individual metaheuristic methods and random selection strategies. In particular, when addressing multimodal functions and high-dimensional tasks, the LTR-MHA achieves faster convergence and greater solution quality, demonstrating the extensive applicability and prospects of LTR-based automated algorithm combinatorial approaches in metaheuristic algorithm development.

The following sections of this work are structured as follows. Section 2 briefly introduces related work, with a particular focus on advancements in metaheuristic algorithms and automated algorithm generation techniques. Section 3 presents the background knowledge of the technologies involved. Section 4 details the proposed LTR-MHA approach. Section 5 introduces the empirical analysis, including experiment settings, experimental results, and discussion. Finally, Section 6 summarizes the work and suggests potential avenues for future research.

2. Related Work

2.1. Metaheuristic Algorithms and Optimization

Metaheuristics have been widely applied to address complex problems across diverse domains, such as engineering design, combinatorial tasks, and multi-objective scenarios [4]. Although these algorithms possess strong search capabilities, as the scale and complexity of problems continue to grow, traditional single algorithms increasingly exhibit issues such as vulnerability to local optima, sluggish convergence, and high sensitivity to parameter tuning. Consequently, improving metaheuristic algorithms, particularly through algorithm integration and hybrid strategies to enhance their performance, has become a prominent research focus.

To overcome the limitations of traditional approaches, researchers have proposed a variety of improvement strategies. Kareem et al. conducted a systematic review of current mainstream metaheuristic algorithms and their variants, highlighting that single algorithms often struggle with high-dimensional and non-convex optimization problems and that algorithm hybridization has become one of the effective means to enhance algorithm performance [4]. Talbi [14] indicated that hybrid metaheuristics, as an important future direction for optimization algorithms, is capable of enhancing solution diversity while simultaneously lowering the likelihood of local extrema. Wang et al. [5] combined a Genetic Algorithm with a simulated annealing algorithm to propose a search-based fault localization method. By transforming the fault localization problem into a search problem for optimal modeling combinations, they achieved heuristic approximations of near-optimal solutions. Jin et al. [15] proposed a Quality-of-Service (QoS) characterization model for cloud manufacturing services, as well as an QoS-aware service creation approach using Genetic Algorithms. They presented a new approach [16] that combines the hawk strategy with an enhanced Whale Optimization Algorithm to improve the QoS composition solutions. To address the limitations of the WOA, Gavvala et al. [6] introduced the ESWOA to reconcile exploration and exploitation. Empirical findings demonstrated that the ESWOA achieves superior performance in locating globally optimal solutions. Furthermore, the EGolden-SWOA [17] enhances population diversity via an elite opposition-based learning technique and uses the golden ratio to optimize the search process, successfully balancing global exploration and local exploitation capabilities. Abraham and Ngadi conducted a systematic review of the emerging Dwarf Mongoose Optimization Algorithm (DMOA), discussing its latest variants, hybrid strategies, and application trends over the past three years, and emphasized that algorithm hybridization can effectively improve search efficiency and global convergence [7].

Overall, through continuous algorithmic optimization and diversified integration strategies, metaheuristic algorithms have achieved remarkable progress in addressing complicated optimization issues. Whether by dynamically combining multiple algorithms or harmonizing exploration and exploitation, these approaches have effectively enhanced the performance of individual metaheuristic algorithms and broadened their application boundaries. However, despite these advancements, most current algorithm composition methods still rely on empirical design and static configurations, lacking flexible adaptive regulation and intelligent combination capabilities. As problem scales continue to expand, strategies that rely solely on manual design are increasingly insufficient to fully unleash the potential of these algorithms.

Against this backdrop, hyper-heuristic approaches and automated algorithm composition frameworks have emerged as important research directions for achieving intelligent scheduling and automatic evolution of algorithms. At the same time, automated algorithm composition methods that integrate machine learning with evolutionary mechanisms can dynamically select and combine multiple algorithms based on problem characteristics, enabling more targeted and efficient optimization outcomes.

2.2. Hyper-Heuristics and Automated Algorithm Generation Based on Machine Learning

Hyper-heuristics and automated algorithm generation and composition are becoming important directions in the intelligent development of algorithm design. The core idea lies in employing higher-level heuristic search and learning mechanisms to dynamically select and combine multiple underlying heuristic algorithms, thereby aiming to solve complex problems [9].

In recent years, applying machine learning to the design of efficient and robust metaheuristic algorithms has become a research hotspot, with many machine learning-enhanced metaheuristic algorithms demonstrating superior performance. Talbi [10] investigated the integration of machine learning and metaheuristic algorithms and established a unified classification system based on search components, including optimization objectives and high- and low-level components of metaheuristic algorithms, with the aim of encouraging researchers in the optimization field to explore synergistic mechanisms between machine learning and metaheuristics.

To address the challenge of ranking massive volumes of documents in information retrieval systems, a Learning-to-Rank method combining an improved Genetic Algorithm with the Nelder–Mead approach was proposed [18]. By optimizing the ranking weight coefficients, this method significantly improved ranking metrics such as NDCG. Becerra-Rozas et al. [11] enhanced the behavior selection mechanism of the WOA using SARSA, thereby improving the algorithm’s solution performance. Li et al. [12] developed a preference-driven interactive learning framework aimed at enhancing both the convergence rate and diversity of traditional multi-objective methods. By periodically collecting user feedback and dynamically optimizing the search direction using an LTR model, this approach effectively guides the heuristic algorithm toward rapid solution discovery. Oliva et al. [19] proposed a Bayesian model-guided hyper-heuristic framework, which introduces a heuristic selection strategy assisted by probabilistic graphical models for single-objective continuous optimization problems, thereby achieving automation in algorithm selection and scheduling. Yi et al. [1] developed a general search framework that employs DQN and proximal policy optimization methods to realize automated design of metaheuristic algorithms. Similarly, Kallestad et al. [20] utilized the general search framework as a foundation for analyzing algorithm components in the automated design of hyper-heuristics. Within this framework, novel metaheuristic algorithms were automatically designed for CVRPTW problems.

Hyper-heuristic algorithms and automated algorithm generation frameworks are gradually moving away from heavy reliance on expert knowledge, leveraging machine learning techniques like reinforcement learning and Learning to Rank to drive the optimization process toward greater automation and intelligence. This development trend lays a solid theoretical and technological foundation for building efficient and adaptive optimization algorithm systems. In addition, reinforcement learning, with its advantage of dynamic interaction, has demonstrated great potential in exploring complex state spaces. However, its strong dependence on reward mechanisms and the high cost of training limit its applicability in certain ranking tasks. In contrast, Learning to Rank, with its ranking-oriented nature, directly models the relationship between features and ranking objectives through supervised or weakly supervised learning. This not only enables algorithm generation and composition strategies but also offers strong interpretability and lightweight model characteristics. This indicates that Learning to Rank holds significant potential in algorithm combinatorial optimization, warranting further exploration of its effectiveness in enhancing algorithm adaptability and performance.

Moreover, recent studies on metaheuristics highlight two major types of learning mechanisms: (1) strategy-level learning mechanisms and (2) parameter control. Hsieh et al. [21,22] proposed online strategy ranking methods for ridesharing problems, where search strategies are dynamically evaluated and reordered during evolution. In contrast, Xu and Chen [23] and Norat et al. [24] employed learning techniques to adapt algorithmic parameters, such as inertia weights or crossover/mutation rates. These studies represent two distinct directions in learning-enhanced metaheuristics. Unlike the online learning mechanisms or parameter-tuning approaches, our method introduces an offline Learning-to-Rank framework for strategy selection. While online updates can be responsive, they often rely on short-term performance and may suffer from instability in complex or high-dimensional problems. Our offline LTR model is trained on broader search history data, enabling more stable, generalizable, and feature-oriented decision-making. As far as we know, this study is the first to employ LTR for the development of hybrid metaheuristic frameworks, offering a novel and theoretically grounded pathway in the landscape of automated algorithm design.

While our work shares the core goal of algorithm automation with hyperheuristics, it differs in modeling granularity and learning objectives. Traditional hyperheuristics typically focus on selecting or generating operators based on heuristic performance, often relying on manually designed rules. In contrast, our approach does not target operator selection but instead learns the mapping between candidate solution features and algorithm behaviors. This enables strategy-level integration of multiple metaheuristics.

3. Preliminaries

3.1. Problem Formulation

In this study, we focus on solving a real-parameter continuous optimization problem, formally defined as:

$$\underset{x\in {\mathbb{R}}^D}{min}f\left(x\right),\mathrm{subject}\mathrm{to}{x}_i\in [l{b}_i,u{b}_i],i=1,2,...,D.$$

(1)

where $x=[x_1,x_2,...,x_D]\in {\mathbb{R}}^D$ is the decision vector, and $f\left(x\right)$ is the objective function to be minimized. In this work, $f\left(x\right)$ is selected from the CEC2017 benchmark suite [25], which contains a diverse set of optimization problems. Unless otherwise specified, the default search space for all variables is $[-100,100]$. The objective is to find the global minimum of $f\left(x\right)$ within this domain.

3.2. Metaheuristic Algorithms

3.2.1. Whale Optimization Algorithm

The Whale Optimization Algorithm [26] is modeled after the hunting strategies of humpback whales. During the exploration, the agents perform a global search to locate promising solutions, while the exploitation stage focuses on localized refinement. The agents exhibit three core hunting strategies: encircling prey, bubble-net attacking, and random search. The mathematical models for each behavior are described in detail below.

(1) Encircling Prey

The WOA assumes that the prey nearest to the optimum serves as the best candidate solution. After identifying the leading agent, the rest adjust their positions to approach this optimal candidate. The equation below is used to mathematically explain the encircling mechanism in the WOA.

$$\overrightarrow{X}(t+1)={\overrightarrow{X}}^{*}\left(t\right)-\overrightarrow{A}·\overrightarrow{Dis}$$

(2)

where $\overrightarrow{Dis}=\left|\overrightarrow{C}·{\overrightarrow{X}}^{*}\left(t\right)-\overrightarrow{X}\left(t\right)\right|$ represents the distance between the current individual and the best individual identified so far. Here, $\overrightarrow{X}\left(t\right)$ and ${\overrightarrow{X}}^{*}\left(t\right)$ indicate the position vectors of the current individual and the optimal solution at iteration t, respectively. Note that in these equations, “$\left|\right|$” denotes the absolute value applied element-wise to vectors. “·” represents element-by-element multiplication [26]. $\overrightarrow{A}$ and $\overrightarrow{C}$ are coefficient vectors, computed using the following equations:

$$\overrightarrow{A}=2\overrightarrow{a}·\overrightarrow{r}-\overrightarrow{a},\overrightarrow{C}=2·\overrightarrow{r}$$

(3)

where $\overrightarrow{a}$ is linearly decreased from 2 to 0 over the course of iterations. $\overrightarrow{r}$ is a random vector in the range $[0,1]$.

The switching mechanism between exploration and exploitation in the WOA is controlled by the $\overrightarrow{A}$, enabling the algorithm to balance global and local search effectively. When the absolute value of every component of $\overrightarrow{A}$ is less than 1 ($|\overrightarrow{A}| <1$), i.e., $|A_i| <1$ for all $i=1,\dots ,D$, the agent moves toward the best-known solution (exploitation). Conversely, if any component satisfies $|A_i| \ge 1$, the agent performs exploration by moving toward a randomly selected individual.

(2) Bubble-Net Attacking

In the exploitation phase (when $|\overrightarrow{A}| <1$), bubble-net attacking utilizes two strategies: shrinking encircling and spiral updating. The spiral updating mechanism is expressed using a formula like this:

$$\overrightarrow{X}(t+1)={\overrightarrow{Dis}}^{\prime }·e^{bl}·cos\left(2\pi l\right)+{\overrightarrow{X}}^{*}\left(t\right)$$

(4)

where ${\overrightarrow{Dis}}^{\prime }=\left|{\overrightarrow{X}}^{*}\left(t\right)-\overrightarrow{X}\left(t\right)\right|$ represents the distance between the current whale and the best whale found so far, b is a constant, and l is a random number in the range $[-1,1]$. During the prey hunting phase, the shrinking encircling mechanism and the spiral updating position are performed simultaneously. The equation is as follows:

$$\overrightarrow{X}(t+1)=\left\{\begin{array}{cc}{\overrightarrow{X}}^{*}\left(t\right)-\overrightarrow{A}·\overrightarrow{Dis},\hfill & \mathrm{if}p<0.5\hfill \\ {\overrightarrow{Dis}}^{\prime }·e^{bl}·cos\left(2\pi l\right)+{\overrightarrow{X}}^{*}\left(t\right),\hfill & \mathrm{if}p\ge 0.5\hfill \end{array}\right.$$

(5)

where p is a random number in the range $[0,1]$. These two mechanisms are selected with equal probability, and the value of p determines which mechanism is applied in each iteration.

(3) Random Search

In the WOA, a certain degree of exploration is necessary to enhance global search capability. When $|\overrightarrow{A}| \ge 1$, the WOA randomly selects a whale from the population to update the position, as described by the following equation:

$$\overrightarrow{X}(t+1)={\overrightarrow{X}}_{\mathrm{rand}}-\overrightarrow{A}·\overrightarrow{Dis}$$

(6)

where $\overrightarrow{Dis}=\left|\overrightarrow{C}·{\overrightarrow{X}}_{\mathrm{rand}}-\overrightarrow{X}\left(t\right)\right|$ is the distance vector, and ${\overrightarrow{X}}_{\mathrm{rand}}$ represents the position vector of a whale randomly selected from the current population. As in the encircling mechanism, both the absolute value and multiplication operators are applied element-wise to vectors.

3.2.2. Harris Hawks Optimization Algorithm

The Harris Hawks Optimization algorithm [27] imitates Harris-hawk collaboration and chase methods during the hunting phase, and the algorithm strikes a balance between exploration and exploitation. HHO determines the exploration and exploitation via the escape energy E. When $\left|E\right|\ge 1$, the algorithm is in the exploration stage, and when $\left|E\right|<1$, it shifts to the exploitation stage. The equation goes as follows:

$$E=2E_0\left(1-{\displaystyle \frac{t}{T}}\right)$$

(7)

where $E_0$ is the initial energy of the prey, t is the current iteration number, and T is the maximum number of iterations.

(1) Exploration Phase

In exploration, search agents conduct random searches for the location of their prey. The mathematical model is expressed as:

$$X(t+1)=\left\{\begin{array}{cc}{X}_{\mathrm{rand}}\left(t\right)-r_1\left|X_{\mathrm{rand}}\left(t\right)-2r_{2}X\left(t\right)\right|,\hfill & q\ge 0.5\hfill \\ \left(X_{\mathrm{rabbit}}\left(t\right)-X_m\left(t\right)\right)-r_3\left(lb+r_4(ub-lb)\right),\hfill & q<0.5\hfill \end{array}\right.$$

(8)

$$X_m\left(t\right)={\displaystyle \frac{1}{N}}\sum _{i=1}^N{X}_i\left(t\right)$$

(9)

where $X\left(t\right)$ represents the current position of an individual, $X_{\mathrm{rand}}\left(t\right)$ is the position of a randomly selected individual, and $X_{\mathrm{rabbit}}\left(t\right)$ is the position of the prey. $r_1,r_2,r_3,r_4,q\in (0,1)$ are random numbers, while $ub$ and $lb$ denote the upper and lower bounds of the search space. $X_m\left(t\right)$ represents the mean position of all individuals in the current population. Note that in Equation (8), “$\left|\right|$” denotes the absolute value applied element-wise to vectors. The multiplication operator “·” represents element-wise multiplication between vectors.

Assuming an equal chance q for each perching strategy, individuals either perch based on the positions of other members for $q<0.5$ or choose random tall trees when $q\ge 0.5$, as described in Equation (8).

(2) Exploitation Phase

In this phase, the algorithm updates positions using four different strategies based on the escape energy E and the escape probability $r\in (0,1)$.

Soft besiege: When $0.5\le \left|E\right|<1$ and $r\ge 0.5$, the position is updated as follows:

$$X(t+1)=\Delta X\left(t\right)-E\left|J·X_{\mathrm{rabbit}}\left(t\right)-X\left(t\right)\right|$$

(10)

where $\Delta X\left(t\right)=X_{\mathrm{rabbit}}\left(t\right)-X\left(t\right)$ represents the distance between the individual and the prey, and $J=2(1-r_5)$ denotes the random jump strength of the prey, with $r_5$ being a random number in the range $(0,1)$. Similar to the exploration phase, “$\left|\right|$” and “·” in this formula are applied element-wise to vectors.

Hard besiege: When $\left|E\right|<0.5$ and $r\ge 0.5$, the position is updated as follows (parameters are the same as above):

$$X(t+1)=X_{\mathrm{rabbit}}\left(t\right)-E\left|\Delta X\left(t\right)\right|$$

(11)

The absolute value and multiplication operators here also follow the element-wise rule as defined in the algorithm.

Soft besiege with progressive rapid dives: When $0.5\le \left|E\right|<1$ and $r<0.5$, the position is updated as follows:

$$X(t+1)=\left\{\begin{array}{cc}Y=X_{\mathrm{rabbit}}\left(t\right)-E\left|J·X_{\mathrm{rabbit}}\left(t\right)-X\left(t\right)\right|,\hfill & \mathrm{if}F\left(Y\right)<F\left(X\right(t\left)\right)\hfill \\ Z=Y+S\times LF\left(x\right),\hfill & \mathrm{if}F\left(Z\right)<F\left(X\right(t\left)\right)\hfill \end{array}\right.$$

(12)

where S is a random vector of the same dimension as the problem space, with each component typically drawn uniformly from the range $[0,1]$ and is used to control the perturbation of the Lévy step size. The Lévy flight function $LF\left(x\right)$ generates a Lévy-distributed random vector of the same dimension as the problem, and its components are defined as:

$$LF\left(x\right)=0.01\times {\displaystyle \frac{u\times \sigma }{{\left|v\right|}^{1/\beta }}},\sigma ={\left({\displaystyle \frac{\Gamma (1+\beta )\times sin\left(\frac{\pi \beta }{2}\right)}{\Gamma \left(\frac{1+\beta }{2}\right)\times \beta \times 2^{\frac{\beta -1}{2}}}}\right)}^{1/\beta }$$

(13)

where u and v follow a normal distribution, and $\beta =1.5$. If neither condition $F\left(Y\right)<F\left(X\right(t\left)\right)$ nor $F\left(Z\right)<F\left(X\right(t\left)\right)$ is satisfied, the current position remains unchanged in that iteration.

Hard besiege with progressive rapid dives: When $\left|E\right|<0.5$ and $r<0.5$, the position is updated as follows (with the same parameter definitions as above):

$$X(t+1)=\left\{\begin{array}{cc}Y=X_{\mathrm{rabbit}}\left(t\right)-E\left|J·X_{\mathrm{rabbit}}\left(t\right)-X_m\left(t\right)\right|,\hfill & \mathrm{if}F\left(Y\right)<F\left(X\right(t\left)\right)\hfill \\ Z=Y+S\times LF\left(x\right),\hfill & \mathrm{if}F\left(Z\right)<F\left(X\right(t\left)\right)\hfill \end{array}\right.$$

(14)

Similarly, if both $F\left(Y\right)<F\left(X\right(t\left)\right)$ and $F\left(Z\right)<F\left(X\right(t\left)\right)$ fail to hold, no update is performed, and the position remains at $X\left(t\right)$ for that iteration.

3.2.3. Genetic Algorithm

The Genetic Algorithm [28] is a stochastic optimization method based on evolutionary mechanisms. The GA iteratively evolves a population to gradually approach the optimal solution of a problem. Its core procedure includes the following steps:

(1)

Population Initialization: Randomly construct initial population, with each $X_i$ representing a possible solution to the problem. Individuals are often encoded using binary strings, real-valued vectors, or other formats.

(2)

Fitness Evaluation: Compute the fitness of every individual, where the fitness function $F\left(X_i\right)$ assesses the quality of each corresponding solution.

(3)

Selection: Select individuals for the next generation via their fitness. Roulette wheel and tournament selection are two common selection procedures. Individuals with high fitness are more likely to be selected.

(4)

Crossover Operation: With a crossover probability ($croRate$), combine the genes of two parent individuals to generate new offspring, simulating genetic recombination in biological reproduction. In this study, we adopt single-point crossover for real-valued encoding. One parent is the current individual $X_p$, and another $X_q$ is randomly selected from the population. For these two parent individuals $X_p=(x_p^1,x_p^2,...,x_p^D)$ and $X_q=(x_q^1,x_q^2,...,x_q^D)$, we randomly select a crossover point $c\in [1,D-1]$ and generate offspring as $X_{\mathrm{offspring}}=(x_p^1,...,x_p^c,x_q^{c+1},...,x_q^D)$, where the first part is taken from parent $X_p$ and the second part from parent $X_q$. A single-point crossover is performed to generate a new individual, which replaces the current one.

(5)

Mutation Operation: With a mutation probability ($mutRate$), randomly modify the genes of individuals to enhance population diversity and reduce the risk of premature convergence. In our implementation, mutation is performed by randomly selecting several dimensions of an individual and replacing their values with new random values drawn uniformly from the allowed range of each dimension. This method introduces diversity by directly altering certain genes within their feasible bounds.

(6)

Population Update: Replace the current population with newly generated individuals to form the next generation. Individuals that are not selected for crossover or mutation are retained unchanged (i.e., Replication Operation). This replication mechanism helps preserve high-quality individuals and accelerates convergence. However, excessive replication may reduce population diversity and increase the risk of premature convergence to local optima.

(7)

Termination Condition: The method ends when the maximum iterations are achieved or the fitness fulfills the predefined condition and the best solution is output.

3.3. Learning to Rank

Learning to Rank (LTR) is a machine learning technique developed to address ranking problems, with the core objective of learning a ranking model that ensures the ranking results align as closely as possible with the true relevance labels [29]. Specifically, given a set of queries Q and their corresponding document set D, the goal of LTR is to learn a ranking function $f(q,d)$, such that for each query $q\in Q$, the ranking of documents $d\in D$ reflects their relevance. The relevance labels can be binary (relevant/irrelevant) or multi-level (e.g., grades from 0 to 4).

LTR algorithms can be broadly categorized into three types: pointwise methods, pairwise methods, and listwise methods. Pointwise methods treat each sample as an independent input and compute the loss function based on individual samples. Typical algorithms include McRank [30] and Prank [31]. Pairwise methods divide the data into sample pairs, such as $(x_i,x_j)$, and perform ranking by comparing the relative order of these sample pairs, for example, determining whether $x_i$ should be ranked higher than $x_j$. Classic pairwise methods include RankNet [29] and RankBoost [32]. Listwise methods, on the other hand, take all samples corresponding to a query as a whole input and directly optimize the ranking error of the entire list. Representative methods include ListNet [33]. These approaches generally fall under fully supervised learning and require a large amount of labeled data.

In this study, our method employs the Random Forest algorithm. The implementation process includes the following steps:

(1)

Dataset construction: Historical search data are collected from a selected subset of benchmark problem instances. Feature vectors are extracted for each candidate update behavior, and fitness-based weight values are assigned as labels.

(2)

Model training: A Random Forest model is trained to learn the mapping from feature vectors to predicted performance scores.

(3)

Prediction: During the hybrid metaheuristic process, multiple candidate behaviors are generated for each search agent. Their feature vectors are computed, and the trained model predicts a performance score for each. The behavior with the highest predicted score is selected for execution.

This framework enables real-time ranking and selection of update strategies based on dynamic features, enhancing the adaptability of the algorithm. For full implementation details, please refer to Section 4.

4. Methodology

4.1. Method Overview

The core concept of the LTR-MHA method is to leverage the LTR framework to extract knowledge from historical execution data of multiple metaheuristic algorithms. The trained prediction model dynamically predicts the scores of candidate update behaviors during the search process, thereby intelligently selecting the update behavior most likely to improve the current solution. The overall methodological flow is illustrated in Figure 1.

First, information is extracted from the update behaviors during the solving process of metaheuristic algorithms to construct a feature set and the corresponding label set. Next, a prediction model is trained to learn the relationship between different update behaviors and solution quality, which is used to predict the effectiveness of each candidate update behavior. Once the prediction model is trained, the relevant feature vectors of all candidate behaviors for the search agent to be updated are input into the model. By evaluating the feature vector of the current search agent, the model predicts a corresponding score, which reflects the potential solution quality after applying the given update behavior. Finally, the behavior with the highest predicted score is chosen to update agents.

In this way, the search process of algorithm can be guided more intelligently, avoiding blind exploration and thereby improving convergence speed and solution quality. The innovation of the LTR-MHA lies in applying LTR to learn the ranking of metaheuristic algorithm behaviors, enabling the automated generation of new algorithms. This approach breaks through the fixed search framework of traditional metaheuristic algorithms and offers a novel perspective for tackling optimization tasks. Notably, the primary objective of this study is not to identify the optimal algorithm combination but to verify the feasibility of multi-algorithm integration strategies in boosting the performance of individual algorithms. Based on this objective, three representative classical metaheuristic algorithms (GA, WOA, and HHO) are selected as the subjects of investigation in this work.

4.2. Feature Selection

The training feature set can be represented as a matrix $FS\in {\mathbb{R}}^{N\times M}$, where each row corresponds to a feature vector, and $F_{ij}$ denotes the feature value of the i-th feature vector at the j-th component. There are three sorts of features: search-dependent, solution-dependent, and instance-dependent [1]. Search-dependent features are relevant to the search procedure, such as overall improvement over the initial solution. Solution-dependent features are linked to the solution encoding scheme. For example, in the TSP, the whole path encoding can be defined explicitly as a feature. Instance-dependent features record the issue instance’s specific properties, such as the number of vehicles and vehicle capacity. It is worth mentioning that when search-dependent or instance-dependent features are used, the knowledge gained can be transferred to other instances of comparable issues or even used to solve different problems. However, solution-dependent features are frequently constrained by unique issues, making it challenging to create generalizable approaches.

Therefore, in this method, search-dependent features are used to construct the feature set. Furthermore, two main coefficient vectors of the WOA, $\overrightarrow{A}$ and $\overrightarrow{C}$; the escape energy E in HHO; and the crossover and mutation rates in the GA are also included as components of the feature set. These parameters help to more comprehensively reflect the performance characteristics of the algorithm under different update behaviors.

Moreover, quantitatively assessing the levels of exploration and exploitation in algorithms remains an open scientific question [34]. To address this issue, a feasible approach is to monitor the diversity of the population during the search process [35,36]. As an important metric, population diversity can provide a certain level of assessment of the exploration and exploitation in metaheuristics. Population diversity describes the extent of dispersion or clustering of search agents during the iterative search process. It can be calculated with the following formula:

$$Di{v}_j={\displaystyle \frac{1}{n}}\sum _{i=1}^n\left|x_i^j-\mathrm{median}\left(x^j\right)\right|,Div={\displaystyle \frac{1}{m}}\sum _{j=1}^{m}Di{v}_j$$

(15)

where $\mathrm{median}\left(x^j\right)$ represents the median value of the j-th variable across all individuals in the population, and $x_i^j$ denotes the value of the j-th variable for the i-th search agent. The total number of agents in the current iteration is given by n, while m represents the number of variables in the potential solution to the optimization problem. The term $Di{v}_j$ quantifies the average distance between each individual’s value in the j-th dimension and the median of that dimension, thus representing the diversity of the population along that specific variable. $Div$, in turn, is the average of all $Di{v}_j$ values across all dimensions, which reflects the overall diversity of the population. It is important to note that population diversity should be recalculated at each iteration. And

Table 1. Feature variables and definitions.

Type	Feature	Description
Algorithm Parameters	$\overrightarrow{A}$	Core coefficient vector of WOA
	$\overrightarrow{C}$	Core coefficient vector of WOA
	E	Escape energy, core parameter of HHO
	$croRate$	Crossover rate, core parameter of GA
	$mutRate$	Mutation rate, core parameter of GA
Search-Dependent Features	$stage$	Current algorithm stage, calculated as $t/I_{max}$, where t is the current iteration and $I_{max}$ is the maximum iterations
	$Div$	Population diversity, calculated according to the given formula Equation (15)
	$incre$	Increase in fitness value of the current agent compared to its initial fitness value
	$diff$	Difference between the current individual and the best fitness value

presents the list of feature variables used in this study, along with their definitions.

4.3. Feature Extraction and Model Training

The core of the LTR-MHA lies in extracting key features from each iteration update of the metaheuristic algorithms. Specifically, the target problem is solved individually using the selected metaheuristic algorithms (WOA, HHO, and GA). These algorithms optimize solutions through a series of update behaviors, such as shrinking encircling, spiral updating, and random search in the WOA. To systematically represent these diverse update behaviors for the purpose of Learning-to-Rank modeling, each behavior is numerically encoded as a distinct action.

Table 2. Update behaviors of the metaheuristic algorithms.

Metaheuristics	Actions Encoding	Description
WOA	1	RS: Random Search, Equation (6)
	2	SE: Shrinking Encircling, Equation (2)
	3	SU: Spiral Updating, Equation (4)
HHO	4	RM: Perch relying on the locations of other random members, Equation (8)
	5	RT: Perch on random tall trees, Equation (8)
	6	HB: Hard Besiege, Equation (11)
	7	SB: Soft Besiege, Equation (10)
	8	SRD: Soft Besiege with progressive rapid dives, Equation (12)
	9	HRD: Hard Besiege with progressive rapid dives, Equation (14)
GA	10	CRO: Single-Point Crossover Operation
	11	MUT: Mutation Operation
	12	REP: Replication Operation

presents the update behaviors of the three metaheuristic algorithms, along with their corresponding numerical encodings for the convenience of subsequent experiments.

Based on the information in Table 2, the action space of the LTR-MHA can be defined as follows:

$$Actions=\{\mathrm{RS},\mathrm{SE},\mathrm{SU},\mathrm{RM},\mathrm{RT},\mathrm{HB},\mathrm{SB},\mathrm{SRD},\mathrm{HRD},\mathrm{CRO},\mathrm{MUT},\mathrm{REP}\}$$

(16)

In continuous function optimization problems, the objective of metaheuristic algorithms is to search for the best solution within the continuous space that minimizes the objective function value. Let the algorithms set be $Alg=\{\mathrm{WOA},\mathrm{HHO},\mathrm{GA}\}$, where the population of algorithm $al{g}_i\in Alg$ is denoted as $P=(X_1,X_2,\dots ,X_i,\dots ,X_m)$, consisting of m search agents (individuals). Each search agent $X_i$ represents a candidate solution. A solution $X_i$ in D-dimensional space is encoded as:

$$X_i=(x_{i1},x_{i2},\dots ,x_{ij},\dots ,x_{iD})$$

(17)

where D represents the dimension, and $x_{ij}$ denotes the j-th variable in the solution vector. Each variable $x_{ij}$ satisfies predefined boundary constraints. By continuously updating the positions of search agents within the population, the algorithm drives the objective function value $f\left(X_i\right)$ progressively closer to the global optimum.

At each iteration of the algorithm, the search agent $X_i$ selects one action from multiple candidate update behaviors to update its position and constructs the corresponding feature vector $F_i$. According to Table 1 and Table 2, suppose the update behavior selected by $X_i$ in the current iteration is $ac{t}_i\in \mathrm{Actions}$, where the value range of $ac{t}_i$ is $[1,12]$. To ensure that all feature values fall within the range $[0,1]$, normalization is applied to each feature individually. The normalization formula for $ac{t}_i$ is as follows:

$$ac{t}_i^{\mathrm{norm}}={\displaystyle \frac{ac{t}_i-lb}{ub-lb}}$$

(18)

where $ub$ and $lb$ represent the upper and lower bounds, which are 12 and 1, respectively. Similarly, $incre$ and $diff$ are normalized in the same way. The values of $Div$, $croRate$, and $mutRate$ are originally within the range $[0,1]$. Meanwhile, $\overrightarrow{A}$ and $\overrightarrow{C}$ are D-dimensional vectors with each component of $\overrightarrow{A}$ in $[-2,2]$ and each component of $\overrightarrow{C}$ in $[0,2]$, while E is a scalar in $[-2,2]$. After normalization, these three features are also scaled to $[0,1]$. Thus, the feature vector can be expressed as follows:

$$F_i=\left\{stag{e}_i,ac{t}_i^{\mathrm{norm}},Di{v}_i,incr{e}_i^{\mathrm{norm}},dif{f}_i^{\mathrm{norm}},{\displaystyle \frac{1}{D}}\sum _{j=1}^D{\displaystyle \frac{|A_{ij}|}{2}},{\displaystyle \frac{1}{D}}\sum _{j=1}^D{\displaystyle \frac{|C_{ij}|}{2}},{\displaystyle \frac{|E_i|}{2}},croRat{e}_i,mutRat{e}_i\right\}$$

(19)

Here, $A_{ij}$ and $C_{ij}$ denote the j-th component of the coefficient vectors $\overrightarrow{A}$ and $\overrightarrow{C}$ corresponding to the i-th individual in the population. To convert the vector-valued parameters into scalar features, we compute the the mean value of $\overrightarrow{A}$ and $\overrightarrow{C}$ as follows: ${\displaystyle \frac{1}{D}}{\sum }_{j=1}^D{\displaystyle \frac{|A_{ij}|}{2}},{\displaystyle \frac{1}{D}}{\sum }_{j=1}^D{\displaystyle \frac{C_{ij}}{2}}$.

It is worth noting that the information from unselected candidate actions is also crucial for model training. Therefore, corresponding feature samples need to be constructed for these actions as well. To prevent any impact on the optimization process, a replica of the current search agent should be created to simulate the updates of other candidate actions and record their feature data. In addition, when constructing the feature set, the core parameter values of other algorithms should be preserved and assigned a value of zero. For example, when executing the WOA algorithm, the parameter E of HHO, as well as the crossover rate and mutation rate of GA, should all be retained in the feature vector but uniformly set to zero. This design ensures the completeness of the feature vector.

Figure 2 illustrates the flowchart of training set construction and model training. To reduce the complexity of the figure, only a subset of feature vectors ($F1$–$F4$) is retained as examples.

For the selected action, the $Label$ is assigned as “1”, while for the unselected candidate actions, the $Label$ is set to “0”. To assess the performance of three algorithms, we rank their best fitness ${\mathit{fitness}}^{*}$ in descending order (where lower values indicate better solutions) and assign the corresponding ranking numbers as the new $\mathit{Label}$ values. For example, as shown in Figure 2, if the GA achieves the best fitness values ($fitnes{s}^{*}=0.3$) among the three algorithms, then the $Label$ for the selected actions within the GA is adjusted from “1” to “3”. Similarly, the $Label$ for the WOA and HHO are adjusted to “2” and “1”, respectively. This strategy more properly reflects each algorithm’s relative performance during the optimization process, as well as providing more discriminative annotations for predictive model training. After completing the optimization phase of each algorithm, the feature sets corresponding to the optimal solutions provided by the three algorithms are merged to form the training feature set for the prediction model $LTRMHA$. The detailed implementation of the training set construction for the LTR-MHA is shown in Algorithm 1, with the specific feature extraction and construction process of the metaheuristic algorithm exemplified by the WOA in Algorithm 2.

Algorithm 1 The procedure of training set construction of LTR-MHA

Require:  Metaheuristics set $Alg=\{\mathrm{WOA},\mathrm{GA},\mathrm{HHO}\}$, Update behaviors set $\mathit{Actions}$, Dimension D, Maximum iterations $I_{max}$, Population size m, Bounds $lb,ub$, fitness function $func$; Ensure:  Training feature set, label set;   1: Initialize search population $P=\{X_i\mid i=1,2,\dots ,m\wedge |X_i|=D\}$;   2: for algorithm $al{g}_j\in Alg$ do                     ▹See detailed WOA update steps in Algorithm 2   3:     Compute fitness values for all search agents via $fitnes{s}_i=func\left(X_i\left(0\right)\right)$;   4:     Select the best search agent $X^{*}$;   5:     while $t<I_{max}$ do   6:         for search agent $X_i\in P$ do   7:            Execute strategy of $al{g}_j$;                                           ▹Update strategy follows Equation (16)   8:            Record selected action ${\mathit{act}}_{\mathrm{selected}}$;   9:            Construct feature vector $F_{\mathrm{selected}}$ according to Equation (19); 10:            for candidate action ${\mathit{act}}_k\in \mathit{Actions}$ do 11:                if ${\mathit{act}}_k={\mathit{act}}_{\mathrm{selected}}$ then 12:                    $\mathit{Label}=1$; 13:                else 14:                    $\mathit{Label}=0$; 15:                    Construct feature vector $F_{\mathrm{unselected}}$ for unselected actions via Equation (19); 16:                end if 17:            end for 18:         end for 19:         Adjust search agents exceeding search space boundaries via $rand(lb,ub)$; 20:         Recalculate fitness values for all search agents via $fitnes{s}_i=func\left(X_i(t+1)\right)$; 21:         Update $X^{*}$ when a better solution is available; 22:         $t=t+1$; 23:     end while 24:     Record best fitness value ${\mathit{fitness}}_j^{*}$ for algorithm $al{g}_j$; 25: end for 26: Sort algorithms by ${\mathit{fitness}}_j^{*}$ values; 27: reassign $Labe{l}_j=\mathrm{rank}\left({\mathit{fitness}}_j^{*}\right)$, where rank is the descending order; 28: return Training feature set, label set;

Algorithm 2 The procedure of feature extraction and construction of WOA

Require:  Initialize search population P, max iterations $I_{max}$, fitness function $func$, WOA parameters. Ensure:  For each agent: construct feature vectors and $\mathit{Label}$ for both the selected and unselected actions.   1: Evaluate fitness $fitnes{s}_i=func\left(X_i\left(0\right)\right)$ for all search agents;   2: Select the best search agent $X^{*}$;   3: while  $t<I_{max}$   do   4:     for each whale $X_i\in P$ do   5:         Update $a,\overrightarrow{A},\overrightarrow{C},l$, and p;   6:         if $p<0.5$ then   7:            if $|\overrightarrow{A}| <1$ then                                                                             ▹Shrinking Encircling (SE)   8:                Compute new position via Equation (2);   9:                ${\mathit{act}}_{\mathit{i}}=2$; //The numerical coding of update behaviors is shown in Table 2 10:                ${\mathit{Label}}_{\mathit{i}}^{\mathit{2}}=1$; 11:            else                                                                                                  ▹Random Search (RS) 12:                Select random leader $X_{\mathrm{rand}}$; 13:                Compute new position via Equation (6); 14:                ${\mathit{act}}_{\mathit{i}}=1$; 15:                ${\mathit{Label}}_{\mathit{i}}^{\mathit{1}}=1$; 16:            end if 17:         else                                                                                                    ▹Spiral Updating (SU) 18:            Compute new position via Equation (4); 19:            ${\mathit{act}}_{\mathit{i}}=3$; 20:            ${\mathit{Label}}_{\mathit{i}}^{\mathit{3}}=1$; 21:         end if 22:         Construct feature vector $F_{\mathrm{selected}}$ according to Equation (19); 23:         for candidate action ${\mathit{act}}_k\in [1,2,3]$ do 24:            if ${\mathit{act}}_k=1$ then                                                                                   ▹select Random Search 25:                ${\mathit{Label}}_{\mathit{i}}^{\mathit{2}}=0$; 26:                Construct feature vector $F_{\mathrm{unselected}}$ for unselected action (SE) via Equation (19); 27:                ${\mathit{Label}}_{\mathit{i}}^{\mathit{3}}=0$; 28:                Construct feature vector $F_{\mathrm{unselected}}$ for unselected action (SU) via Equation (19); 29:                    else if ${\mathit{act}}_k=2$ then                                                              ▹select Shrinking Encircling 30:                Similarly, construct the feature vectors for the unselected actions (RS, SU); 31:            else                                                                                               ▹select Spiral Updating 32:                Similarly, construct the feature vectors for the unselected actions (SE, RS); 33:            end if 34:         end for 35:     end for 36:     Adjust search agents exceeding search space boundaries via $rand(lb,ub)$; 37:     Recalculate fitness values for all search agents via $fitnes{s}_i=func\left(X_i(t+1)\right)$; 38:     Update $X^{*}$ when a better solution is available; 39:     $t=t+1$; 40: end while 41: return The best ${\mathit{fitness}}^{*}$ of WOA;

In Algorithm 1, to ensure fairness in the comparison among the algorithms, a unified initial population is used. Subsequently, the algorithms in the given algorithm set are executed sequentially, and the initial fitness values are calculated (lines 1–4). Within the $I_{\max }$, the search agents are updated according to the strategies of the metaheuristic algorithms while recording the selected update action $ac{t}_{\mathrm{selected}}$ and constructing the corresponding feature vector $F_{\mathrm{selected}}$ (lines 6–9). The update behaviors of each metaheuristic algorithm (WOA, HHO, GA) are the original, unmodified versions. The specific procedure for feature extraction and construction is illustrated using the WOA as an example, as shown in Algorithm 2. At the same time, the information of unselected candidate actions is equally crucial for model training. Therefore, feature vectors $F_{\mathrm{unselected}}$ for these actions are also constructed (lines 11–15). In each iteration, the algorithm checks whether the population exceeds the search space boundaries and performs necessary adjustments, followed by recalculating the fitness values of each solution. Whenever a better agent is available, the best agent $X^{*}$ is updated (lines 19–21). At the end of the algorithm, the best fitness of each algorithm is recorded (line 24). Finally, the algorithms are ranked according to their best fitness values ${\mathit{fitness}}^{*}$, and their corresponding labels are reassigned based on this ranking. The ranking is in descending order of best fitness, with the resulting position used as the new $Label$ (lines 26–27). Thus, among the three algorithms, the one with the smallest best fitness value receives the highest label (i.e., $\mathit{Label}=3$). The feature vectors set and its corresponding labels set together form the training dataset.

During the training stage of the predictive model $LTRMHA$, the constructed feature set, along with its corresponding label set, is used as the training set. Through supervised learning, the $LTRMHA$ model is able to predict the potential quality of the solutions generated by the update actions performed by the current search agent and produce a prediction score. This score guides the algorithm in making decisions during the search process, steering the exploration toward more promising regions of the solution space. The $LTRMHA$ model is implemented using the standard RandomForestRegressor from scikit-learn, without modification to its core training procedure. The full set of hyperparameter configurations is provided in the experimental settings.

4.4. Algorithm Implementation of LTR-MHA

Once the predictive model is trained, it can be employed to guide the search process. During each iteration, when a search agent requires position updating, the feature vectors for all candidate update actions of the current search agent are first constructed and fed into the predictive model $LTRMHA$. The model evaluates these feature vectors and outputs a set of predicted scores. Based on these scores, the algorithm selects the candidate action with the highest predicted score for execution. As illustrated in Figure 1, the model predicts that the action $ac{t}_3$ corresponds to the solution with the highest predicted score (0.78), indicating that this action is most likely to guide the search process towards the best solution. Therefore, in this iteration, the search agent selects $ac{t}_3$. The implementation of the LTR-MHA is detailed in Algorithm 3.

Algorithm 3 Pseudocode of LTR-MHA

Require:  predictive model $LTRMHA$, Update behaviors set $\mathit{Actions}$, Dimension D, Maximum iterations $I_{max}$, Population size m, Bounds $lb,ub$, fitness function $func$; Ensure:  The best solution $X^{*}$, the best fitness;   1: Initialize population $P=\{X_i\mid i=1,2,\dots ,m\wedge |X_i|=D\}$;   2: Compute fitness values for all search agents via $fitnes{s}_i=func\left(X_i\left(0\right)\right)$;   3: Select best agent to $X^{*}$;   4: while  $t<I_{max}$  do   5:     for each agent $X_i\in P$ do   6:         for candidate behavior ${\mathit{act}}_k\in \mathit{Actions}$ do   7:            Construct feature vector $F_{\mathrm{test}}^k$ for ${\mathit{act}}_k$ according to Equation (19);   8:         end for   9:         Feed feature set to $LTRMHA$, obtain prediction scores $\mathit{PS}$; 10:         Determine the optimal behavior: ${\mathit{act}}_{\mathrm{predicted}}=arg{max}_k{\mathit{PS}}_k$; 11:         Update $X_i$ using ${\mathit{act}}_{\mathrm{predicted}}$;                                                                    ▹Update strategy follows Equation (16) 12:     end for 13:     Adjust search agents exceeding search space boundaries via $rand(lb,ub)$; 14:     Recalculate fitness values via $fitnes{s}_i=func\left(X_i(t+1)\right)$; 15:     Update $X^{*}$ if a better solution is available; 16:     $t=t+1$; 17: end while 18: return $X^{*}$, the best fitness;

First, the population of search agents P is initialized, and the fitness value of each search agent is calculated. The best search agent is selected as the initial optimal solution $X^{*}$ (lines 1–3). Then, within the $I_{\max }$, for each search agent and candidate action, the feature vectors to be evaluated are constructed. Since this method involves 12 update actions, the feature set to be predicted should contain 12 feature vectors (lines 5–8). These feature vectors are then fed into the $LTRMHA$ predictive model, which outputs a set of predicted scores. The algorithm selects the update action corresponding to the highest predicted score for execution (lines 9–11). Subsequently, the algorithm checks whether any search agent has exceeded the search space boundaries, adjusts their positions accordingly, and recalculates the fitness values of all search agents (lines 13–14). If a better solution is found, the $X^{*}$ is updated (line 14). After the loop ends, the final optimal solution $X^{*}$ is returned (line 17).

5. Experiment Evaluation

5.1. Experimental Setup

In this study, the performance of the LTR-MHA algorithm is evaluated using the CEC2017 benchmark function set [25]. These functions fall into four categories: unimodal functions (F1–F3), simple multimodal functions (F4–F10), hybrid functions (F11–F20), and composition functions (F21–F30). However, during the actual experiments, errors occurred when invoking functions F2, F16, F17, F20, and F29. Upon investigation, it was found that these issues were primarily caused by numerical instabilities or boundary calculation anomalies in the implementation of these functions on specific platforms. Such issues include overflows, division by zero, or undefined logarithmic operations resulting from extreme inputs. Additionally, certain functions exhibited compatibility issues during the porting process. To ensure the stability and fairness of the experimental results, these functions were reasonably excluded to prevent technical problems from interfering with the overall evaluation. The range of all functions is $[-100,100]$, with problem dimensions set to D = 10, 30, 50, and 100.

Table 3. CEC2017 test suite.

Type	No.	Function	Dim	Range	Optimum
Unimodal Function	F1	Shifted and Rotated Bent Cigar Function	10, 30, 50, 100	[−100, 100]	100
	F3	Shifted and Rotated Zakharov Function	10, 30, 50, 100	[−100, 100]	300
Simple Multimodal Function	F4	Shifted and Rotated Rosenbrock’s Function	10, 30, 50, 100	[−100, 100]	400
	F5	Shifted and Rotated Rastrigin’s Function	10, 30, 50, 100	[−100, 100]	500
	F6	Shifted and Rotated Expanded Schaffer’s F6 Function	10, 30, 50, 100	[−100, 100]	600
	F7	Shifted and Rotated Lunacek Bi_Rastrigin Function	10, 30, 50, 100	[−100, 100]	700
	F8	Shifted and Rotated Non-Continuous Rastrigin’s Function	10, 30, 50, 100	[−100, 100]	800
	F9	Shifted and Rotated Levy Function	10, 30, 50, 100	[−100, 100]	900
	F10	Shifted and Rotated Schwefel’s Function	10, 30, 50, 100	[−100, 100]	1000
Hybrid Function	F11	Hybrid Function 1 (N = 3)	10, 30, 50, 100	[−100, 100]	1100
	F12	Hybrid Function 2 (N = 3)	10, 30, 50, 100	[−100, 100]	1200
	F13	Hybrid Function 3 (N = 3)	10, 30, 50, 100	[−100, 100]	1300
	F14	Hybrid Function 4 (N = 4)	10, 30, 50, 100	[−100, 100]	1400
	F15	Hybrid Function 5 (N = 4)	10, 30, 50, 100	[−100, 100]	1500
	F18	Hybrid Function 8 (N = 5)	10, 30, 50, 100	[−100, 100]	1800
	F19	Hybrid Function 9 (N = 5)	10, 30, 50, 100	[−100, 100]	1900
Composition Function	F21	Composition Function 1 (N = 3)	10, 30, 50, 100	[−100, 100]	2100
	F22	Composition Function 2 (N = 3)	10, 30, 50, 100	[−100, 100]	2200
	F23	Composition Function 3 (N = 4)	10, 30, 50, 100	[−100, 100]	2300
	F24	Composition Function 4 (N = 4)	10, 30, 50, 100	[−100, 100]	2400
	F25	Composition Function 5 (N = 5)	10, 30, 50, 100	[−100, 100]	2500
	F26	Composition Function 6 (N = 5)	10, 30, 50, 100	[−100, 100]	2600
	F27	Composition Function 7 (N = 6)	10, 30, 50, 100	[−100, 100]	2700
	F28	Composition Function 8 (N = 6)	10, 30, 50, 100	[−100, 100]	2800
	F30	Composition Function 10 (N = 3)	10, 30, 50, 100	[−100, 100]	3000

includes information about the CEC2017.

The objective of the experiments is to confirm the effectiveness of the LTR-MHA method, focusing on three aspects: convergence speed, solution precise, and computing efficiency. The LTR-MHA is compared against individual metaheuristic algorithms, namely the WOA, HHO, and the GA. Under the same algorithmic framework, a comparison is conducted with the Rand-MHA method, which adopts a random update strategy. In the Rand-MHA, the update operation is randomly selected at each position update step, without relying on any learning process, meaning that each update operation has an equal probability of being chosen. Additionally, our approach is compared to two recent improved algorithms, namely the ISGA [8] and RLWOA [13].

In all comparative experiments, the algorithm parameters are uniformly configured to ensure the fairness and reproducibility of the experiments. Specifically, during the training phase, one function from each of the four categories in the CEC2017 benchmark suite is selected to form the training function set. In this study, functions F1, F4, F11, and F21 are chosen as the training set. Therefore, these four functions are excluded from the testing phase to avoid evaluation bias, as they have been used to train the Learning-to-Rank model. This ensures a fair performance comparison on unseen benchmark functions. For each function in the benchmark set, algorithms are each run 15 times, with the population size and iterations set to 30 and 500, respectively. Other settings are summarized in

Table 4. Parameter configurations for all algorithms used in the experiments.

Algorithm	Parameter	Value
WOA	a	Linearly decreased from 2 to 0
	b	1
HHO	Lévy flight $\beta$	1.5
GA	Crossover rate $croRate$	0.3
	Mutation rate $mutRate$	0.08
	Selection operation	Tournament (size = 3)
	Crossover operation	Single-point crossover
	Mutation operation	Randomly replace selected genes within feasible range
ISGA	Weighting parameter w	Linearly decreasing from 0.9 to 0.4
	Perturbation factor	The perturbation is computed as a random number $\mathrm{rand}\in [-1,1]$ multiplied by a linearly decreasing factor $(1-t/max\_iter)$
RLWOA	a	Linearly decreased from 2 to 0
	b	1
	Weighting parameter $\sigma$	0.6
	Learning rate	Linearly decreased from 0.9 to 0.1
	Discount factor	0.8
LTR-MHA	Model	Random Forest (scikit-learn)
	RF parameters	n_estimators = 50, max_depth = 10, min_samples_split = 10, min_samples_leaf = 5

for reproducibility.

To further eliminate the influence of initial randomness, all algorithms use the same initial population configuration, ensuring that performance differences arise primarily from the algorithmic mechanisms rather than stochastic factors. Subsequently, the historical information of the optimal solutions is used as training data to train the predictive model based on a Random Forest ranking algorithm. During the testing phase, the trained predictive model is applied to test functions other than F1, F4, F11, and F21. To reduce the effect of randomness on the experimental outcomes, each algorithm is executed independently 15 times.

5.2. Experimental Results and Discussion

Table 5. Comparison of unimodal and simple multimodal functions.

Funcs	Algorithm	Dim = 10			Dim = 30			Dim = 50			Dim = 100
		Mean	Std	Best	Mean	Std	Best	Mean	Std	Best	Mean	Std	Best
F3	WOA	$2.09\times {10}^4$	$8.40\times {10}^2$	$2.01\times {10}^4$	$3.20\times {10}^{11}$	$2.59\times {10}^{10}$	$2.94\times {10}^{11}$	$3.82\times {10}^5$	$2.79\times {10}^3$	$3.79\times {10}^5$	$7.64\times {10}^5$	$1.66\times {10}^5$	$5.98\times {10}^5$
	HHO	$1.45\times {10}^4$	$2.45\times {10}^3$	$1.20\times {10}^4$	$4.74\times {10}^{11}$	$1.36\times {10}^{11}$	$3.38\times {10}^{11}$	$1.97\times {10}^5$	$2.48\times {10}^3$	$1.95\times {10}^5$	$3.73\times {10}^5$	$6.72\times {10}^3$	$3.66\times {10}^5$
	GA	$2.63\times {10}^4$	$1.17\times {10}^4$	$1.46\times {10}^4$	$4.50\times {10}^{10}$	$1.20\times {10}^{10}$	$3.00\times {10}^{10}$	$4.10\times {10}^5$	$7.47\times {10}^4$	$3.35\times {10}^5$	$8.30\times {10}^5$	$4.82\times {10}^4$	$7.82\times {10}^5$
	ISGA	$2.20\times {10}^4$	$9.50\times {10}^3$	$1.50\times {10}^4$	$2.80\times {10}^9$	$8.10\times {10}^8$	$1.90\times {10}^9$	$4.30\times {10}^5$	$7.80\times {10}^4$	$3.50\times {10}^5$	$8.50\times {10}^5$	$5.00\times {10}^4$	$8.00\times {10}^5$
	RLWOA	$1.35\times {10}^4$	$3.80\times {10}^3$	$1.25\times {10}^4$	$\mathbf{2}.\mathbf{37}\times {\mathbf{10}}^{\mathbf{9}}$	$7.23\times {10}^8$	$1.64\times {10}^9$	$1.90\times {10}^5$	$1.70\times {10}^4$	$1.70\times {10}^5$	$3.70\times {10}^5$	$6.00\times {10}^3$	$3.60\times {10}^5$
	Rand-MHA	$1.30\times {10}^4$	$3.60\times {10}^3$	$1.24\times {10}^4$	$5.63\times {10}^9$	$6.23\times {10}^8$	$4.06\times {10}^9$	$1.87\times {10}^5$	$2.36\times {10}^4$	$1.85\times {10}^5$	$\mathbf{3}.\mathbf{60}\times {\mathbf{10}}^{\mathbf{5}}$	$5.97\times {10}^3$	$3.55\times {10}^5$
	LTR-MHA	$\mathbf{5}.\mathbf{89}\times {\mathbf{10}}^{\mathbf{3}}$	$2.17\times {10}^2$	$5.67\times {10}^3$	$4.04\times {10}^{10}$	$1.19\times {10}^{10}$	$2.85\times {10}^{10}$	$\mathbf{1}.\mathbf{85}\times {\mathbf{10}}^{\mathbf{5}}$	$1.62\times {10}^4$	$1.69\times {10}^5$	$8.90\times {10}^5$	$8.88\times {10}^2$	$8.90\times {10}^5$
F5	WOA	$5.67\times {10}^2$	$1.47\times {10}^0$	$5.66\times {10}^2$	$9.28\times {10}^2$	$2.99\times {10}^1$	$8.98\times {10}^2$	$1.18\times {10}^3$	$1.03\times {10}^1$	$1.17\times {10}^3$	$2.08\times {10}^3$	$9.71\times {10}^0$	$2.07\times {10}^3$
	HHO	$5.59\times {10}^2$	$2.67\times {10}^0$	$5.56\times {10}^2$	$8.67\times {10}^2$	$8.78\times {10}^{-1}$	$8.66\times {10}^2$	$1.16\times {10}^3$	$3.72\times {10}^1$	$1.12\times {10}^3$	$2.02\times {10}^3$	$1.33\times {10}^1$	$2.01\times {10}^3$
	GA	$5.32\times {10}^2$	$1.82\times {10}^1$	$5.14\times {10}^2$	$6.94\times {10}^2$	$4.28\times {10}^1$	$6.52\times {10}^2$	$1.03\times {10}^3$	$5.21\times {10}^1$	$9.76\times {10}^2$	$1.95\times {10}^3$	$1.55\times {10}^2$	$1.79\times {10}^3$
	ISGA	$5.30\times {10}^2$	$1.80\times {10}^1$	$5.12\times {10}^2$	$7.00\times {10}^2$	$4.30\times {10}^1$	$6.60\times {10}^2$	$1.04\times {10}^3$	$5.20\times {10}^1$	$9.80\times {10}^2$	$1.96\times {10}^3$	$1.50\times {10}^2$	$1.80\times {10}^3$
	RLWOA	$5.35\times {10}^2$	$8.50\times {10}^0$	$5.27\times {10}^2$	$7.30\times {10}^2$	$2.50\times {10}^1$	$6.90\times {10}^2$	$9.00\times {10}^2$	$4.30\times {10}^1$	$8.80\times {10}^2$	$1.66\times {10}^3$	$1.80\times {10}^1$	$1.64\times {10}^3$
	Rand-MHA	$5.36\times {10}^2$	$8.46\times {10}^0$	$5.28\times {10}^2$	$7.28\times {10}^2$	$2.53\times {10}^1$	$6.88\times {10}^2$	$\mathbf{8}.\mathbf{95}\times {\mathbf{10}}^{\mathbf{2}}$	$4.31\times {10}^1$	$8.78\times {10}^2$	$1.65\times {10}^3$	$1.82\times {10}^1$	$1.63\times {10}^3$
	LTR-MHA	$\mathbf{5}.\mathbf{28}\times {\mathbf{10}}^{\mathbf{2}}$	$3.88\times {10}^0$	$5.24\times {10}^2$	$\mathbf{6}.\mathbf{32}\times {\mathbf{10}}^{\mathbf{2}}$	$2.13\times {10}^1$	$6.11\times {10}^2$	$1.04\times {10}^3$	$3.47\times {10}^1$	$1.01\times {10}^3$	$\mathbf{1}.\mathbf{48}\times {\mathbf{10}}^{\mathbf{3}}$	$1.14\times {10}^1$	$1.37\times {10}^3$
F6	WOA	$6.51\times {10}^2$	$1.39\times {10}^0$	$6.50\times {10}^2$	$6.88\times {10}^2$	$7.33\times {10}^{-1}$	$6.88\times {10}^2$	$7.36\times {10}^2$	$4.07\times {10}^0$	$7.32\times {10}^2$	$7.28\times {10}^2$	$1.29\times {10}^0$	$7.26\times {10}^2$
	HHO	$6.49\times {10}^2$	$1.16\times {10}^1$	$6.37\times {10}^2$	$6.89\times {10}^2$	$1.88\times {10}^1$	$6.71\times {10}^2$	$7.27\times {10}^2$	$4.59\times {10}^0$	$7.23\times {10}^2$	$7.18\times {10}^2$	$3.54\times {10}^0$	$7.14\times {10}^2$
	GA	$6.15\times {10}^2$	$6.78\times {10}^0$	$6.08\times {10}^2$	$6.66\times {10}^2$	$3.35\times {10}^0$	$6.62\times {10}^2$	$6.99\times {10}^2$	$1.26\times {10}^1$	$6.86\times {10}^2$	$7.39\times {10}^2$	$8.36\times {10}^0$	$7.31\times {10}^2$
	ISGA	$6.20\times {10}^2$	$8.50\times {10}^0$	$6.12\times {10}^2$	$6.68\times {10}^2$	$3.40\times {10}^0$	$6.64\times {10}^2$	$7.00\times {10}^2$	$1.25\times {10}^1$	$6.87\times {10}^2$	$7.40\times {10}^2$	$8.40\times {10}^0$	$7.32\times {10}^2$
	RLWOA	$6.22\times {10}^2$	$8.50\times {10}^0$	$6.15\times {10}^2$	$6.63\times {10}^2$	$2.40\times {10}^0$	$6.60\times {10}^2$	$7.00\times {10}^2$	$1.45\times {10}^1$	$6.93\times {10}^2$	$6.98\times {10}^2$	$4.70\times {10}^0$	$6.93\times {10}^2$
	Rand-MHA	$6.21\times {10}^2$	$8.48\times {10}^0$	$6.14\times {10}^2$	$6.62\times {10}^2$	$2.35\times {10}^0$	$6.59\times {10}^2$	$6.99\times {10}^2$	$1.45\times {10}^1$	$6.92\times {10}^2$	$6.97\times {10}^2$	$4.72\times {10}^0$	$6.92\times {10}^2$
	LTR-MHA	$\mathbf{6}.\mathbf{12}\times {\mathbf{10}}^{\mathbf{2}}$	$1.84\times {10}^0$	$6.10\times {10}^2$	$\mathbf{6}.\mathbf{44}\times {\mathbf{10}}^{\mathbf{2}}$	$3.85\times {10}^{-1}$	$6.43\times {10}^2$	$\mathbf{6}.\mathbf{80}\times {\mathbf{10}}^{\mathbf{2}}$	$1.94\times {10}^0$	$6.78\times {10}^2$	$\mathbf{6}.\mathbf{73}\times {\mathbf{10}}^{\mathbf{2}}$	$2.78\times {10}^0$	$6.51\times {10}^2$
F7	WOA	$8.18\times {10}^2$	$6.94\times {10}^0$	$8.11\times {10}^2$	$1.46\times {10}^3$	$3.60\times {10}^1$	$1.42\times {10}^3$	$2.06\times {10}^3$	$1.33\times {10}^1$	$2.05\times {10}^3$	$3.98\times {10}^3$	$7.42\times {10}^1$	$3.91\times {10}^3$
	HHO	$8.25\times {10}^2$	$6.11\times {10}^0$	$8.18\times {10}^2$	$1.39\times {10}^3$	$1.25\times {10}^1$	$1.38\times {10}^3$	$1.95\times {10}^3$	$1.24\times {10}^1$	$1.94\times {10}^3$	$3.83\times {10}^3$	$6.42\times {10}^1$	$3.76\times {10}^3$
	GA	$\mathbf{7}.\mathbf{42}\times {\mathbf{10}}^{\mathbf{2}}$	$5.01\times {10}^0$	$7.37\times {10}^2$	$\mathbf{9}.\mathbf{03}\times {\mathbf{10}}^{\mathbf{2}}$	$1.32\times {10}^0$	$9.02\times {10}^2$	$1.22\times {10}^3$	$9.69\times {10}^1$	$1.13\times {10}^3$	$\mathbf{2}.\mathbf{45}\times {\mathbf{10}}^{\mathbf{3}}$	$1.12\times {10}^2$	$2.33\times {10}^3$
	ISGA	$7.45\times {10}^2$	$7.50\times {10}^0$	$7.36\times {10}^2$	$9.05\times {10}^2$	$1.35\times {10}^0$	$9.03\times {10}^2$	$1.23\times {10}^3$	$9.70\times {10}^1$	$1.14\times {10}^3$	$2.46\times {10}^3$	$1.10\times {10}^2$	$2.34\times {10}^3$
	RLWOA	$7.50\times {10}^2$	$7.50\times {10}^0$	$7.40\times {10}^2$	$1.09\times {10}^3$	$1.80\times {10}^1$	$1.05\times {10}^3$	$1.63\times {10}^3$	$1.10\times {10}^2$	$1.52\times {10}^3$	$3.56\times {10}^3$	$1.40\times {10}^2$	$3.42\times {10}^3$
	Rand-MHA	$7.48\times {10}^2$	$7.45\times {10}^0$	$7.39\times {10}^2$	$1.08\times {10}^3$	$1.75\times {10}^1$	$1.04\times {10}^3$	$1.62\times {10}^3$	$1.05\times {10}^2$	$1.51\times {10}^3$	$3.55\times {10}^3$	$1.38\times {10}^2$	$3.41\times {10}^3$
	LTR-MHA	$7.65\times {10}^2$	$2.38\times {10}^0$	$7.63\times {10}^2$	$1.20\times {10}^3$	$2.59\times {10}^{-1}$	$1.20\times {10}^3$	$\mathbf{1}.\mathbf{16}\times {\mathbf{10}}^{\mathbf{3}}$	$4.66\times {10}^0$	$1.12\times {10}^3$	$4.00\times {10}^3$	$3.31\times {10}^1$	$3.96\times {10}^3$
F8	WOA	$8.44\times {10}^2$	$5.13\times {10}^0$	$8.39\times {10}^2$	$1.13\times {10}^3$	$1.71\times {10}^1$	$1.12\times {10}^3$	$1.47\times {10}^3$	$2.29\times {10}^1$	$1.45\times {10}^3$	$2.51\times {10}^3$	$2.72\times {10}^1$	$2.48\times {10}^3$
	HHO	$8.53\times {10}^2$	$2.41\times {10}^1$	$8.29\times {10}^2$	$1.11\times {10}^3$	$2.59\times {10}^1$	$1.08\times {10}^3$	$1.45\times {10}^3$	$7.93\times {10}^0$	$1.45\times {10}^3$	$2.50\times {10}^3$	$3.09\times {10}^1$	$2.47\times {10}^3$
	GA	$8.25\times {10}^2$	$6.27\times {10}^0$	$8.19\times {10}^2$	$9.80\times {10}^2$	$2.82\times {10}^1$	$9.51\times {10}^2$	$1.23\times {10}^3$	$7.96\times {10}^1$	$1.15\times {10}^3$	$2.24\times {10}^3$	$1.04\times {10}^1$	$2.23\times {10}^3$
	ISGA	$8.27\times {10}^2$	$6.30\times {10}^0$	$8.21\times {10}^2$	$9.82\times {10}^2$	$2.80\times {10}^1$	$9.53\times {10}^2$	$1.24\times {10}^3$	$7.90\times {10}^1$	$1.16\times {10}^3$	$2.25\times {10}^3$	$1.00\times {10}^1$	$2.24\times {10}^3$
	RLWOA	$8.22\times {10}^2$	$3.50\times {10}^0$	$8.15\times {10}^2$	$9.60\times {10}^2$	$3.80\times {10}^1$	$9.25\times {10}^2$	$1.22\times {10}^3$	$8.60\times {10}^0$	$1.22\times {10}^3$	$2.15\times {10}^3$	$4.60\times {10}^0$	$2.14\times {10}^3$
	Rand-MHA	$8.21\times {10}^2$	$3.47\times {10}^0$	$8.14\times {10}^2$	$\mathbf{9}.\mathbf{59}\times {\mathbf{10}}^{\mathbf{2}}$	$3.82\times {10}^1$	$9.22\times {10}^2$	$\mathbf{1}.\mathbf{21}\times {\mathbf{10}}^{\mathbf{3}}$	$8.54\times {10}^0$	$1.21\times {10}^3$	$\mathbf{2}.\mathbf{14}\times {\mathbf{10}}^{\mathbf{3}}$	$4.56\times {10}^0$	$2.13\times {10}^3$
	LTR-MHA	$\mathbf{8}.\mathbf{20}\times {\mathbf{10}}^{\mathbf{2}}$	$1.79\times {10}^0$	$7.26\times {10}^2$	$9.04\times {10}^3$	$2.57\times {10}^{-1}$	$1.04\times {10}^3$	$1.31\times {10}^3$	$1.92\times {10}^1$	$1.29\times {10}^3$	$2.21\times {10}^3$	$3.55\times {10}^1$	$2.17\times {10}^3$
F9	WOA	$1.34\times {10}^3$	$1.98\times {10}^1$	$1.32\times {10}^3$	$1.06\times {10}^4$	$1.61\times {10}^3$	$9.04\times {10}^3$	$2.95\times {10}^4$	$5.80\times {10}^2$	$2.89\times {10}^4$	$7.83\times {10}^4$	$2.42\times {10}^3$	$7.59\times {10}^4$
	HHO	$1.41\times {10}^3$	$9.73\times {10}^1$	$1.32\times {10}^3$	$7.79\times {10}^3$	$1.32\times {10}^3$	$6.47\times {10}^3$	$2.87\times {10}^4$	$1.33\times {10}^3$	$2.74\times {10}^4$	$7.19\times {10}^4$	$3.96\times {10}^3$	$6.79\times {10}^4$
	GA	$\mathbf{9}.\mathbf{03}\times {\mathbf{10}}^{\mathbf{2}}$	$2.18\times {10}^0$	$9.01\times {10}^2$	$8.37\times {10}^3$	$6.70\times {10}^3$	$1.67\times {10}^3$	$2.18\times {10}^4$	$1.16\times {10}^3$	$2.07\times {10}^4$	$9.74\times {10}^4$	$1.39\times {10}^4$	$8.35\times {10}^4$
	ISGA	$9.65\times {10}^2$	$1.15\times {10}^1$	$9.41\times {10}^2$	$8.40\times {10}^3$	$6.70\times {10}^3$	$1.70\times {10}^3$	$2.19\times {10}^4$	$1.15\times {10}^3$	$2.08\times {10}^4$	$9.75\times {10}^4$	$1.38\times {10}^4$	$8.36\times {10}^4$
	RLWOA	$9.67\times {10}^2$	$1.15\times {10}^1$	$9.43\times {10}^2$	$7.38\times {10}^3$	$3.72\times {10}^3$	$6.79\times {10}^3$	$2.18\times {10}^4$	$4.55\times {10}^3$	$1.93\times {10}^4$	$6.13\times {10}^4$	$8.70\times {10}^2$	$6.04\times {10}^4$
	Rand-MHA	$9.66\times {10}^2$	$1.13\times {10}^1$	$9.42\times {10}^2$	$7.36\times {10}^3$	$3.70\times {10}^3$	$6.77\times {10}^3$	$2.17\times {10}^4$	$4.52\times {10}^3$	$1.92\times {10}^4$	$6.12\times {10}^4$	$8.64\times {10}^2$	$6.03\times {10}^4$
	LTR-MHA	$9.38\times {10}^2$	$8.71\times {10}^0$	$9.29\times {10}^2$	$\mathbf{5}.\mathbf{04}\times {\mathbf{10}}^{\mathbf{3}}$	$1.45\times {10}^2$	$4.90\times {10}^3$	$\mathbf{1}.\mathbf{79}\times {\mathbf{10}}^{\mathbf{4}}$	$3.79\times {10}^3$	$1.41\times {10}^4$	$\mathbf{6}.\mathbf{14}\times {\mathbf{10}}^{\mathbf{4}}$	$5.47\times {10}^1$	$6.03\times {10}^4$
F10	WOA	$2.39\times {10}^3$	$2.82\times {10}^2$	$2.10\times {10}^3$	$7.94\times {10}^3$	$1.28\times {10}^3$	$6.66\times {10}^3$	$1.44\times {10}^4$	$2.31\times {10}^2$	$1.42\times {10}^4$	$3.28\times {10}^4$	$5.53\times {10}^1$	$3.28\times {10}^4$
	HHO	$2.26\times {10}^3$	$1.26\times {10}^2$	$2.13\times {10}^3$	$7.78\times {10}^3$	$5.25\times {10}^2$	$7.26\times {10}^3$	$1.41\times {10}^4$	$6.04\times {10}^1$	$1.40\times {10}^4$	$3.23\times {10}^4$	$4.39\times {10}^2$	$3.18\times {10}^4$
	GA	$1.68\times {10}^3$	$5.76\times {10}^1$	$1.62\times {10}^3$	$5.45\times {10}^3$	$5.02\times {10}^2$	$4.55\times {10}^3$	$9.96\times {10}^3$	$2.98\times {10}^2$	$9.66\times {10}^3$	$2.62\times {10}^4$	$8.42\times {10}^1$	$2.61\times {10}^4$
	ISGA	$1.70\times {10}^3$	$5.80\times {10}^1$	$1.64\times {10}^3$	$5.50\times {10}^3$	$5.00\times {10}^2$	$4.60\times {10}^3$	$1.00\times {10}^4$	$3.00\times {10}^2$	$9.70\times {10}^3$	$2.63\times {10}^4$	$8.40\times {10}^1$	$2.62\times {10}^4$
	RLWOA	$1.78\times {10}^3$	$7.80\times {10}^1$	$1.77\times {10}^3$	$6.36\times {10}^3$	$5.65\times {10}^2$	$6.28\times {10}^3$	$1.09\times {10}^4$	$8.70\times {10}^2$	$1.03\times {10}^4$	$2.48\times {10}^4$	$7.05\times {10}^2$	$2.41\times {10}^4$
	Rand-MHA	$1.77\times {10}^3$	$7.76\times {10}^1$	$1.76\times {10}^3$	$6.35\times {10}^3$	$5.62\times {10}^2$	$6.27\times {10}^3$	$1.08\times {10}^4$	$8.66\times {10}^2$	$1.02\times {10}^4$	$2.47\times {10}^4$	$7.02\times {10}^2$	$2.40\times {10}^4$
	LTR-MHA	$\mathbf{1}.\mathbf{65}\times {\mathbf{10}}^{\mathbf{3}}$	$7.02\times {10}^1$	$1.58\times {10}^3$	$\mathbf{5}.\mathbf{17}\times {\mathbf{10}}^{\mathbf{3}}$	$1.80\times {10}^2$	$4.79\times {10}^3$	$\mathbf{9}.\mathbf{31}\times {\mathbf{10}}^{\mathbf{3}}$	$1.03\times {10}^3$	$9.21\times {10}^3$	$\mathbf{2}.\mathbf{15}\times {\mathbf{10}}^{\mathbf{4}}$	$5.88\times {10}^2$	$2.09\times {10}^4$

,

Table 6. Comparison of hybrid functions.

Funcs	Algorithm	Dim = 10			Dim = 30			Dim = 50			Dim = 100
		Mean	Std	Best	Mean	Std	Best	Mean	Std	Best	Mean	Std	Best
F12	WOA	$8.44\times {10}^7$	$1.91\times {10}^7$	$6.53\times {10}^7$	$3.06\times {10}^{10}$	$1.06\times {10}^{10}$	$2.00\times {10}^{10}$	$2.77\times {10}^{11}$	$2.54\times {10}^{10}$	$2.51\times {10}^{11}$	$1.28\times {10}^{12}$	$1.72\times {10}^{11}$	$1.11\times {10}^{12}$
	HHO	$8.65\times {10}^8$	$8.25\times {10}^8$	$4.03\times {10}^7$	$1.10\times {10}^{11}$	$2.37\times {10}^{10}$	$8.67\times {10}^{10}$	$4.61\times {10}^{11}$	$2.68\times {10}^{11}$	$1.93\times {10}^{11}$	$1.51\times {10}^{12}$	$1.74\times {10}^{11}$	$1.34\times {10}^{12}$
	GA	$7.45\times {10}^6$	$2.00\times {10}^6$	$5.45\times {10}^6$	$5.10\times {10}^7$	$2.96\times {10}^6$	$4.80\times {10}^7$	$\mathbf{5}.\mathbf{57}\times {\mathbf{10}}^{\mathbf{8}}$	$1.09\times {10}^7$	$5.46\times {10}^8$	$1.81\times {10}^{10}$	$3.79\times {10}^9$	$1.43\times {10}^{10}$
	ISGA	$7.00\times {10}^6$	$1.80\times {10}^6$	$5.10\times {10}^6$	$4.50\times {10}^7$	$2.50\times {10}^6$	$4.20\times {10}^7$	$4.80\times {10}^8$	$9.50\times {10}^6$	$4.70\times {10}^8$	$1.50\times {10}^{10}$	$3.20\times {10}^9$	$1.20\times {10}^{10}$
	RLWOA	$4.50\times {10}^6$	$1.20\times {10}^5$	$4.40\times {10}^6$	$1.80\times {10}^7$	$6.50\times {10}^7$	$1.50\times {10}^9$	$2.60\times {10}^{10}$	$1.70\times {10}^9$	$2.45\times {10}^{10}$	$1.20\times {10}^{10}$	$3.20\times {10}^9$	$1.15\times {10}^{10}$
	Rand-MHA	$6.13\times {10}^6$	$2.24\times {10}^5$	$1.20\times {10}^7$	$1.23\times {10}^8$	$4.60\times {10}^7$	$1.09\times {10}^8$	$2.81\times {10}^9$	$1.35\times {10}^9$	$2.71\times {10}^9$	$3.33\times {10}^{10}$	$9.40\times {10}^9$	$2.39\times {10}^{10}$
	LTR-MHA	$\mathbf{3}.\mathbf{82}\times {\mathbf{10}}^{\mathbf{6}}$	$5.24\times {10}^4$	$3.77\times {10}^6$	$\mathbf{1}.\mathbf{33}\times {\mathbf{10}}^{\mathbf{7}}$	$5.89\times {10}^7$	$1.27\times {10}^9$	$2.78\times {10}^{10}$	$1.86\times {10}^9$	$2.59\times {10}^{10}$	$\mathbf{1}.\mathbf{11}\times {\mathbf{10}}^{\mathbf{10}}$	$3.05\times {10}^9$	$1.08\times {10}^{10}$
F13	WOA	$2.13\times {10}^4$	$1.07\times {10}^4$	$1.06\times {10}^4$	$1.04\times {10}^{10}$	$2.97\times {10}^9$	$7.40\times {10}^9$	$1.33\times {10}^{11}$	$6.98\times {10}^{10}$	$6.32\times {10}^{10}$	$3.30\times {10}^{11}$	$8.39\times {10}^{10}$	$2.46\times {10}^{11}$
	HHO	$1.66\times {10}^4$	$5.48\times {10}^3$	$1.11\times {10}^4$	$3.86\times {10}^{10}$	$3.01\times {10}^{10}$	$8.58\times {10}^9$	$3.95\times {10}^{11}$	$4.45\times {10}^{10}$	$3.51\times {10}^{11}$	$3.92\times {10}^{11}$	$1.87\times {10}^{10}$	$3.73\times {10}^{11}$
	GA	$1.28\times {10}^6$	$4.16\times {10}^5$	$8.62\times {10}^5$	$6.44\times {10}^7$	$1.34\times {10}^7$	$5.10\times {10}^7$	$2.45\times {10}^8$	$7.02\times {10}^7$	$1.75\times {10}^8$	$\mathbf{1}.\mathbf{22}\times {\mathbf{10}}^{\mathbf{9}}$	$1.51\times {10}^8$	$1.07\times {10}^9$
	ISGA	$1.10\times {10}^6$	$3.80\times {10}^5$	$7.50\times {10}^5$	$5.80\times {10}^7$	$1.20\times {10}^7$	$4.60\times {10}^7$	$2.20\times {10}^8$	$6.50\times {10}^7$	$1.60\times {10}^8$	$1.10\times {10}^9$	$1.40\times {10}^8$	$9.80\times {10}^8$
	RLWOA	$1.10\times {10}^4$	$6.00\times {10}^3$	$9.00\times {10}^3$	$3.00\times {10}^7$	$1.50\times {10}^7$	$1.50\times {10}^7$	$1.30\times {10}^8$	$7.80\times {10}^9$	$7.80\times {10}^7$	$2.30\times {10}^9$	$2.70\times {10}^8$	$2.00\times {10}^9$
	Rand-MHA	$\mathbf{1}.\mathbf{04}\times {\mathbf{10}}^{\mathbf{4}}$	$5.63\times {10}^3$	$8.69\times {10}^3$	$\mathbf{2}.\mathbf{84}\times {\mathbf{10}}^{\mathbf{7}}$	$1.36\times {10}^7$	$1.42\times {10}^7$	$\mathbf{1}.\mathbf{20}\times {\mathbf{10}}^{\mathbf{8}}$	$7.55\times {10}^9$	$7.37\times {10}^7$	$2.22\times {10}^9$	$2.60\times {10}^8$	$1.96\times {10}^9$
	LTR-MHA	$9.98\times {10}^4$	$6.89\times {10}^3$	$9.29\times {10}^4$	$3.17\times {10}^8$	$2.12\times {10}^7$	$2.96\times {10}^8$	$6.79\times {10}^9$	$2.05\times {10}^9$	$4.74\times {10}^9$	$2.57\times {10}^{10}$	$2.31\times {10}^9$	$2.33\times {10}^{10}$
F14	WOA	$5.69\times {10}^3$	$5.14\times {10}^1$	$5.63\times {10}^3$	$4.73\times {10}^6$	$1.18\times {10}^6$	$3.56\times {10}^6$	$9.11\times {10}^6$	$3.86\times {10}^6$	$5.25\times {10}^6$	$9.83\times {10}^7$	$5.74\times {10}^7$	$4.09\times {10}^7$
	HHO	$3.24\times {10}^3$	$2.52\times {10}^2$	$1.98\times {10}^3$	$4.13\times {10}^6$	$1.97\times {10}^6$	$2.16\times {10}^6$	$1.00\times {10}^8$	$6.73\times {10}^7$	$3.30\times {10}^7$	$5.51\times {10}^7$	$1.57\times {10}^7$	$3.94\times {10}^7$
	GA	$4.33\times {10}^4$	$4.94\times {10}^3$	$8.32\times {10}^3$	$1.35\times {10}^6$	$1.19\times {10}^6$	$1.60\times {10}^5$	$8.33\times {10}^6$	$1.22\times {10}^6$	$7.11\times {10}^6$	$5.33\times {10}^7$	$3.33\times {10}^7$	$2.00\times {10}^7$
	ISGA	$4.00\times {10}^4$	$4.50\times {10}^3$	$7.80\times {10}^3$	$1.20\times {10}^6$	$1.10\times {10}^6$	$1.40\times {10}^5$	$7.80\times {10}^6$	$1.10\times {10}^6$	$6.80\times {10}^6$	$5.00\times {10}^7$	$3.10\times {10}^7$	$1.90\times {10}^7$
	RLWOA	$3.20\times {10}^3$	$1.30\times {10}^3$	$3.10\times {10}^3$	$2.50\times {10}^5$	$1.60\times {10}^5$	$8.00\times {10}^4$	$3.30\times {10}^6$	$4.20\times {10}^5$	$3.25\times {10}^6$	$1.20\times {10}^7$	$1.30\times {10}^7$	$1.05\times {10}^7$
	Rand-MHA	$3.38\times {10}^3$	$4.34\times {10}^3$	$2.10\times {10}^3$	$3.19\times {10}^5$	$7.45\times {10}^5$	$1.63\times {10}^5$	$3.22\times {10}^6$	$4.67\times {10}^5$	$3.21\times {10}^6$	$1.99\times {10}^7$	$5.11\times {10}^6$	$1.48\times {10}^7$
	LTR-MHA	$\mathbf{3}.\mathbf{13}\times {\mathbf{10}}^{\mathbf{3}}$	$1.12\times {10}^3$	$3.01\times {10}^3$	$\mathbf{2}.\mathbf{19}\times {\mathbf{10}}^{\mathbf{5}}$	$1.45\times {10}^5$	$7.43\times {10}^4$	$\mathbf{3}.\mathbf{16}\times {\mathbf{10}}^{\mathbf{6}}$	$3.97\times {10}^5$	$3.11\times {10}^6$	$\mathbf{1}.\mathbf{13}\times {\mathbf{10}}^{\mathbf{7}}$	$1.22\times {10}^7$	$1.01\times {10}^7$
F15	WOA	$2.67\times {10}^4$	$1.74\times {10}^4$	$9.28\times {10}^3$	$2.98\times {10}^9$	$1.42\times {10}^8$	$2.84\times {10}^9$	$2.81\times {10}^{10}$	$1.50\times {10}^{10}$	$1.30\times {10}^{10}$	$1.74\times {10}^{11}$	$3.22\times {10}^{10}$	$1.41\times {10}^{11}$
	HHO	$1.35\times {10}^4$	$1.56\times {10}^3$	$1.20\times {10}^4$	$1.20\times {10}^9$	$9.84\times {10}^8$	$2.19\times {10}^8$	$3.42\times {10}^{10}$	$5.26\times {10}^9$	$2.89\times {10}^{10}$	$2.18\times {10}^{11}$	$1.56\times {10}^{10}$	$2.02\times {10}^{11}$
	GA	$1.11\times {10}^5$	$1.65\times {10}^4$	$9.41\times {10}^4$	$2.87\times {10}^7$	$1.62\times {10}^7$	$1.26\times {10}^7$	$\mathbf{4}.\mathbf{68}\times {\mathbf{10}}^{\mathbf{7}}$	$1.99\times {10}^7$	$2.69\times {10}^7$	$\mathbf{1}.\mathbf{75}\times {\mathbf{10}}^{\mathbf{8}}$	$8.96\times {10}^6$	$1.66\times {10}^8$
	ISGA	$1.00\times {10}^5$	$1.50\times {10}^4$	$8.50\times {10}^4$	$2.60\times {10}^7$	$1.50\times {10}^7$	$1.10\times {10}^7$	$4.30\times {10}^7$	$1.80\times {10}^7$	$2.50\times {10}^7$	$1.60\times {10}^8$	$8.20\times {10}^6$	$1.50\times {10}^8$
	RLWOA	$1.50\times {10}^4$	$5.00\times {10}^3$	$1.30\times {10}^4$	$7.00\times {10}^6$	$5.50\times {10}^6$	$4.20\times {10}^6$	$4.80\times {10}^7$	$1.40\times {10}^7$	$4.50\times {10}^7$	$4.50\times {10}^8$	$2.00\times {10}^8$	$2.50\times {10}^8$
	Rand-MHA	$\mathbf{1}.\mathbf{16}\times {\mathbf{10}}^{\mathbf{4}}$	$4.56\times {10}^3$	$1.16\times {10}^4$	$\mathbf{5}.\mathbf{82}\times {\mathbf{10}}^{\mathbf{6}}$	$5.21\times {10}^6$	$3.89\times {10}^6$	$4.70\times {10}^7$	$1.35\times {10}^7$	$4.41\times {10}^7$	$4.38\times {10}^8$	$1.93\times {10}^8$	$2.45\times {10}^8$
	LTR-MHA	$2.31\times {10}^4$	$2.88\times {10}^4$	$1.43\times {10}^4$	$1.70\times {10}^7$	$4.21\times {10}^6$	$1.28\times {10}^7$	$4.83\times {10}^8$	$1.81\times {10}^8$	$3.02\times {10}^8$	$9.53\times {10}^9$	$1.26\times {10}^9$	$8.27\times {10}^9$
F18	WOA	$1.71\times {10}^4$	$3.30\times {10}^3$	$1.37\times {10}^4$	$5.25\times {10}^7$	$4.56\times {10}^7$	$6.90\times {10}^6$	$5.61\times {10}^7$	$2.97\times {10}^7$	$2.64\times {10}^7$	$8.41\times {10}^7$	$4.62\times {10}^7$	$3.79\times {10}^7$
	HHO	$1.64\times {10}^4$	$1.04\times {10}^4$	$2.01\times {10}^3$	$3.56\times {10}^7$	$3.05\times {10}^7$	$5.14\times {10}^6$	$5.89\times {10}^7$	$2.50\times {10}^7$	$3.39\times {10}^7$	$7.96\times {10}^7$	$3.39\times {10}^6$	$7.62\times {10}^7$
	GA	$1.70\times {10}^5$	$1.33\times {10}^5$	$3.70\times {10}^4$	$4.16\times {10}^6$	$3.04\times {10}^6$	$1.13\times {10}^6$	$1.19\times {10}^7$	$2.45\times {10}^6$	$9.43\times {10}^6$	$2.90\times {10}^7$	$1.01\times {10}^7$	$1.90\times {10}^7$
	ISGA	$1.60\times {10}^5$	$1.25\times {10}^5$	$3.50\times {10}^4$	$3.90\times {10}^6$	$2.90\times {10}^6$	$1.00\times {10}^6$	$1.10\times {10}^7$	$2.30\times {10}^6$	$9.00\times {10}^6$	$2.70\times {10}^7$	$9.50\times {10}^6$	$1.80\times {10}^7$
	RLWOA	$1.50\times {10}^4$	$2.50\times {10}^4$	$1.45\times {10}^4$	$1.20\times {10}^6$	$3.60\times {10}^5$	$8.00\times {10}^5$	$8.60\times {10}^6$	$4.60\times {10}^6$	$8.40\times {10}^6$	$1.50\times {10}^7$	$7.00\times {10}^6$	$1.35\times {10}^7$
	Rand-MHA	$1.68\times {10}^4$	$1.35\times {10}^5$	$9.07\times {10}^3$	$9.00\times {10}^6$	$3.22\times {10}^6$	$6.46\times {10}^6$	$8.75\times {10}^6$	$4.35\times {10}^6$	$8.62\times {10}^6$	$1.57\times {10}^7$	$7.42\times {10}^6$	$8.29\times {10}^6$
	LTR-MHA	$\mathbf{1}.\mathbf{55}\times {\mathbf{10}}^{\mathbf{4}}$	$2.34\times {10}^4$	$1.42\times {10}^4$	$\mathbf{1}.\mathbf{11}\times {\mathbf{10}}^{\mathbf{6}}$	$3.39\times {10}^5$	$7.69\times {10}^5$	$\mathbf{8}.\mathbf{40}\times {\mathbf{10}}^{\mathbf{6}}$	$4.50\times {10}^6$	$8.35\times {10}^6$	$\mathbf{1}.\mathbf{48}\times {\mathbf{10}}^{\mathbf{7}}$	$6.86\times {10}^6$	$1.30\times {10}^7$
F19	WOA	$3.28\times {10}^4$	$2.07\times {10}^3$	$3.07\times {10}^4$	$2.12\times {10}^9$	$2.04\times {10}^9$	$8.36\times {10}^7$	$1.68\times {10}^{10}$	$7.12\times {10}^9$	$9.66\times {10}^9$	$1.09\times {10}^{11}$	$2.22\times {10}^{10}$	$8.68\times {10}^{10}$
	HHO	$1.54\times {10}^5$	$4.87\times {10}^4$	$1.06\times {10}^5$	$1.09\times {10}^{10}$	$3.90\times {10}^9$	$7.02\times {10}^9$	$2.09\times {10}^{10}$	$2.27\times {10}^9$	$1.86\times {10}^{10}$	$2.21\times {10}^{11}$	$2.89\times {10}^{10}$	$1.92\times {10}^{11}$
	GA	$5.54\times {10}^5$	$5.30\times {10}^5$	$2.45\times {10}^4$	$1.08\times {10}^7$	$2.89\times {10}^5$	$1.05\times {10}^7$	$1.14\times {10}^7$	$6.22\times {10}^5$	$1.07\times {10}^7$	$2.65\times {10}^8$	$1.51\times {10}^8$	$1.15\times {10}^8$
	ISGA	$5.20\times {10}^5$	$5.00\times {10}^5$	$2.30\times {10}^4$	$1.00\times {10}^7$	$2.70\times {10}^5$	$9.80\times {10}^6$	$1.10\times {10}^7$	$6.00\times {10}^5$	$1.05\times {10}^7$	$2.50\times {10}^8$	$1.45\times {10}^8$	$1.10\times {10}^8$
	RLWOA	$3.50\times {10}^4$	$4.30\times {10}^3$	$3.30\times {10}^4$	$5.00\times {10}^7$	$3.50\times {10}^7$	$1.35\times {10}^7$	$1.15\times {10}^7$	$8.80\times {10}^7$	$1.10\times {10}^7$	$2.35\times {10}^8$	$2.25\times {10}^8$	$2.25\times {10}^8$
	Rand-MHA	$\mathbf{2}.\mathbf{58}\times {\mathbf{10}}^{\mathbf{4}}$	$4.35\times {10}^4$	$1.90\times {10}^4$	$\mathbf{1}.\mathbf{63}\times {\mathbf{10}}^{\mathbf{6}}$	$3.22\times {10}^5$	$4.14\times {10}^5$	$2.77\times {10}^7$	$6.46\times {10}^4$	$4.90\times {10}^6$	$3.88\times {10}^8$	$1.27\times {10}^8$	$2.61\times {10}^8$
	LTR-MHA	$3.76\times {10}^4$	$4.11\times {10}^3$	$3.35\times {10}^4$	$4.56\times {10}^7$	$3.27\times {10}^7$	$1.29\times {10}^7$	$\mathbf{1}.\mathbf{12}\times {\mathbf{10}}^{\mathbf{7}}$	$8.69\times {10}^7$	$1.05\times {10}^7$	$\mathbf{2}.\mathbf{31}\times {\mathbf{10}}^{\mathbf{8}}$	$2.19\times {10}^8$	$2.19\times {10}^8$

and

Table 7. Comparison of composition functions.

Funcs	Algorithm	Dim = 10			Dim = 30			Dim = 50			Dim = 100
		Mean	Std	Best	Mean	Std	Best	Mean	Std	Best	Mean	Std	Best
F22	WOA	$2.77\times {10}^3$	$3.56\times {10}^2$	$2.41\times {10}^3$	$9.53\times {10}^3$	$5.17\times {10}^2$	$9.01\times {10}^3$	$1.57\times {10}^4$	$2.77\times {10}^2$	$1.54\times {10}^4$	$3.48\times {10}^4$	$2.12\times {10}^2$	$3.46\times {10}^4$
	HHO	$2.83\times {10}^3$	$3.21\times {10}^2$	$2.51\times {10}^3$	$9.41\times {10}^3$	$2.20\times {10}^2$	$9.19\times {10}^3$	$1.62\times {10}^4$	$5.20\times {10}^2$	$1.57\times {10}^4$	$3.44\times {10}^4$	$3.04\times {10}^2$	$3.41\times {10}^4$
	GA	$2.31\times {10}^3$	$9.78\times {10}^{-2}$	$2.31\times {10}^3$	$6.33\times {10}^3$	$2.17\times {10}^2$	$6.12\times {10}^3$	$1.16\times {10}^4$	$1.60\times {10}^2$	$1.15\times {10}^4$	$2.80\times {10}^4$	$3.77\times {10}^2$	$2.76\times {10}^4$
	ISGA	$2.31\times {10}^3$	$9.50\times {10}^{-2}$	$2.31\times {10}^3$	$6.20\times {10}^3$	$2.10\times {10}^2$	$6.00\times {10}^3$	$1.14\times {10}^4$	$1.55\times {10}^2$	$1.13\times {10}^4$	$2.75\times {10}^4$	$3.70\times {10}^2$	$2.71\times {10}^4$
	RLWOA	$2.30\times {10}^3$	$8.00\times {10}^{-1}$	$2.25\times {10}^3$	$5.90\times {10}^3$	$3.00\times {10}^3$	$2.90\times {10}^3$	$1.13\times {10}^4$	$4.80\times {10}^2$	$1.08\times {10}^4$	$2.40\times {10}^4$	$1.55\times {10}^2$	$2.30\times {10}^4$
	Rand-MHA	$2.31\times {10}^3$	$8.57\times {10}^{-1}$	$2.31\times {10}^3$	$7.71\times {10}^3$	$3.17\times {10}^2$	$7.53\times {10}^3$	$1.22\times {10}^4$	$1.38\times {10}^3$	$1.16\times {10}^4$	$2.98\times {10}^4$	$4.47\times {10}^2$	$2.94\times {10}^4$
	LTR-MHA	$\mathbf{2}.\mathbf{30}\times {\mathbf{10}}^{\mathbf{3}}$	$7.73\times {10}^{-1}$	$2.22\times {10}^3$	$\mathbf{5}.\mathbf{84}\times {\mathbf{10}}^{\mathbf{3}}$	$3.18\times {10}^3$	$2.66\times {10}^3$	$\mathbf{1}.\mathbf{12}\times {\mathbf{10}}^{\mathbf{4}}$	$4.85\times {10}^2$	$1.07\times {10}^4$	$\mathbf{2}.\mathbf{38}\times {\mathbf{10}}^{\mathbf{4}}$	$1.50\times {10}^2$	$2.27\times {10}^4$
F23	WOA	$2.68\times {10}^3$	$2.53\times {10}^1$	$2.65\times {10}^3$	$3.30\times {10}^3$	$3.88\times {10}^1$	$3.26\times {10}^3$	$4.33\times {10}^3$	$7.59\times {10}^1$	$4.26\times {10}^3$	$6.11\times {10}^3$	$1.43\times {10}^2$	$5.97\times {10}^3$
	HHO	$2.70\times {10}^3$	$1.71\times {10}^1$	$2.68\times {10}^3$	$3.41\times {10}^3$	$2.82\times {10}^1$	$3.38\times {10}^3$	$4.34\times {10}^3$	$6.72\times {10}^1$	$4.28\times {10}^3$	$6.38\times {10}^3$	$2.29\times {10}^2$	$6.15\times {10}^3$
	GA	$2.64\times {10}^3$	$9.32\times {10}^{-1}$	$2.63\times {10}^3$	$2.85\times {10}^3$	$5.40\times {10}^1$	$2.80\times {10}^3$	$3.19\times {10}^3$	$1.02\times {10}^1$	$3.18\times {10}^3$	$3.99\times {10}^3$	$8.92\times {10}^1$	$3.90\times {10}^3$
	ISGA	$2.64\times {10}^3$	$9.00\times {10}^{-1}$	$2.63\times {10}^3$	$2.83\times {10}^3$	$5.20\times {10}^1$	$2.78\times {10}^3$	$3.17\times {10}^3$	$9.80\times {10}^0$	$3.16\times {10}^3$	$3.95\times {10}^3$	$8.70\times {10}^1$	$3.86\times {10}^3$
	RLWOA	$2.65\times {10}^3$	$8.50\times {10}^{-1}$	$2.63\times {10}^3$	$2.84\times {10}^3$	$1.60\times {10}^1$	$2.82\times {10}^3$	$3.17\times {10}^3$	$3.10\times {10}^0$	$3.13\times {10}^3$	$3.10\times {10}^3$	$8.50\times {10}^1$	$3.02\times {10}^3$
	Rand-MHA	$2.64\times {10}^3$	$3.23\times {10}^0$	$2.63\times {10}^3$	$2.99\times {10}^3$	$3.50\times {10}^1$	$2.91\times {10}^3$	$3.78\times {10}^3$	$3.33\times {10}^0$	$3.72\times {10}^3$	$4.74\times {10}^3$	$2.44\times {10}^2$	$4.49\times {10}^3$
	LTR-MHA	$\mathbf{2}.\mathbf{63}\times {\mathbf{10}}^{\mathbf{3}}$	$8.16\times {10}^{-1}$	$2.63\times {10}^3$	$\mathbf{2}.\mathbf{83}\times {\mathbf{10}}^{\mathbf{3}}$	$1.57\times {10}^1$	$2.81\times {10}^3$	$\mathbf{3}.\mathbf{16}\times {\mathbf{10}}^{\mathbf{3}}$	$3.03\times {10}^0$	$3.12\times {10}^3$	$\mathbf{3}.\mathbf{09}\times {\mathbf{10}}^{\mathbf{3}}$	$8.38\times {10}^1$	$3.01\times {10}^3$
F24	WOA	$2.78\times {10}^3$	$2.89\times {10}^1$	$2.76\times {10}^3$	$3.86\times {10}^3$	$7.38\times {10}^0$	$3.85\times {10}^3$	$4.52\times {10}^3$	$1.50\times {10}^2$	$4.37\times {10}^3$	$9.50\times {10}^3$	$1.95\times {10}^2$	$9.30\times {10}^3$
	HHO	$2.82\times {10}^3$	$6.89\times {10}^0$	$2.82\times {10}^3$	$3.72\times {10}^3$	$3.71\times {10}^0$	$3.72\times {10}^3$	$4.68\times {10}^3$	$8.61\times {10}^1$	$4.60\times {10}^3$	$9.32\times {10}^3$	$4.34\times {10}^1$	$9.28\times {10}^3$
	GA	$2.78\times {10}^3$	$9.22\times {10}^0$	$2.76\times {10}^3$	$3.17\times {10}^3$	$4.58\times {10}^1$	$3.12\times {10}^3$	$3.66\times {10}^3$	$2.00\times {10}^1$	$3.64\times {10}^3$	$4.88\times {10}^3$	$1.64\times {10}^2$	$4.72\times {10}^3$
	ISGA	$2.78\times {10}^3$	$9.00\times {10}^0$	$2.76\times {10}^3$	$3.15\times {10}^3$	$4.40\times {10}^1$	$3.10\times {10}^3$	$3.64\times {10}^3$	$1.95\times {10}^1$	$3.62\times {10}^3$	$4.85\times {10}^3$	$1.60\times {10}^2$	$4.70\times {10}^3$
	RLWOA	$2.78\times {10}^3$	$4.50\times {10}^0$	$2.76\times {10}^3$	$3.06\times {10}^3$	$2.20\times {10}^0$	$3.06\times {10}^3$	$3.42\times {10}^3$	$1.05\times {10}^1$	$3.41\times {10}^3$	$4.82\times {10}^3$	$5.20\times {10}^1$	$4.77\times {10}^3$
	Rand-MHA	$2.79\times {10}^3$	$6.72\times {10}^0$	$2.78\times {10}^3$	$3.28\times {10}^3$	$4.78\times {10}^1$	$3.16\times {10}^3$	$3.90\times {10}^3$	$1.02\times {10}^2$	$3.80\times {10}^3$	$5.62\times {10}^3$	$4.84\times {10}^1$	$5.57\times {10}^3$
	LTR-MHA	$\mathbf{2}.\mathbf{77}\times {\mathbf{10}}^{\mathbf{3}}$	$4.45\times {10}^0$	$2.76\times {10}^3$	$\mathbf{3}.\mathbf{05}\times {\mathbf{10}}^{\mathbf{3}}$	$2.13\times {10}^0$	$3.05\times {10}^3$	$\mathbf{3}.\mathbf{41}\times {\mathbf{10}}^{\mathbf{3}}$	$1.00\times {10}^1$	$3.40\times {10}^3$	$\mathbf{4}.\mathbf{80}\times {\mathbf{10}}^{\mathbf{3}}$	$5.15\times {10}^1$	$4.75\times {10}^3$
F25	WOA	$3.18\times {10}^3$	$1.17\times {10}^2$	$3.06\times {10}^3$	$4.39\times {10}^3$	$3.85\times {10}^2$	$4.00\times {10}^3$	$1.02\times {10}^4$	$4.63\times {10}^2$	$9.73\times {10}^3$	$2.29\times {10}^4$	$1.96\times {10}^3$	$2.09\times {10}^4$
	HHO	$3.34\times {10}^3$	$1.05\times {10}^2$	$3.24\times {10}^3$	$4.37\times {10}^3$	$4.35\times {10}^1$	$4.33\times {10}^3$	$1.50\times {10}^4$	$1.01\times {10}^3$	$1.40\times {10}^4$	$2.83\times {10}^4$	$7.32\times {10}^2$	$2.75\times {10}^4$
	GA	$2.95\times {10}^3$	$2.84\times {10}^0$	$2.95\times {10}^3$	$3.05\times {10}^3$	$6.30\times {10}^0$	$3.00\times {10}^3$	$\mathbf{3}.\mathbf{31}\times {\mathbf{10}}^{\mathbf{3}}$	$1.11\times {10}^2$	$3.20\times {10}^3$	$\mathbf{5}.\mathbf{63}\times {\mathbf{10}}^{\mathbf{3}}$	$6.81\times {10}^1$	$5.56\times {10}^3$
	ISGA	$2.95\times {10}^3$	$2.80\times {10}^0$	$2.95\times {10}^3$	$3.04\times {10}^3$	$6.10\times {10}^0$	$2.99\times {10}^3$	$3.30\times {10}^3$	$1.10\times {10}^2$	$3.19\times {10}^3$	$5.60\times {10}^3$	$6.70\times {10}^1$	$5.53\times {10}^3$
	RLWOA	$2.94\times {10}^3$	$2.40\times {10}^1$	$2.92\times {10}^3$	$3.03\times {10}^3$	$1.65\times {10}^1$	$2.30\times {10}^3$	$4.75\times {10}^3$	$2.85\times {10}^2$	$4.46\times {10}^3$	$1.69\times {10}^4$	$4.82\times {10}^2$	$1.65\times {10}^4$
	Rand-MHA	$2.99\times {10}^3$	$2.56\times {10}^1$	$2.90\times {10}^3$	$3.04\times {10}^3$	$6.67\times {10}^0$	$2.99\times {10}^3$	$3.59\times {10}^3$	$2.96\times {10}^1$	$3.56\times {10}^3$	$7.29\times {10}^3$	$1.13\times {10}^2$	$7.18\times {10}^3$
	LTR-MHA	$\mathbf{2}.\mathbf{93}\times {\mathbf{10}}^{\mathbf{3}}$	$2.36\times {10}^1$	$2.91\times {10}^3$	$\mathbf{3}.\mathbf{02}\times {\mathbf{10}}^{\mathbf{3}}$	$1.61\times {10}^1$	$2.27\times {10}^3$	$4.73\times {10}^3$	$2.82\times {10}^2$	$4.44\times {10}^3$	$1.68\times {10}^4$	$4.78\times {10}^2$	$1.64\times {10}^4$
F26	WOA	$4.31\times {10}^3$	$3.77\times {10}^2$	$3.93\times {10}^3$	$9.64\times {10}^3$	$9.57\times {10}^2$	$8.68\times {10}^3$	$1.79\times {10}^4$	$5.33\times {10}^2$	$1.73\times {10}^4$	$5.09\times {10}^4$	$2.74\times {10}^3$	$4.81\times {10}^4$
	HHO	$4.28\times {10}^3$	$2.64\times {10}^2$	$4.01\times {10}^3$	$1.05\times {10}^4$	$4.48\times {10}^2$	$1.00\times {10}^4$	$1.56\times {10}^4$	$6.68\times {10}^2$	$1.49\times {10}^4$	$5.08\times {10}^4$	$9.32\times {10}^2$	$4.98\times {10}^4$
	GA	$3.65\times {10}^3$	$7.02\times {10}^2$	$2.94\times {10}^3$	$6.51\times {10}^3$	$1.47\times {10}^2$	$6.36\times {10}^3$	$9.06\times {10}^3$	$5.51\times {10}^2$	$8.51\times {10}^3$	$2.14\times {10}^4$	$1.34\times {10}^3$	$2.00\times {10}^4$
	ISGA	$3.60\times {10}^3$	$6.90\times {10}^2$	$2.90\times {10}^3$	$6.40\times {10}^3$	$1.45\times {10}^2$	$6.25\times {10}^3$	$8.95\times {10}^3$	$5.40\times {10}^2$	$8.40\times {10}^3$	$2.17\times {10}^4$	$1.30\times {10}^3$	$1.97\times {10}^4$
	RLWOA	$2.97\times {10}^3$	$3.10\times {10}^1$	$2.94\times {10}^3$	$5.02\times {10}^3$	$1.08\times {10}^3$	$4.00\times {10}^3$	$9.05\times {10}^3$	$3.15\times {10}^2$	$8.94\times {10}^3$	$2.13\times {10}^4$	$5.45\times {10}^1$	$2.07\times {10}^4$
	Rand-MHA	$\mathbf{2}.\mathbf{95}\times {\mathbf{10}}^{\mathbf{3}}$	$3.23\times {10}^1$	$2.82\times {10}^3$	$5.96\times {10}^3$	$1.46\times {10}^3$	$3.75\times {10}^3$	$1.18\times {10}^4$	$1.46\times {10}^2$	$1.16\times {10}^4$	$3.01\times {10}^4$	$5.49\times {10}^2$	$2.95\times {10}^4$
	LTR-MHA	$2.96\times {10}^3$	$3.09\times {10}^1$	$2.93\times {10}^3$	$\mathbf{5}.\mathbf{00}\times {\mathbf{10}}^{\mathbf{3}}$	$1.06\times {10}^3$	$3.94\times {10}^3$	$\mathbf{9}.\mathbf{03}\times {\mathbf{10}}^{\mathbf{3}}$	$3.13\times {10}^2$	$8.92\times {10}^3$	$\mathbf{2}.\mathbf{12}\times {\mathbf{10}}^{\mathbf{4}}$	$5.39\times {10}^1$	$2.06\times {10}^4$
F27	WOA	$3.21\times {10}^3$	$2.73\times {10}^1$	$3.18\times {10}^3$	$3.84\times {10}^3$	$4.25\times {10}^1$	$3.80\times {10}^3$	$5.72\times {10}^3$	$5.77\times {10}^2$	$5.14\times {10}^3$	$1.07\times {10}^4$	$7.04\times {10}^2$	$1.00\times {10}^4$
	HHO	$3.21\times {10}^3$	$2.21\times {10}^1$	$3.19\times {10}^3$	$5.08\times {10}^3$	$2.34\times {10}^2$	$4.84\times {10}^3$	$7.23\times {10}^3$	$7.77\times {10}^2$	$6.45\times {10}^3$	$1.26\times {10}^4$	$5.55\times {10}^2$	$1.21\times {10}^4$
	GA	$3.40\times {10}^3$	$2.40\times {10}^0$	$3.10\times {10}^3$	$\mathbf{3}.\mathbf{26}\times {\mathbf{10}}^{\mathbf{3}}$	$1.85\times {10}^1$	$3.24\times {10}^3$	$3.52\times {10}^3$	$3.64\times {10}^0$	$3.52\times {10}^3$	$4.12\times {10}^3$	$1.37\times {10}^1$	$4.11\times {10}^3$
	ISGA	$3.38\times {10}^3$	$2.35\times {10}^0$	$3.09\times {10}^3$	$3.35\times {10}^3$	$1.80\times {10}^1$	$3.23\times {10}^3$	$3.51\times {10}^3$	$3.60\times {10}^0$	$3.51\times {10}^3$	$4.12\times {10}^3$	$1.35\times {10}^1$	$4.09\times {10}^3$
	RLWOA	$3.13\times {10}^3$	$2.60\times {10}^1$	$3.11\times {10}^3$	$3.28\times {10}^3$	$1.35\times {10}^1$	$3.26\times {10}^3$	$3.46\times {10}^3$	$3.80\times {10}^1$	$3.32\times {10}^3$	$4.11\times {10}^3$	$4.55\times {10}^0$	$4.05\times {10}^3$
	Rand-MHA	$3.15\times {10}^3$	$3.77\times {10}^1$	$3.10\times {10}^3$	$3.31\times {10}^3$	$1.65\times {10}^1$	$3.29\times {10}^3$	$3.73\times {10}^3$	$1.23\times {10}^2$	$3.61\times {10}^3$	$5.21\times {10}^3$	$7.67\times {10}^1$	$5.14\times {10}^3$
	LTR-MHA	$\mathbf{3}.\mathbf{12}\times {\mathbf{10}}^{\mathbf{3}}$	$2.57\times {10}^1$	$3.10\times {10}^3$	$3.27\times {10}^3$	$1.31\times {10}^1$	$3.25\times {10}^3$	$\mathbf{3}.\mathbf{45}\times {\mathbf{10}}^{\mathbf{3}}$	$3.73\times {10}^1$	$3.31\times {10}^3$	$\mathbf{4}.\mathbf{10}\times {\mathbf{10}}^{\mathbf{3}}$	$4.49\times {10}^0$	$4.04\times {10}^3$
F28	WOA	$3.75\times {10}^3$	$1.31\times {10}^2$	$3.62\times {10}^3$	$6.89\times {10}^3$	$1.22\times {10}^3$	$5.67\times {10}^3$	$9.97\times {10}^3$	$1.09\times {10}^3$	$8.88\times {10}^3$	$2.77\times {10}^4$	$1.26\times {10}^3$	$2.64\times {10}^4$
	HHO	$3.80\times {10}^3$	$6.62\times {10}^1$	$3.74\times {10}^3$	$7.04\times {10}^3$	$4.09\times {10}^2$	$6.63\times {10}^3$	$1.26\times {10}^4$	$8.81\times {10}^2$	$1.17\times {10}^4$	$2.99\times {10}^4$	$6.29\times {10}^1$	$2.98\times {10}^4$
	GA	$3.42\times {10}^3$	$7.10\times {10}^0$	$3.41\times {10}^3$	$3.26\times {10}^3$	$2.10\times {10}^1$	$3.15\times {10}^3$	$4.14\times {10}^3$	$1.86\times {10}^2$	$3.96\times {10}^3$	$7.01\times {10}^3$	$6.04\times {10}^2$	$6.40\times {10}^3$
	ISGA	$3.48\times {10}^3$	$7.60\times {10}^{-1}$	$3.38\times {10}^3$	$3.30\times {10}^3$	$1.45\times {10}^1$	$3.28\times {10}^3$	$4.63\times {10}^3$	$7.70\times {10}^1$	$3.55\times {10}^3$	$7.18\times {10}^3$	$6.00\times {10}^2$	$6.78\times {10}^3$
	RLWOA	$\mathbf{3}.\mathbf{38}\times {\mathbf{10}}^{\mathbf{3}}$	$7.65\times {10}^{-1}$	$3.38\times {10}^3$	$3.32\times {10}^3$	$1.48\times {10}^1$	$3.30\times {10}^3$	$\mathbf{3}.\mathbf{65}\times {\mathbf{10}}^{\mathbf{3}}$	$7.76\times {10}^1$	$3.57\times {10}^3$	$6.69\times {10}^3$	$6.15\times {10}^2$	$6.13\times {10}^3$
	Rand-MHA	$3.57\times {10}^3$	$7.46\times {10}^0$	$3.41\times {10}^3$	$3.39\times {10}^3$	$1.65\times {10}^1$	$3.35\times {10}^3$	$4.19\times {10}^3$	$1.00\times {10}^2$	$4.09\times {10}^3$	$9.41\times {10}^3$	$3.02\times {10}^2$	$9.11\times {10}^3$
	LTR-MHA	$3.41\times {10}^3$	$7.00\times {10}^0$	$3.40\times {10}^3$	$\mathbf{3}.\mathbf{25}\times {\mathbf{10}}^{\mathbf{3}}$	$2.08\times {10}^1$	$3.13\times {10}^3$	$4.13\times {10}^3$	$1.84\times {10}^2$	$3.95\times {10}^3$	$\mathbf{6}.\mathbf{67}\times {\mathbf{10}}^{\mathbf{3}}$	$6.10\times {10}^2$	$6.11\times {10}^3$
F30	WOA	$1.79\times {10}^7$	$3.67\times {10}^6$	$1.42\times {10}^7$	$1.38\times {10}^9$	$9.29\times {10}^8$	$4.49\times {10}^8$	$6.04\times {10}^9$	$1.00\times {10}^9$	$5.03\times {10}^9$	$2.07\times {10}^{11}$	$1.95\times {10}^{10}$	$1.87\times {10}^{11}$
	HHO	$2.33\times {10}^7$	$7.62\times {10}^6$	$1.57\times {10}^7$	$1.56\times {10}^9$	$1.29\times {10}^9$	$2.69\times {10}^8$	$8.27\times {10}^{10}$	$8.10\times {10}^9$	$7.46\times {10}^{10}$	$2.85\times {10}^{11}$	$2.39\times {10}^{10}$	$2.61\times {10}^{11}$
	GA	$1.35\times {10}^6$	$9.71\times {10}^5$	$3.81\times {10}^5$	$1.56\times {10}^7$	$5.67\times {10}^6$	$9.94\times {10}^6$	$1.18\times {10}^9$	$1.02\times {10}^7$	$1.17\times {10}^9$	$1.09\times {10}^{10}$	$7.22\times {10}^8$	$1.02\times {10}^{10}$
	ISGA	$1.30\times {10}^6$	$9.40\times {10}^5$	$3.60\times {10}^5$	$1.87\times {10}^7$	$1.98\times {10}^6$	$4.00\times {10}^6$	$1.48\times {10}^9$	$1.68\times {10}^6$	$2.85\times {10}^8$	$3.68\times {10}^{10}$	$4.90\times {10}^7$	$2.51\times {10}^8$
	RLWOA	$1.00\times {10}^6$	$3.00\times {10}^5$	$7.00\times {10}^5$	$1.58\times {10}^7$	$5.70\times {10}^6$	$1.00\times {10}^7$	$1.19\times {10}^9$	$1.03\times {10}^7$	$1.18\times {10}^9$	$1.10\times {10}^{10}$	$7.25\times {10}^8$	$1.03\times {10}^{10}$
	Rand-MHA	$1.88\times {10}^6$	$8.98\times {10}^5$	$1.02\times {10}^6$	$8.35\times {10}^6$	$5.77\times {10}^6$	$7.71\times {10}^6$	$1.84\times {10}^8$	$5.15\times {10}^7$	$1.33\times {10}^8$	$1.12\times {10}^9$	$3.94\times {10}^8$	$7.23\times {10}^8$
	LTR-MHA	$\mathbf{9}.\mathbf{66}\times {\mathbf{10}}^{\mathbf{5}}$	$2.98\times {10}^5$	$6.68\times {10}^5$	$\mathbf{6}.\mathbf{22}\times {\mathbf{10}}^{\mathbf{6}}$	$2.04\times {10}^6$	$4.18\times {10}^6$	$\mathbf{3}.\mathbf{14}\times {\mathbf{10}}^{\mathbf{7}}$	$1.73\times {10}^6$	$2.97\times {10}^7$	$\mathbf{3}.\mathbf{13}\times {\mathbf{10}}^{\mathbf{8}}$	$5.03\times {10}^7$	$2.62\times {10}^8$

present a comparison of the results between the LTR-MHA and the baseline algorithms, focusing on the mean, standard deviation, and best solution values. The best average value is highlighted in bold. The statistics demonstrate that our proposed method significantly outperforms the others in solving various test functions across different dimensions.

Specifically, in solving unimodal and simple multimodal functions (as shown in Table 5), the LTR-MHA consistently achieves the lowest average values across most functions, demonstrating a remarkable advantage. Additionally, the LTR-MHA maintains the lowest or second-lowest standard deviation in nearly all functions and dimensions, indicating a more stable convergence process. In certain cases, such as functions F3, F7, and F9, the GA occasionally attains the lowest average value, suggesting that traditional heuristic algorithms still remain competitive when dealing with relatively simple problem structures. Furthermore, the RLWOA occasionally obtains the best average value among all compared methods, highlighting the effectiveness of parameter adaptation based on reinforcement learning. Overall, the RLWOA ranks directly after the LTR-MHA and Rand-MHA in solution precision. Moreover, although the Rand-MHA performs reasonably well in terms of solution accuracy, its generally higher standard deviations reveal a lack of stability in the algorithm’s performance.

Table 6 shows that the performance gap between algorithms increases when evaluated on hybrid functions. The LTR-MHA achieves the lowest average values on F14 and F18 and secures the best solutions across nearly all dimensions while also maintaining the lowest standard deviations. This demonstrates its ability to obtain high-precision solutions and maintain excellent convergence consistency in high-dimensional search spaces. The GA and Rand-MHA, on the other hand, approach the LTR-MHA’s performance on certain functions. In particular, the Rand-MHA and the GA outperform the LTR-MHA in terms of average performance on F13 and F15. This indicates that the LTR-MHA’s learning model still has room for improvement in terms of stability and accuracy when handling certain complex hybrid structures. By contrast, the performance of the WOA and HHO degrades significantly in high-dimensional environments, with their convergence curves exhibiting considerable fluctuations. The ISGA and RLWOA exhibit comparable results to the baseline methods but do not surpass the LTR-MHA on the tested hybrid functions, indicating limitations when addressing complex hybrid functions.

When tackling the composition functions in the CEC2017 benchmark (Table 7), the LTR-MHA demonstrates a significant advantage across most functions: it consistently achieves the lowest average values (e.g., F22, F23, F24, and F30), as well as the best solutions, while maintaining relatively low standard deviations. The GA performs notably well on certain high-dimensional problems (e.g., F25). The RLWOA obtains the best average value on F28, ranking after the LTR-MHA in overall composition function performance. Although the Rand-MHA approaches the performance of the LTR-MHA in some lower-dimensional scenarios, its results exhibit considerable fluctuations in high-dimensional settings. Overall, the WOA and HHO show relatively poor performance, indicating limited adaptability to complex problems. In summary, the LTR-MHA delivers the best overall performance in composition function optimization, particularly excelling in high-dimensional problems by balancing both accuracy and robustness, while traditional algorithms remain competitive only in specific, simpler cases.

To balance problem complexity with an effective evaluation of algorithmic performance, the convergence speed and runtime analyses are conducted using the 30-dimensional test functions. On one hand, 10-dimensional problems are relatively simple and may not adequately demonstrate the advantages of the algorithm in complex search spaces. On the other hand, 100-dimensional problems can be overly complex, potentially leading to inefficient searches and making algorithm performance highly susceptible to random factors. The 30-dimensional setting, which is widely adopted in current academic research, strikes an appropriate balance between computational cost and evaluation depth, thereby providing a reliable basis for validating the algorithm’s performance [37,38].

Figure 3 shows the average fitness convergence curves of five algorithms on nine typical functions (F3, F6, F9, F12, F14, F19, F22, F24, and F30) from the CEC2017 benchmark, with a dimensional setting of $D=30$. Overall, the proposed LTR-MHA demonstrates the best final fitness values on most test functions, with its advantages being particularly evident on multimodal and composition functions (e.g., F6, F22, and F24), approaching the optimal region within just 100 iterations, whereas the other algorithms generally converge more slowly and are more prone to local optima. Although the Rand-MHA, with its random update strategy, surpasses traditional metaheuristic algorithms on certain functions (e.g., F3, F9, F14, and F24), its overall performance still lags behind the LTR-MHA and exhibits greater variability. Among the three conventional algorithms, the GA performs the best. The ISGA yields convergence behavior similar to the GA across most functions. The RLWOA converges rapidly on a majority of the tested functions, achieving final fitness values that are comparable to or only marginally lower than those of the LTR-MHA. HHO, despite occasionally achieving a rapid decline in the early iterations, suffers from premature convergence and stagnates in the later stages, resulting in noticeably poorer final solutions. These findings demonstrate that the multi-strategy fusion update mechanism learned by the LTR-MHA enables stable and efficient optimization across various types of complex search spaces.

Table 8. Average runtime comparison of LTR-MHA and baseline algorithms (in seconds).

Funcs	WOA	HHO	GA	ISGA	RLWOA	Rand-MHA	LTR-MHA
F1	0.4819	1.4700	0.7766	4.8352	57.3926	3.5126	70.4798
F3	0.4377	1.4866	0.7803	4.9267	58.1473	3.5139	58.2547
F4	0.4392	1.4842	0.7704	4.8159	57.9638	3.4413	57.8522
F5	0.4321	1.5854	0.8290	5.2847	58.7264	3.4510	64.2786
F6	0.4910	1.7595	0.7793	4.9261	56.8355	5.3804	56.2355
F7	0.4663	2.0480	0.8303	5.1738	57.4909	3.5970	55.0909
F8	0.4799	1.7791	0.7745	4.8632	58.6083	4.3683	61.1083
F9	0.4447	1.7802	0.7644	4.7953	57.2079	3.4204	58.7079
F10	0.9688	3.0292	0.8834	5.4267	58.4041	4.3267	63.9041
F11	0.4923	2.6668	0.8092	5.1252	57.1205	3.8252	54.6205
F12	0.5161	2.7848	0.8552	5.3034	57.4699	3.9034	54.9699
F13	0.5058	2.9435	0.8101	5.2558	57.4127	3.9558	54.9127
F14	0.5039	2.8387	0.8249	5.2831	59.4465	4.0831	64.9465
F15	0.4861	2.6731	0.7965	5.1307	57.1656	3.8307	54.6656
F18	0.5051	3.0541	0.8101	5.1766	57.9965	3.8766	56.4965
F19	0.5852	3.6280	0.9318	5.5323	58.0511	4.1323	55.5511
F21	0.5713	3.8656	0.8651	5.6503	56.2671	4.2503	53.7671
F22	0.6556	4.6999	0.9891	5.9955	57.9133	4.5955	54.4133
F23	0.6968	5.0680	1.0333	6.2073	56.4508	4.8073	53.9508
F24	0.6312	4.7852	0.9419	6.0494	56.4387	4.5494	53.9387
F25	0.6443	4.8955	0.9769	6.0807	55.7819	4.6807	53.2819
F26	0.7358	5.8243	1.0733	6.5357	57.1906	5.1357	54.6906
F27	0.8057	6.3997	1.1641	6.7742	58.4299	5.3742	55.9299
F28	0.7657	5.9329	1.3762	6.5956	55.0276	5.1956	53.5276
F30	0.8444	8.8503	1.1513	7.0268	57.3208	6.5268	54.8208

presents the average runtime of the five algorithms on the CEC2017 test functions. The results indicate that the WOA consistently exhibits the lowest computational overhead across all test functions, with an average runtime ranging from 0.4 to 0.96 s. The GA follows closely, requiring approximately 0.7 to 1.5 s. Due to its more complex internal search strategies, HHO incurs a longer runtime of 1.4 to 8.9 s. The Rand-MHA, which involves randomly selecting and executing multiple update operations in each iteration, experiences a further increase in average runtime. The ISGA takes about 4 to 7 s per run, which reflects its additional clustering and adaptive migration techniques. The RLWOA holds the highest overhead among compared methods, with runtimes ranging from 56 to 60 s due to its online reinforcement learning-based parameter adjustment. The LTR-MHA, requiring feature generation and online prediction via the model at each iteration, introduces additional computational complexity, resulting in the longest runtime among the compared algorithms. This difference arises from the algorithmic design of the LTR-MHA. In each iteration, for every individual in the population, the LTR-MHA constructs $m=12$ candidate update strategies. Each candidate is represented by a feature vector composed of 10 components (as shown in Equation (19)). These m feature vectors are then passed into the trained predictive model to compute scores and select the most promising strategy. As a result, the per-iteration time complexity of the LTR-MHA is approximately $O(n·m·(k+T_{pred}))$, where n is the population size, $k=10$ is the feature dimension, $T_{pred}$ is the model’s prediction time, and D is the problem dimension. This is significantly higher than other metaheuristics that apply a single, fixed rule per individual per iteration. In conclusion, while the LTR-MHA clearly outperforms in convergence speed and solution precision, its increased computational cost requires a trade-off with time efficiency in practical applications.

Notably, the development time of automated methods and manually designed approaches is generally difficult to compare directly, as such information is typically not disclosed in published studies. Furthermore, although the proposed algorithm incurs additional computational time in both the training and testing steps, the primary goal of this research is not to discover the optimal approach but rather to explore an approach capable of automatically generating highly generalizable and state-of-the-art search strategies. In the long term, this additional computational overhead is justified by the ability to efficiently solve a broad range of problem instances.

The Wilcoxon rank-sum test was used at a significance level of 0.05 to determine whether the LTR-MHA’s optimization results outperformed the compared algorithms significantly.

Table 9. Results of Wilcoxon rank-sum test.

Funcs	WOA	HHO	GA	ISGA	RLWOA	Rand-MHA
F1	3.35 $\times {10}^{-11}$ +	3.34 $\times {10}^{-11}$ +	3.34 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	4.12 $\times {10}^{-11}$ +	4.45 $\times {10}^{-11}$ +
F3	2.39 $\times {10}^{-8}$ +	1.58 $\times {10}^{-8}$ +	7.15 $\times {10}^{-5}$ −	2.87 $\times {10}^{-8}$ +	3.22 $\times {10}^{-4}$ −	3.71 $\times {10}^{-4}$ −
F4	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.15 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +
F5	6.13 $\times {10}^{-10}$ +	7.56 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	5.44 $\times {10}^{-10}$ +	1.63 $\times {10}^{-5}$ −	1.95 $\times {10}^{-5}$ −
F6	4.70 $\times {10}^{-8}$ +	2.23 $\times {10}^{-6}$ +	3.02 $\times {10}^{-11}$ +	3.85 $\times {10}^{-4}$ +	1.42 $\times {10}^{-5}$ +	1.64 $\times {10}^{-10}$ +
F7	1.17 $\times {10}^{-9}$ +	6.12 $\times {10}^{-10}$ +	3.02 $\times {10}^{-5}$ −	9.28 $\times {10}^{-10}$ +	2.45 $\times {10}^{-4}$ −	2.88 $\times {10}^{-}3$ −
F8	2.46 $\times {10}^{-10}$ +	5.15 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	2.11 $\times {10}^{-10}$ +	1.87 $\times {10}^{-8}$ +	2.00 $\times {10}^{-9}$ +
F9	1.36 $\times {10}^{-10}$ +	3.34 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	1.18 $\times {10}^{-10}$ +	7.92 $\times {10}^{-7}$ =	8.65 $\times {10}^{-6}$ =
F10	1.96 $\times {10}^{-5}$ =	4.32 $\times {10}^{-10}$ +	3.02 $\times {10}^{-11}$ +	1.05 $\times {10}^{-6}$ =	1.32 $\times {10}^{-9}$ +	1.49 $\times {10}^{-9}$ +
F11	3.45 $\times {10}^{-10}$ +	1.91 $\times {10}^{-8}$ +	3.32 $\times {10}^{-11}$ +	2.97 $\times {10}^{-10}$ +	2.31 $\times {10}^{-10}$ +	2.56 $\times {10}^{-10}$ +
F12	3.45 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +
F13	3.02 $\times {10}^{-11}$ +	3.23 $\times {10}^{-11}$ +	3.56 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +
F14	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +
F15	3.35 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.24 $\times {10}^{-6}$ −	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +
F18	3.34 $\times {10}^{-11}$ +	3.21 $\times {10}^{-5}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	1.52 $\times {10}^{-7}$ +	1.75 $\times {10}^{-7}$ +
F19	3.02 $\times {10}^{-11}$ +	3.32 $\times {10}^{-8}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	2.28 $\times {10}^{-8}$ +	2.53 $\times {10}^{-10}$ +
F21	3.24 $\times {10}^{-9}$ +	3.41 $\times {10}^{-8}$ +	6.74 $\times {10}^{-8}$ +	2.95 $\times {10}^{-9}$ +	8.16 $\times {10}^{-6}$ −	9.47 $\times {10}^{-4}$ −
F22	3.02 $\times {10}^{-11}$ +	3.42 $\times {10}^{-9}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	1.61 $\times {10}^{-9}$ +	1.73 $\times {10}^{-7}$ +
F23	3.02 $\times {10}^{-11}$ +	3.42 $\times {10}^{-9}$ +	5.20 $\times {10}^{-}1$ +	3.02 $\times {10}^{-11}$ +	1.72 $\times {10}^{-7}$ =	1.85 $\times {10}^{-6}$ =
F24	4.50 $\times {10}^{-11}$ +	4.50 $\times {10}^{-11}$ +	3.32 $\times {10}^{-6}$ +	4.50 $\times {10}^{-11}$ +	1.61 $\times {10}^{-9}$ +	1.74 $\times {10}^{-8}$ +
F25	3.21 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-5}$ −	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +
F26	6.70 $\times {10}^{-11}$ +	5.67 $\times {10}^{-11}$ +	3.26 $\times {10}^{-8}$ +	6.12 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +
F27	2.33 $\times {10}^{-10}$ +	8.15 $\times {10}^{-11}$ +	9.06 $\times {10}^{-7}$ =	2.01 $\times {10}^{-10}$ +	1.95 $\times {10}^{-11}$ +	2.07 $\times {10}^{-11}$ +
F28	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +
F30	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-6}$ −	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +	3.02 $\times {10}^{-11}$ +
+/=/−	24/1/0	25/0/0	19/1/5	24/1/0	19/2/4	19/2/4

presents the statistical analysis results of the LTR-MHA against the other algorithms under the 30-dimension setting. In the table, the symbols ‘+’, ‘=’, and ‘−’ demonstrate that the LTR-MHA performs significantly better than, similarly to, and significantly worse than the compared algorithm. As shown in Table 9, the LTR-MHA predominantly achieves the ‘+’ symbol across most cases, indicating that its performance on the CEC2017 benchmark optimization tasks is significantly superior to that of the other algorithms.

In summary, the LTR-MHA shows significant advantages in solution precision, convergence speed, and statistical significance. Across tests on unimodal, simple multimodal, hybrid, and composite functions, the LTR-MHA consistently yields the lowest average fitness values in most scenarios while maintaining the lowest or second-lowest standard deviations. Moreover, the LTR-MHA is able to rapidly approach the optimal regions, particularly in simple multimodal and composite functions. Although the model prediction process leads to longer runtimes, this additional computational cost is offset in the long term by the algorithm’s ability to efficiently solve a wide range of problem instances. In contrast, traditional metaheuristic algorithms exhibit acceptable performance in specific functions or lower-dimensional problems but suffer significant degradation in high-dimensional, complex environments. Therefore, by leveraging a multi-strategy fusion mechanism, the LTR-MHA effectively addresses complex optimization problems, though the trade-off between computational cost and performance should be carefully considered in practical applications based on specific problem requirements.

6. Conclusions

To address the limitations of flexibility and adaptability in traditional metaheuristic algorithms when dealing with diverse optimization problems, as well as their tendency to get trapped in local optima, this paper proposes the LTR-MHA, an automated algorithm generation method based on Learning to Rank. This approach analyzes the historical search processes of the GA, WOA, and HHO to extract key features, including the iteration stage, core algorithm parameters, and diversity metrics, for constructing the training dataset. A predictive model is then trained using the Random Forest algorithm. During the optimization process, the LTR-MHA dynamically evaluates the potential benefit scores of candidate update actions and intelligently selects the optimal update strategy. This allows the method to significantly improve search efficiency, minimize premature convergence, and improve the quality of the solution.

Experimental validation via the CEC2017 benchmark test suite demonstrates that the LTR-MHA exhibits clear advantages across unimodal, simple multimodal, hybrid, and composition function tests. Compared with single algorithms and random combination strategies, the LTR-MHA consistently yields the lowest average and the best fitness values in nearly all test scenarios while maintaining strong stability. In particular, for multimodal and high-dimensional problems, the LTR-MHA effectively accelerates convergence through its multi-strategy integration mechanism. Although the model prediction introduces additional computational overhead, considering the overall balance between algorithm performance and computational cost, the LTR-MHA still delivers a favorable cost/performance ratio in practical applications.

Future research will further explore the search characteristics of different metaheuristic algorithms, investigate the optimal number of algorithm combinations, and develop more rational combination strategies. Additionally, we will be made to incorporate other artificial intelligence techniques or optimization algorithms to improve model prediction efficiency and reduce computational overhead, ultimately achieving a more efficient real-time algorithm selection strategy. The LTR-MHA methodology will next be compared to existing state-of-the-art approaches and applied to more challenging circumstances to ensure its generalizability and practical relevance.