Advanced Optimization of Flowshop Scheduling with Maintenance, Learning and Deteriorating Effects Leveraging Surrogate Modeling Approaches

Abstract

Metaheuristics are powerful optimization techniques that are well-suited for addressing complex combinatorial problems across diverse scientific and industrial domains. However, their application to computationally expensive problems remains challenging due to the high cost and significant number of fitness evaluations required during the search process. Surrogate modeling has recently emerged as an effective solution to reduce these computational demands by approximating the true, time-intensive fitness function. While surrogate-assisted metaheuristics have gained attention in recent years, their application to complex scheduling problems such as the Permutation Flowshop Scheduling Problem (PFSP) under learning, deterioration, and maintenance effects remains largely unexplored. To the best of our knowledge, this study is the first to investigate the integration of surrogate modeling within the artificial bee colony (ABC) framework specifically tailored to this problem context. We develop and evaluate two distinct strategies for integrating surrogate modeling into the optimization process, leveraging the ABC algorithm. The first strategy uses a Kriging model to dynamically guide the selection of the most effective search operator at each stage of the employed bee phase. The second strategy introduces three variants, each incorporating a Q-learning-based operator in the selection mechanism and a different evolution control mechanism, where the Kriging model is employed to approximate the fitness of generated offspring. Through extensive computational experiments and performance analysis, using Taillard’s well-known standard benchmarks, we assess solution quality, convergence, and the number of exact fitness evaluations, demonstrating that these approaches achieve competitive results.

1. Introduction

Metaheuristics, a class of approximate optimization techniques designed to tackle complex optimization problems by finding (near) optimal solutions within a reasonable computational time [1], have seen evolutionary or nature-based approaches emerge as a promising framework for addressing real-world combinatorial challenges in science and industry [2]. In general, metaheuristics involve an iterative search process that can escape local optima and conduct a robust exploration of the search space. Throughout this process, numerous solutions are generated and evaluated until the algorithm converges on an optimal or near-optimal solution. Consequently, the cost of optimizing expensive problems is dominated by the number of fitness function evaluations required for algorithm convergence [3], resulting in a huge computational overhead. In many real-world applications, however, the computational cost is often severely constrained [4]. To overcome this shortcoming and reduce the number of costly fitness function evaluations, surrogate or meta-models [5,6] have been introduced in the literature to provide an efficient approximation of the true fitness function.

Surrogate-assisted evolutionary algorithms (SAEAs) have recently proven to be an efficient optimization tool for addressing computationally expensive problems [7]. By employing surrogate models to approximate the fitness function, SAEA enhances the ability to identify robust solutions while significantly reducing computational time. These surrogate models, built using machine learning (ML) techniques such as the Gaussian Process (Kriging) [8], Radial Basis Function (RBF) [9], Random Forest (RF) [10], and Support Vector Regression (SVR) [11], act as efficient substitutes for the true and time-consuming fitness function during the search process. The design of SAEA typically involves two main phases. (1) First, the surrogate model can be constructed using an offline approach [1], using data from past runs on similar problems. Alternatively, in an online approach [1], the model is continuously updated and refined during the optimization process. (2) Then, the interaction with the metaheuristic, referred to as model management or evolution control [12], involves strategies to determine when to rely on the surrogate model instead of performing real fitness function evaluations. To mitigate the risk of approximation errors from the surrogate model leading to false optima convergence [13,14], two main management mechanisms are employed in the literature [15]: (1) individual-based evolution control, where the surrogate model evaluates a certain number of individuals within each generation; and (2) population-based evolution control, where a portion of the total generations is evaluated using the surrogate model. These mechanisms strike a balance between computational efficiency and optimization accuracy, effectively guiding the search toward promising regions and ultimately toward the true optimal solution(s).

Scheduling problems within the permutation flow shop environment (PFSP) represent a critical class of problems commonly encountered in manufacturing and large-scale production, with significant social and economic implications [16]. The PFSP is an NP-hard combinatorial optimization problem [17] aiming to determine the optimal sequence for processing a set of n jobs in the same order on a set of m machines. Many scholars have recently concentrated on studying the PFSP in real-world settings to bridge the gap between theoretical models and industrial applications [18,19]. In this regard, this paper examines a PFSP that reflects real-world applications by considering unavailability periods due to predictive maintenance [20], as well as learning [21] and deterioration [22] effects. The learning effect reduces maintenance durations as they are scheduled later in the sequence. This reflects the improved efficiency of maintenance teams over time, as confirmed by [21]. Ignoring this effect may lead to overestimating maintenance durations and inefficient scheduling. In contrast, the deterioration effect increases the processing times of production jobs when they are started later in the sequence. This reflects real-world scenarios where delays in processing can lead to resource degradation or material spoilage, as highlighted by [22]. Failing to account for this effect may result in underestimated processing times, thus increasing the risk of production delays. The objective of this work is to determine the sequence of production jobs and maintenance operations that minimizes the makespan criterion, considering the learning and deterioration effects. The integration of these effects is critical for generating accurate and practical schedules [23]. Given that this problem is also NP-hard, metaheuristics are the most effective optimization methods to solve it, and a variety of these approaches have been proposed in the literature [24,25].

The artificial bee colony (ABC) algorithm [26] is an efficient evolutionary approach inspired by the intelligent foraging behavior of honeybees. It mimics the food-search process of three types of foraging bees—employed, onlooker, and scout—maintaining a balance between exploration and exploitation, as scout bees promote diversity by exploring new areas, while employed and onlooker bees concentrate on refining promising regions. Initially proposed for continuous optimization problems, the ABC algorithm was later extended to tackle discrete problems as well [27], and has shown strong performance in addressing a range of combinatorial problems, notably the PFSP [28].

Although the ABC algorithm primarily relies on exploitation mechanisms through its employed and onlooker bees, its exploitation capability may still be insufficient to ensure rapid convergence, particularly when dealing with complex, multimodal, or large-scale search spaces [4,29,30]. The use of multiple search operators to effectively exploit promising regions of the search space has been widely adopted in the ABC algorithm for enhancing its performance [31,32,33,34]. However, selecting the most suitable operator remains a key challenge [29]. Notably, refs. [31,32] showed that the random selection of search operators during the employed bee phase often led to premature convergence, primarily due to the insufficient exploitation of promising solutions. To address this limitation, ref.  [35] proposed an approach based on the ABC algorithm, incorporating a Q-learning-based operator selection mechanism. This reinforcement-learning-driven strategy demonstrated superior performance regarding solution quality and convergence properties, highlighting the importance of selecting the best search operator. While the standard ABC algorithm relies on systematically evaluating a full set of solutions, resulting in a high number of costly fitness evaluations, the key contributions of this paper are the proposal of the Surrogate-Assisted ABC (SABC) algorithms, which reduce computational effort while enhancing both the exploitation and the exploration capabilities. Additionally, we propose three variants of surrogate modeling optimization approaches, each incorporating a different evolution control mechanism. The first, Individual-based Surrogate Modeling Optimization (ISQABC), improves exploitation by using a surrogate model to perform a more intensive local search in the neighborhood of a subset of the current population during the employed bee phase. In contrast, the second approach, Generation-based Surrogate Modeling Optimization (GSQABC), enhances the exploration capability of the algorithm by evaluating newly generated populations with the surrogate model across the employed, onlooker, and scout bee phases. Finally, the third approach, Combined Surrogate Modeling Optimization (CSQABC), aims to balance exploitation and exploration by integrating individual- and generation-based surrogate modeling techniques. Together, these three approaches offer novel strategies for optimizing the PFSP through surrogate modeling techniques.

This paper is organized as follows: Section 2 reviews recent advancements in surrogate modeling and its integration into metaheuristic optimization. Section 3 presents the formulation of the PFSP with maintenance, learning, and deterioration effects. Section 4 describes the proposed surrogate-based approaches for solving the problem. Section 5 evaluates their performance through computational experiments and discusses the results. Finally, Section 6 concludes the paper by summarizing the key findings and outlining directions for future research.

2. Review of Recent Advancements in Surrogate Modeling for Metaheuristic Optimization

The use of surrogate models within metaheuristic algorithms to reduce computational costs has received significant attention in recent years. This trend is particularly evident in the development of Surrogate-Assisted Evolutionary Algorithms (SAEAs) [12], which have been applied to both single-objective [36] and multi-objective optimization problems [37]. According to [36], SAEAs are classified into two main types based on their modeling approaches: regression-based models and similarity-based models. Regression-based models use approximation techniques to map a solution vector to its predicted fitness value and have been the most extensively studied in the literature. The primary challenge lies in selecting suitable regression models for two distinct tasks: local modeling, where the surrogate predicts fitness values within a specific region of the search space, and global modeling, where the surrogate predicts fitness values across the entire search space. In a systematic comparison study, ref. [38] demonstrated that Kriging models are particularly well-suited for global modeling due to their ability to capture complex patterns and provide uncertainty estimates. On the other hand, similarity-based models rely on past evaluations to infer fitness values for new solutions based on their proximity to previously evaluated points. Although less common than regression-based models, these approaches are useful for certain optimization problems [39]. A significant advancement in SAEAs is the use of multiple surrogate models rather than reliance on a single model [40]. As discussed in [12], incorporating diverse surrogates with different characteristics and modeling capabilities can reduce prediction errors and improve optimization performance. However, this approach introduces the additional challenge of effectively selecting suitable models for the problem at hand and balancing their contributions. Moreover, training multiple surrogate models simultaneously can significantly increase computational time.

Over the past few years, various SAEAs have been proposed by combining different surrogate models and metaheuristics. For instance, ref. [41] combined a Radial Basis Function (RBF) model with a hybrid approach integrating teaching–learning-based optimization and differential evolution. Similarly, ref. [42] paired an RBF model with a multi-population particle swarm optimization algorithm to improve search efficiency. RF models have also been widely used in hybrid frameworks, with ref. [43] combining RFs with particle swarm optimization and ref. [44] integrating them with genetic algorithms. Meanwhile, Kriging models, known for their adaptability in global modeling tasks, were effectively integrated with genetic algorithms [45].

The ABC algorithm is a well-established metaheuristic that has demonstrated effectiveness in solving a wide range of combinatorial optimization problems [31,32,35,46,47,48]. These studies have successfully adapted the ABC algorithm to discrete and combinatorial domains by modifying the solution representation and defining suitable neighborhood optimization over permutations. The integration of surrogates with the ABC algorithm has been explored in several studies, which leverage surrogate models to estimate the fitness landscape, thereby reducing the number of exact evaluations and improving the overall efficiency of the algorithm [4,29]. For instance, ref. [4] applied RBF and Kriging models to assist the employed and onlooker bee stages, respectively. Moreover, ref. [29] employed an RBF model to evaluate the offspring generated by the search operator pool during the employed bee phase.

