GAILS: an effective multi-object job shop scheduler based on genetic algorithm and iterative local search

The job shop scheduling problem (JSSP) is critical for building one smart factory regarding resource management, effective production, and intelligent supply. However, it is still very challenging due to the complex production environment. Besides, most current research only focuses on classical JSSP, while flexible JSSP (FJSSP) is more usual. This article proposes an effective method, GAILS, to deal with JSSP and FJSSP based on genetic algorithm (GA) and iterative local search (ILS). GA is used to find the approximate global solution for the JSSP instance. Each instance was encoded into machine and subtask sequences. The corresponding machine and subtasks chromosome could be obtained through serval-time gene selection, crossover, and mutation. Moreover, multi-objects, including makespan, average utilization ratio, and maximum loading, are used to choose the best chromosome to guide ILS to explore the best local path. Therefore, the proposed method has an excellent search capacity and could balance globality and diversity. To verify the proposed method's effectiveness, the authors compared it with some state-of-the-art methods on sixty-six public JSSP and FJSSP instances. The comparative analysis confirmed the proposed method's effectiveness for classical JSSP and FJSSP in makespan, average utilization ratio, and maximum loading. Primarily, it obtains optimal-like solutions for several instances and outperforms others in most instances.


GAILS
The job shop scheduling problem (JSSP) is critical for building one smart factory regarding resource management, effective production, and intelligent supply.However, it is still very challenging due to the complex production environment.Besides, most current research only focuses on classical JSSP, while flexible JSSP (FJSSP) is more usual.This article proposes an effective method, GAILS, to deal with JSSP and FJSSP based on genetic algorithm (GA) and iterative local search (ILS).GA is used to find the approximate global solution for the JSSP instance.Each instance was encoded into machine and subtask sequences.The corresponding machine and subtasks chromosome could be obtained through serval-time gene selection, crossover, and mutation.Moreover, multi-objects, including makespan, average utilization ratio, and maximum loading, are used to choose the best chromosome to guide ILS to explore the best local path.Therefore, the proposed method has an excellent search capacity and could balance globality and diversity.To verify the proposed method's effectiveness, the authors compared it with some state-of-the-art methods on sixty-six public JSSP and FJSSP instances.The comparative analysis confirmed the proposed method's effectiveness for classical JSSP and FJSSP in makespan, average utilization ratio, and maximum loading.Primarily, it obtains optimal-like solutions for several instances and outperforms others in most instances.
With the continuous development of global economics, modern industry is more and more complex 1,2 , causing a new challenge for implementing smart factories 3 .Job shop scheduling plays a core role in the process of building one smart factory, which has extracted more attention 4,5 .
The current methods for solving JSSP consist of exact and approximation methods.The exact methods that can obtain optimal solutions while it is very time-consuming and resource-consuming 6 , especially when meeting one large-scale JSSP instance.Therefore, most current methods mainly focus on approximated methods, including the simplest dispatching rules (DRs) and artificial intelligence (AI) 7 .Among these two methods, DRs such as first in first out (FIFO), shortest processing time (SPT), and earliest completion time first (ECTF) are the most straightforward and simplest but are far from optimal solutions 8 .On the contrary, the AI-based methods extract the hidden information from the JSSP instances to construct the corresponding rules more accurately within a tolerable time, which has been mainstream for solving JSSP.It mainly consists of the artificial immune algorithm 9,10 , genetic algorithm (GA) 11 , swarm intelligence (SI) 12 , local search (LS) algorithms, and networkbased approaches [13][14][15] , etc. GA and neural network-based (NN) methods have extracted more attention.
GA is one global searching algorithm with parallelism, robustness, wide applicability, and interpretability 16 , which has been widely used for solving JSSP-like optimization problems.For instance, Omar et al. applied one improved GA to solve JSSP 17 , in which they initialed the population with some well-known DRs rather than a random solution.Teekeng et al. proposed one improved GA for solving FJSSP by changing three operators: selection, crossover, and mutation 18 .Mohamed 19 proposed a new GA based on the island model for solving JSSP using a migration selection mechanism to evaluate and select the genes, whose effectiveness is demonstrated on 52 public JSSP instances.Li et al. 7 applied GA to search the global solution first, and then Tabu search was used to find the best local solution for solving both JSSP and FJSSP.Sun et al. 20 applied GA with variable neighborhood search for solving FJSSP.Besides, similar to the idea of GA, Lu et al. 21proposed an improved iterated greedy (IIG) algorithm to solve the distributed hybrid flow shop scheduling problem.They constructed three operators to search for the global path, and one LS algorithm consisting of four neighborhood structures is designed to find its best local path.Moreover, GA-based algorithms are developed to solve other JSSP-like problems, including timetabling scheduling 22,23 , traveling salesman problem (TSP) 24 , and network parameter optimization 25,26 .
The NN-based methods have two branches: traditional and deep reinforcement learning (DRL).Traditional learning methods for solving JSSP treat it as one sub-classification problem.It uses other well-known algorithms, such as DRs and GA, to obtain corresponding labels (the priority for each sub-task) and simultaneously calculates the corresponding statuses used to train the model.The trained model is used to predict the priority of each sub-task, which is converted into a JSSP pattern at the end.E. g., Weckman et al. 13 are the first to apply NN for solving JSSP.They utilized GA to solve 6 × 6 JSSP instances first, and then one NN with three hidden layers was adopted to predict each subtask's priority by inputting twelve features.The comparative results on ft06 27 indicated that the NN-based method outperforms attribute-oriented induction (AOI) and SPT but is still far from GA.
Recent deep learning (DL) technology has achieved great success in many fields, such as image classification 28 , fault diagnosis 29 , and medical healthcare 30 , due to its powerful feature extraction capacity.Also, DL has extracted attention in the field of JSSP.For instance, Zang et al. 31 applied a convolutional neural network (CNN) to extract the hidden features from ten input features and their transformations corresponding to the sub-task generated from GA. Shao et al. 14 employed GA to generate training samples and long-short-term memory (LSTM) with K-means to mine key hidden features for solving JSSP.Besides, Kim et al. 8 applied multi-level CNN (ML-CNN) to find the approximate global path and applied ILS to explore the best local solution for solving JSSP.
DRL 32 describes one JSSP as a Markov decision process (MDP), in which the DL part extracts rich hidden features that reflect the current dynamic production environmental state s to predict the corresponding reward r .The RL part records a pair of actions and rewards.Significantly, the current state will be transformed into a new state s ′ by doing action a and returning a reward r .The DRL arranges all sub-tasks in one JSSP instance by maximizing the total reward.E.g., Ye et al. 33 utilized DRL for resource scheduling, which utilizes one-dimension (1-D) CNN to extract the hidden dynamic features.Lin et al. 34 proposed a novel multi-class DRL-based method, deep Q network (DQN), to select the rule for each machine to arrange a corresponding job, in which six DRs are utilized.Considering the shortcoming of a single DQN that predicts and evaluates the action using the same model, double DQN (DDQN) is applied to solve JSSP within eighteen DRs 4 .Besides, Liu et al. 35 combined actorcritic with reinforcement learning (ACRL) to solve JSSP, and the comparative results in terms of makespan on some public JSSP instances indicated its effectiveness; and a graph network is combined with Q-learning to solve JSSP in traffic management 36 .
Although the abovementioned methods have obtained good performance, they still have some limitations, as described in Table 1.The exact method is the most accurate but cannot deal with large-scale JSSP instances and is time-consuming; DRs are simplest but not adequate 37 ; The GA-based method could obtain a near-optimal solution for JSSP instances due to its good global exploring ability, but it lacks some of the local searching ability; On the contrary, LS lacks global exploring ability; Traditional learning methods could solve JSSP fast but highly depends on other algorithms; DRL-based methods are effective and intelligent, but how to design dynamic input nodes and reward function still need to think more.
Table 1 shows that no algorithm can handle all JSSP-like optimization problems well.Besides, most current methods only focused on JSSP or FJSSP, except for 7 .They evaluated the proposed method in makespan, which could not satisfy human beings' needs.Motivated by those, this article presents one effective scheduler, GAILS, to solve multi-objective JSSP and FJSSP.In which an improved GA based on reference 7 is designed to find the approximate global solution for the JSSP and FJSSP instances.The initial chromosome of machine and subtask sequences are randomly set first.Then, three operators, including selection, crossover, and mutation, are designed to explore the global genes for each sequence.Moreover, the multi-object fitness function is designed by combining makespan, average utilization ratio, and maximum loading to choose the best global chromosome to guide ILS to explore the best local path.The reason for choosing ILS rather than other local searching algorithms is to find its best local path because ILS can ensure the solution's diversity by adjusting different perturbation strategies 38 .Powered by GA, ILS, and multi-object fitness function, the proposed method has an excellent searching capacity and could balance globality and diversity for solving JSSP and FJSSP.
The main contributions of this article are summarized as follows: 1.An improved GA is proposed to find the global solution of JSSP and FJSSP instances using three new operators: selection, crossover, and mutation.The comparative results showed that the improved GA is more effective than traditional GA. 2. The ILS is applied to explore the optimal local path from GA obtained global path, which ensures the solution is near optimal.www.nature.com/scientificreports/ 3. A multi-object fitness function that contains makespan, average utilization rate (AUR), and maximum loading (ML) is designed to select the best global and local path, which could be easily extended to other optimization algorithms.Besides, it can easily attach personal goals for different production statutes by adjusting their order in the fitness function.4. Based on the good design of GA, ILS, and multi-object fitness function, the proposed method has an excellent searching capacity.It could balance globality and diversity for solving JSSP and FJSSP.The Comparative analysis based on sixty public instances confirmed its effectiveness in terms of makespan, average utilization rate, and maximum loading.In addition, the effectiveness of GA and ILS has been analyzed in the proposed method.
The rest of this article is arranged as follows.Section "Problem definition" defines the JSSP and FJSSP.Section "The proposed methods" presents the proposed method in detail.Section "Experimental verification" performs the experimental verification based on public JSSP and FJSSP instances.In section "Discussion", we discuss the proposed method in depth.Section "Conclusions" concludes this article.

