A Two-Machine Learning Date Flow-Shop Scheduling Problem with Heuristics and Population-Based GA to Minimize the Makespan

: This paper delves into the scheduling of the two-machine ﬂow-shop problem with step-learning, a scenario in which job processing times decrease if they commence after their learning dates. The objective is to optimize resource allocation and task sequencing to ensure efﬁcient time utilization and timely completion of all jobs, also known as the makespan. The identiﬁed problem is established as NP-hard due to its reduction to a single machine for a common learning date. To address this complexity, this paper introduces an initial integer programming model, followed by the development of a branch-and-bound algorithm augmented with two lemmas and a lower bound to attain an exact optimal solution. Additionally, this paper proposes four straightforward heuristics inspired by the Johnson rule, along with their enhanced counterparts. Furthermore, a population-based genetic algorithm is formulated to offer approximate solutions. The performance of all proposed methods is rigorously evaluated through numerical experimental studies.


Introduction
Learning rates are used in scheduling problems because they are a key parameter in training machine learning models, including those used in optimization problems such as scheduling.In scheduling problems, the goal is to assign tasks or activities to resources in a way that minimizes some objective function, such as the makespan (the length of time it takes to complete all tasks) or the total cost of using the resources.Machine learning algorithms can be used to optimize scheduling decisions by learning from historical data or by simulating different scheduling scenarios (Bottou [1]; Goodfellow et al. [2]; Pinedo [3]).
Learning rates are a critical parameter in the training process of machine learning algorithms because they control the rate at which the model adapts to new information.A high learning rate will cause the model to make large adjustments to the weights or parameters of the model based on each new data point, which can lead to overfitting and poor generalization performance.On the other hand, a low learning rate will cause the model to make very small adjustments based on each data point, which can lead to slow convergence and may cause the model to become stuck in local minima.Therefore, selecting an appropriate learning rate is critical for achieving good performance in scheduling problems and other optimization tasks.The learning rate must be tuned carefully to balance the competing objectives of fast convergence and good generalization, and different learning rate schedules may be used to adapt the learning rate over time as the optimization process progresses (Ruder [4]; Russell and Norvig [5]).
The integration of the learning concept into scheduling research was first introduced by Biskup [6] and Cheng and Wang [7], marking significant milestones in this area of study.Since then, there has been extensive research on scheduling problems that incorporate various types of learning effects (Kuo and Yang [8], Koulamas and Kyparisis [9], Wang [10], Yin et al. [11], Wu et al. [12][13][14], Wang and Wang [15], Niu et al. [16], Zhang et al. [17], etc.).To explore this topic further, readers may refer to the works of Biskup [18], Janiak et al. [19], and Azzouz et al. [20] for a comprehensive survey on incorporating learning effects into scheduling.These resources provide detailed insights into the progress made in this field and offer valuable information for those interested in understanding the impact of learning on scheduling processes.
In the realm of minimizing the makespan on a two-machine flow-shop with learning considerations, various researchers have made significant contributions.Wang and Xia [21] introduced flow-shop scheduling problems with position-based learning effects, aiming to minimize either the makespan or total flowtime.They proposed a heuristic algorithm with a worst-case bound, denoted as m, where m represents the number of machines.Additionally, they developed polynomial algorithms to address specific cases.Expanding on this line of study, Xu et al. [22] investigated flow-shop scheduling problems with position-based learning effects, focusing on minimizing three regular performance criteria: total weighted completion time, discounted total weighted completion time, and the sum of quadratic job completion times.They presented algorithms tailored to their proposed problems and analyzed the worst-case bounds of these algorithms.
Addressing the makespan two-machine problem with a truncated sum of processingtimes-based learning function, Wu et al. [23] devised both a branch-and-bound algorithm and a genetic heuristic-based algorithm.Shifting gears to flow-shop scheduling problems with exponential learning effects, Wang and Wang [24] sought to minimize four regular performance criteria: total completion time; total weighted completion time; discounted total weighted completion time; and the sum of quadratic job completion times.They developed heuristic algorithms utilizing optimal permutations derived from corresponding single-machine scheduling problems and discussed the worst-case bounds of each algorithm.In another study, Cheng et al. [25] proposed a branch-and-bound algorithm along with three crossover-based genetic algorithms to tackle a two-machine flow-shop scheduling problem with a truncated learning function.
Furthermore, Wang et al. [26] presented heuristic algorithms and analyzed their worst-case bounds for minimizing various criteria in flow-shop scheduling with truncated position-based learning effects.These criteria included total completion time, makespan, total weighted completion time, discounted total weighted completion time, the sum of quadratic job completion times, and maximum lateness.In a more recent work, Wang et al. [27] applied several heuristics and a branch-and-bound algorithm to address permutation flow-shop problems with a truncated exponential sum of logarithm processing times based and position-based learning effects.They focused on minimizing the makespan and total weighted completion time, respectively.
For some more recent and relevant instances of the two-machine flop-shop scheduling problem with different assumptions or constraints, researchers have proposed various approaches.Hsu et al. [28] addressed a robust version of the two-machine flow-shop scheduling problem, considering scenario-dependent processing times to minimize the total completion time.They introduced a branch-and-bound method, along with several heuristics and their corresponding counterparts.Additionally, they explored several variants of a cloud theory-based simulated annealing algorithm to tackle the problem.Taking into account time-of-use tariff assumptions, Ho et al. [29] developed three heuris-tics based on Johnson's rule and three heuristics based on Hadda's algorithm.Their aim was to jointly optimize the makespan and electricity cost in the context of a two-machine flow-shop scheduling problem under varying electricity pricing.Addressing the factor of resource recycling, Lo and Lin [30] delved into the relocation problem within a twomachine flow-shop scheduling scenario.They introduced a second machine dedicated to recycling resources returned by jobs completed on the first machine.To tackle this, they applied an integer programming model and employed ant colony optimization techniques.Furthermore, Chen et al. [31] proposed a dynamic programming approach and discussed the worst-case performance ratio for a two-machine flow-shop aiming to maximize the total early work subject to a common due date.To address convex resources to the model, Choi and Park [32] discussed and analyzed the approximation to minimize the sum of the makespan and the total resource consumption cost.The summary of these papers is recorded in Table 1.
Table 1.Some published recent flow-shop scheduling papers on a two-machine setting.