Despite the growing research applying SAEA to general, computationally expensive optimization problems, limited work has been carried out on real-world applications [7]. Production scheduling, a fundamental and widely studied combinatorial optimization problem, has notably received limited attention in the context of surrogate-assisted approaches. Only a few research efforts have addressed this gap: for instance, ref. [49] employed surrogate-assisted Ant Colony Optimization to solve a practical job shop scheduling problem, while ref. [50] proposed a surrogate-assisted differential evolution approach for a practical parallel machine scheduling problem. To the best of the authors’ knowledge, studies applying SAEA to the flowshop scheduling problem remain very limited, with only the work of [51], the most significant study to date. Moreover, no prior studies have addressed the PFSP with maintenance, learning, and deterioration effects, which aligns with the focus of this paper, highlighting a clear gap and underscoring the need for further investigation into the effectiveness of SAEA in this context.

3. Formulation of the Multi-Effect PFSP with Maintenance, Learning, and Deterioration Constraints

We consider an extended version of the permutation flowshop scheduling problem (PFSP), integrating predictive maintenance constraints along with learning and deteriorating effects. In this environment, a set $\mathcal{J}=\{J_1,J_2,\dots ,J_n\}$ of n production jobs is processed through a series $\mathcal{M}=\{M_1,M_2,\dots ,M_m\}$ of m machines, in the same predetermined order from one machine to another; i.e., only permutation schedules are allowed. Moreover, to reflect realistic operational conditions, each machine is continuously monitored by a Prognostics and Health Management (PHM) module, which estimates the Remaining Useful Life (RUL) and the degradation associated with each job. When the accumulated degradation reaches a critical threshold, a maintenance task must be scheduled to prevent system failure.

The complete schedule for each machine $M_i$ consists of a sequence ${\pi }_i$ combining jobs and planned maintenance activities. This sequence is composed of $k_i$$\ge 1$ maintenance operations interleaved with blocks of jobs and can be formally represented as   

${\pi }_i$= $\{B_{i1}, M_{i1}, B_{i2}, M_{i2},..., B_{ik}, M_{i{k}_i}, B_{i(k_i+1)}\}$, where ${\cup }_{l=1}^{k_i+1}{B}_{il}=J$.   

The following assumptions are considered in the problem formulation:

• All jobs are available at the beginning of the schedule (time zero), and preemption is not allowed;
• A machine can perform either a job or a maintenance task at any given time;
• Each job j has a base processing time $p_{ij}$ on machine $M_i$, and each maintenance operation c has a base duration $p{m}_{ic}$;
• Degradation after processing job j on machine i is calculated as ${\sigma }_{ij}=p_{ij}/RU{L}_{ij}$ where $0<{\sigma }_{ij}<1$;
• The degradation threshold $\Delta$ is set to 1 for all machines;
• At least one maintenance operation is scheduled per machine, and no maintenance is allowed after the last job;
• After each maintenance, the machine is fully restored to its original state (“as good as new”).

To make the model more reflective of practical production systems, two dynamic effects are introduced:

• Learning effect: Maintenance durations tend to decrease when scheduled later in the sequence due to improved worker efficiency;
• Deteriorating effect: Job processing times increase over time as machines wear out or experience delays.

These effects are modeled using the following expressions:

$$p{m}_{ic}\left(c\right)=p{m}_{ic}\times c^{\alpha },-1<\alpha <0$$

(1)

$$p_{ij}\left(t\right)=p_{ij}+\beta \times t,\beta >0$$

(2)

where

• $p{m}_{ic}\left(c\right)$ indicates the actual duration of the cth maintenance i scheduled on the ith machine.
• $p{m}_{ic}$ indicates the basic duration of the cth maintenance i on the ith machine.
• $\alpha$ indicates the learning rate.
• $p_{ij}\left(t\right)$ indicates the actual processing time of the jth job scheduled on the ith machine at time t.
• $p_{ij}$ indicates the basic processing time of job j on machine i.
• $\beta$ indicates the deterioration rate.

The objective is to determine the best sequencing of jobs and maintenance operations for each machine to minimize the total schedule completion time, $C_{\max }$, while accounting for dynamic variations in job processing times and maintenance durations. Ignoring these effects would lead to inaccurate estimations of $C_{\max }$, resulting in suboptimal schedules that either overestimate or underestimate the total completion time. By explicitly considering both learning and deteriorating effects, the proposed model ensures a more accurate and realistic estimation of $C_{\max }$, which is critical for generating practical and efficient schedules in industrial settings, considering that

• The learning effect reduces maintenance durations over time, as maintenance teams become more efficient with experience. This reduction directly decreases the $C_{max}$ when maintenance operations are scheduled later in the sequence;
• The deteriorating effect increases the processing times of production jobs if they are started later in the sequence. This increase directly impacts the $C_{max}$ by extending the overall schedule duration.

Given that $C_{\max }$ primarily depends on the sum of job processing times and maintenance durations (as shown in Equation (3)), the expressions for $C_{\max }$ considering both effects simultaneously are provided in Equation (4):

$$C_{max}=IT+{\Sigma }_{j=1}^{j=n}{p}_{mj}+{\Sigma }_{c=1}^{c=k_m}p{m}_{mc}$$

(3)

$$C_{max}=IT+{\Sigma }_{j=1}^{j=n}{p}_{mj}\left(t\right)+{\Sigma }_{c=1}^{c=k_m}p{m}_{mc}\left(c\right)=IT+{\Sigma }_{j=1}^{j=n}(p_{mj}+\beta \times t)+{\Sigma }_{c=1}^{c=k_m}(p{m}_{mc}\times c^{\alpha })$$

(4)

Here, $IT$ represents the total idle time of the last machine m while waiting for job arrivals, and $k_m$ denotes the number of maintenance activities scheduled on the last machine m.

4. Proposed Solving Strategies Leveraging Surrogate-Modeling-Based Approaches

In this paper, four distinct ABC-based optimization approaches are proposed. By integrating surrogate modeling, these approaches approximate the fitness landscape, enabling rapid estimations of the fitness function and supporting extensive investigation of the solution space while significantly reducing reliance on exact evaluations. The foundation of our proposed approaches relies primarily on our previous studies, namely the ABC algorithm [31] and its enhanced variant, the Integrated Q-Learning-based ABC (IQABC) algorithm [35], illustrated in Figure 1. The ABC algorithm is an iterative search process that begins with an initialized population of solutions. Then, it proceeds through three main phases: (i) the employed bee phase, where the neighborhood of current solutions isexploited using randomly selected perturbation operators; (ii) the onlooker bee phase, where solutions are evaluated based on a fitness-based selection process to exploit promising areas of the search space; and (iii) the scout bee phase, which maintains diversity by replacing poor solutions with randomly generated ones. In the ABC framework, the employed and onlooker bee phases are the main drivers of exploitation, focusing on intensifying the search around high-quality solutions through neighborhood exploitation and selection mechanisms. In contrast, the scout bee phase promotes exploration by introducing new random solutions into the population, helping to escape local optima and increase search diversity [52,53] With the aim to ensure more adaptive exploitation of the search space, the IQABC algorithm [35] enhanced our standard ABC by incorporating a Q-learning strategy to guide the exploitation of the employed bees’ neighborhood, replacing its original random mechanism.

The first proposed surrogate-based approach, namely the Surrogate-Assisted ABC (SABC) algorithm, represents an advanced variant of the ABC algorithm designed to optimize search operator selection. It introduces systematic exploitation of the neighborhood by comprehensively covering the pool of search operators. The surrogate model is leveraged to approximate fitness evaluations of offspring, enabling efficient operator selection and improved exploitation of candidate solutions. On the other hand, the Individual-based Surrogate-Assisted ABC (ISQABC), Generation-based Surrogate-Assisted ABC (GSQABC), and Combined-based Surrogate-Assisted ABC (CSQABC) algorithms extend the IQABC algorithm to address both local exploitation and global exploration challenges. The global architecture and hierarchical organization of the proposed surrogate-based approaches is depicted in Figure 2.

These four approaches reflect a deliberate investigation into how surrogate modeling can be integrated within the ABC framework to address different optimization challenges. Specifically,

• SABC focuses on improving exploitation efficiency through systematic operator selection;
• ISQABC enhances local exploitation by systematically refining solutions using surrogate-assisted evaluations of the employed bees’ neighborhood;
• GSQABC prioritizes exploration at the population level, leveraging surrogate modeling to identify and probe promising regions of the search space;
• CSQABC integrates both strategies, simultaneously balancing local exploitation and global exploration to achieve a more comprehensive search.

This structured design enables a systematic investigation of the trade-offs and challenges associated with surrogate-assisted metaheuristics in the context of complex scheduling problems, an area that remains largely underexplored.

Finally, all four proposed algorithms (SABC, ISQABC, GSQABC, and CSQABC) share a common foundation in the ABC framework and its enhancement through surrogate modeling. For clarity and to avoid redundancy, we present here the key parameters that govern the behavior of these algorithms:

• Population size (Pop_Size) refers to the number of candidate solutions (food sources) in the population. Larger populations increase the diversity of the search space, supporting better local exploitation and robustness against premature convergence.
• Maximum number of iterations (Max_iteration) determines the global search horizon. A higher number allows for broader exploration of the solution space.
• Onlooker bee percentage (Onlook%). In our discrete ABC adaptation, we explicitly control the fraction of the population participating in the onlooker phase, which performs neighborhood-based refinements (using local search). Setting this value allows us to intensify exploitation without overriding the search diversity preserved by the rest of the population.
• Scout bee limit (limit) defines the number of consecutive unsuccessful trials after which a food source (solution) is considered stagnant and is replaced. This parameter controls diversification and helps escape local optima.
• Controlled individuals (in ISQABC and CSQABC) determines the number of individuals within the population that are evaluated exactly rather than via surrogate approximation. These individuals are typically those with the best estimated fitness values, ensuring reliable exploitation of promising areas.
• Controlled generations (in GSQABC and CSQABC) indicate the number of iterations (generations) in which all individuals are evaluated exactly. These generations serve to refine solutions periodically and improve the surrogate model’s learning.

In what follows, we first present the construction of our surrogate model, which is crucial to the success of our proposed methods. We then describe how this model is used in each of the four optimization approaches.

4.1. Surrogate Model Design

Our surrogate model is carefully designed to accurately capture the nuances of the makespan function landscape, enhancing estimation precision through the following steps:

1.

Determining the input feature set.

This is a critical process in constructing the surrogate model [50]. Drawing on our domain knowledge and detailed analysis of the fitness function, we have selected a feature set that precisely and uniquely describes solution details. For our specified PFSP problem with n jobs and m machines, each candidate solution is represented through a structured encoding scheme. The production sequence is captured in a job-order vector, while a maintenance scheduling matrix indicates where maintenance operations are inserted along the job timeline for each machine. The matrix is binary-coded, with entries signifying whether a maintenance action occurs after a given job on a specific machine.

In our representation, these two global pieces of information are encoded into $n+m$ features. The first n attributes indicate the order of each job in the sequence, while the last m attributes refer to the decimal encoding of each binary line of the maintenance matrix.

2.

Selection of Surrogate Model Algorithm.

After determining the feature set, the choice of a suitable surrogate model is critical for the success of surrogate-assisted optimization [12], yet it is inherently problem-dependent [54]. As emphasized by [55], “one surrogate model might give good results for a particular problem while it might perform very poorly when applied to another problem”. This observation underlines the importance of empirical evaluation when selecting a surrogate model for a specific problem context. Consequently, we compared five common methods: Random Forest (RF), Support Vector Regression (SVR), Radial Basis Function (RBF), and Kriging. Each model was tested on instances of varying sizes ($n\in \{20,50,100,200,500\}$ and $m\in \{5,10,20\}$). The training set was constructed using solutions generated during an initial ABC algorithm run. The Kriging model demonstrated superior performance in terms of mean squared error (MSE) and computational efficiency.