Problem definition
JSSP aims at arranging n jobs J = {J 1 , J 2 , . . ., J i . . ., J n } to be processed by m machines M = {M 1 , M 2 , . . ., M j , . . ., M m } with satisfactory metrics such as makespan, AUR, and ML.Where each job J i consists of needs to be processed by a functional machine M j within a particular time T i,j ∈ T = {T i,1 , T i,2 , T i,3 , . . ., T i,k , . . ., T i,n i } .Notice that one operation in the JSSP instance can only be processed once by one certain machine.
Unlike classical JSSP, FJSSP needs to determine both a job operation and the corresponding machine to execute the selected operation to attach good criteria.That is, each operation O i,j ∈ O needs to be processed by a machine M i,j, out of a given set M s ∈ M .From the definition of JSSP and FJSSP, we know that FJSSP is one complex kind of JSSP.Generally, both JSSP and FJSSP pursue finding the minimized makespan, defined as (1).Where C i,k is the completion time of k th operation for job i , and C max is the maximum completion time for all operations.Besides, this manuscript aims at developing one accurate algorithm to attach multiple goals, including AUR, and ML, as shown in (2) for AUR, and (3) for ML.Where End i = max C i,j m i is the ending time of machine m i , and idle i is the idle time of m i .
To simplify the problem, we define four constraints for both JSSP and FJSSP, as follows: Constraint 1: Starting time constraint, Eq. 4 (a) indicated that the completing time C i,k equals its operation time T i,1 , which indicates that all jobs start from zero.
Constraint 2: Operation order constraint, Eq. 4 (b) indicated that one job J i has specific orders , T i,3 , . . ., T i,n i } ∈ T for JSSP since the difference between C i,k+1 and C i,k is greater or equal to the opera- tion time T i,k+1 .For FJSSP, the only difference is that each sub-operation O i,k requires selecting the best machine M i,j from a given machine set M s to execute within the corresponding time duration.That is, the next sub- operation will start after completing the previous sub-operation.
Constraint 3: Resource constraint, Eq. 4 (c) indicated that the machine M j can only process one given sub- operation O i,j at once.Where different sub-operations for the i th job's completing time difference C i,k − C i,j should be greater or equal to the k th sub-operation time T i,k .
Constraint 4: Eq. 4 (d) showed that we do not consider the set-up and transmission times during scheduling.