Model Parameters Objective Form Algorithm
Hsu et al. [28] Two-machine flow-shop with scenariodependent processing times A branch-and-bound; a cloud theory-based simulated annealing Ho et al. [29] Two-machine flow-shop under time-of-use tariffs Three heuristics based on Johnson's rule and three heuristics based on Hadda's algorithm Lo and Lin [30] Two-machine flow-shop with resource recycling operations An integer programming model; ant colony optimization Chen et al. [31] Two-machine flow-shop with a common due date

A fully polynomial time approximation scheme
Choi and Park [32] Two-machine flow-shop with convex resource Minimize the sum of the makespan and the total resource consumption cost Approximation method This paper Two-machine flow-shop with learning dates A branch-and-bound; heuristics; population-based GA These studies demonstrate the breadth of research efforts dedicated to understanding and optimizing flow-shop scheduling problems with learning considerations, emphasizing the development of heuristic algorithms, polynomial algorithms, branch-and-bound approaches, and worst-case bound analyses.Several contributions of this paper are provided as follow: 1.
We introduce the two-machine flow-shop scheduling problem with step-learning, where job processing times decrease if they start after their job-dependent learning dates; 2.
We establish that the proposed scheduling problem is NP-hard, which implies that finding an exact optimal solution is computationally challenging; 3.
We present an integer programming model as a method to address the scheduling problem, providing a theoretical framework for optimization.
We devise a branch-and-bound algorithm incorporating two lemmas and a lower bound to facilitate finding an exact optimal solution to the problem and propose four simple heuristics based on the ideas of Johnson's rule, offering practical, faster solutions.We also introduce improved versions of the heuristics, likely enhancing their performance.Additionally, we develop a genetic algorithm to provide approximate solutions to the scheduling problem, demonstrating a metaheuristic approach for tackling the complexity of the problem.
The remainder of this article is structured as follows: Section 2 introduces the necessary notations and presents the problem that is being investigated.In Section 3, an integer programming formulation is proposed for the model, accompanied by the derivation of two lemmas and a lower bound.These components are integral to the branch-andbound method employed for finding an optimal solution.Moving on to Section 4, we present four modified heuristics inspired by the Johnson rule, as well as a genetic algorithm (GA) designed to find approximate solutions.Section 5 focuses on the exploration of the proposed GA's parameters.To assess the effectiveness and efficiency of all the methods discussed, Section 6 presents a series of experimental tests.Finally, the last section offers conclusive remarks and provides insightful suggestions.

Notations and Problem Definition
First, several symbols to be used in this study are defined as follows: M ={M 1 , M 2 }: represents a collection of two machine codes; N = {J 1 , J 2 , . .., J n }: represents a collection of n labeled jobs; P 1j and P 2j : represent the actual processing time of job j on machine 1 and machine 2, respectively; LD 1j and LD 2j : represent the learning dates for job j on machine 1 and machine 2, respectively; u 1j and u 2j : represent the original processing times of job J j on machine 1 and machine 2 in σ; v 1j and v 2j : represent the processing time of job J j on machine one and machine two, respectively, under the learned schedule via σ for the jobs sorted by order; σ, σ : represent two full schedules of jobs; π 1 , π 2 : represent two partial subsequences of jobs; s 1 and s 2 : represent the starting times for a job on machine 1 and machine 2 in σ; C ki (σ) and C kj (σ): represent the completion times of job i and job j on machine k in schedule σ, k = 1, 2; C kj (σ ) and C ki (σ ): represent the completion times of job i and job j on machine k in schedule σ , k = 1, 2; [ ]: represents the position of the job in a certain schedule.
The problem under investigation pertains to the scheduling of two flowline machines, with n jobs waiting to be processed online without any preparation time.Once a job starts processing, it must be completed before the next job can be processed, with no interruptions allowed during the processing.The processing mode for each job is that it must be processed on machine 1 before it can be processed on machine 2. Let P 1j and P 2j denote the processing times of job j on machine 1 and machine 2, respectively.The study also considers the types of learning effects, including temporal dependencies and job-dependent learning effects, referred to as job-dependent learning schedules.Specifically, the original processing time for job j on machine 1 is denoted by u 1j , while v 1j represents the reduced processing time due to the learning date, such that the processing time required under the learning date (v 1j ) is less than or equal to the original processing time (u 1j ) or (v 1j ≤ u 1j ).Similarly, u 2j and v 2j represent the original processing time and processing time required under the learning effect for job j on machine 2, respectively, with v 2j ≤ u 2j .This study assumes that LD 1j and LD 2j are the learning dates for job j on machine 1 and machine 2, respectively.The definition of the actual processing time of job j on machine 1 and machine 2 can be given by synthesizing the above explanations as follows: where s 1 and s 2 represent the starting times of job j on machine 1 and machine 2. The objective function of this study is to find a schedule to minimize the makespan of n given jobs.The problem can be simplified as F2//v 1j ≤ u 1j , v 2j ≤ u 2j LD 1j ; LD 2j //C max .

