{'fraction_non_alphanumeric': 0.02806561637160955, 'fraction_numerical': 0.007731037843105409, 'mean_word_length': 4.779237844940868, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Hybrid Flow Shop with Limited Transportation Scheduling Problem: A Comparison Between Genetics Algorithm, and a Novel Recursive Local Search Heuristic

In this paper, concurrent scheduling of jobs and transportation in a hybrid ﬂow shop system is studied, where multiple jobs, transporters, and stages with parallel unrelated machines are considered. In addition to the mentioned technical features, jobs are able to omit one or more stages, and may not be executable by all the machines, and similarly, transportable by all the transporters. Unlike most studies in the literature, the transport resource is ﬁnite and needs to be simultaneously scheduled with the jobs. Initially, a new mixed integer linear programming (MILP) model is proposed to minimize the makespan. Then, a novel Recursive Local Search Heuristic (RLSH) is proposed to tackle the large-sized instances, which otherwise could not be solved via MILP solver (Gurobi) in a reasonable time. RLSH is also compared against Genetic Algorithm (GA) on a set of numerical examples generated from the uniform distribution. As the computational results demonstrate, it is concluded that RLSH is extremely eﬃcacious dealing with the problem and outperforms GA in the objective value quality. Finally, using two well-known statistical tests: Wald and analysis of variance(ANOVA), we assess the performance of the suggested approaches. programming (MILP), Genetic Algorithms (GA), and a novel Recursive Local Search Heuristic (RLSH).


Introduction
Flow shop (FS), as one of the most applied production systems has been intensively studied over the last decade since it is considerably flexible and cost-efficient.
Classically, FS consists of a number of stages each with one machine, where all the jobs should be processed on.
This form of FS is not practically able to satisfy the industries where mass-production is intended, or not all the jobs have the same production plan. Hence, some additional complementary features are to be taken into account to cover the mentioned requirements.
One characteristic is to consider the unrelated parallel machines on each stage to increase the process speed.
Other flexible attribute is the jobs stage omission, which permits the jobs to omit the stages if required. The transporter eligibility is also another technical characteristic which restricts a job to a certain set of carriers for some technical reasons (e.g., size or vulnerability).  Generally, HFSP is NP-hard even if only two stages exist, where two parallel machines exist on the first stage, and one on the second stage [12]. Thus, it is not practically possible to optimally solve the problem in a reasonable running time if the size of the problem grows larger.
Traditionally, HFSP assumes the infinite transportation resource, which according to the literature, refers to the unlimited number of transporters. In other words, once a transportation is needed, it is assumed that carriers are always available to handle the transportation operation.
In the finite transportation assumed in this study, there might not always be an available carrier to deal with transportation operation, and the job should wait until one of the carriers is ready. Thus, it is also needed to schedule transportation resource concurrently with the job process.
Along with the manufacturing technicalities aforementioned, the input and output buffers are unlimited. Therefore, no capacity limitation exists on the number of jobs queuing at the stage for process, and for transportation from the current stage to the next one.
To tackle the problem, three approaches are employed:a new Mixed integer linear programming (MILP), Genetic Algorithms (GA), and a novel Recursive Local Search Heuristic (RLSH).
The results produced by the methods are compared against one another on a set of numerical instances with setup time, process time, and travel time randomly generated from the uniform distribution. Since the problem is computationally complex, as long as Gurobi is able to deal with the problems in a reasonable running time, the comparison of all the approaches are continued. Otherwise, MILP is excluded from comparison. Eventually, analyzing the objective values and the computation times using statistical tests, the best approach is specified.
The rest of this study is structured as follows: Section 2 goes over the literature of flow shop scheduling problems with transportation. Section 3 presents the problem statement and solution approaches. In Section 4, the computational results are analyzed. Finally, in Section 5 some conclusions are provided.

Literature Review
HFSP problem is one the most computationally complicated problems in terms of solving to optimality. As Gupta [10] proved in his study, even in the two-stage problem with one machine at first stage and two machines at the second stage the problem is NP-Hard. Therefore, the combinatorial optimization is the most computationally reasonable approach for the large-sized instances. Below, we present the most relevant studies employing combinatorial optimization to deal with HFSP problem.
Maggu and Das [18] and Maggu et al. [17] studied scheduling problems with unlimited transportation resource while ignoring the capacity of the carriers to minimize makespan. The transportation times are dependent on the jobs and the buffers are unrestricted. It is also proved that the problem is polynomially solvable.
Kise et al. [14] studied two-machine flow-shop scheduling problem with transporters, where one job could be allocated to each transporter at each time. They also validated that even in the case of two machines, the problem is NP-complete.
Stevens and Gemmill [20] scrutinized a two-machine flow-shop with transportation minimizing the job waiting time. The buffer storage of the second machine is considered unlimited, whereas the first one has no buffer, and the carrier should immediately return after it reaches the second machine. As the solution approaches, two heuristics developed are practically able to generate fine solutions, but not optimal in all cases.
Bank and Werner [1] considered a flexible flow shop scheduling problem with un-related parallel machines. The objective function is distributing the jobs to the machines and to schedule the jobs assigned to each machine so that the weighted sum of linear earliness and tardiness penalties is minimal. To deal with the problem, some structural properties useful to search for an approximate solution is employed.
Additionally, various constructive and iterative heuristic algorithms are suggested and compared on a set of problems.
Brucker et al. [3] investigated flow shop scheduling problems with unlimited transportation and constructed an algorithm producing optimal solution if the process time of the jobs is set to 1.
Lee and Strusevich [15] examined the two-machine flow shop scheduling problems with an uncapacitated inter-stage transporter. To tackle the makespan minimization problem, they utilized an approximation heuristic given that there exists an optimal schedule with exactly two shipments.
Naderi et al. [19] exploited an improved simulated annealing to minimize makespan in FFS with sequence-dependent setup and transfer times, where the transfer times produced are uniformly distributed. Comparative tests support the robustness of the algorithm.
Fattahi et al. [8] investigated a HFSP with assembly operations, in which a number of the similar jobs are considered, and makespan is the objective function. Due to NP-hardness of the problem, a hierarchical branch and bound algorithm is presented.
They also suggested some lower and upper bounds to augment the effectiveness of the developed algorithm.
Kheirandish et al. [13] studied a HFSP with two stages, wherein the jobs after process are assembled. In the first stage, the jobs are executed, and transferred to the second stage for assembly operation. A MILP model is developed to minimize the makespan and Lingo is employed to tackle the problem. Since the model is NP-hard, an artificial bee colony algorithm in addition to GA are proposed to obtain nearoptimal solutions in a reasonable time. Additionally, the efficiency of the solution approaches is investigated on different instances of the problem.
Gheisariha et al. [9] developed an promoted multi-objective harmony search (EMOHS) heuristic and a Gaussian mutation to address the flexible flow shop scheduling problems with sequence-based setup time, transfer time, and probable rework. A constructive heuristic is designed to construct the initial solution, and clustering is exercised to improve the solution. The suggested algorithm uses response surface methodology to simultaneously minimize both makespan and mean tardiness.
Yuan et al. [22] examined a two-machine flow shop group scheduling problem with job-related blocking and transportation times. To minimize makespan, a MILP model is formulated. Since the problem is strongly NP-hard, a co-evolutionary genetic algorithm (CGA) is proposed to tackle the problem, and a block-mining-based artificial chromosome construction mechanism is developed to accelerate the convergence process. The computational results reveal that CGA is effective dealing with the problem.
In the study carried out by Xin et al. [21], a permutation flow shop scheduling problem considering sequence-dependent setup time and a new conveyor speed control energy-saving mechanism is investigated. The objective is to discover the optimal sequence of jobs and conveyor belt speed scheme between any two nodes. A MILP model is developed to minimize both the makespan and total energy consumption.
To address this bi-objective model, an enhanced discrete whale swarm optimization (IDWSO) is taken into account that combines differential evolution, the promoted search, and job-swapped mutation to augment the performance.
Lei et al. [16] studied FFSP with transport waiting times (FFSPDW), where AGVs handle the transportation operations. In order for minimizing makespan considering the dynamic waiting times, they suggested a waiting time calculation method to evaluate waiting time and makespan. This method takes two situations into account: infinite buffer capacity and zero buffer capacity. To solve the problem, a memetic algorithm integrated with waiting time calculation method is developed.
Finally, they verified the algorithm parameters via ANOVA. Computational results support that the algorithm is able to deal with the problem in short computation time.
Cai et al. We use Table 1  As table 1 demonstrates, despite all the above-mentioned studies have both scientifically and practically made great achievements, they treated the simultaneous scheduling of jobs and transportation with some limiting assumptions, which are briefly described in the following: • A number of studies aforementioned reviewed the infinite transport resources, a special case which rarely happens in reality. This assumption is only limited to industries using conveyor belt systems not all the industries.
• Only Batur et al. [2] took the stage omission possibility into account, however, the considered HFSP problem is limited to two operational stages, hence, it is not viable for operationally complicated industries with numerous stages.
Stage omission possibility provides considerable adaptability to the industries employing HFSP since it is possible to add a new job with different production plan.
• In the studies fulfilled by Elmi and Topaoglu [5], the transportation and job process both are handled by robot, a characteristic which can considerably narrow down the application of the model. The robots considered in their studies are responsible for both transportation and process. So, after a robot has transferred a job to a stage, it should execute the job, and cannot start the next transport while executing the job. In other words, the transportation and job process are completely dependent and are unable to behave as two stand-alone components.
• Zabihzadeh and Rezaeian [24] considered FFSP, where transportation is carried out by robots. In their study, setup time is not assumed. The MILP model presented does not sequence the travels of each robot realistically since travel time between the previous position of the robot to the current position of the job assigned to the robot in not considered, and only the travel time between the current position of the job and its next position is assumed.
• Some of studies assumed fixed transportation time between all the nodes, which technically is not sensible and practical.
• In the works of Batur et al. [2], Lee and Strusevich [15], and Maggu and Das [18] the number of machines is restricted to two, which is far from practical considering the high-capacity production lines with the numerous machines most companies need.
• None of the researches investigating HFSP with the limited transportation considered the transporter eligibility constraint, which from the technical point of view, is so remarkable since not all the jobs are transportable by all the carries given some restricting characteristics like job size, or job vulnerability.
To best of our knowledge, this study is the first research considering transporter eligibility, stage omission, and machine eligibility in a HFSP with finite multiple transporters. Furthermore, a new heuristic along with a novel MILP model are introduced.

Problem statement and solution approaches
In the HFSP , there are I jobs to be executed on J i stages, each of which consists of M j parallel unrelated machines.
To execute a job, the machine needs to be prepared for, therefore, the setup and process times both are taken into account.
As mentioned in section 1, the input and output buffers are unlimited, which implies that no limitation exists on the queue capacity for incoming and outgoing jobs. If the job coming on one of the eligible machines is the first job assigned, no setup time is required, since it is presumed that the machine is quite prepared for its first process in advance. Otherwise, the setup time is incurred after the process of the previous job is terminated. The process sequence of jobs on a machine is independent from the times they arrive at.
When the process of the job is complete, it should wait until one of the T i transporters is ready to transport it.
After the job has been carried to the machine, the carrier either waits there to convey the job to the next stage after the process has been terminated, or it commences another travel and leaves conveying the in-process job to another carrier, or it returns later to convey it itself. The model opts out one of these strategies based on the improvement it results in the makespan.
Before going through the solution approaches, some assumptions are taken into account in the following: 1. All the jobs and transporters start their routes from stage zero.
2. All the jobs, machines, and transporters are available at time zero.
3. Each job, for each of its process can only be transported by one of the eligible carriers.
4. Stage omission for jobs is allowed.
5. At each stage, the job can only be executed by one of the eligible machines.
6. Input and output buffers are assumed unlimited. I.e., there is no limitation on the number of the jobs waiting at the machine to be executed, or to be transferred from the machine to the next stage.
7. Each transporter is only able to convey one job each time.
In the next section, we develop an efficacious mixed integer linear programming model to tackle the problem. T : The number of transporters, where t ∈ {1, 2, ..., T }.

Sets
M j ,i : The machines of stage j eligible to execute job i.
T i : The transporters technically able to transfer job i.
J i : The stages, the job i should be processed on.
J m : The stage, the machine m is located on.
O i,j : A set determining the sequence of stages for job i, wherein the stage visited first by the job takes rank 1, the second stage visited takes rank 2 and so on. BM : A big number (The traditional bigM).   (1)

Variables
A i,j ≥ 0 i = 1, ..., I, j ∈ J i (16)  (10) and (11) sequence the job processes on a machine. Constraints (12) and (13) indicates that if jobs i and i ′ are allocated to the same machine either job i is processed before job i ′ or vice versa.
Constraints (14) to (21) state the range of values the variables can take.

The Illustrative Instance
In order to better communicate the concept of the MILP model, employing Figure 2, a simple illustrative instance is suggested, for which Tables 2 and 3 illustrate the values of all the parameters required.
According to Figure 2, three jobs need to be processed, where stage 1 is input section, stage 2 involves machines 1 and 2, and stage 3 consists of machine 3.
As the production plan, job 1 is only processed on stage 2 and other two jobs are processed on stage 2 and then on stage 3. Hence, 5 production operations are to be scheduled. To transport the jobs, two carriers namely T1 and T2 handle all the transportation operations. The transporter 2 is the only carrier eligible to convey the job 1, while the jobs 2 and 3 can be transferred by both transporters.
The curved dark arrows each with a number above indicates the movement sequence of the carrier T1 and the dashed one shows that of T2 and the numbers refer to the order of the sequence. The large black dots with numbers below which placed on X coordinate demonstrate the time, at which the process of the respective job is complete, and the largest number among them is the makespan.    The value of makespan is computed provided that the transportation resource is finite. As illustrated, the unavailability and the eligibility of transporter impacts the makespan. These technicalities are the main contribution of this model, which have been neglected in most past researches.
As far as we know, the only researches considering the finite multiple transporters are those fulfilled by Elmi and Topaoglu [5], and Zabihzadeh and Rezaeian [24]. In the study of Elmi and Topaoglu [5], the transportation and job process are completely dependent and are unable to behave independently. So, the dependence between the transportation and the job process hugely limits the application of the model.
Whereas in our study, the transportation and the job process are two stand-alone factors behaving independently. The flexibility granted by the machine eligibility, the stage omission, and the transporter eligibility, even more widens the range of the problems the model can handle.
Since MILP is not able to solve large-sized problems, the genetic algorithm, and the novel recursive local search heuristic are presented in the next section.

Genetic Algorithm (GA)
Holland [11] introduced Genetic algorithm which is an adaptive method inspired by the genetic process of the biological organisms and are vastly utilized in many combinatorial optimization problems. The first and crucial step to carry out the Genetic Algorithm (GA) is to select the chromosome representation which is the way to encode a complete solution for implementing the GA operators.
The initial population of our GA is randomly generated using the uniform distribution and the complete solutions are constructed by the decoding method stated in To construct the next generation, first, a number of best solutions(i.e., chromosomes) as selected by the cost evaluation process, is directly sent to the next generation.
Thereafter, the remaining chromosomes for the next generation are produced via genetic operations: uniform crossover and mutation.
The uniform crossover operator is applied to the chromosomes to augment the exploration in the solutions. As Figure 3 shows, in this process, a random binary bit λ is generated for each gene and the value of the gene in the first offspring is defined by X C hild1 = λX P arent2 + (1 − λ)X P arent1 , where each gene X C hild1 of the child 1 is either the gene value of X P arent1 or X P arent2 .
In this process, swapping the genes of two parents may result in infeasible children, to prevent which two strategies to avoid the infeasibility are utilized.
In the first strategy, the algorithm opts out a gene from parent 1 and looks for a gene with the technically similar characteristics (i.e., same job and stage indices) in parent 2, and then exchange them.
In the latter strategy, regardless of the properties of the chosen gene in parent 2, the algorithm exchanges the genes, then, if the job and stage of both were similar, there would be no technical issue, but if they were not identical(e.g., job 1, stage 1 in gene 1, and job 2, stage 2 in gene 2), the swapping would lead to the infeasible children.
Consequently, the result would be two genes in child 2 with job 1 and stage 1 and two genes in child 1 each with job 2 and stage 2. To address this problem, after swapping, the algorithm commences scanning from the very left side of child 2, and once the second gene with job 1 and stage 1 has been detected, the algorithm replaces the the job 1 and the stage 1 by the job 2 and the stage 2.
Now, the job and the operation indices make sense, and to correct the machine and transporter indices, the algorithm randomly selects one of the eligible machine from stage 2, and one of the qualified transporters. Similarly, the same procedure is used for child 1. After all the steps above-mentioned have been implemented, sorting the offsprings (i.e., children 1 and 2) according to the stage order of the jobs, two new feasible children are resulted. Figure 3 demonstrates this mechanism.

19:
Add Child1 and Child2 to P opC 20: end for 21: for k in Range (Round(N m)

The Recursive Local Search Heuristic (RLSH)
RLSH applies a recursion mechanism to explore through the solution space, and unlike meta-heuristics, where solutions are created randomly, the solution generation is cost-oriented. Thus, given that cost is a determining factor in the solution generation process, each solution is rather a good solution.
As Algorithm 2 illustrates, Combination refers to an incomplete solution to a problem structurally identical to a chromosome in GA, except, it is not a solution yet.
In this algorithm, all the updates will be copied on Combination as it is supposed to be a complete solution to the problem.
As the lines 8 to 17 of Algorithm 2 demonstrate, in each iteration, the Algorithm 2 chooses one job, its operational stage, an eligible transporter, and one of the eligible machines at operational stage. Then, stores this selection as a "Case". After this case has been considered, the algorithm adds its updates on a copy of input Combination.
Each time the algorithm generates a case, thereafter, adds the case to a copy of the input combination. Running the lines 8 to 17 of Algorithm 2, the input combination indicated in line 1 of Algorithm 1 will be copied i∈Jobs j∈J i M i,j × T i times, where M i,j stands for the machines eligible to execute j th operation of the job i, and T i denotes the transporters eligible to transfer job i.
Each of the newly generated combinations have a new case added to the current cases. Thereafter, they are added to List, then, applying the sort operation to List, a number of combinations as specified in lines 19 are selected for next recursion, and the rest are discarded. To this end, InitialPer which is a decimal is multiplied by the length of the List and the result is rounded to nearest integer. This process yields a shorter list consisting of the selected combinations for the next recursion.
As line 20 implies, following list shortening operation, if each Combination included in List is a complete solution, then it is added to GlobalList as one of the candidates for final evaluation, otherwise, it will go through the lines 23 to 27 for the next recursion. In the next recursion, the recurred Combination will be treated as the input Combination with all the updates it brought along from the previous recursion.
In lines 23 to 25, before the incomplete Combination goes through the next recursion, its InitialP er is decreased by DecreaseP er in order to narrow down the next generated branches from the incomplete Combination. If this operation ended up in the negative value, the InitialP er will be equal to the shortest acceptable length ShortAccLen.
The above-mentioned process will be recursively repeated until the number of the complete Combination added to GlobalList is equal to the allowed number of solutions for evaluation. Algorithm 2 clearly demonstrate the aforementioned process.   As reflected in Figure 4, in the first level, 4 cases can at most be considered. Each case is copied on a incomplete "Combination", then added to "List". Hence, in the first level, there are four combinations in the list, each of which is a branch which can lead to a solution to the problem.
After the combinations have been stored in the list, they are sorted, and a number of them (i.e., 2 combinations) with lower costs are selected for the next recursion.
This process takes place in line 19 of Algorithm 2.
Each of these two combinations has already one case added, and in the next recursion, the algorithm finds the second best case for each.
In level 2 (next recursion), there are three possible cases for each combination, and after the sort operation, a number of them are chosen for the next recursion. Now, one combination on the left branch (list) and one on the right branch(list) are continued, and each has two possible cases as demonstrated in level 3 (third recursion). After they are sorted, one of each (According to line 19 of Algorithm 2) is selected for the next recursion.
Presently, each continuing combination includes 3 cases, and in level 4 (fourth recursion), the last case is added and the number of cases for each combination is equal to the number of total operations ( i∈Jobs Operations i ) which indicates that all the required operations have been processed and the algorithm is terminated.
Consequently, comparing the two resulted combinations, it is deduced that the left branch produced a better makespan which is the best solution found.

Computational Experiments
In this section, the results of computational experiments assessing the performances of the proposed approaches are presented.
Similar to Elmi and Topaloglu's research [5], the sizes of problems were established by changing the levels of four parameters, which respectively are the jobs, stages,

Parameters Setting
In order to calibrate the developed GA and RLSH, the Taguchi method is em- For this purpose, we define the assessment parameter Sol Length = (length(P roducts)× length(Stages) × length(M achines) × length(V ehicles)). To best exploit the algorithms, for each individual range of Sol Length , the parameters are calibrated and indicated in Table 4. Alongside the parameters considered for RLSH, we set limitation on the maximum number of the generated solutions (MGS) in order to terminate the algorithm in a reasonable time.

Numerical Instances
Employing parameter setting presented in Table 4, we dealt with 36 differentsized problems, which are reported in Table 5, where Sol Length refers to the scale of the problem, and Time(m) stands for the computation time in minutes. The column of jobs ranges from 9 to 500, where the total number of operations (NOP) is stated.
The number of jobs varies from 3 to 50, which by the carriers ranging from 1 to 8 are distributed to the stages varying from 3 to 10. The number of machines placed on the stages also fluctuates between 1 and 8.
The uniform distribution is used to randomly generate the process times, setup times, and distance matrix from U [0, 25].

Figure 5. Computational results
As both Table 5 and Figure 5 corroborate, for Gurobi is not computationally capable to tackle the large-sized problems, from the thirteenth instance on, it is removed from comparison. Table 5 and Figure 5 also indicate that the larger the size of the numerical instances grows, the better RLSH performs than GA. To support this, similar to Elmi and Topaloglu [5], we utilize Wald test.
Before implementing Wald test, it is necessary to compute the gap between the means of GA and RLSH using the formulas below.
Computing the equation (20), M eanGAP equals to 5.29 %. In other words, if the solutions obtained by RLSH algorithm is implemented in a real manufacturing system, a given annual production volume of this system is gained within 5.29% shorter time than GA.
Due to the stochastic nature of the suggested GA, it may lead to a distinctive GAP for dissimilar problem instances. Thus, GAP can be treated as a random variable and using GAP formulas, the data reported in Table 5 are considered as a sample for this variable. Let µ indicates the value of GAP to be tested for the following hypothesis:  Implementing Wald test, it has been ratified that RLSH augments the productivity. Employing ANOVA one-way test, we assess if there are significant differences between the computation times of GA and RLSH as demonstrated in Table 5 and  As illustrated by Table 6 and Figure 6 , pvalue = 0.08539 is larger than 0.05, supporting that no significant difference exists, and consequently, H 0 is rejected.
Based on the test results, we infer that there is no significant difference between computation times of the solution approaches.

Conclusion
In this study, we scrutinize the hybrid flow shop scheduling problem (HFSP) with transportation, where there are multiple jobs, transporters, stages, and machines.
Technically, the job may skip some stages, and may not be transportable by all the carriers, and executable by all the machines. Initially, a novel mixed-integer linear programming (MILP) model is proposed to minimize makespan. Since the MILP model is unable to generate favorable solutions in a reasonable computing time as the size of the problems augments, two alternative solution approaches namely GA and a new heuristic(i.e., RLSH) are developed and compared against each other on a set of 36 numerical instances generated from uniform distribution.
As the Wald test supports, RLSH outperforms GA in performance, and using ANOVA test with α = 5%, it is concluded that there is no significance difference between the computation times of the solution approaches.
Finally, despite the RLSH is computationally fast and reliable, it is still unproved if RLSH is able to compete with other meta-heuristics such as PSO, and SA. Therefore, it is strongly recommended to compare RLSH against PSO and SA on a larger set of instances. Furthermore, the uncertain nature of the parameters can be studied and tackled using uncertainty techniques such as fuzzy programming, robust optimization and stochastic optimal control.