The proposed methods
The proposed method consists of two parts: GA finds the global path (step 1 to step 6), and ILS explores the optimal local path (step 7 to step 9), whose workflow is shown in Fig. 1.The overall procedure of the proposed method is described in the subsequent sections.
Step 1: Setting the parameters of the proposed method, including max generation Gen , population size Pop size , crossover ratio Cr , and mutation ratio Mr .Setting a bigger Gen and Pop size may receive more satisfactory results, but they require massive resources to find the global path.Considering both performance and time costing, we set Gen and Pop size as 400, which is similar to the work of Gao 7 .Moreover, the relatively bigger crossover and smaller mutation ratios can ensure gene diversity while simultaneously preserving excellent genes to optimize the algorithm.Thus, we set the crossover ratio Cr and mutation ratio Mr as 0.8 and 0.1, respectively.
(1) } will be processed by machine {3,3,1,1,2}, respectively.After obtaining the final chromosomes, the decoding method generates the FJSSP pattern in step 9.The JSSP only needs to update OS while all elements of MS are equal to 0 since it only requires one machine for one sub-operation.
Step 3: Evaluate the population.If Gen is up to 400, it will output the global solution and feed it into ILS in step 7. Else, go to step 4. The evaluation metric is the combination of { Makespan,AUR, ML }.The makespan is defined as (1), AUR and ML are expressed as (2) and (3).Noticing that the traditional JSSP instance's operation-machine pair is already given and cannot change during the scheduling.Therefore, the ML is the same for all methods www.nature.com/scientificreports/ in JSSP but is different in FJSSP.As a result, the proposed method will first evaluate the population by C max ; if several solutions have the same C max , then check AUR for JSSP and check AUR and ML for FJSSP, respectively.
Step 4: Selection operator.The proposed method combined elitist and tournament selection methods as selection operators.Mainly, elitist selection copies 5% of individuals from the original population Pop as a part of the new population newPop .The rest 95% of the new population is generated from the tournament selec- tion algorithm.The tournament selection algorithm sets k = 2 to select the rest of the individuals.That is, two individuals are evaluated using the fitness function Best = {C m ,AUR, ML} , and the best one will be selected and added to the new population.The whole algorithm, as described in Algorithm 2.

