Elsevier

Applied Soft Computing

Volume 110, October 2021, 107606
Applied Soft Computing

Ensembles of priority rules for resource constrained project scheduling problem

https://doi.org/10.1016/j.asoc.2021.107606Get rights and content

Highlights

  • Ensembles of priority rules were created.

  • Four different learning methods for creating ensembles were used.

  • Two different methods for combining individual rules in ensembles were analyzed.

  • The ensemble subset search method was applied to created ensembles.

  • Ensembles of priority rules achieved better results than single priority rule.

Abstract

Resource constrained project scheduling problem is an NP-hard problem that attracts many researchers because of its complexity and daily use. In literature there are a lot of various solving methods for this problem. The priority rules are one of the prominent methods used in practice. Because of their simplicity, speed, and possibility to react to changes in the system, they can be used in a dynamic environment. In this paper, ensembles of priority rules were created to improve the performance of priority rules created with genetic programming. For ensemble creation, four different methods will be considered: simple ensemble combination, BagGP, BoostGP, and cooperative coevolution. The priority rules that are part of the ensemble will be combined with the sum and vote methods in reaching the final decision. Additionally, the ensemble subset search method will be applied to the created ensembles to find the optimal subset of priority rules. The results achieved in this paper show that ensembles of priority rules can achieve significantly better results than those achieved when using only a single priority rule.

Introduction

Scheduling can be defined as the process of allocating resources to tasks while optimizing one or more objectives. Usually, scheduling problems come with some limitations like a limited amount of resources, the capacity of vehicles, working hours of employees, etc. Resource constrained project scheduling problem (RCPSP) is one of such problems. The RCPSP comes with two kinds of constraints — precedence and resource. Precedence constraints determine the way in which activities can be scheduled while available amounts of resources are given with resource constraints.

Because of its complexity and use in real-world applications, the RCPSP attracts many researchers. The RCPSP belongs to the class of NP-hard problems [1], and in most cases, it is not possible to find the optimal solution. In general, solving methods for the RCPSP can be divided into two main groups — exact methods and heuristics. Exact methods search the whole solution space and guarantee optimality, but they are impractical for larger instances. Because of that, heuristics are mostly used for solving RCPSP. Usually, two groups of heuristic methods used in solving RCPS are distinguished — constructive heuristics and improvement heuristics. Constructive heuristics build schedule through iteration, starting with an empty schedule and add one or more activities to schedule in each iteration until the whole schedule is built. The representative of constructive heuristics are priority rules [2]. Unlike constructive heuristics, improvement heuristics start with an initial solution which is then further improved through iterations. Representatives of improvement heuristics are various evolutionary and population-based meta-heuristics such as genetic algorithm (GA) and ant colony optimization [3], [4], [5], [6]. Most heuristic methods can be used only in the static environment, while only a small number is applicable in dynamic conditions. One of them are priority rules. Although the results obtained with priority rules are usually worse than those obtained with heuristics applicable only in the static environment, they achieve remarkable results in dynamic environments [7], [8], [9].

Priority rules (PRs) are used in combination with a schedule generation scheme (SGS) and construct schedule by iteration. Because of that, when using PRs, it is possible to react to changes in the system at any time. This method can be used for optimizing various criteria but usually requires an expert to develop a good rule. Recently, several attempts to automate this process by using genetic programming (GP) have been reported in the literature [10], [11]. These papers show that PRs developed by GP can achieve statistically better results than those achieved by the best-known human-made rules. Heuristic methods used in static environments, like the GA, usually solve each problem instance separately. On the other hand, evolved PRs are designed to solve multiple instances at a time, which means that the same rule is used for different problem instances.

PRs are usually evolved in advance, and because of it, the solving process of new instances is very fast. Usually, the time needed for building the whole schedule with PR is under one second, which is, regardless of the type of environment in which it is applied, a big advantage over other heuristic methods that need to start from scratch each time. Also, when PRs are used for building, the activity can be started with execution before the whole schedule is built, which is not possible if other heuristic methods are used. This allows PRs to react to breakdowns and changes in real-world problems, which is sometimes more important than the better quality of solutions achieved with other heuristic methods.

Although the PRs evolved by GP achieve better results than human-made ones, different PRs still find solutions of different quality for the same problem instance. The next question to ask is: Is it possible to achieve even better results if we do not use only one priority rule but a combination of them? This paper tries to answer this question by combining PRs in an ensemble. In this paper, the way of creating ensembles, their sizes, and the way of combining individual PRs in an ensemble are analyzed.

The paper is organized as follows: a brief overview of using GP in the evolving process of priority rules is given in Section 2, while in Section 3, a definition of the RCPSP can be found. Section 4 describes how GP is used in evolving PRs for the RCPSP. In Section 5, the process of creating ensembles of PRs is described, while results achieved by ensembles are given in Section 6. Finally, a short conclusion and future research direction are given in Section 7.

Section snippets

Literature overview

GP is an evolutionary algorithm that can evolve complex structures without knowing the precise form of a solution. This is the main reason why GP is quite often used as a hyperheuristic [12], [13] for evolving dispatching or priority rules [14], [15]. For the first time, GP was used to evolve dispatching rules in paper [16]. In this paper, evolved rules were used for a classic one-machine scheduling problem, and they achieved better results than previously known rules. After that, researchers

RCPSP

RCPSP is a problem in which n activities need to be scheduled, and for each activity we need one or more of m resources available in limited amounts. Resources can be renewable, non-renewable, and doubly-constrained [43]. The available amount of renewable resources is the same in each time period, while the amount of non-renewable resources is reduced by the use. Doubly-constrained resources are limited per each time period, and a constant amount of it is given for the whole project. While

Evolving PRs with GP