Furthermore, Kriging has several theoretical advantages that support its integration into surrogate-assisted metaheuristics: it provides exact interpolation of known data points, it offers uncertainty quantification, enabling informed decisions about whether to trust approximate fitness or trigger exact evaluations, and it is flexible and adaptable to high-dimensional or noisy landscapes, making it well-suited to complex discrete optimization problems such as PFSP [56]. These advantages, both empirical and theoretical, justify the adoption of Kriging in the proposed surrogate-assisted framework.

3.

Training of the Surrogate Model.

Training the surrogate model is a critical step in its construction, directly affecting its accuracy and effectiveness in approximating the fitness landscape. We used an online training approach to continuously update the model throughout the optimization process, ensuring its accuracy as new solutions are generated. Training begins in the initialization phase, where accurate evaluations of solutions generated using a combination of NEH-based methods and random generation are used to build the initial model. As optimization progresses, the surrogate model is incrementally retrained with new exact evaluations until its accuracy plateaus. This plateau is defined as no significant improvement in accuracy over six consecutive iterations; at this point, retraining ceases to minimize the computational overhead [14]. The incremental training approach allows the surrogate model to adapt to the evolving fitness landscape, achieving a balance between computational efficiency and prediction accuracy.

4.2. Surrogate-Assisted Artificial Bee Colony Algorithm

The Surrogate-Assisted ABC (SABC) algorithm enhances our previous ABC variant [32] by replacing the random selection of a single neighborhood operator with a systematic evaluation of multiple operators, guided by surrogate-assisted fitness estimation. This improvement aims to produce higher-quality offspring while reducing the number of evaluations required during the exploitation of the neighborhood at each employed bee stage. The search operator pool, as introduced in [32,35], comprises six strategies designed to enhance solution exploitation as follows:

• Swap Move on Production Jobs randomly swaps the positions of two production jobs within the sequence.
• Double Swap Move executes two consecutive swap operations on production jobs.
• Insert Move on Production Jobs removes a randomly selected job from its current position and reinserts it into a different position.
• Double Insert Move performs two consecutive insertion operations on production jobs.
• Right Shift on Maintenance Activities moves a maintenance activity to the right, placing it immediately after the next job in the sequence.
• Left Shift on Maintenance Activities: Moves a maintenance activity to the left, placing it immediately before the preceding job in the sequence.

These operators enable flexible adjustments to both job sequences and maintenance schedules, enhancing the diversity and efficiency of the search process.

The following steps detail the execution of the SABC algorithm, from initialization to the generation of optimized solutions, highlighting its mechanisms for balancing exploration and exploitation within the search space as follows:

• Initialization. The initial population is generated using the integrated NEH (INEH) algorithm and a modified version of the INEH algorithm [31], along with random generation to enhance diversity and quality. Each solution is decoded and evaluated to construct the initial training sample for the Kriging model.
• Surrogate-assisted Employed Bee Phase. Initially, a search operator from the pool is randomly selected to generate offspring for each solution in the population. The offspring are then evaluated using the exact fitness function. Subsequently, each employed bee applies all six search operators, and the Kriging model evaluates the resulting offspring. Greedy selection (Algorithm 1) is then used to determine whether to replace the current solution with the best offspring generated. The goal is to enhance the solution quality efficiently, minimizing the number of exact evaluations.
• Onlooker Bee Phase. Onlooker bees select candidates from employed bees using the roulette wheel method. The Iterated Local Search (ILS) algorithm [57] is then applied to improve the selected solutions (Algorithm 2). This local search operates in two phases: (i) a destruction phase, where a subset of d jobs is randomly removed from the current solution, and (ii) a reconstruction phase, where the removed jobs are reinserted using the NEH heuristic. To accelerate the search, we implement two stopping strategies: a first-improvement criterion for all food sources and a complete-insertion strategy applied only to the best solution.
• Scout Bee Phase. Solutions not improved beyond a certain limit are abandoned and replaced with new random ones to maintain diversity and avoid stagnation. Specifically, each solution is associated with a trial counter that tracks the number of consecutive iterations without improvement. When this counter exceeds a predefined threshold, the solution is considered stagnant and is replaced by a newly generated random permutation, ensuring the exploration of new regions in the search space.

The employed, onlooker, and scout bee phases are iterated until a specified maximum number of iterations is reached. Throughout these iterations, the surrogate model is incrementally trained using accurately evaluated solutions from all phases, continuously refining its accuracy until reaching a stagnation point, defined as no improvement in the Kriging model’s accuracy for six consecutive iterations. Figure 3 illustrates the flowchart of the SABC algorithm, and its pseudo code is described in Algorithm 3.

Algorithm 1 Greedy Selection for Updating Solution

Require:X: Current solution, $f\left(X\right)$: Real fitness value of X, $X_i$: Neighboring solution, $\tilde{f}\left(X_i\right)$: Approximate fitness value of $X_i$ by surrogate model 1: if$\tilde{f}\left(X_i\right)<f\left(X\right)$then 2:     Compute $f\left(X_i\right)$ (exact fitness value of $X_i$) 3:     if $f\left(X_i\right)<f\left(X\right)$ then 4:          $X\leftarrow X_i$ 5:          $f\left(X\right)\leftarrow f\left(X_i\right)$ 6:     end if 7: else 8:       Keep X as is 9: end if         return$X,f\left(X\right)$

Algorithm 2 Iterated Local Search (ILS) algorithm

Require: S: Current solution, d: Number of jobs to remove, $\mathtt{type}$: stopping criterion (first-improve or full) Ensure: Improved solution $S^{*}$   1: $S^{*}\leftarrow S$   2: Randomly remove d distinct jobs from S to form job set R   3: $S_{\mathrm{partial}}\leftarrow S$ without the jobs in R   4: if  $\mathtt{type}=\mathtt{first}-\mathtt{improve}$  then   5:      for all job j in R do   6:            for all insertion position p in $S_{\mathrm{partial}}$ do   7:                  Insert j at position p to obtain $S_{\mathrm{new}}$   8:                  if $f\left(S_{\mathrm{new}}\right)<f\left(S^{*}\right)$ then   9:                        $S^{*}\leftarrow S_{\mathrm{new}}$ 10:                        break inner loop 11:                  end if 12:            end for 13:      end for 14: else 15:      for all job j in R do 16:            Evaluate all possible insertions of j in $S_{\mathrm{partial}}$ 17:            Select the best insertion to update $S_{\mathrm{partial}}$ 18:      end for 19:      if $f\left(S_{\mathrm{partial}}\right)<f\left(S^{*}\right)$ then 20:            $S^{*}\leftarrow S_{\mathrm{partial}}$ 21:      end if 22: end if         return$S^{*}$

4.3. Individual-Based Surrogate Assisted Q-Learning ABC

The Individual-based Surrogate-Assisted Q-learning ABC (ISQABC) algorithm is designed to significantly boost the exploitation capabilities of the baseline IQABC algorithm [35] by leveraging a larger population size and integrating a Kriging model for efficient fitness approximation. One of the key challenges in surrogate-assisted optimization is avoiding premature convergence to false optima while maintaining computational efficiency [13,14]. To address this, ISQABC incorporates individual-based evolution control, wherein a carefully selected portion of the population undergoes exact fitness evaluations. Deciding which individuals to control is a critical open problem in the field [3], as improper selection may lead to suboptimal solutions. In ISQABC, we employ a strategy that prioritizes exact evaluations for the best-performing individuals—which are most likely to lead to optimal solutions—while approximating less promising individuals using the surrogate model. This approach strikes a balance between enhancing solution quality and reducing the computational burden, thereby improving the overall efficiency of the algorithm.

Algorithm 3 Surrogate -Assisted ABC (SABC) Algorithm

Require: $Max\_Iter$, $Pop\_Size$, $limit$, $Onlook\%$   1: Initialize population using INEH, modified INEH, and random solutions   2: Evaluate initial population exactly and construct the initial training set   3: Train initial Kriging model   4: $stagnation\_counter\leftarrow 0$   5: for $t=1$ to $MaxIter$ do   6:       if Kriging model accuracy not yet stagnated then   7:            // Employed Bee Phase with Exact Evaluation   8:            for each solution $X_i$ do   9:                  Select one search operator at random 10:                  Generate offspring $X_i^{\prime }$ and evaluate it exactly 11:                  if $f\left(X_i^{\prime }\right)<f\left(X_i\right)$ then 12:                        $X_i\leftarrow X_i^{\prime }$, $f\left(X_i\right)\leftarrow f\left(X_i^{\prime }\right)$ 13:                        $tria{l}_i\leftarrow 0$ 14:                  else 15:                        $tria{l}_i\leftarrow tria{l}_i+1$ 16:                  end if 17:                  Add $(X_i^{\prime },f\left(X_i^{\prime }\right))$ to training set 18:             end for 19:       else 20:            // Surrogate-Assisted Employed Bee Phase 21:            for each solution $X_i$ do 22:                 Generate six offspring using all search operators 23:                 Evaluate offspring with surrogate model 24:                 Apply Greedy Selection (Algorithm 1) 25:                 if solution $X_i$ updated by exact evaluation then 26:                      $tria{l}_i\leftarrow 0$ 27:                 else 28:                      $tria{l}_i\leftarrow tria{l}_i+1$ 29:                 end if 30:            end for 31:       end if 32:       // Onlooker Bee Phase 33:       Select $Onlook\%\ast Pop\_Size$ solutions via roulette wheel 34:       for each selected solution do 35:             Apply ILS (Algorithm 2) 36:             if solution improved then 37:                  $tria{l}_i\leftarrow 0$ 38:             else 39:                  $tria{l}_i\leftarrow tria{l}_i+1$ 40:             end if 41:       end for 42:       // Scout Bee Phase 43:       for each $X_i$ do 44:             if $tria{l}_i>limit$ then 45:                  Replace $X_i$ with a new random solution 46:                  $tria{l}_i\leftarrow 0$ 47:             end if 48:       end for 49:       Update Kriging model with new exact evaluations 50:       if model accuracy improved then 51:             $stagnation\_counter\leftarrow 0$ 52:       else 53:             $stagnation\_counter\leftarrow stagnation\_counter+1$ 54:       end if 55: end for 56: return Best solution found

The steps outlined below describe the execution of the ISQABC algorithm, from initialization to the generation of optimized solutions, emphasizing its exploitation within the search space as follows:

• Initialization. The initial population is generated using the INEH, modified INEH, and random generation methods. The population is then sorted based on fitness values to identify individuals best suited for exact fitness evaluations and those suitable for approximate assessment.
• Employed bee phase. During this phase, two swarms are created: the first swarm targets the top $P1\%$ of the best individuals, using the Q-learning algorithm [35] with exact fitness evaluations to generate offspring and update the Q-table, guiding the selection of search operators. The second swarm, composed of the remaining individuals, uses the Q-table to generate offspring whose fitness is evaluated using the Kriging model. This population, seeded with controlled individuals evaluated using the exact fitness function and approximated individuals assessed with the Kriging model, helps mitigate the risk of false optima by maintaining a diverse exploitation of the search space while ensuring accurate evaluation of the most promising solutions.
• Onlooker bee phase. In this phase, the ILS algorithm (Algorithm 2) is applied to a subset of solutions generated by the first swarm and the best-updated individual from the second swarm.
• Scout bee phase. Finally, the scout bee phase replaces individuals that have not been updated after a defined number of trials with new random individuals to sustain the diversity in the population.