Exact Solution Methods
In this section, we consider using mixed integer programming to mathematically model the proposed problem and utilize CPLEX software to obtain the optimal solution.The initial modeling approach is described as follows: For all possible ordering problems of n jobs, there are L = n! different arrangements.Considering n jobs, each of which is processed on two machines in a certain order, the same ordering is used for processing on both machines.
In Equation ( 1), f σ J represents the objective function, which is the completion time under the job sequencing plan J.The goal of this project is to find the job sequencing plan σ * that minimizes the objective function value among all possible plans, as well as the corresponding optimal objective function value f σ * .
In Equation (2), when the job numbered k undergoes processing at the ith position, the following variables are defined: X ik is a 0-1 variable used to indicate whether the job k is processed at the ith position.
Equation ( 3) ensures that only one task is chosen to be executed at each time instant.
Equation ( 4) ensures that each task is executed only at one time instant.p ik denotes the processing time of job k on machine 1.
q ik denotes the processing time of job k on machine 2.
A ik denotes the starting time of job k placed on ith position on machine 1.
denotes the starting time of job k placed on ith position on machine 2.
C ik denotes the completion time of job k to be processed on the ith position on machine 2.
X ik q ik t ik represents the waiting time required for the job k after completing processing in machine 1 and before starting processing in machine 2.
Y ik is a binary variable (0 or 1) used to determine whether the job k needs to wait when being processed in the ith sequence in machine 2.

Branch-and-Bound Method
In what follows, we will propose several dominances based on the characteristics of the completion time of the workpieces above to cooperate with the branch-and-bound method to find the optimal solution. For and assuming that J L is the last job in partial schedule π 1 , s 1 and s 2 are the starting times of job J L on machine 1 and machine2.Regarding this problem, from the above data examples, we preliminarily propose the following characteristics: To show that σ 1 dominates σ 2 , one suffices to show that Lemma 1.If the jobs J i and J j are present in both σ 1 and σ 2 , On the other hand, since s 1 + u 1j ≤ min LD 1i , LD 1j , it implies s 1 < LD 1j and s 1 + u 1j < LD 1j .Thus, one has From the given max s 1 + u 1j , s 2 + u 2i < min LD 2i , LD 2j , and u 2j < u 2i , one has From the given max s 1 + u 1j , s 2 + u 2i < min LD 2i , LD 2j , and u 2j < u 2i one has From the given u 1i ≤ u 1j and u 2j ≤ u 2i , comparing the two max terms of C 2j (σ 1 ) in Equation ( 5) with the two max terms of C 2i (σ 2 ) in Equation ( 6), one obtains C 2j (σ 1 ) ≤ C 2i (σ 2 ).
Lemma 2. If the jobs J i and J j are present in both σ 1 and σ Proof.To show that σ 1 dominates σ 2 , one suffices to show that C 1j (σ 1 ) ≤ C 1i (σ 2 ), and For the schedule σ 1 , from the given From the given LD 1j ≤ s 1 + v 1i , and Owing to Thus, one has For the schedule σ 2 , from the given From the given v 1i ≤ v 1j and v 2j ≤ v 2i , comparing two max terms of C 2j (σ 1 ) in Equation (7) and two max terms of C 2i (σ 2 ) in Equation (8), one obtains C 2j (σ 1 ) ≤ C 2i (σ 2 ).
In branch-and-bound algorithms, the lower bound plays a crucial role in guiding the search process and improving efficiency.Its primary function is to provide an estimate of the minimum possible value for the objective function or cost in an optimization problem.By using a lower bound, the branch-and-bound algorithm intelligently prunes unpromising branches, reducing the overall search space and improving the chances of finding the optimal solution more efficiently.It acts as a guiding factor to focus the search on the most promising areas, saving computational resources and speeding up the optimization process.Considering these observations, we also propose the following lower bound.Moreover, let σ = (π, π c ), where π and π c denote the sequence with i scheduled jobs and the sequence with ( n − i + 1) unscheduled jobs, respectively, and s 1 and s 2 denote the completion times of the last job on machine 1 and 2, respectively, in π.According to the definition of completion time of a job to be scheduled on the (i + 1)-th position on machine 1 and machine 2, we have the following equalities.
It is noted that X [q] s and Y [q] s denote two indicator variables to indicate whether the starting times of a job j assigned to the q-th position is more than the learning dates of the job j on machines 1 and 2, respectively.
In a similar way, another lower bound can be obtained as follows: . . .
Based on the above Equation ( 11), we have From Equations ( 9) and ( 12), a tighter lower bound (LB) can obtained as follows:

Heuristics and Population-Based Genetic Algorithm
A heuristic method is a problem-solving strategy that relies on practical and experiencebased approaches to find a solution, instead of following a strict algorithmic process.There are several compelling reasons for using a heuristic method to solve complex problems with limited resources.For instance, heuristic methods can offer faster solutions than rigorous methods, and they are particularly useful when facing difficult problems that may not have straightforward solutions.
The Johnson rule is a heuristic method used to solve a two-machine flow-shop scheduling problem with the objective of minimizing the makespan (i.e., F2//C max ).The makespan is the total time it takes to complete all jobs on both machines.This process continues until all jobs have been scheduled.The Johnson rule guarantees that the resulting schedule is optimal for minimizing the makespan in a two-machine flow-shop scheduling problem.However, the Johnson rule, proposed by Johnson [33], cannot find an optimal solution for the proposed problem due to the fact that the proposed problem F2//v 1j ≤ u 1j , v 2j ≤ u 2j LD 1j ; LD 2j //C max is an NP-hard one.The following are the steps involved in applying Johnson's rule: Step 1: Identify the set of jobs that need to be processed; Step 2: Determine the smallest processing times across all n jobs and two machines; Step 3: If the smallest processing time from the first machine is at the beginning of the process, schedule that job first.On the other hand, if the smallest processing time from the second machine is at the beginning of the process, schedule that job last; Step 4: Remove the job that has been scheduled from the set of jobs; and Step 5: Repeat steps 1-4 until all jobs have been scheduled.Following Johnson's rule, we apply the Johnson rule to each of the four different initial inputs: {LD 1i , LD 2i , i ∈ Ω = {1, 2, . . . ,n} ; {u 1i , u 2i , i ∈ Ω = {1, 2, . . . ,n}}; {v 1i , v 2i , i ∈ Ω = {1, 2, . . . ,n}}; and {u 1i , v 2i , i ∈ Ω = {1, 2, . . . ,n}} and then refine them further using a pairwise interchange method.The complexity of Johnson's Rule is O(n log n), where n represents the number of jobs, while the complexity associated with the pairwise interchange method is O(n 2 ).Therefore, the computational time of each of four proposed heuristics is O(n 2 ).The details of four proposed heuristics are introduced below:

Genetic Algorithm
Numerous literature studies have consistently shown that heuristics, in general, are characterized by their relative simplicity and ease of construction.On the other hand, metaheuristics are notably more complex and challenging to design and employ effectively, particularly when it comes to intelligent random search strategies (Holland [34]; Essafi et al. [35]; Nguyen et al. [36]; Fan et al. [37]; Tutumlu and Saraç [38]; Wang and Chen [39]).Among the various metaheuristics, the genetic algorithm (GA) stands out as a widely applied and successful approach for obtaining high-quality approximate solutions to a diverse range of combinatorial problems.
The GA capitalizes on genetic and neural selection mechanisms, including mutation, crossover, and reproduction, to conduct an efficient search for optimal solutions in complex problem domains.The effectiveness of these genetic operators has been particularly evident in solving numerous NP-hard combinatorial problems.By leveraging these operators, the GA iteratively refines and explores the solution space, gradually converging towards high-quality solutions.The GA's ability to strike a balance between exploration and exploitation enables it to effectively navigate large solution spaces and uncover nearoptimal solutions.This makes it a valuable tool for addressing complex optimization problems where traditional approaches may struggle.
In the GA framework, we utilize a set of continuous real numbers to represent order codes through random number encoding.For instance, a chromosome (0.63, 0.51, 0.21, 0.53, 0.18) can be decoded using the ranking method into a schedule (5, 3, 2, 4, 1).During the reproduction stage, parents are selected, and a specific crossover operator, such as linear order crossover (Iyer and Saxena [40]; Wu et al. [41]), is employed to generate offspring.Alternatively, readers can refer to Larranaga et al. [42] for a partially mapped crossover operator or Kellegoz et al. [43] or Castelli et al. [44] for a single crossover point operator.
To introduce diversity, we incorporate the fourth displacement mutation (referred to as M4) proposed by Nearchou [45].This mutation involves randomly selecting a subsequence of orders and inserting them at a random position.In the context of our study, let n_size represent the number of parents, P m denote the mutation rate, and g_size represent the number of iterations or generations for executing the GA.Now, let us summarize the main structures of the proposed GA: The details of GA: Step 1. Initialize parameters: Set the values of n_size (number of parents), P m (mutation rate), and g_size (number of iterations); Step 2. Generate an initial population of n_size parents (schedules) and evaluate their fitness values; Step 3. Iterate i from 1 to g_size: -Select two parents from the population using the roulette wheel method; -Apply linear order crossover to produce a set of n_size offspring; -For each offspring, generate a random number r (0 < r < 1).If r is less than P m , perform a displacement mutation to create a new offspring; -Keep track of the best schedule found so far; -Replace the current population of parents with their offspring; Step 4. End the iteration loop (g_size); Step 5. Output the final best schedule and its corresponding fitness value.
By following these steps, the GA gradually evolves a population of schedules over multiple iterations, utilizing crossover and mutation operators to explore the search space and improve the quality of the solutions.The algorithm terminates after reaching the specified number of iterations, providing the best schedule found and its associated fitness value as the output.

The Parameter Exploration for GA
In this section, two different values of n are utilized for parameter exploration of GA: a large n = 400 and a small n = 10.Additionally, the learning dates control parameters for both machines, denoted as w 1 and w 2 , are set to 0.5.For the scenarios with large n = 400 and small n = 10, one hundred instances are generated for each case.Data analysis is conducted for each dataset, involving the processing times u 1i and u 2i of jobs on machine M 1 and machine M 2 , respectively.These times are uniformly distributed within the range U(51, 100).Under the influence of learning effect, the processing times v 1i and v 2i for jobs on machine M 1 and machine M 2 are generated from U(1, 50).The learning dates LD 1 and LD 2 for machine M 1 and machine M 2 are derived from U(1, U(1, w 1 ∑ n i=1 u 1i )) and U(1, w 2∑ n i=1 u 2i ), respectively.In this data context, we compute both the optimal solutions (Oi) obtained through the branch-and-bound method and the approximate solutions (Hi) obtained using the genetic algorithm (GA).The average error percentage (AEP) is calculated as A AEP = ∑ 100 1 (Hi − Oi)/Oi × 100% to investigate the simulated parameter combinations (such as evolution generations Gsize, mutation rate p, and chromosome count n_size) within the GA algorithm.The experimental approach entails initially fixing two parameters and then varying the third parameter as the experimental subject for testing and exploration.This process continues until the minimum AEP value is identified.The parameter is then treated as a fixed parameter, and the aforementioned method is applied to identify the next suitable parameter.This iterative process persists until appropriate values are determined for all parameters.
First, the scenario with n = 10 was tested.Figure 1a depicts the parameter exploration of evolution generations (g_size) under the condition of a fixed mutation rate of p = 0.02 and a chromosome count of n_size = 500.The g_size was varied from 20 to 360, with increments of 20 generations.From Figure 1a, it is evident that the lowest point of the average error percentage (AEP) was reached at 240 generations.Therefore, 240 generations was selected as the value for the g_size for subsequent simulation testing.Based on the above findings, the optimal number of evolution generations was determined to be 240.Therefore, with the evolution generations fixed at g_size = 240 and the mutation rate at r = 0.02, we conducted an exploration of the chromosome count parameter (n_size).Specifically, we varied the chromosome count (n_size) from a minimum of 10 chromosomes to a maximum of 200 chromosomes, increasing by 10 chromosomes in each step.In Figure 1b, it can be observed that the GA reached a relatively stable state around 100 chromosomes.However, the lowest point occurred at 180 chromosomes.Hence, we selected 180 chromosomes as the reference value for the n_size in the subsequent GA simulation testing.Based on the above findings, the optimal number of evolution generations was determined to be 240.Therefore, with the evolution generations fixed at g_size = 240 and the mutation rate at p = 0.02, we conducted an exploration of the chromosome count parameter (n_size).Specifically, we varied the chromosome count (n_size) from a minimum of 10 chromosomes to a maximum of 200 chromosomes, increasing by 10 chromosomes in each step.In Figure 1b, it can be observed that the GA reached a relatively stable state around 100 chromosomes.However, the lowest point occurred at 180 chromosomes.Hence, we selected 180 chromosomes as the reference value for the n_size in the subsequent GA simulation testing.
Based on the results above, we determined that suitable values were g_size = 240 for evolution generations and n_size = 180 for chromosome count.Therefore, in the subsequent steps, we fixed g_size = 240 and n_size = 180 to explore the parameter range of mutation rate (p).We considered a mutation rate range from 0.01 to 0.2, with increments of 0.01.As evident from Figure 1c, it became evident that the GA achieved the minimum error at a mutation rate of 0.16.Consequently, this study employed a mutation rate of 0.16 as the basis for GA testing in the subsequent phases.
Next, the initial setup for parameter exploration involving a larger n was conducted with n = 400.The branch-and-bound method was utilized to calculate the root lower bound value (LBi), and the genetic algorithm (GA) was used to compute approximate solutions (Hi).The percentage gap in their differences (average gap percentage or GAP) was computed as GAP = ∑ 100 1 (Hi − LBi)/LBi × 100% to explore the parameter values of g_size (evolution generations), p (mutation rate), and n_size (chromosome count) for the GA.The goal was to determine the optimal values of g_size, p, and n_size that yielded the most suitable GAP values.These optimal values were intended for reference in subsequent GA algorithm simulations for larger n.
As shown in Figure 1d, when n = 400, with n_size = 2000 fixed and a mutation rate of p = 0.02, the exploration of the evolution generations (g_size) ranges from a minimum of 100 generations to a maximum of 2000 generations, increasing by 100 generations in each step.From the graph, it is evident that the lowest GAP value occurred at around 1500 generations.Consequently, the evolution generations for the subsequent GA simulations was set to g_size = 1500.
Subsequently, the exploration of the mutation rate was conducted with n = 400, g_size = 1500, and n_size = 2000 held constant.The range of mutation rates for investigation was set from 0.01 to 0.2, increasing by increments of 0.01.From Figure 1e, it becomes evident that the mutation rate p reached its lowest GAP value at 0.16.Therefore, the subsequent GA algorithm adopted a mutation rate setting of p = 0.16.
Finally, with n = 400, g_size = 1500, and p = 0.16 fixed, we explored the parameter n_size (chromosome count).Figure 1f illustrates that when setting the chromosome count from 400 to 4000, with increments of 400 chromosomes in each step for simulation testing, the results indicated a progressively increasing trend in GAP values.Consequently, we considered an exploration range for an n_size between 100 and 400 chromosomes, increasing by 100 chromosomes in each step.Additionally, we also assessed the performance of GA with a chromosome count of 50.Observing the graph, it is apparent that the lowest GAP value occurred at a chromosome count of 200.Therefore, the decision was taken to utilize 200 chromosomes as the parameter for subsequent GA testing.

Simulation Results for Proposed Algorithms
In this section, we conducted several experimental designs to evaluate the performances of the four proposed algorithms, a population-based genetic algorithm, and a branch-and-bound method.The designs included six different values of n with n = 8, 10, and 12 for the small number of jobs and n = 100, 200, and 400 for the big number of jobs, along with nine cases of learning date control parameters (w 1 , w 2 ) with (0.25, 0.25), (0.25, 0.5), (0.25,0.75), (0.5, 0.25), (0.5, 0.5), (0.5,0.75), (0.75, 0.25), (0.75, 0.5), and (0.75,0.75).For each case, the processing times u 1i and u 2i of jobs on machine M 1 and machine M 2 were generated from within the range U(51, 100), uniformly distributed, respectively.Meanwhile, under the influence of learning effect, the processing times v 1i and v 2i for jobs on machine M 1 and machine M 2 were generated from U(1, 50), respectively.Additionally, the learning dates LD 1 and LD 2 for machine M 1 and machine M 2 were derived from U(1, U(1, w 1 ∑ n i=1 u 1i )) and U(1, w 2∑ n i=1 u 2i ), respectively.This study reports 54 cases and one hundred instances for each case.In total, we generated 5400 tested instance problems where 2700 instances were for the small number of jobs and for the big number of jobs, respectively.The results of six different values of n with n = 8, 10, and 12 for the small number of jobs and n = 100, 200, and 400 for the big number of jobs are reported in Tables 2  and 3.
For the cases of the small number of jobs, we computed both the optimal solutions (Oi) obtained through the branch-and-bound method (B&B) and the approximate solutions (Hi) obtained using the four heuristics (J2LD-pi, J2U-pi, J2V-pi, J2UV-pi) and genetic algorithm (GA).The average error percentage (AEP) was calculated as AEP= ∑ 100 1 (Hi − Oi)/Oi × 100% and standard deviation (STD) of errors to determine the performances of all the proposed algorithms over the different values of n, w 1 , and w 2 .Regarding the performance of B&B, we reported the mean and maximum of explored nodes and their corresponding CPU time (in second) for each case.Additionally, we designed a tested instance problem as not feasible one when the B&B consumed the number of nodes up to 10 9 .The effects of n, w 1, and w 2 in Tables 4 and 5 were obtained from Table 2.For the performance of B&B, Table 4 shows that B&B took more nodes at w 2 = 0.75 than those at w 2 = 0.25 or 0.5.The pattern of w 1 was similar to that of w 2 , except n = 8.The pattern became clear as n increases.It also can be observed in Table 2 that B&B consumed fewer nodes at w 1 = 0.5 or w 2 = 0.5.We also noted that in the two cases of n = 10, with different weight configurations w 1 = 0.25 and w 1 = 0.5, although the total mean node count was higher in the case of w 1 = 0.25, this is because in this case, the maximum node count for the weight configuration (w = 0.5, w 2 = 0.75) was even greater than the maximum node count for (w 1 = 0.25, w 2 = 0.75).However, the time taken to solve these two scenarios was remarkably similar.This is why, in the scenario with w 1 = 0.25, despite having a higher total mean node count, the time required to solve the problem was less.Overall, the nodes grew very large as n increased.It can be confirmed this problem is an NP-hard one.
With respect to the achieved results of the four proposed heuristics and the genetic algorithm (GA) applied to the case of small n, Table 5 and Figure 2 illustrate their AEPs.In summary, the mean AEP values were 7.23, 7.13, 6.23, 5.64, and 0.25 for J2LD_pi, J2U_pi, J2V_pi, J2UV_pi, and GA, respectively.It is evident that the GA algorithm outperformed all of the other four heuristics.
Table 5 further presents the means of AEP values corresponding to different levels of the factors n, w 1 , and w 2 .An observation from Table 5 revealed that the AEPs of the four heuristics and the GA algorithm exhibited a slight increase as n increased from 8 to 12. Conversely, these AEPs remained relatively unaffected by variations in the values of w 1 or w 2 .Turning to the computational times, Figure 3 demonstrates that all four heuristics and the GA algorithm required less than 1 s to execute.Conversely, these AEPs remained relatively unaffected by variations in the values of  or  2 .Turning to the computational times, Figure 3 demonstrates that all four heuristi and the GA algorithm required less than 1 s to execute.Statistical evidence to determine the significance of differences among the four he ristics and the GA algorithm is discussed below.Initially, an analysis of varian (ANOVA) method using a linear model was employed on the AEP data within SAS 9.However, the normality assumption of the linear model was found to be violated.Th was evident from the Kolmogorov-Smirnov normality test, which yielded a r-value le than 0.05 (with a statistic value of 0.084).Consequently, due to this non-normality, th data were handled using a nonparametric approach.Specifically, for the 32 instances the (n*w1*w2) problem, the Friedman test (with r-value less than 0.0001) was conducte based on ranks of AEP values.The results of the test provided evidence that the AEP sam ples were not drawn from the same distribution at a significance level of α = 0.05.
To further assess ( 5 2 ) pairwise differences among the four heuristics and the GA a gorithm, the WNMT (Wilcoxon-Nemenyi-McDonald-Thompson) procedure was intr duced.Table 6 (column 3) illustrates the sum of ranks of AEP for the 32 instance problem across the four heuristics and the GA algorithm.The rank sums for J2LD_pi, J2U_p J2V_pi, J2UV_pi, and GA were 118, 117, 88, 55, and 27, respectively.Statistically, there w no significant difference among the groups of J2LD_pi, J2U_pi, and J2V_pi at a signi Statistical evidence to determine the significance of differences among the four heuristics and the GA algorithm is discussed below.Initially, an analysis of variance (ANOVA) method using a linear model was employed on the AEP data within SAS 9.4.However, the normality assumption of the linear model was found to be violated.This was evident from the Kolmogorov-Smirnov normality test, which yielded a p-value less than 0.05 (with a statistic value of 0.084).Consequently, due to this non-normality, the data were handled using a nonparametric approach.Specifically, for the 32 instances of the (n*w 1 *w 2 ) problem, the Friedman test (with p-value less than 0.0001) was conducted based on ranks of AEP values.The results of the test provided evidence that the AEP samples were not drawn from the same distribution at a significance level of α = 0.05.
To further assess 5 2 pairwise differences among the four heuristics and the GA algorithm, the WNMT (Wilcoxon-Nemenyi-McDonald-Thompson) procedure was introduced.Table 6 (column 3) illustrates the sum of ranks of AEP for the 32 instance problems across the four heuristics and the GA algorithm.The rank sums for J2LD_pi, J2U_pi, J2V_pi, J2UV_pi, and GA were 118, 117, 88, 55, and 27, respectively.Statistically, there was no significant difference among the groups of J2LD_pi, J2U_pi, and J2V_pi at a significance level of 0.05.However, J2UV_pi demonstrated a significant improvement over each of the J2LD_pi, J2U_pi, and J2V_pi heuristics.Additionally, the GA algorithm exhibited significant superiority compared to each of the J2LD_pi, J2U_pi, J2V_pi, and J2UV_pi heuristics.Notably, the GA yielded the smallest AEP and rank sum for a small number of jobs.Concerning the obtained results in Table 3 for the proposed four heuristics and the GA algorithm in the context of large n, Table 6 (summarized from Table 3) and Figure 4 provide an account of the average Relative Percentage Deviation (RPD) for the four heuristics and the GA algorithm.It is evident from Table that, regardless of the value of n, the GA consistently achieved the lowest average RPD among all job sequences.The average RPD values for J2LD_pi, J2U_pi, J2V_pi, J2UV_pi, and GA were 8.65, 7.09, 8.33, 6.84, and 0.14, respectively.Furthermore, Figure 4 presents box plots depicting the distribution of average RPD for both the four heuristics and the GA algorithm.These box plots indicate that the interquartile ranges of average RPDs for J2LD_pi, J2U_pi, J2V_pi, and J2UV_pi in comparison to the GA algorithm were broader.It is also noteworthy from Table 3 that as the value of n increased from 100 to 400, the average RPD values of J2LD_pi, J2U_pi, J2V_pi, and J2UV_pi decreased.Conversely, the average RPD of the GA algorithm experienced only a slight increase.A linear model was applied to the average RPD observations in order to analyze the distinctions between the four heuristics and a GA algorithm.Nevertheless, the assumption of normality for the RPD samples was violated, as indicated by p-values lower than 0.05 in the Kolmogorov-Smirnov normality test.The calculated statistic was 0.096.Consequently, the Friedman's test with a chi-square value of 69.1532 (p-value of less than 0.0001) was employed to explore the pairwise variations among all proposed algorithms.Examining the sum of ranks of the average RPD computed for each of the 27 blocks related to the test problem instances, these outcomes validated that the average RPD samples did not adhere to the same distribution.In other words, J2LD_pi, J2U_pi, J2V_pi, J2UV_pi, and GA exhibited distinct search performances.
Table 7 (column 5) displays the rank-sum of average RPDs for J2LD_pi, J2U_pi, J2V_pi, J2UV_pi, and GA.To conduct a more detailed comparison of (( 52 )) pairwise differences among 2LD_pi, J2U_pi, J2V_pi, J2UV_pi, and GA, the WNMT test (with a significance level of 0.05) was employed.The results indicated that GA achieved the best performance, being placed in the group with the lowest rank-sum of 31.On the other hand, the heuristics (J2LD_pi, J2U_pi, J2V_pi, J2UV_pi) were categorized in the group with higher rank-sums (76, 112), implying inferior performance.This test confirmed that, at a significance level of α = 0.05, the GA algorithm statistically outperformed each of the four heuristics individually.Overall, the GA algorithm demonstrated the most effective search capability, particularly for scenarios involving a large number of jobs.
Regarding computational time, Figure 5 displays the box plots of CPU times (in seconds) for the five proposed algorithms.On average, the GA algorithm required a mean CPU time of 10.36 s to solve an instance problem, whereas each of the J2LD_pi, J2U_pi, J2V_pi, and J2UV_pi heuristics necessitated an average CPU time of 0.32 s to solve an instance problem.This discrepancy in CPU time can be attributed to the heightened computational demands of the GA algorithm when compared to each of the J2LD_pi, J2U_pi, J2V_pi, and J2UV_pi heuristics.The underlying factors contributing to the increased CPU time for GA include its elevated complexity, the need for diversity maintenance, adaptation, global search, and problem-specific techniques intrinsic to metaheuristic approaches.400 0.25 0.25

Conclusions and Suggestions
This study delved into the scheduling of the two-machine flow-shop problem using step-learning.In this context, job processing times decrease if they commence after their job-dependent learning dates.Initially, we concentrated on a scenario where there was no allowance for idle time between successive jobs on the first machine, yet idle periods were permissible on the second machine.The main goal of this investigation was to optimize resource allocation and task sequencing, aiming to maximize time utilization efficiency and ensure the timely completion of all jobs, a shared objective in the pursuit of scheduling process optimization.
For this challenging problem, we proposed a Mixed-Integer Programming (MIP) model.Subsequently, we employed a branch-and-bound method with two dominance properties and a lower bound to generate optimal solutions for cases with a small number of jobs (e.g., n = 8, 10, and 12).This method performed well up to n = 12 jobs, which encompassed various combinations of job classes and controllable learning indices w 1 and w 2 for learning dates.For cases with a larger number of jobs, such as n = 100, 200, and 400, we introduced four problem-based heuristics, each accompanied by a pairwise interchange scheme, along with a genetic algorithm (GA) for obtaining approximate solutions.It was observed that the GA outperformed the other four heuristics in both small n and large n tested instances.
One of the issues for future study is to expand the production environment to a twostage three-machine flow-shop production process with learning dates.Additionally, it is worthwhile to consider extending the same setup to minimize the total completion times of all provided jobs.

Figure 1 .
Figure 1.The parameter exploration for GA on n = 10 and 400.

Figure 2 .
Figure 2. Violin plots of AEP for 4 heuristics and GA for small n.

Figure 2 .
Figure 2. Violin plots of AEP for 4 heuristics and GA for small n.

Figure 3 .
Figure 3. Violin plots of CPU times for 4 heuristics and GA for small n.

Figure 3 .
Figure 3. Violin plots of CPU times for 4 heuristics and GA for small n.

Figure 4 .
Figure 4.The box plots of RPD for 4 heuristics and GA for big n.

Figure 5 .
Figure 5.The box plots of CPU times for 4 heuristics and GA for big n.

Figure 5 .
Figure 5.The box plots of CPU times for 4 heuristics and GA for big n.

Table 2 .
The performance of four heuristics and GA on the small number of jobs.

Table 3 .
The performance of four heuristics and GA on the big number of jobs.

Table 4 .
The summary performance of B&B.

Table 5 .
The summary AEP performance of proposed algorithms for small n.

Table 5 .
The summary AEP performance of proposed algorithms for small n.

Table 6 .
The summary RPD performance of proposed algorithms for big n.

Table 7 .
The sum of ranks for four heuristics and GA algorithm.

Table 7 .
The sum of ranks for four heuristics and GA algorithm.