Comparison of schedule generation schemes for designing dispatching rules with genetic programming in the unrelated machines environment
Graphical abstract
Introduction
Scheduling problems have been extensively researched in the literature due to their complexity and applicability in different areas. In general, scheduling is defined as the process in which a certain set of jobs (activities) has to be scheduled on a scarce set of machines (resources) to optimise some user-specified criteria [1]. Scheduling problems are quite widespread and have applications in different areas from the medical sector [2], [3], workforce scheduling [4], biopharmaceutical companies [5], and many others. Since most scheduling problems are NP-hard, the majority of researchers focused on either designing new problem-specific heuristic methods or applying existing metaheuristic methods. However, the type of methods that can be applied depends on the conditions under which the schedule has to be constructed. For example, if all the information about the schedule is known beforehand, then the entire schedule can first be constructed and then executed. In such static conditions, it is possible to use a great number of heuristic and metaheuristic methods to construct the schedules [6], [7], [8].
Metaheuristics have become one of the most popular methods used for solving not only scheduling but also other continuous or combinatorial optimisation problems. Among them, the most prevalently used are some of the older and most acclaimed methods like genetic algorithms [9], particle swarm optimisation [10], and ant colony optimisation [11]. However, in recent years a plethora of new metaheuristic methods, which usually mimic various natural phenomena or animal behaviour, have been designed by different researchers. Some of these newer metaheuristic algorithms include the sine–cosine optimisation method [12], grey wolf optimisation [13], whale inspired optimisation algorithms [14], [15], moth flame algorithm [16], salp chain optimisation methods [17], [18], and many others.
Aside from the aforementioned methods that search for the optimal solution of only one problem instance, methods like genetic programming (GP) [19], gene expression programming (GEP) [20], Cartesian genetic programming (CGP) [21], and others have also been proposed. These methods differ in the sense that they can be used to evolve a strategy or heuristic that can solve a set of problems, rather than only one problem instance. GP has not only demonstrated the ability to obtain good solutions for many different problems [22], [23], but also that it is highly appropriate of being applied as a hyperheuristic method, i.e. a method for automatic design of novel heuristics [24], [25], [26], [27], [28], [29]. In recent years, GP and similar methods were applied for automatic generation of heuristics for various problems like the capacitated arc routing problem [30], [31], [32], timetabling problem [33], [34], [35], vehicle routing problem [36], design of pipeline networks [37], and multidimensional knapsack problem [38].
In the case when scheduling is performed under dynamic conditions, the number of methods that can be used to construct the schedule is limited. This is because the characteristics of jobs become available during the execution of the system and are not known at the beginning. Thus, algorithms that search the solution space, as most metaheuristics do, cannot be applied to these problems without modifications, since they would not have all the necessary information to construct valid solutions. Such scheduling problems are usually solved by using constructive heuristics, which iteratively construct the schedule during the execution of the system. Constructive heuristics are most often designed in the form of dispatching rules (DRs), which rank all the jobs by a certain priority calculated based on selected job and system parameters, and then schedule the job with the highest priority [39], [40], [41]. Therefore, DRs do not need all the information about the problem, but rather use only the information that is currently available to construct the schedule. However, DRs are problem-specific heuristics, which means that different DRs need to be designed for optimising different criteria and solving different kinds of scheduling problems. Designing DRs is not a trivial task, and a lot of domain knowledge and experience is necessary to design effective DRs. This is a serious drawback since it would mean that DRs would need to be manually designed for all possible scheduling problems that could appear, which is not feasible.
Fig. 1 illustrates how a DR could schedule a certain set of jobs in a simple scheduling problem. In this example, six jobs need to be scheduled on three available machines starting from a certain time point . The DR is invoked each time a machine is free and decides which job to schedule on which machine. At the start of the system, the DR selects and schedules one job on each of the machines as all three machines are free. Based on the properties of jobs, the DR ranks all the jobs and selects the best one, which would in this case be job . The DR then schedules this job on one of the machines that are free. In this case, it would schedule the selected job on machine , as denoted in Fig. 1(a). Since some machines are still available, the remaining jobs are ranked again, and the best job is selected and scheduled on a free machine. This is illustrated in Fig. 1(b), where job is selected and scheduled on machine . Machine is still available, therefore the entire procedure is repeated once again, after which job is selected and scheduled on machine . At this point, there are no free machines, and the system executes those jobs that are currently scheduled on the machines until a certain machine becomes available again. This happens at time moment , when machine finishes executing its job. At that point, the DR is invoked again and determines that job should be executed on that machine. This is shown in Fig. 1(d). After this, the machines continue executing until machine becomes available at time moment . The entire procedure is repeated, and the DR selects and schedules job on machine , as shown in Fig. 1(e). Finally, the DR is invoked one last time at moment when machine becomes available once again. Since only job is left, the DR selects and schedules it on machine , as illustrated in Fig. 1(f). The machines would then continue executing until all the jobs are completed.
In recent years, a great deal of research focused on applying GP and similar methods for the automatic creation of DRs. In this approach, the DR is decomposed into two parts, a priority function (PF) used to calculate the priorities of jobs, and a schedule generation scheme (SGS) that uses the PF to construct the schedule. Such an approach of designing DRs has demonstrated to be quite efficient, not only because new DRs can be designed in a smaller amount of time, but also since the automatically designed DRs perform equally well or even better than existing manually designed DRs. As a consequence, the topic became extensively researched [42], [43]. However, the entirety of research focused almost exclusively on designing PFs, while the SGS part did not receive a lot of attention. One of the main reasons for this is that most research focused on the job shop environment, in which the only decision that had to be made was the ordering of jobs. Therefore, the SGS only had to rank all the jobs using the PF and then schedule them in that order. However, research in different scheduling environments has already demonstrated that even subtle differences in the design of the SGS can lead to a significant difference in the obtained results [44]. Therefore, in environments in which ordering the jobs is not the sole decision that has to be made, the SGS also has a more significant influence on the quality of the constructed schedule. For example, in some environments, it is additionally required to determine to which machine the selected job will be allocated, like in the parallel machines environment. Therefore, the SGS does not only have to rank the jobs but also in a certain way determine how to allocate them to different machines. Thus, they are required to perform an additional decision that can have a significant effect on the quality of the constructed schedules. Even though DRs have already been generated for the unrelated machines environment, the design and choice of an appropriate SGS have still not received much attention, and thus it is not known whether better results could be obtained by performing different design choices.
Because of the above reasons, the goal of this paper is to analyse how different designs of the SGS can affect the performance of automatically generated DRs in the unrelated machines environment. Therefore, in addition to the existing SGS used in the literature for the unrelated machines environment, two additional schemes are proposed. One proposed SGS is modelled to more closely resemble the schemes used in manually designed DRs. By using this scheme it will be possible to determine whether the existing manually designed DRs already present the best that can be obtained or whether it is possible to fine-tune the PF even further. The second SGS is modelled with the motivation to separate the choice of selecting the next job and the machine it will execute on into two independent PFs, which was not the case until now. This division should hopefully lead to the design of more interpretable PFs. Furthermore, the paper also analyses the influence of several design choices, like selecting whether to schedule jobs with the smallest or largest priority value, or whether to take the absolute value of the priorities, which have also not been considered until now. The influence of using an SGS with and without idle times will also be analysed, as in the unrelated machines environment this decision largely affects the construction process of the schedule. Although it is intuitively expected that using idle times should lead to better schedules, we were unable to find any research in designing DRs to support this claim. A detailed analysis of the evolved DRs is also performed, both based on the interpretability of the evolved PFs, and the decisions performed by the different DRs. The analysis shows that the main reason for the superior performance of the automatically designed DRs lies in their ability to evolve the strategy by which to allocate jobs on machines. This observation can influence how DRs are designed, especially the manually designed ones, as it demonstrates the significance of the decision of allocating jobs to machines, and the limitation of the scheme used by manually designed DRs. Therefore, instead of putting most focus on designing the PF which ranks the jobs, equal attention should be placed also on designing better schemes for allocating jobs on machines. The contributions of the paper can be summarised through the following points:
- 1.
Comparison of three SGS variants for the unrelated machines environment, two of which are proposed in this paper
- 2.
Analysis of the influence of selecting jobs with highest or lowest priorities, taking absolute values of priorities, and inserting idle times in the schedule
- 3.
A detailed analysis of the scheduling decisions performed by the SGS variants showing that a superior performance can be obtained by those SGS variants which also use a PF for the allocation of jobs to machines
The rest of the paper is organised as follows. Section 2 gives a short overview of the existing research performed in the area of automatic design of DRs by GP. Section 3 provides background information about scheduling in the unrelated machines environment and designing new DRs with GP. The SGS variants are described in Section 4. Section 5 describes the experimental design and outlines the selected parameter values for performing the experiments. The results obtained from the performed experiments are presented in Section 6. Section 7 provides an analysis of several PFs that were designed for different SGS variants. The discussion about the obtained results and the performed analysis is given in Section 8. Finally, the conclusion and directions for further research are given in Section 9.
Section snippets
Literature overview
The topic of automatically designing DRs for various scheduling problems has become quite extensively researched in the literature. In the first attempts, GP was applied to generate DRs for the single machine and job shop environments [45], [46]. Even in those first studies, it became evident that GP holds great potential for the automated design of DRs. Further research in this area has focused on many different topics, mostly to improve the results of the generated DRs, or to apply them to
Unrelated machines environment
The unrelated machines environment is a scheduling environment in which several machines that can process jobs are executing in parallel. This environment belongs to the class of single stage environments, which means that each job needs to be executed on a single machine to be completed. The unrelated machines environment is a special type of the parallel machines environment, in which each job has a different execution time on each of the machines. These execution times are completely
Schedule generation schemes
This section gives details about some SGS variants that can be defined for the unrelated machines environment.
Parameters and experimental setup
For the PF design, the standard GP algorithm based on the steady state tournament selection process is used. The outline of this algorithm is denoted by the flowchart in Fig. 3. At the start, the algorithm randomly initialises the population of individuals. After that, the algorithm randomly selects 3 individuals from the population which form the tournament. The two best individuals in the tournament are selected to participate in the crossover. Since several crossover operators can be
Experimental results
The results for all the tested SGS variants that use idle times are collected in Table 5, with the best results denoted in bold for each SGS. The priority columns denote whether the maximum or minimum value of the PF is used for selecting machines and jobs. Furthermore, the results for the three previously outlined manually designed DRs are also included in the table. Since all three DRs are deterministic, only a single value is denoted for them. It can immediately be seen that all the proposed
Analysis of the generated PFs
In this section, the different PFs which were generated by GP for the tested SGS variants are analysed to gain knowledge about their behaviour and mutual differences. For each SGS the corresponding PF with the best performance on the test set was selected. All the PFs were additionally simplified by removing parts which do not significantly influence the performance of the DR (meaning that the performance of the DR in question did not change by more than 1% on the entire test set), so that the
Discussion
The experimental results and analysis which were presented in the previous two sections show that the performance of the generated DRs significantly depends on the SGS variant that is used. Out of the three tested SGS variants, the heuristic SGS has achieved the worst results, while the twotrees and simple SGS achieved similar results, with the simple SGS being usually slightly better. The general conclusion which can be made based on these results is that it seems that the main strength of
Conclusion
This paper analysed several SGS variants for the automatic generation of DRs in the unrelated machines environment. The proposed SGS variants were tested in different ways for optimising the criterion. Generally, it was demonstrated that the SGS in which the PF is used to only select the job, while the machine on which it will be executed is selected by a predefined heuristic, achieves the worst performance out of the tested SGS variants. The other two SGS variants achieved a similar
CRediT authorship contribution statement
Marko Đurasević: Conceptualization, Software, Methodology, Validation, Formal analysis, Investigation, Writing - original draft, Writing - review & editing, Visualization. Domagoj Jakobović: Conceptualization, Validation, Writing - original draft, Writing - review & editing.
Declaration of Competing Interest
The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.
References (101)
- et al.
Dynamic scheduling of multi-product continuous biopharmaceutical facilities: A hyper-heuristic framework
Comput. Chem. Eng.
(2019) - et al.
A hybrid differential evolution algorithm with column generation for resource constrained job scheduling
Comput. Oper. Res.
(2019) - et al.
A comparative study of solution representations for the unrelated machines environment
Comput. Oper. Res.
(2020) - et al.
An opposition-based sine cosine approach with local search for parameter estimation of photovoltaic models
Energy Convers. Manage.
(2019) - et al.
Efficient boosted grey wolf optimizers for global search and kernel extreme learning machine training
Appl. Soft Comput.
(2019) - et al.
Multi-strategy boosted mutative whale-inspired optimization approaches
Appl. Math. Model.
(2019) - et al.
An efficient chaotic mutative moth-flame-inspired optimizer for global optimization tasks
Expert Syst. Appl.
(2019) - et al.
Asynchronous accelerating multi-leader salp chains for feature selection
Appl. Soft Comput.
(2018) - et al.
Recent advances in selection hyper-heuristics
European J. Oper. Res.
(2020) - et al.
A study of heuristic combinations for hyper-heuristic systems for the uncapacitated examination timetabling problem
European J. Oper. Res.
(2009)
A unified framework of graph-based evolutionary multitasking hyper-heuristic
IEEE Trans. Evol. Comput.
Dynamic mapping of a class of independent tasks onto heterogeneous computing systems
J. Parallel Distrib. Comput.
A comparison of eleven static heuristics for mapping a class of independent tasks onto heterogeneous distributed computing systems
J. Parallel Distrib. Comput.
Evolving priority rules for resource constrained project scheduling problem with genetic programming
Future Gener. Comput. Syst.
Evolving dispatching rules using genetic programming for solving multi-objective flexible job-shop problems
Comput. Ind. Eng.
Evolving priority scheduling heuristics with genetic programming
Appl. Soft Comput.
Evolutionary generation of dispatching rule sets for complex dynamic scheduling problems
Int. J. Prod. Econ.
An investigation of ensemble combination schemes for genetic programming based hyper-heuristic approaches to dynamic job shop scheduling
Appl. Soft Comput.
Evolving priority rules for on-line scheduling of jobs on a single machine with variable capacity over time
Appl. Soft Comput.
Improving genetic algorithm performance by population initialisation with dispatching rules
Comput. Ind. Eng.
Adaptive scheduling on unrelated machines with genetic programming
Appl. Soft Comput.
Scheduling unrelated parallel machines with optional machines and jobs selection
Comput. Oper. Res.
Evaluation of mixed integer programming formulations for non-preemptive parallel machine scheduling problems
Comput. Ind. Eng.
Scheduling: Theory, algorithms, and systems
A genetic algorithm for radiotherapy pre-treatment scheduling
Nurse rostering problems
Workforce scheduling and routing problems: literature survey and computational study
Ann. Oper. Res.
Evolutionary scheduling: A review
Genet. Program. Evol. Mach.
Genetic Algorithms in Search, Optimization and Machine Learning
Particle swarm optimization
Ant system: optimization by a colony of cooperating agents
IEEE Trans. Syst. Man Cybern. B
An enhanced associative learning-based exploratory whale optimizer for global optimization
Neural Comput. Appl.
Chaos-induced and mutation-driven schemes boosting salp chains-inspired optimizers
IEEE Access
A Field Guide to Genetic Programming
Gene expression programming: a new adaptive algorithm for solving problems
Complex Syst.
A survey on the application of genetic programming to classification
IEEE Trans. Syst. Man Cybern. C
Human-competitive results produced by genetic programming
Genet. Program. Evol. Mach.
Automatic heuristic generation with genetic programming
Exploring hyper-heuristic methodologies with genetic programming
Comput. Intell.
Hyper-heuristics: a survey of the state of the art
J. Oper. Res. Soc.
A classification of hyper-heuristic approaches: Revisited
The general combinatorial optimization problem: Towards automated algorithm design
IEEE Comput. Intell. Mag.
Genetic programming hyper-heuristics with vehicle collaboration for uncertain Capacitated arc routing problems
Evol. Comput.
Novel ensemble genetic programming hyper-heuristics for uncertain capacitated arc routing problem
A predictive-reactive approach with genetic programming and cooperative coevolution for the uncertain Capacitated arc routing problem
Evol. Comput.
A review of hyper-heuristics for educational timetabling
Ann. Oper. Res.
A hyper-heuristic with two guidance indicators for bi-objective mixed-shift vehicle routing problem with time windows
Appl. Intell.
Parallel hyperheuristic algorithm for the design of pipeline networks
Ind. Eng. Chem. Res.
A genetic programming hyper-heuristic for the multidimensional knapsack problem
Kybernetes
Cited by (25)
Collaboration methods for ensembles of dispatching rules for the dynamic unrelated machines environment
2023, Engineering Applications of Artificial IntelligenceAutomated design of heuristics for the container relocation problem using genetic programming
2022, Applied Soft ComputingCitation Excerpt :Automated design of heuristics has probably achieved the largest application in scheduling [26,27], where GP was used to design heuristics for different machine environments like the one-machine problem [28], job shop scheduling [29–31], unrelated machine environment [32,33], and resource constrained project scheduling problem [34,35]. In recent years, various research directions in the automated design of heuristics were investigated like ensemble learning [36–40], multi-objective optimisation [41,42], surrogate models [43,44], multitask GP [45], solution construction strategies [46], feature selection [47], and many others. In this study, GP is applied for constructing simple RRs, which iteratively determine how the containers should be relocated.
Local search based methods for scheduling in the unrelated parallel machines environment
2022, Expert Systems with ApplicationsSelection of dispatching rules evolved by genetic programming in dynamic unrelated machines scheduling based on problem characteristics
2022, Journal of Computational ScienceCitation Excerpt :Some recent studies investigated the possibility of generating DRs for the resource-constrained project scheduling problem [43,44] and the single-machine variable capacity problem modelled from a real-world problem [16,45]. For both problem variants, it was shown that using GP it was possible to evolve DRs that perform significantly better than existing manually designed DRs. In order to improve the results of the generated DRs and gain better insight into the decision-making process they perform, different schedule generation schemes that can be used in automatically designed DRs were analysed and compared in [46]. The results suggest that it is important that GP can develop a DR that performs both sequencing and scheduling decisions.