Algorithm 2. Selection algorithm
Step 5: Crossover operator.The proposed method adopted precedence operation crossover (POX) and jobbased crossover (JBX) for OS string.Each selected 50% randomly to crossover the OS string and adopted a two-point crossover for the MS string, which is identical to 7 .
Step 6: Mutation operator.The proposed method applies neighbor mutation for 15% of the OS string.The process of neighbor mutation is described in the following steps and Fig. 3 (a).
1) Randomly select three different elements in parent P and generate all neighbors of the OS string.
2) Randomly select one neighbor as the current OS string, denoted as C. Also, adopting a job-based half mutation operator for the MS string, as shown in Fig. 3 (b).The half gene in each job will be mutated using a job-based half-mutation operator.After mutation operation, set Gen = Gen + 1 , and go to step 3.
Step 7: Output the global solution and feed it into ILS.
Step 8: The ILS algorithm explores the optimal local path for the JSSP and FJSSP instances.We set the maximum iteration to be 10, 000 and the maximum no-improved value for make-span is 0.02.The ILS algorithm used in this article is the same as our previous paper 8 .
Step 9: If some criteria are satisfied (generation step up to 10,000 or no improved value is less than 0.02) in the ILS algorithm, output the solution.The final solution will be decoded into JSSP or FJSSP pattern using reference 7 .Else, go to step 8.