As in the SABC approach, the employed, onlooker, and scout bee phases are iterated until a specified maximum number of iterations is reached. During these iterations, the surrogate model is incrementally trained using accurately evaluated solutions from all phases—employed, onlooker, and scout bees—to improve its accuracy. Figure 4 illustrates the flowchart of the ISQABC algorithm, while Algorithm 4 describes its pseudo code.

Algorithm 4 Individual-based Surrogate-Assisted Q-Learning ABC (ISQABC)

Require: $Max\_Iter$, $Pop\_Size$, $Onlook\%$, $limit$, P: Percentage of controlled individuals.   1: Initialize population using INEH, modified INEH, and random methods   2: Evaluate all solutions exactly and sort by fitness   3: Select top $P\%$ individuals as controlled swarm, rest as approximate swarm   4: Initialize Q-learning table   5: for $t=1$ to $Max\_Iter$ do   6:       // Employed Bee Phase   7:       for each controlled individual $X_i$ do   8:             Select operator using Q-learning   9:             Generate $X_i^{\prime }$ and evaluate exactly 10:             Update Q-table based on improvement 11:             if $f\left(X_i^{\prime }\right)<f\left(X_i\right)$ then 12:                  $X_i\leftarrow X_i^{\prime }$, $tria{l}_i\leftarrow 0$ 13:             else 14:                  $tria{l}_i\leftarrow tria{l}_i+1$ 15:             end if 16:             Add $(X_i^{\prime },f\left(X_i^{\prime }\right))$ to training set 17:       end for 18:       Train Kriging model 19:       for each approximate individual $X_j$ do 20:             Select operator using Q-table 21:             Generate $X_j^{\prime }$ and evaluate $\tilde{f}\left(X_j^{\prime }\right)$ with Kriging model 22:             Apply Greedy Selection (Algorithm 1) 23:             if solution $X_i$ updated by exact evaluation then 24:                  $tria{l}_i\leftarrow 0$ 25:             else 26:                  $tria{l}_i\leftarrow tria{l}_i+1$ 27:             end if 28:       end for 29:       Update training set with new exact evaluations 30:       // Onlooker Bee Phase 31:       Select a subset of individuals from the controlled swarm and best updated from the approximated swarm 32:       for each selected individual do 33:             Apply ILS (Algorithm 2) 34:             if solution improved then 35:                  $tria{l}_i\leftarrow 0$ 36:             else 37:                  $tria{l}_i\leftarrow tria{l}_i+1$ 38:             end if 39:       end for 40:       // Scout Bee Phase 41:       for each $X_i$ do 42:             if $tria{l}_i>limit$ then 43:                   Replace $X_i$ with a new random solution 44:                   $tria{l}_i\leftarrow 0$ 45:             end if 46:       end for 47: end for 48: return Best solution found

4.4. Generation-Based Surrogate Assisted Q-Learning ABC

The Generation-based Surrogate Assisted Q-learning ABC (GSQABC) algorithm is engineered to enhance the exploration capabilities of the baseline IQABC algorithm [35] by leveraging generation-based evolution control and surrogate modeling. A Kriging model is integrated to estimate the fitness of individuals during key phases (employed, onlooker, and scout bees) across selected generations, expediting the search process by reducing the number of exact fitness evaluations required in early iterations. To prevent premature convergence to false optima, GSQABC implements a controlled evolution approach during the initial generations. During these critical early stages, exact evaluations guide the algorithm’s exploration, ensuring accurate training of the surrogate model and preventing misleading fitness approximations. Once the initial control phase ends, the surrogate model is used to efficiently explore the broader search space. To further refine the solution quality, GSQABC applies a greedy selection mechanism (Algorithm 1) at the end of each uncontrolled generation, ensuring that the best-found solutions are continuously updated. This combination of controlled early evolution and surrogate-guided exploration significantly improves the algorithm’s ability to mainly explore and exploit the search space, enhancing both the quality of solutions and the computational efficiency of the optimization process.

The steps outlined below describe the execution of the GSQABC algorithm, from its initialization to the generation of optimized solutions, emphasizing its exploration within the search space, as follows:

• Initialization. Generate the initial population using the INEH, modified INEH, and random generation methods.
• Controlled Early Generations. During the employed, onlooker, and scout bee phases, the fitness of all individuals is evaluated exactly. After these generations, the surrogate model is trained using the individuals that underwent exact evaluation during these phases.
• Uncontrolled Generations. During the uncontrolled generation, the fitness of new individuals in the employed, onlooker, and scout bee phases is approximated using the surrogate model. At the end of each generation, a greedy selection process is applied to update the best solutions based on exact evaluations, ensuring the accuracy and quality of the best solutions found.

The employed, onlooker, and scout bee phases are iterated until a specified maximum number of iterations is reached. During these iterations, the surrogate model is incrementally trained using accurately evaluated solutions from all phases—employed, onlooker, and scout bees—during controlled generations to improve its accuracy. Figure 5 illustrates the flowchart of the GSQABC algorithm, and Algorithm 5 describes its pseudo code.

Algorithm 5 Generation-based Surrogate-Assisted Q-Learning ABC (GSQABC)

Require: $Max\_Iter$,$Pop\_Size$, $limit$, $Onlook\%$,$G_c$: Number of controlled generations,   1: Initialize population using INEH, modified INEH, and random generation   2: Evaluate all individuals using exact fitness function   3: Initialize Q-learning table   4: for $t=1$ to $Max\_Iter$ do   5:       if $t\le G_c$then                                                                 ▹ — Controlled Generations —   6:             // Employed Bee Phase   7:             for each individual $X_i$ do   8:                   Select operator using Q-learning   9:                   Generate $X_i^{\prime }$, evaluate exact $f\left(X_i^{\prime }\right)$ 10:                   if $f\left(X_i^{\prime }\right)<f\left(X_i\right)$ then 11:                         $X_i\leftarrow X_i^{\prime }$, $tria{l}_i\leftarrow 0$ 12:                   else 13:                         $tria{l}_i\leftarrow tria{l}_i+1$ 14:                   end if 15:                   Add $(X_i^{\prime },f\left(X_i^{\prime }\right))$ to training set 16:             end for 17:             // Onlooker Bee Phase 18:             Select individuals using roulette wheel 19:             for each selected $X_j$ do 20:                   Apply ILS (Algorithm 2) 21:                   if solution improved then 22:                         $tria{l}_j\leftarrow 0$ 23:                   else 24:                         $tria{l}_j\leftarrow tria{l}_j+1$ 25:                   end if 26:             end for 27:             // Scout Bee Phase 28:             for each $X_k$ do 29:                   if $tria{l}_k>limit$ then 30:                         Replace $X_k$ with new random solution 31:                         $tria{l}_k\leftarrow 0$ 32:                   end if 33:             end for 34:             Train Kriging model using exact evaluations 35:     else                                                                               ▹ — Uncontrolled Generations — 36:             // Employed Bee Phase 37:             for each individual $X_i$ do 38:                   Select operator using Q-learning 39:                   Generate $X_i^{\prime }$ and evaluate $\tilde{f}\left(X_i^{\prime }\right)$ with Kriging model 40:                   Apply Greedy Selection (Algorithm 1) using exact $f\left(X_i^{\prime }\right)$ only if $\tilde{f}\left(X_i^{\prime }\right)<f\left(X_i\right)$ 41:             end for 42:             // Onlooker Bee Phase 43:             Select individuals and apply ILS using surrogate-based evaluations 44:             // Scout Bee Phase 45:             for each $X_k$ do 46:                   if $tria{l}_k>limit$ then 47:                         Replace $X_k$ with new random solution 48:                         $tria{l}_k\leftarrow 0$ 49:                   end if 50:             end for 51:       end if 52: end for 53: return Best solution found

4.5. Combined Surrogate Assisted Q-Learning ABC

The CSQABC algorithm is designed to harness the complementary strengths of ISQABC and GSQABC, merging individual and generation-based control mechanisms for more robust optimization. In CSQABC, the individual-based evolution control from ISQABC is used to fine-tune the exploitation phase of the algorithm by ensuring that only the most promising individuals—based on exact fitness evaluations—are refined with exact fitness values. This mechanism minimizes computational overhead while improving the accuracy of high-performing solutions, thus boosting the exploitation capabilities of the algorithm. Simultaneously, the generation-based control from GSQABC enhances the exploration phase. This enables broader exploration of the solution space through surrogate-guided fitness evaluations, reducing the risk of premature convergence and enabling more efficient navigation of the search space. During the critical early stages, exact fitness evaluations are employed to train the surrogate model effectively, ensuring accuracy in the subsequent exploration phase.

The following steps outline the execution of the CSQABC algorithm, from initialization to the generation of optimized solutions. We focus on how it effectively balances exploration and exploitation within the search space, as detailed below.

• Initialization. Generate an initial population of solutions using the INEH, the modified INEH, and random generation. This diverse initialization ensures a broad exploration of the solution space from the start.
• Controlled Generations
  • Employed Bee Phase. In the early generation, the population is divided into two swarms. The first swarm focuses on the top $P1\%$ of the best individuals, applying the Q-learning algorithm with exact fitness evaluations. These evaluations guide the generation of new offspring and update the Q-table, which informs the selection of search operators to ensure effective optimization. The second swarm consists of the remaining individuals and relies on the surrogate Kriging model for fitness evaluations. These individuals use the Q-table learned from the exact evaluations of the first swarm to produce new offspring, but their fitness is approximated using the surrogate model. This partitioning helps balance the precise exploration of promising solutions with computational efficiency, mitigating the risk of converging on false optima.
  • Onlooker Bee Phase. In this phase, the ILS algorithm (Algorithm 2) is applied to refine a subset of solutions from the first swarm and the best-updated individual from the second swarm. This improves solution quality by focusing on regions of the search space where promising solutions have been found.
  • Scout Bee Phase. The scout bee phase ensures population diversity by replacing individuals not improved after a number limit of trials with randomly generated ones, keeping the algorithm from stagnating.
  At the end of these controlled generations, the surrogate model is trained using the precisely evaluated individuals from this phase, enhancing its accuracy for future generations.
• Uncontrolled Generations
  After the initial control phase, the surrogate model is employed extensively to approximate the fitness of new individuals across the employed, onlooker, and scout bee phases. Moreover, at the end of each generation, a greedy selection process is applied to maintain solution quality. This process uses exact fitness evaluations for the best-found solutions, refining and updating them to maintain the accuracy of the optimization results.

Figure 6 illustrates the flowchart of the CSQABC algorithm.

4.6. Study of Algorithmic Complexity