In scheduling, PRs are used in combination with a schedule generation scheme (SGS). Consequently, the process of evolving PRs can be divided into two parts: defining SGS and generating PRs.

Ensembles of priority rules

Ensembles of PRs for RCPSP consist of several PRs. In the process of determining the priority of activity by an ensemble, all PRs from the ensemble are used. Therefore, it is necessary to define how individual rule participates in the calculation of the priority. Another important thing is how to choose or evolve the PRs that will be part of the ensembles. This decision is made based on the learning method that is used.

The main advantage of ensembles over single rules when making the scheduling

Experimental results

All experiments in this paper were made using the C++ programming language and ECF [55].

Conclusion

In this paper, the design of an ensemble of priority rules for the RCPSP is analyzed. For creating an ensemble, two ways of combining individual rules into an ensemble were considered — sum and vote methods and four ensemble learning approaches — SEC, BagGP, BoostGP and cooperative coevolution. Additionally, for BoostGP as combining methods, the weighted sum method and weighted vote method were used. In these methods, the confidences calculated while evolving PRs were used as weights.

The

CRediT authorship contribution statement

Mateja Đumić: Conceptualization, Methodology, Software, Validation, Formal analysis, Investigation, Resources, Data curation, Writing - original draft, review & editing, Visualization. Domagoj Jakobović: Conceptualization, Methodology, Software, Validation, Formal analysis, Resources, Data curation, Writing - review & editing, Supervision.

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.

Acknowledgment

The research reported in this paper has been partially supported by the Croatian Science Foundation under the project IP-2019-04-4333, which is titled Hyperheuristic Design of Dispatching Rules (HyDDRa). Any conclusions or recommendations stated here are those of the authors and do not necessarily reflect the official positions of any organization included in this project.

Mateja Đumić is a postdoctoral researcher at the Department of Mathematics, University of Osijek. She received a master’s degree in Financial and business mathematics in 2014 at the University of Osijek - Department of Mathematics and a Ph.D. degree in May 2020 on the subject of evolving priority rules for resource constrained project scheduling problems at the Faculty of Electrical Engineering and Computing, University of Zagreb.

References (58)

  • FreundY. et al.

    A decision-theoretic generalization of on-line learning and an application to boosting

    J. Comput. System Sci.

    (1997)
  • ParkJ. et al.

    An investigation of ensemble combination schemes for genetic programming based hyper-heuristic approaches to dynamic job shop scheduling

    Appl. Soft Comput.

    (2018)
  • Gil-GalaF.J. et al.

    Evolving priority rules for on-line scheduling of jobs on a single machine with variable capacity over time

    Appl. Soft Comput.

    (2019)
  • SłowinskiR.

    Multiobjective network scheduling with efficient use of renewable and nonrenewable resources

    European J. Oper. Res.

    (1981)
  • KolischR.

    Serial and parallel resource-constrained project scheduling methods revisited: Theory and computation

    European J. Oper. Res.

    (1996)
  • HartmannS. et al.

    A survey of variants and extensions of the resource-constrained project scheduling problem

    European J. Oper. Res.

    (2010)
  • BrownG. et al.

    Diversity creation methods: A survey and categorisation

    Inf. Fusion

    (2005)
  • KolischR. et al.

    PSPLIB - A project scheduling problem library: OR software - ORSEP operations research software exchange program

    European J. Oper. Res.

    (1997)
  • F. Gargiulo, D. Quagliarella, Genetic algorithms for the resource constrained project scheduling problem, in: 13th IEEE...
  • HindiK.S. et al.

    An evolutionary algorithm for resource-constrained project scheduling

    Evol. Comput. IEEE Trans.

    (2002)
  • KadamS. et al.

    Solving resource-constrained project scheduling problem by genetic algorithms

    Bus. Inf. Manage.

    (2014)
  • MerkleD. et al.

    Ant colony optimization for resource-constrained project scheduling

    IEEE Trans. Evol. Comput.

    (2002)
  • JakobovićD. et al.

    Dynamic scheduling with genetic programming

  • R. Poli, W.B. Langdon, N.F. McPhee, A Field Guide to Genetic Programming, Published via http://lulu.com and freely...
  • KozaJ.R.

    Genetic Programming: On the Programming of Computers by Means of Natural Selection

    (1992)
  • BrankeJ. et al.

    Automated design of production scheduling heuristics: A review

    IEEE Trans. Evol. Comput.

    (2016)
  • NguyenS. et al.

    Genetic programming for production scheduling: A survey with a unified framework

    Complex Intell. Syst.

    (2017)
  • NguyenS. et al.

    A computational study of representations in genetic programming to evolve dispatching rules for the job shop scheduling problem

    IEEE Trans. Evol. Comput.

    (2013)
  • HuntR. et al.

    Evolving machine-specific dispatching rules for a two-machine job shop using genetic programming

  • Cited by (28)

    View all citing articles on Scopus

    Mateja Đumić is a postdoctoral researcher at the Department of Mathematics, University of Osijek. She received a master’s degree in Financial and business mathematics in 2014 at the University of Osijek - Department of Mathematics and a Ph.D. degree in May 2020 on the subject of evolving priority rules for resource constrained project scheduling problems at the Faculty of Electrical Engineering and Computing, University of Zagreb.

    Domagoj Jakobović is a Full professor at the Faculty of Electrical Engineering and Computing, University of Zagreb. He received a BS degree in December 1996. and MS degree in December 2001. in Electrical Engineering. Since April 1997. he is a member of the research and teaching staff at the Department of Electronics, Microelectronics, Computer and Intelligent Systems of the Faculty of Electrical Engineering and Computing, University of Zagreb. He received a Ph.D. degree in December 2005. on the subject of generating scheduling heuristics with genetic programming.

    View full text