Experimental verification
The authors implemented the proposed method based on the system of Ubuntu 16.0.4with Intel(R) i7-7700 CPU at 3.60 GHz, and the programming language is Python 3.5.Moreover, we compared the proposed method with some leading methods to indicate its effectiveness for both classical JSSP and FJSSP in some public instances.
The results indicated that the proposed method outperforms others for all JSSP instances.Besides, the GA1 applied in the proposed method performs better than GA 39 .ILS performs better than GA1 on ft10 and ft20.We calculate the scheduling score score = C optimal C al , as shown in Fig. 4, except method ACRL 35 since it is incomplete.Where C al and C Optimal are the makespans of each method and optimal solution.The results indicated that the proposed method obtained scheduling scores higher than 90% for six JSSP instances and outperformed others.The averaged scheduling scores are also given in Table 2.The results confirmed the proposed method's effectiveness, with an average scheduling score of 96.94%.To show the priority of the proposed improved GA1, we compare it with GA 39 .The calculation result indicated that GA1 had improved a 36.20%= (94.92-69.69)/69.69scheduling score compared to GA 39 .Also, the application of ILS has improved by 2.13% = (96.94-94.92)/94.92 of the average scheduling score, which is conducted by comparing the proposed method with GA1.The priority of each method could be ranked as: The proposed > GA1 > ILS > DDQN > HDNN > GA.
We also compare the proposed method with the current leading learning-based methods, DDQN 4 , ACRL 35 , ML-CNN 8 , and GA1, ILS, on more la01 to la20 41 .The results in terms of makespan are shown in Table 3.The findings showed that the proposed method performs much better than ACRL 35 on la11 to la 15, whose solutions are optimal, while ACRL 35 is not for la12, la133, and la15.Besides, the proposed method won all cases for twenty JSSP instances compared to other algorithms.In addition, it received eighteen optimal solutions except for la20.It indicated that the proposed method outperforms others and could effectively solve JSSP in terms of makespan.The solution of la16 using the proposed method is shown in Fig. 5, whose makespan is 945.
To see the difference between the proposed method and others, we calculate each method's average scheduling score except ACRL 35 , as shown in Fig. 6.The results indicated that the proposed method is the most near to the optimal method, whose average scheduling scores are 99.97%.Besides, all method's scheduling scores are  The proposed > ML-CNN > ILS > DDQN > ILS.In addition, the application of ILS has improved the scheduling scores from 98.84 to 99.97, proving that the GA lacks some local search capacity and that ILS could guide GA to find the best local path.

Average utilization rate (AUR)
The proposed method aims at optimizing multiple objects, including makespan, AUR, and ML, for each instance.
Here, we give the AUR for each JSSP instance using GA1, ILS, and the proposed method since all MLs are the same for JSSP, as shown in Fig. 7.The results showed that the proposed method won fourteen times out of twenty in terms of AUR, including la01, la02, la05, la06, la07, la09, and la12-la19.On the contrary, GA only won one time on la12, and ILS won five times out of twenty, including la03, la04, la08, la10, and la20, respectively.The results confirmed each component's effectiveness again in terms of AUR.In summary, the proposed method could process JSSP effectively within a satisfactory makespan and AUR.

Verification for FJSSP
The above section has confirmed the effectiveness of the proposed method for solving JSSP.This section focuses on verifying its effectiveness for FJSSP.We compared the proposed method with existing leading methods, including TSN1 and TSN2 44 , the improved GA1, and ILS on forty FJSSP instances from rdata 44 .

Makespan
The comparative results in terms of makespan are shown in Table 4.The results indicated that the proposed method won thirty-seven times out of forty FJSSP instances in terms of makespan, while the components of GA1 and ILS won zero.It illustrates that only using GA1 or ILS cannot solve FJSSP well since GA lacks local exploring capacity while ILS lacks global searching capacity.Combining GA and ILS could solve FJSSP effectively.TSN1 and TSN2 won six and seven times out of forty FJSSP instances.Moreover, ILS generally performs better than GA1.Similar to makespan, the scheduling score results showed that the proposed method is near 99% and won 37 times out of 40 FJSSP instances.Those methods could be ranked as: The proposed > TSN2 > TSN1 > ILS > GA.
One example of la19's solution using the proposed method is given in Fig. 8, whose makespan is 704.
To see each method's difference, we calculate the average scheduling scores of each method, as shown in Fig. 9.The results confirmed that the proposed method is one near-optimal method for solving FJSSP, whose average scheduling score is 99.0%.Another finding is that only using GA1 or ILS cannot solve FJSSP well, as their average scheduling scores are 93.45% and 95.48%, which are far from the proposed method.The performance  of each method for solving FJSSP could be ranked as: The proposed > TSN1 > TSN2 > ILS > GA1 according to average scheduling scores.