The computational complexity of metaheuristic algorithms is a critical aspect of their design and analysis, as it directly impacts their scalability and applicability to large-scale optimization problems. In this section, the complexity of the proposed algorithms is analyzed in terms of their major components: initialization, fitness evaluation, surrogate model training, and search operator application. The following assumptions are made:

• n: Number of jobs.
• m: Number of machines.
• P: Population size.
• T: Total number of iterations.
• $T_c$: Number of controlled generations (where the exact fitness evaluation is used).
• $T_u$: Number of uncontrolled generations (where the surrogate model is used for fitness estimation).
• k: Number of training samples for the Kriging model.
• E: Total number of exact fitness evaluations.
• S: Number of states in the Q-learning table.
• A: Number of actions in the Q-learning table.

Assessing SABC Algorithmic Complexity

• Initialization:
  • The INEH and modified INEH algorithms have a complexity of $O(n^3\times m)$ [58].
  • The random generation has a complexity of $O(n\times m)$.
  • Exact fitness evaluation (makespan calculation) has a complexity of $O(n\times m)$ [59].
  • The total complexity is  $O(P\times n^3\times m)$.
• Surrogate-assisted Employed Bee Phase:
  • Generating offspring using search operators: $O(T\times P\times n\times m)$.
  • Exact fitness evaluations (during controlled generations): $O(T_c\times P\times n\times m)$.
  • Fitness estimation using the Kriging model costs $O\left(k^2\right)$ [60] during the uncontrolled generations: $O(T_u\times P\times k^2)$.
  • Greedy selection applied on B solutions during the uncontrolled generations: $O(T_u\times B\times n\times m)$.
  • Total complexity: $O(T\times P\times n\times m)+O(T_u\times P\times k^2)$.
• Onlooker Bee Phase:
  • The Roulette wheel selection costs $O\left(P\right)$ [61]; total complexity is then $O(T\times P)$.
  • Applying Iterated Local Search (ILS): ILS has a complexity of $O(n^2\times m)$ per solution [57].
  • Total complexity:  $O(T\times P\times n^2\times m)$
• Scout Bee Phase:
  • Replacing abandoned solutions: $O(T\times P\times n\times m)$.
  • Total complexity: $O(T\times P\times n\times m)$.
• Surrogate model training:
  • Training the Kriging model has a complexity of $O\left(k^3\right)$ [60]; then, the total complexity is $O(T_c\times k^3)$.

Overall time complexity of the SABC is  $O(P\times n^3\times m)+O(T\times P\times n^2\times m)+O(T_u\times P\times k^2)+O(T_c\times k^3)$

Assessing ISQABC Algorithmic Complexity

• Initialization:
  • Same as SABC: $O(P\times n^3\times m)$.
• Employed Bee Phase:
  • The first swarm($P1\%·P$): Q_table selecting and updates ($O(S\times A)$), generating offspring ($O(n\times m)$), exact fitness evaluation ($O(n\times m)$). The total complexity is then $O(T\times P1\%.·P\times (n\times m+S\times A\left)\right)$.
  • The second swarm: Q_table selecting ($O\left(A\right)$), generating offspring ($O(n\times m)$), fitness estimation by Kriging ($O\left(k^2\right)$). The total complexity is then $O(T\times (1-P1\%)·P\times (n\times m+A+k^2))$.
  • Total complexity: $O(T\times P\times (n\times m+P1\%\times S\times A+(1-P1\%)\times (A+k^2)))$.
• Onlooker Bee Phase:
  • Same as SABC: $O(T\times P\times n^2\times m)$.
• Scout Bee Phase:
  • Same as SABC: $O(T\times P\times n\times m)$.
• Surrogate Model Training:
  • Same as SABC: $O(T\times k^3)$.

Overall Time Complexity of ISQABC is   $O(T\times P\times (n^2\times m+P1\%\times S\times A+(1-P1\%)\times (A+k^2))+T\times k^3)$

Assessing GSQABC Algorithmic Complexity

• Initialization: same as SABC: $O(P\times n^3\times m)$.
• Controlled generations: $O(T_c\times P\times (n\times m+S\times A))$.
• Surrogate model training: $O\left(k^3\right)$.
• Uncontrolled generations: $O(T_u\times P\times (n\times m+A+k^2))$,

Overall Time Complexity of GSQABC: $O(T_c\times P\times (n\times m+S\times A)+T_u\times P\times (n\times m+A+k^2)+k^3)$.

Assessing CSQABC Algorithmic Complexity

• Initialization: same as SABC: $O(P\times n^3\times m)$.
• Controlled generations: $O(T_c\times P\times (n^2\times m+P1\%\times S\times A+(1-P1\%)\times (A+k^2))+T_c\times k^3)$.
• Surrogate model training: $O\left(k^3\right)$.
• Uncontrolled generations:  $O(T_u\times P\times (n\times m+A+k^2))$

Overall Time Complexity of CSQABC is $O(T_c\times P\times (n^2\times m+P1\%\times S\times A+(1-P1\%)\times (A+k^2))+T_c\times k^3+T_u\times P\times (n\times m+A+k^2))$.

While the theoretical time complexity of each proposed algorithm has been detailed individually, a comparative interpretation is necessary to better highlight their computational demands.

• The SABC algorithm has a complexity of $O(P\times n^3\times m)+O(T\times P\times n^2\times m)+O(T_u\times P\times k^2)+O(T_c\times k^3)$, where the computational overhead mainly stems from Kriging retraining and surrogate-assisted offspring evaluation during the employed bee phase.
• The ISQABC algorithm involves more computational effort due to a larger population and the selective use of exact evaluations based on Q-learning feedback. Its complexity is $O(T\times P\times (n^2\times m+P1\%\times S\times A+(1-P1\%)\times (A+k^2))+T\times k^3)$. The key contributor to its higher cost is the combination of online surrogate usage and controlled evaluation on selected individuals across the full iteration range.
• The GSQABC algorithm, while emphasizing exploration, limits exact evaluations to a subset of generations $T_c$. Its complexity is $O(T_c\times P\times (n\times m+S\times A)+T_u\times P\times (n\times m+A+k^2)+k^3)$. This structure significantly reduces the number of expensive exact evaluations compared to ISQABC.
• The CSQABC algorithm combines both individual- and generation-based evolution control. It inherits the overhead of both strategies, leading to the highest overall complexity: $O(T_c\times P\times (n^2\times m+P1\%\times S\times A+(1-P1\%)\times (A+k^2))+T_c\times k^3+T_u\times P\times (n\times m+A+k^2))$. The primary computational overhead in CSQABC arises from maintaining two control mechanisms (on both individual and generation levels) and frequent Kriging retraining, especially during the controlled phase.

In summary, although CSQABC offers a balanced exploration–exploitation strategy, it is also the most computationally expensive due to its hybrid evolution control and dual training cycles. This explains the observed increase in CPU time compared to other variants.

5. Computational Results and Discussion

In this section, we conduct a thorough experimental analysis to evaluate the performance of the proposed surrogate-modeling-based optimization approaches. All algorithms and tests were developed using Python 3.9.5 and executed on a personal computer running Windows 10 Enterprise operating system, an Intel i5 CPU running at 2.10 GHz and 8 GB of RAM.

Below, we present the key components of our experiment, datasets, metrics, and algorithm parameters, which form the foundation of our research methodology. We compare our surrogate-modeling-based optimization approaches to IQABC [31], a competitive baseline previously shown to outperform both ABC [31] and the Variable Neighborhood Search (VNS) algorithm [62] under consistent conditions adapted to PFSP with learning, maintenance, and deterioration effects.

5.1. Datasets and Evaluation Metrics

We conducted experiments using 11 test beds from the Taillard benchmark, covering a range of PFSP problem sizes, with $n\in \{20,50,100,200\}$ and $m\in \{5,10,20\}$. Each test bed consists of 10 instances to ensure robust evaluation. To this test bed, which contains only production data (job processing times), we incorporated maintenance and learning/deterioration effects.

For the maintenance data, job degradation values—crucial for scheduling maintenance—were generated based on job processing times. Two maintenance scenarios were considered to simulate different levels of maintenance complexity:

• Mode 1: Frequent maintenance operations with medium durations, generated from a uniform distribution $\mathcal{U}[50,100]$.
• Mode 2: Complex maintenance operations with longer durations, generated from a uniform distribution $\mathcal{U}[100,150]$.

Additionally, for learning and deteriorating effects, random indices (rates) were generated from a uniform distribution $\mathcal{U}[0,1]$ to simulate variable learning and deterioration over time.

The performance of the surrogate-modeling-based approaches was assessed based on three key metrics:

• Solution Quality: Each instance was executed five times per solution approach, and the average makespan value was retained. The Average Relative Percentage Deviation (RPD) was then calculated for the best-known solution for the Taillard instance without maintenance, learning, or deteriorating effects (Equation (5)).

  $$RPD={\displaystyle \frac{1}{R}}\times {\Sigma }_{i=1}^R{\displaystyle \frac{C_{max}^{So{l}_i}-C_{max}^{best}}{C_{max}^{best}}}\times 100.$$

  (5)

  where $C_{max}^{best}$ is Taillard’s best-known solution, $C_{max}^{So{l}_i}$ is the returned value, and R is the number of similar scaled instances running.
• Computational efficiency: To evaluate the computational efficiency of the proposed algorithms, we employ the following two complementary metrics:

  −

  CPU Time: This metric captures the actual time (in seconds) consumed by each algorithm during its execution. It accounts for both the metaheuristic search and the overhead introduced by surrogate model training and prediction.

  −

  gain_FE: This metric estimates the percentage reduction in the number of exact fitness evaluations (FEs) required by surrogate-assisted algorithms compared to the baseline IQABC. It is defined as

  $$gain\_FEs=1-{\displaystyle \frac{\mathrm{Controlled}\mathrm{individuals}\times \mathrm{Controlled}\mathrm{generations}}{\mathrm{Total}\mathrm{Exact}\mathrm{Fitness}\mathrm{evaluations}\mathrm{in}\mathrm{IQABC}}}.$$

  (6)

  This is a conservative estimate, considering only the fixed evaluations in the employed bee phase. Additional exact evaluations (e.g., during onlooker or scout phases) are not included, as they are non-deterministic and depend on the dynamic behavior of the algorithm. Nonetheless, gain_FE provides a lower-bound indicator of evaluation efficiency.
• Convergence Abilities: The convergence speed and behavior of each algorithm were analyzed to assess how quickly each method approaches optimal or near-optimal solutions.

5.2. Parameters Setting

The choice of parameters for the four proposed algorithms—SABC, ISQABC, GSQABC, and CSQABC—was made to balance exploration and exploitation while ensuring a fair comparison in terms of the number of exact function evaluations. Below, we detail and justify the parameter settings for each algorithm:

• The parameters for the SABC algorithm were chosen to mirror those of the IQABC algorithm, which has proven to be effective in addressing the PFSP. Specifically, we retained a population size of 70, a maximum of 200 iterations, an onlooker bee percentage of $40\%$, and a scout limit threshold of 5. These parameters ensure that the SABC algorithm retains a similar balance between exploration and exploitation, allowing a direct comparison between SABC and IQABC while incorporating surrogate-assisted evaluations to reduce the number of exact fitness evaluations.
• In the ISQABC algorithm, the population size, representing the number of employed bees, was increased to 120. This larger population is designed to enhance the exploitation capabilities during the employed bee phase by providing more potential solutions for refinement. However, we kept the number of controlled individuals, i.e., the number of employed bees performing exact evaluations, at 70 identical to the IQABC algorithm. This decision ensures that the total number of exact fitness evaluations remains comparable across algorithms. The remaining parameters, maximum iterations set at 200, onlooker bee percentage set at $40\%$, and scout limit threshold set at 5, were retained from the IQABC algorithm, allowing us to isolate the impact of increased exploitation through a larger population.
• To enhance the exploration capabilities of the algorithm, the number of generations (iterations) was increased to 270. We contend that a longer runtime enables the GSQABC algorithm to explore a larger portion of the search space, potentially improving convergence for complex problem instances. However, we maintained the number of controlled generations at 200, consistent with the IQABC algorithm, to ensure the comparability of the number of exact fitness evaluations. The remaining parameters, population size set at 70, onlooker bee percentage at $40\%$, and scout limit threshold at 5, were also kept identical to those of the IQABC algorithm to ensure that the effect of extended exploration was the primary distinguishing factor.
• For the CSQABC algorithm, we adopted a hybrid strategy by combining elements from the ISQABC and GSQABC algorithms. The population size was set to 120, of which 70 are controlled individuals performing exact evaluations. Similarly, the maximum number of iterations was set to 270, with 200 controlled iterations, allowing the CSQABC algorithm to balance exploration (through increased iterations) and exploitation (through a larger population), while maintaining a comparable number of exact evaluations as the IQABC algorithm. The onlooker bee percentage ($40\%$) and scout limit threshold (5) were retained to ensure that all algorithms share a consistent foundation for the bee colony behavior.

To ensure transparency and facilitate reproducibility,

Table 1. Summary of key configuration parameters for all algorithms.

Parameter	SABC	ISQABC	GSQABC	CSQABC
Pop_Size	70	120	70	120
Max_iteration	200	200	270	270
Onlook%	40%	40%	40%	40%
limit	5	5	5	5
Controlled individuals	–	70	–	70
Controlled iterations	–	–	200	200

summarizes the key configuration parameters used for each of the four algorithms.

It is important to note that these surrogate-assisted algorithms may trigger additional exact evaluations beyond those counted in standard algorithmic iterations. These are selectively used when the surrogate model predicts an improved solution, either to replace a current one or to update the best-found solution within an iteration. Such validations are essential to prevent false optima and maintain the integrity of the search. These additional evaluations do not aim to enhance the search but rather aim to ensure correctness and prevent the premature rejection of promising solutions due to surrogate approximation errors. This behavior reflects a common and necessary trade-off in surrogate-assisted optimization, where maintaining reliability sometimes requires limited, targeted exact evaluations in addition to those driving the search dynamics.

In the following section, we evaluate the performance of the proposed algorithms in comparison to the baseline IQABC algorithm. The results are based on 1100 independent runs across a comprehensive benchmark. Detailed insights are provided through multiple metrics, including the frequency with which each algorithm achieves the best solutions, along with statistical validation. The performance assessment is organized into two parts:

• Ablation Analysis, assessing the individual and combined effects of exploitation and exploration.
• Overall Comparison, evaluating algorithms across various problem scales and metrics, including solution quality, computational efficiency, and convergence behavior.

5.3. SABC, ISQABC, GSQABC, and CSQABC Ablation Analysis

The ablation analysis evaluates the individual contributions of the surrogate-assisted components in the proposed algorithms. The goal of this analysis is to isolate the effects of exploitation, exploration, and their combination, providing insights into the strengths and limitations of each approach.

5.3.1. SABC Algorithm

The SABC algorithm serves as a bridge between the basic ABC [32] and the more advanced IQABC [35]. It replaces the random operator selection of the ABC algorithm with a surrogate-based systematic operator selection mechanism, which improves the efficiency and effectiveness of the search process. The results from

Table 2. RPD values of small problem scales for the M1 and M2 maintenance modes.

	M1					M2
Instance	IQABC	SABC	ISQABC	GSQABC	CSQABC	IQABC	SABC	ISQABC	GSQABC	CSQABC
20x5_1	12.83	9.58	7.54	9.24	9.62	9.49	14.42	14.12	13.36	10.98
20x5_2	8.54	9.25	9.92	12.39	8.46	12.94	11.73	11.96	13.69	11.25
20x5_3	11.99	8.38	12.42	8.72	7.34	5.94	12.16	8.27	8.85	6.68
20x5_4	13.86	13.86	13.74	16.4	7.66	6.34	11.81	9.08	7.52	13.55
20x5_5	8.98	7.5	9.15	9.68	10.65	6.02	5.24	9.17	6.62	8.25
20x5_6	8.92	13.19	9	9.59	9.89	7.41	6.91	10.59	11.87	7.89
20x5_7	10.02	9.94	4.79	10.22	7.46	11.95	9.62	9.35	9.63	11.26
20x5_8	6.16	11.53	11.02	7.49	8.87	5.44	10.88	10.71	9.13	10.17
20x5_9	9.25	12.41	12.02	12.41	12.77	14.53	13	11.88	11.45	13.36
20x5_10	5.81	8.14	6.88	8.37	7.6	12.31	9.37	10.53	11.15	11.26
Average	9.63	10.37	9.64	10.45	9.03	9.23	10.51	10.56	10.32	10.46
W	4	1	2	0	3	4	3	1	1	1
20x10_1	17.06	17.55	19.52	19.7	18.27	18.93	19.75	21.5	20.26	19.27
20x10_2	30.05	27.68	30.19	31.36	30.98	26.21	28.64	24.71	28.06	26.78
20x10_3	20.48	19.85	19.99	21.31	18.96	22.62	21.68	18.41	20.17	22.36
20x10_4	14.87	16.19	16.34	16.07	15.45	15.8	18.03	16.39	22.09	17.57
20x10_5	20.23	16.11	20.11	14.25	15.85	14.53	14.25	13.03	17.97	16.05
20x10_6	19.09	19.3	20.32	22.69	17.49	15.26	15.22	16.98	15.91	13.37
20x10_7	16	18.05	18.16	18.28	13.89	18.46	18.44	20.28	18.82	17.02
20x10_8	15.75	16.48	13.19	18.5	11.75	16.4	18.56	21.34	19.08	18.01
20x10_9	23.66	25.84	23.89	27.47	24.77	27.01	25.05	26.13	26.39	25.15
20x10_10	15.9	17.99	16.71	18.6	12.15	15.33	16.25	14.37	12.86	10.9
Average	19.30	19.50	19.84	20.82	17.95	19.05	19.58	19.31	20.16	18.64
W	3	1	0	1	5	3	1	3	0	3
20x20_1	31.89	32.38	31.23	35.75	32.72	32.81	35.75	32.87	35.28	31.46
20x20_2	25.45	28.13	27.85	23.88	24.77	24.68	27.98	25.76	26.33	26.8
20x20_3	33.98	32.48	31.83	33.02	32.74	32.17	31.97	31.18	31.47	32.64
20x20_4	34.56	35.65	35.87	36.87	34.26	35.29	36.75	35.65	35.61	35.6
20x20_5	36.85	35.09	37.02	33.55	36.55	36.34	33.38	36.71	37.26	35.93
20x20_6	30.59	31.27	29.57	30.77	30.11	34.95	37.88	35.12	35.27	32.75
20x20_7	27.52	30.83	30.35	26.33	27.64	31.71	33.47	32.63	33.95	32.16
20x20_8	29.04	31.41	27.76	31.69	27.47	31.56	31.48	31.86	34.65	31.23
20x20_9	28.39	27.72	26.98	29.27	27.73	29.42	33.29	28.91	31.03	31.69
20x20_10	29.89	30.21	29.64	29.56	29.64	32.11	34.44	30.18	32.36	32.7
Average	30.82	31.51	30.81	31.06	30.36	32.10	33.63	32.08	33.32	32.29
W	0	0	4	4	2	3	1	3	0	3

,

Table 3. RPD values of medium problem scales for the M1 and M2 maintenance modes.

	M1					M2
Instance	IQABC	SABC	ISQABC	GSQABC	CSQABC	IQABC	SABC	ISQABC	GSQABC	CSQABC
50x5_1	5.6	9.5	6.25	8.88	12.23	9.39	8.27	6.3	8.49	10.17
50x5_2	5.26	6.55	8.58	10.44	8.96	7.75	9.46	5.72	6.28	6.88
50x5_3	13.45	11.72	11.95	13.43	14.69	8.05	4.63	7.79	5.29	8.22
50x5_4	10.03	12.21	8.89	10.33	8.3	11.3	12.26	10.35	5.51	11.46
50x5_5	7.08	9.68	7.55	10.9	9.12	7.42	5.47	6.18	6.87	5.88
50x5_6	3.12	8.51	8.5	10	9.72	7	-1.3	1.91	6.12	3.14
50x5_7	10.74	8.57	11.55	10.98	7.39	9.5	11.3	7.55	9.51	8.17
50x5_8	4.21	7.75	8.07	9.58	9.51	12.24	15.22	9	7.67	8.17
50x5_9	9.63	7.44	10.52	8.3	9.15	8.49	7.15	12.42	7.6	11.93
50x5_10	10.45	6.72	11.57	8.88	10.82	4.73	4.4	10.47	4.57	4.94
Average	7.95	8.86	9.34	10.17	9.98	8.58	7.68	7.76	6.79	7.89
W	5	3	0	0	2	0	5	3	2	0
50x10_1	13.15	17.98	18.24	20.43	13.97	12.74	12.69	11.18	10.91	13.27
50x10_2	12.94	8.71	13.22	13.03	10.42	12.98	14.17	12.78	13.93	12.64
50x10_3	15.85	16.63	15.7	16.69	16.12	15	14.35	14.4	13.78	8.46
50x10_4	13.38	10.69	12.47	11.5	13.19	17.31	16.5	16.75	13.6	16.81
50x10_5	11.09	12.06	12.85	11.98	11.73	16.41	13.94	13.73	11.85	11.99
50x10_6	13.21	12.99	13.18	13.2	13.01	15.22	19.97	11.08	19.19	16.22
50x10_7	15.83	13.8	12.05	9.44	11.83	10.61	16.85	18.06	16.07	14.54
50x10_8	16.13	15.07	12.86	13.42	14.4	11.61	12.13	9.04	8.57	10.17
50x10_9	15.35	14.57	12.31	16.1	12.81	10.96	10.54	10.48	12.86	9.18
50x10_10	13.98	15.11	18.51	16.51	16.77	15.67	14.93	14.24	12.55	10.14
Average	14.09	13.76	14.13	14.23	13.42	13.851	14.607	13.17	13.33	12.34
W	3	3	3	1	0	1	0	1	4	4
50x20_1	22.74	22.99	20.68	22.54	21.13	19.85	19.29	21.39	21.32	19.96
50x20_2	21.22	23.37	21.2	24.21	21.74	25.33	27.49	26.62	27.16	25.64
50x20_3	24.58	23.5	23.7	19.22	21.39	21.86	17.9	19.54	20.79	18.71
50x20_4	25.88	27.59	25.86	25.49	21.73	25.7	26.91	24.56	25.86	27.42
50x20_5	22.65	22.87	21.01	22.35	23.65	28.65	29.73	28.93	26.37	28.19
50x20_6	23.21	22.54	23.57	23.52	21.39	23.42	22.9	20.94	20.7	20.07
50x20_7	19.97	18.06	20.57	17.03	19.12	20.49	19.39	19.36	21.18	20.54
50x20_8	21.71	20.73	23.71	22.3	21.63	19.66	23.24	20.92	21.15	22.26
50x20_9	25.07	28.18	26.35	26	23.93	26.21	26.43	25.83	25.75	24.88
50x20_10	23.84	21.48	24.16	24.4	23.39	20.49	19.11	19.82	17.72	18.2
Average	23.09	23.13	23.08	22.70	21.91	23.16	23.23	22.79	22.8	22.58
W	0	2	3	2	3	2	2	2	2	2