Average utilization ratio (AUR)
The AUR illustrates each machine's utilization ratio during the whole production process.Generally, the higher the AUR, the better performance the algorithm shows.We calculate the AUR of each method on forty FJSSP, as shown in Fig. 10.The results showed that the proposed method performed better and won most cases.It won thirty-three times out of 40 FJSPP instances, including la02-la13, la15, la16, la18, la19, la22-la24, la26-la30, and la32-la40, respectively.On the contrary, GA1 and ILS only won eight and six times out of forty.The proposed method has an absolute advantage on large-scale FJSSP instances conducted from la23-la40.Moreover, all methods perform well on small-scale FJSSP instances, from la01 to la16, whose AURs are high up to 99%.The above findings indicated that the proposed method could arrange each sub-operation well on the selected machine to execute for solving FJSSP, and only using GA or ILS cannot obtain satisfactory AUR.

Max loading (ML)
The max loading (ML) represents each machine's loading capacity.The huge load may damage the machine and result in a delay in the whole manufacturing process.Therefore, testing the proposed method's ML for each FJSSP instance is necessary.The results showed that the proposed method has a low ML compared to GA1 and ILS, as shown in Fig. 11.The proposed method won thirty-three times out of forty instances, including la01-la18, la22, la23, and la25-la37, respectively.However, GA1 only won six times, including la19, la21, la24, la38, la39, and la 40, respectively; and ILS only won la20.The above evidence showed that the proposed method could deal with FJSSP with low max loading, and only using GA1 or ILS cannot find the best solution due to the lack of local exploring and global searching capacities.In summary, the proposed method could process FJSSP instances within satisfactory makespan, AUR, and ML due to its excellent global search and local exploring capacities.

Discussion
Job shop scheduling is critical in building one smart factory regarding resource supply and intelligent production.Most current methods only focus on one type of job shop scheduling: JSSP or FJSSP, and single-object, which cannot satisfy human beings' needs.This article proposes an effective scheduler, GAILS, to solve JSSP and FJSSP with multiple objects, including makespan, AUR, and ML.
Considering each algorithm's advantages and disadvantages, as summarized in Table 1.The proposed GAILS applied GA to find the global path and guide ILS to explore the optimal local path.In GA, three improved operators, including selection, crossover, and mutation operators, are utilized to find the best chromosome for each instance.Therefore, the proposed method has an excellent search capacity and could balance globality and diversity.The whole process of the proposed method includes nine steps, as shown in Fig. 1.Steps 1-6 are to find the global path, while steps 7-9 are for best local path exploring.
To verify the proposed method's effectiveness, we tested and compared the proposed method and several leading methods based on sixty-six JSSP instances.We compared the proposed method with GA 39 , DDQN 4 , ACRL 35 , HDNN 31 , and ML-CNN 8 on twenty-six JSSP instances to validate its effectiveness for solving classical JSSP.The results in terms of makespan showed that the proposed method outperforms others, which can be seen in Tables 2 and 3. Besides, we calculated their scheduling scores to see their performance compared to the optimal method.The results indicated that the proposed method is near the optimal method, whose average scheduling score is higher than 95%, which could be conducted in Figs. 4 and 6.
To verify each component's effectiveness for solving JSSP in the proposed method, we compared it with GA1 and ILS.The results showed that only using GA1 or ILS cannot solve JSSP effectively, as shown in Tables 2, 3, and Figs. 4 and 6.One solution using the proposed method for solving la16 is given in Fig. 5.The AUR testing results indicated that the proposed method could deal well with JSSP with a good AUR, as shown in Fig. 7.
Moreover, we tested and compared the proposed GAILS with TSN1 and TSN2 44 on forty FJSSP instances to validate its effectiveness.The results in terms of makespan indicated that the proposed method performs the best.It won thirty-seven times out of forty, as shown in Table 4. Similar to JSSP, we calculated the scheduling score of the proposed method, and the results showed that the proposed method could receive 99.0% of the average scheduling score for solving FJSSP, as shown in Fig. 9.It indicated that the proposed method is one near-optimal solution for FJSSP.Besides the comparative results between the proposed GAILS and GA1, ILS has confirmed each component's effectiveness.Another finding is that using GA1 or ILS alone cannot solve FJSSP well, as their average scheduling scores are 93.45% and 95.48%, which are far from the proposed method.One solution using the proposed method based on the la19 FJSSP instance is given in Fig. 8, whose makespan is 704.
The AUR results showed that the proposed method could deal with FJSSP instances well with satisfactory AUR, as shown in Fig. 10.The proposed method has an absolute advantage on large-scale FJSSP instances.
The ML testing results showed that the proposed method could arrange each operation on the selected machine well and has a small ML, which could be conducted in Fig. 11.The comparative results between the proposed method and GA1, ILS, confirmed the proposed method's effectiveness again.
In summary, the proposed method could effectively process both JSSP and FJSSP within multiple objectives.By changing the order of makespan, AUR, and ML in the fitness function, we can easily receive multiple solutions for different production statuses.However, GA is much more time-consuming as it requires executing the selection, crossover, and mutation operations 400 hundred times.Respectively, it takes almost half-day to process la40 while ILS only needs ten seconds.How to design one effective and time-saving GA to search global path is worth thinking more about.