and

Table 4. RPD values of large problem scales for the M1 and M2 maintenance modes.

	M1					M2
Instance	IQABC	SABC	ISQABC	GSQABC	CSQABC	IQABC	SABC	ISQABC	GSQABC	CSQABC
100x5_1	6.41	13.59	7.77	8.15	10.09	0.93	5.6	8.34	6.09	11.63
100x5_2	10.38	7.85	7.02	13.97	8.2	7.16	2.41	7.13	8.83	8.34
100x5_3	10.68	5.49	8.39	9.55	9.91	6.55	7.62	7.77	10.09	4.68
100x5_4	11.96	3.16	1.92	6.01	6.41	6.42	4.5	10.44	1.49	9.49
100x5_5	9.1	13.26	4.68	2.23	8.32	4.97	4.09	7.39	10.81	5.67
100x5_6	4.35	8.39	5.94	9.49	12.06	6.64	5.18	9.15	4.47	7.35
100x5_7	10.63	5.71	9.09	8.58	3	−1.27	4.59	7.81	10.62	8.17
100x5_8	−0.49	2.68	7.8	6.78	10.17	7.68	8	4	4.76	2.95
100x5_9	4.96	10.2	0.32	11.08	5.28	8.85	10.66	8.99	5.1	9.84
100x5_10	10.51	4.42	10.75	7.45	6.72	8.3	6.84	7.2	3.42	4.18
Average	7.84	7.47	6.36	8.32	8.01	5.62	5.94	7.82	6.56	7.23
W	3	2	3	1	1	2	2	0	4	2
100x10_1	10.7	6.62	10.15	8.74	9.08	4.92	7.77	8.52	6.46	7.99
100x10_2	4.92	6.37	3.71	4.26	6.07	8.78	6.01	10.98	6.79	9.23
100x10_3	7.35	7.02	7.57	9.18	9.48	11.98	11.03	7.48	8.32	10.29
100x10_4	7.4	10.49	6.7	11.41	10.52	10.66	6.27	4.75	11.24	7.53
100x10_5	12.9	9.72	14.08	11.85	15.42	8.96	7.49	10.95	8.91	7.95
100x10_6	11.96	11.93	7.69	14.35	12.48	12.7	12.84	9.96	8.44	14.88
100x10_7	12.56	9.65	13.02	14.74	12.25	7.38	7.11	8.62	9.44	8.9
100x10_8	12.8	14.5	10.22	11.17	12.39	6.85	12.81	13.02	10.55	7.28
100x10_9	10.99	10.36	11.15	9.52	10.56	10.59	14.85	10.37	9.82	10.61
100x10_10	12.53	9.36	8.99	11.58	10.59	5.9	9.37	6.51	6.91	8.54
Average	10.41	9.60	9.32	10.68	10.88	8.87	9.55	9.11	8.68	9.32
W	0	4	5	1	0	3	3	2	2	0
100x20_1	19.75	24.03	19.41	19.5	19.35	20.92	21.74	17.29	20.33	19.52
100x20_2	11.28	12.69	11.49	15.74	11.92	11.95	11.4	12.35	11.17	9.53
100x20_3	14.46	14.83	12.8	14.65	14.23	11.93	14.86	15.01	14.91	14.9
100x20_4	17.26	16.85	15.82	15.98	15.47	15.82	17.28	13.36	16.6	18.66
100x20_5	12.86	15.06	15.36	14.22	15.13	10.91	13.03	9.12	9.52	13.72
100x20_6	21.64	21.34	20.18	17.65	20.12	15.81	15.74	17.33	17.3	17.28
100x20_7	18.89	17.92	17.47	19.84	18.36	12.95	12.43	10.5	14.64	12.01
100x20_8	17.71	19.5	18.07	21.34	18.8	18.85	19.93	19.45	19.77	18.49
100x20_9	19.61	18.89	20.99	22.94	21.7	16.92	14.85	15.88	17.58	18.16
100x20_10	20.82	21.49	18.37	20.08	19.35	19.44	20.11	18.96	20.59	21.65
Average	17.42	18.26	16.99	18.19	17.44	15.55	16.13	14.92	16.24	16.39
W	3	1	3	1	2	1	2	5	0	2
200x10_1	11.09	8.1	6.8	6.97	8.02	8.98	7.25	3.36	4.64	7.55
200x10_2	9.87	4.28	8.51	11.47	7.49	6.33	6.34	12.21	4.74	7.62
200x10_3	11.57	10.98	13.55	12.63	6.12	5.66	9.61	5.82	8.3	7.05
200x10_4	9.88	5.34	10.81	10.4	9.72	7.19	12.07	8.39	4.95	3.34
200x10_5	7.55	6.14	5.42	11.06	4.9	7.51	4.14	7.51	12	9.11
200x10_6	6.21	10.62	8.78	9.92	6.78	7.86	4.73	6.66	2.58	12.46
200x10_7	11.83	9.09	9.46	8.04	14.45	5.26	4.48	6.28	3.26	7.76
200x10_8	7.18	9.52	6.28	10.11	11.97	8.72	9.02	12.04	10.45	9.42
200x10_9	8.95	7.69	5.12	7.24	6.52	7.31	3.1	9.08	6.49	5.96
200x10_10	11.52	11.88	11.18	13	11.95	6.95	11.1	4.46	10.1	11.24
Average	9.56	8.36	8.59	10.08	8.79	7.17	7.18	7.58	6.75	8.15
W	1	2	4	1	2	2	2	2	3	1
200x20_1	12.22	12.45	15.09	11.7	12.55	10.73	12.61	9.98	13.77	10.23
200x20_2	15.55	8.36	13.8	12.23	15.6	12.48	15.14	13.89	10.8	13.28
200x20_3	14.32	14.36	12.85	13.68	14.93	13.55	11.84	11.02	10.84	11.83
200x20_4	13.98	17.47	15	15.66	15.94	15.39	12.79	14.17	9.56	11.28
200x20_5	13.27	13.41	10.87	13.09	10.26	10.42	12.88	9.82	12.68	9.51
200x20_6	9.24	12.94	10.17	11.16	10.72	10.69	10.01	12.45	11.07	9.59
200x20_7	11.66	11.87	11.52	11.22	13.15	9.49	11.94	11.99	11.15	11.73
200x20_8	9.91	10.21	12.2	11.91	12.21	12.64	11.99	10.61	13.5	9.85
200x20_9	12.94	12.8	11.16	14.07	12.74	12.27	14.35	11.12	10.89	11.76
200x20_10	16.15	16.15	15.01	16.5	16.46	13.16	14.11	14.37	14.97	11.84
Average	12.92	13.00	12.76	13.12	13.45	12.08	12.76	11.94	11.92	11.09
W	3	1	3	2	1	1	0	1	4	4

show that SABC achieves performance equivalent to IQABC, outperforming the basic ABC algorithm. This demonstrates the effectiveness of surrogate-assisted approaches in enhancing the performance of metaheuristic algorithms.

5.3.2. Exploitation-Focused Algorithm (ISQABC)

The ISQABC algorithm enhances the exploitation of IQABC by increasing the number of employed bees through a larger population size, thereby intensifying local refinement, leveraging surrogate-assisted fitness estimation during the employed bee phase. It performs well on large-scale problems (Table 4) due to its ability to refine high-quality solutions through focused exploitation, which is particularly effective in high-dimensional search spaces. However, on small-scale problems (Table 2), its strong exploitation tendency can lead to premature convergence and stagnation in local optima, reducing its performance. This is because small-scale problems often require a better balance between exploration and exploitation, which ISQABC’s heavy focus on exploitation may not adequately provide.

5.3.3. Exploration-Focused Algorithm (GSQABC)

The GSQABC algorithm enhances the exploratory capacity of IQABC by increasing the number of iterations; when combined with low-cost surrogate-assisted evaluations, this broadens the likelihood of identifying promising regions over time, even in the presence of partial stagnation. This approach performs well on specific large-scale instances (Table 4), particularly under maintenance mode 2, e.g., 100 × 5 (M2), 200 × 10 (M2), where its exploration capabilities prove beneficial. However, its performance suffers on small-scale problems (Table 2), as excessive exploration leads to inefficiency.

5.3.4. Combined Approach (CSQABC)

The CSQABC algorithm combines the strengths of ISQABC and GSQABC to balance exploitation and exploration. This hybrid approach achieves competitive performance across all problem scales, highlighting the versatility and robustness of CSQABC in a wide range of scenarios. This demonstrates the effectiveness of combining exploitation and exploration in surrogate-assisted optimization.

5.3.5. Summary

These findings highlight that while no single algorithm universally outperforms the others, their combined capabilities demonstrate a high degree of adaptability and efficiency. Each algorithm’s unique characteristics make it particularly suited to specific problem scenarios, proving the overall effectiveness of the proposed approaches in addressing the complexities of PFSPs under varying conditions. This equivalence further validates the utility of these algorithms as reliable solutions for scheduling problems with maintenance, learning, and deteriorating effects.

5.4. Comparative Assessment of SABC, ISQABC, GSQABC, and CSQABC

The overall comparison evaluates the algorithms across different problem scales (small, medium, and large) using solution quality (Table 2, Table 3 and Table 4), computational efficiency (

Table 5. Average CPU time of proposed algorithms by problem scale and maintenance mode.

	M1					M2
Instance	IQABC	SABC	ISQABC	GSQABC	CSQABC	IQABC	SABC	ISQABC	GSQABC	CSQABC
20x5	13.20	13.71	44.43	24.13	59.56	13.36	13.89	49.05	25.10	54.11
20x10	15.89	16.74	36.69	25.53	55.04	16.66	17.62	40.46	26.50	60.83
20x20	25.00	25.42	54.35	37.18	73.94	23.75	23.96	51.33	34.50	68.63
50x5	21.62	21.66	129.94	42.90	101.13	21.37	21.53	63.34	40.02	91.36
50x10	31.29	31.93	75.03	51.55	106.36	31.66	32.25	71.78	50.99	98.91
50x20	52.44	52.90	99.85	79.70	142.35	53.12	53.53	96.13	78.44	135.25
100x5	46.66	47.96	185.44	92.69	213.09	46.05	48.62	213.78	89.74	179.18
100x10	76.36	78.00	185.95	126.73	229.78	73.82	75.28	193.56	121.78	207.72
100x20	135.83	140.19	272.52	200.39	329.27	138.97	141.91	250.98	196.90	321.29
200x10	224.46	229.05	597.76	354.97	548.53	216.88	219.40	341.20	332.47	532.68
200x20	362.64	374.81	570.29	535.43	792.09	372.62	381.27	597.62	522.34	752.84

and

Table 6. Estimated gain in exact fitness evaluations (gain_FEs) for each algorithm.

Algorithm	Controlled Ind.	Controlled Gen.	Est. Exact FEs	gain_FEs (%)
IQABC	70	200	14,000	0
ISQABC	70	200	14,000	41.66
GSQABC	70	200	14,000	25.92
CSQABC	70	200	14,000	56.79

) and convergence behavior, analyzed through convergence curves (Figure 7).

5.4.1. Solution Quality Assessment

The RPD results, presented in Table 2, Table 3 and Table 4, reveal distinct performance trends across problem scales. For small-scale problems, CSQABC and ISQABC consistently outperform the other algorithms, demonstrating their ability to handle smaller problem scales effectively. In medium-scale problems, the performance of all algorithms converges, with minor differences in RPD values. For large-scale problems, the performance differences narrow further, with ISQABC and CSQABC occasionally excelling in specific instances. GSQABC shows weaker results than its counterparts, except in specific large-scale instances under maintenance mode 2.

5.4.2. Computational Efficiency Assessment

The CPU time results, presented in Table 5, reveal that the surrogate-assisted algorithms require more execution time than the baseline IQABC. This increase is mainly due to the overhead introduced by the surrogate model, particularly the online training and evaluation steps. However, the increase remains moderate, and the approaches remain practical even for large-scale instances.

To complement this analysis, we calculated the gain_FE metric as a conservative estimate of real fitness evaluation savings (Table 6). For example, in the GSQABC algorithm, 70 controlled individuals over 270 iterations yield 18,900 exact fitness evaluations, compared to the fixed 18,900 in IQABC. If GSQABC explored more iterations with fewer controlled ones (e.g., 200 controlled generations), the gain_FE could reach up to 25.9%, showing a clear reduction in costly evaluations while maintaining competitive performance. In the case of the SABC algorithm, which does not use explicitly defined controlled individuals or generations, estimating the number of exact fitness evaluations is more complex. During each iteration, each employed bee applies six search operators and generates candidate solutions, all evaluated via the surrogate model. A single exact fitness evaluation is performed only if the best surrogate-evaluated solution outperforms the current solution. Thus, at most one exact evaluation per bee per iteration is performed, but this number can be lower in practice. Given this stochastic behavior, we do not report a specific gain_FE value for SABC. However, the CPU time results show that SABC maintains computational efficiency comparable to IQABC, supporting the assumption that exact evaluations are effectively reduced through surrogate usage, even without explicit control mechanisms.

These results highlight that surrogate modeling enables the algorithm to explore deeper or broader search spaces (more individuals, more iterations) without proportionally increasing exact evaluations, demonstrating a good compromise between computational efficiency and solution quality. Nonetheless, we recognize that

• Extra exact evaluations are still needed (e.g., in greedy selection) to correct potential surrogate inaccuracy;
• Online model training may consume time, especially in early iterations or with complex landscapes.

Despite these challenges, the proposed surrogate-assisted algorithms show effective scalability and efficiency for solving complex PFSP instances, paving the way for future research on improving surrogate reliability and integration policies.

5.4.3. Convergence Behavior

The convergence curves, in Figure 7, illustrate how quickly each algorithm approaches optimal or near-optimal solutions. CSQABC consistently demonstrates superior convergence performance, with GSQABC following closely behind. This indicates that CSQABC effectively balances exploitation and exploration throughout the optimization process, while GSQABC benefits from its exploration-focused design. In contrast, IQABC, SABC, and ISQABC show slower convergence, reflecting their limitations in balancing exploration and exploitation. The superior performance of the CSQABC algorithm can be attributed to the combined individual- and generation-based control mechanisms, which dynamically adapt the search behavior. Specifically, the individual-based control enhances the algorithm’s exploitation capabilities by focusing on promising regions of the solution space, allowing the precise refinement of high-quality solutions. Meanwhile, the generation-based control mechanism promotes exploration by periodically diversifying the search, thus mitigating premature convergence to local optima.

5.4.4. Frequency of Best Solutions

The frequency (W) at which each algorithm identified the best solution provides additional insights into their comparative behavior. While ISQABC frequently obtains the best solutions across a range of instances, including both small-scale (20 × 20) and large-scale problems, e.g., 100 × 20, 200 × 10 (M1), 200 × 20 (M1), other algorithms also excel in specific scenarios. For example, CSQABC performs well in both small- and large-scale problems, including 20 × 10, 50 × 20, and 200 × 20 (M2). GSQABC shows strength in large-scale problems involving complex maintenance conditions, e.g., 100 × 5 (M2), 200 × 10 (M2), while SABC achieves strong results on medium-scale problems (50 × 5). This variation reflects the specialized strengths of each strategy, aligning with their respective focus on exploitation, exploration, or balance. The overall performance parity among the algorithms, confirmed by statistical tests, underscores the complexity of designing a universally superior surrogate-assisted approach for PFSP and highlights the necessity of tailoring algorithmic strategies to instance characteristics.

These findings highlight the efficiency of surrogate-assisted approaches, as they enable broader exploration of the search space within a fixed computational budget, thereby increasing the likelihood of discovering high-quality solutions. This demonstrates the potential of SM-based algorithms to enhance optimization performance across various problem domains.

5.4.5. Statistical Validation

To confirm the significance of the observed differences, we performed a Friedman test at the 5% significance level over the 220 problem instances. The test confirmed significant differences among the five algorithms (see

Table 7. Friedman’s two-way analysis of variance summary.

Total N	220
Chi-square	10,306
Degree Of Freedom	4
p-value	0.036

) with the reported average ranks in

Table 8. Algorithms’ mean ranks in Friedman’s test.

Algorithm	Rank
IQABC	2.92
SABC	3.11
ISQABC	2.84
GSQABC	3.25
CSQABC	2.88

.

Following the Friedman test, we applied the Nemenyi post hoc test to calculate the Critical Difference (CD). For $k=5$ algorithms and $N=220$ problem instances, the CD at $\alpha =0.05$ is approximately 0.412. Since no pair of algorithms exhibits a rank difference greater than the CD, no statistically significant difference was found using this criterion.

In addition, we conducted Wilcoxon signed-rank tests for all 10 pairwise comparisons and applied the Holm–Bonferroni correction (

Table 9. Pairwise comparisons using Wilcoxon test.

Comparison	p_Value	Adjusted $\mathit{\alpha }$	Significant (Y/N)
IQABC vs. SABC	0.115	0.01	N
IQABC vs. ISQABC	0.567	0.0166	N
IQABC vs. GSQABC	0.041	0.00625	N
IQABC vs. CSQABC	0.585	0.025	N
SABC vs. ISQABC	0.085	0.00833	N
SABC vs. GSQABC	0.559	0.0125	N
SABC vs. CSQABC	0.067	0.00714	N
ISQABC vs. GSQABC	0.021	0.0055	N
ISQABC vs. CSQABC	0.900	0.05	N
GSQABC vs. CSQABC	0.013	0.005	N

). Although some unadjusted p-values were below 0.05 (e.g., GSQABC vs. CSQABC = 0.013), none remained significant after correction, reinforcing the conclusion that observed differences are not statistically significant under rigorous control.

These results confirm that while GSQABC often yields lower-quality solutions, no algorithm statistically outperforms the others across all test instances at the 5% level.

6. Conclusions and Future Research Directions

In this research paper, we investigate the effectiveness of surrogate-modeling-based optimization for solving the flowshop scheduling problem, a classical combinatorial problem that becomes increasingly challenging when incorporating real-world complexities such as maintenance, learning, and deteriorating effects. By combining the robust exploration and exploitation capabilities of the ABC algorithm with the predictive power of surrogate models, we aimed to significantly reduce the computational cost associated with evaluating a high number of exact fitness functions. To this end, we proposed four surrogate-assisted approaches, each tailored to address specific aspects of the optimization process as follows:

• The Surrogate-Assisted ABC (SABC) focused on enhancing the search operator selection mechanism, enabling a systematic application of the operator pool. Surrogate models were employed to efficiently evaluate the offspring, helping guide the search toward promising areas of the solution space.
• The Individual-based Surrogate-Assisted Q-learning ABC (ISQABC) prioritized local exploitation by refining solutions systematically within the employed bees’ neighborhood. This approach used individual-based evolution control, ensuring the surrogate model accurately captured the local fitness landscape for improved refinement.
• The Generation-based Surrogate-Assisted Q-learning ABC (GSQABC) shifted focus toward global exploration by leveraging generation-based evolution control. This approach used surrogate modeling to identify and probe promising regions of the search space, enhancing population-level diversity and exploration.
• The hybrid approach, Combined Surrogate-Assisted Q-learning ABC (CSQABC), effectively balanced the strengths of ISQABC and GSQABC, delivering a comprehensive search that harmonizes local exploitation with global exploration.

A critical challenge in surrogate-modeling-based optimization is ensuring the accuracy of the surrogate model to avoid convergence toward false optima. To address this, we adopted an incremental online learning strategy, where the surrogate model was continually updated with accurately evaluated solutions during the controlled evolution process. This dynamic learning approach enhanced the surrogate model’s reliability and supported consistent optimization performance.

While the proposed algorithms did not consistently outperform the baseline IQABC across all instances, the findings offer several important insights: First, we observed that no single strategy is universally superior; rather, performance varies depending on the instance scale and maintenance scenario, which highlights the importance of adaptive surrogate integration. Second, the study reveals that model accuracy is a crucial bottleneck. A better understanding of the factors influencing surrogate precision in combinatorial spaces is needed to unlock the full potential of this approach. Third, the false optima issue remains a major challenge. Future work should explore alternative mechanisms (e.g., confidence thresholds or ensemble surrogates) to reduce reliance on exact fitness evaluations for model correction. Fourth, training time for online surrogate updates, while sometimes offset by reduced evaluations, must be optimized to ensure that surrogate-assisted algorithms remain competitive in practice. Fifth, while this study focused primarily on performance indicators such as solution quality, convergence, and fitness evaluation cost, it did not include direct or indirect measurement of the exploration–exploitation dynamics (e.g., via population diversity or attraction basin analysis). Future work should incorporate such measures to better characterize how surrogate-assisted control mechanisms influence the search behavior over time. Finally, although this study adopted tailored control parameters to ensure balanced computational effort, future investigations could further enhance comparability and generalizability by adopting termination criteria based on equal CPU time or consumed fitness evaluations.

In conclusion, this study opens a new and promising research avenue by demonstrating the feasibility, complexity, and future potential of using surrogate models to solve challenging scheduling problems. Promising directions include investigating the integration of advanced machine learning techniques for improved surrogate modeling, exploring hybrid metaheuristic frameworks, and extending these approaches to other complex scheduling environments. The insights gained from this work can guide researchers and practitioners in selecting and tailoring surrogate-assisted methods for their specific optimization problems, ultimately driving advancements in this important field.