Conclusions
This article proposes an effective job shop scheduler, GAILS, to solve both JSSP and FJSSP within multiple objects, including makespan, AUR, and ML.In the proposed method, GA is used to search approximate global solutions, and the searched solution is fed into ILS to explore the best optimal local solution.In the GA, three improved operators, including selection, crossover, and mutation, are designed to select the best chromosome for the global solution by using one combination fitness function made of makespan, AUR, and ML.Thus, the proposed method has an excellent searching capacity and could balance globality and diversity.The comparative analysis based on sixty-six instances has confirmed the effectiveness of the proposed method for both JSSP and FJSSP.It received a 96.94% average scheduling score in large-scale JSSP instances (see Table 2), won all cases on la01-la20 JSSP instances in terms of makespan, and won fourteen times out of twenty in terms of AUR.For FJSSP, it won thirty-seven, thirty-three, and thirty-three times out of forty FJSSP instances in terms of makespan, AUR, and ML, respectively.
As discussed in the above section, the GA used in the proposed method is much more time-consuming.In the future, we will focus on designing one time-saving GA to combine with ILS for solving JSSP and FJSSP.Besides, we will compare the proposed method with other multi-objective JSSP algorithms to validate its effectiveness.
: an effective multi-object job shop scheduler based on genetic algorithm and iterative local search Xiaorui Shao 1 , Fuladi Shubhendu Kshitij 2 & Chang Soo Kim 2*

Figure 1 .
Figure 1.The workflow of the proposed GAILS for solving JSSP and FJSSP.

Figure 3 .
Figure 3. Mutation operator for OS and MS.

Figure 4 .
Figure 4.The scheduling scores for each method.

Figure 5 .
Figure 5.The solution of la16 with the proposed method.

Figure 6 .
Figure 6.The average scheduling scores of each method for solving JSSP on la01-la20.

Figure 7 .
Figure 7.The average utilization ratio of each method for solving JSSP on la01-la20.

Figure 8 .
Figure 8.The FJSSP solution of la19 using the proposed, whose makespan is 704.

Figure 9 .
Figure 9.The average scheduling scores of each method for solving FJSSP on la01-la40.

Figure 10 .
Figure 10.The AUR of each method for solving FJSSP on la01-la40.

Figure 11 .
Figure 11.The ML of each method for solving FJSSP on la01-la40.

Table 1 .
The description of each method for JSSP.
DRLEffective and intelligent Hard to select input nodes and reward function

Table 2 .
The comparative results for solving JSSP in terms of makespan.
near 99%, but the proposed method is the highest.According to the average scheduling scores, they can rank as:

Table 3 .
The comparative results for solving JSSP in terms of makespan.Significant values are in bold.

Table 4 .
The comparative results for FJSSP in terms of makespan.Significant values are in bold.