Evolving rollout-justification based heuristics for resource constrained project scheduling problems

https://doi.org/10.1016/j.swevo.2019.07.002Get rights and content

Abstract

Resource constrained project scheduling is critical in logistic and planning operations across a range of industries. An interesting heuristic for solving this problem is the Rollout-Justification (RJ) procedure. This procedure, which has conceptual similarities with dynamic programming, incrementally builds a solution by identifying the next activity to schedule based on the projections made using a guiding priority rule (heuristic) coupled with forward-backward local search. A critical component that affects the performance of RJ procedure is the guiding priority rule (or a set of rules). In this study, instead of using existing rules from literature, we aim to evolve new priority rules using genetic programming, and systematically investigate their use with the RJ procedure. Apart from evolving new rules, we also investigate new ways of integrating/utilizing the rules within RJ procedure. To this end we consider the use of both forward and backward scheduling, independent and cohesive ensemble rule approaches, limited and unlimited number of function evaluations, among others. We use data from the project scheduling library (PSPLib) to train and test the evolved rules and their integration with RJ. A comprehensive set of numerical experiments are performed to benchmark the rules evolved using the proposed approach against a range of existing rules. The results demonstrate the competence and potential of the proposed approach, both in terms of accuracy and complexity.

Introduction

Resource constrained project scheduling problem (RCPSP) is a classical NP-hard combinatorial optimization problem. Given a set of activities, the goal is to find the schedule with minimum makespan (time) solution while ensuring that none of the precedence or resource constraints are violated. Due to the wide applicability of the problem in the areas of manufacturing [1,2], construction and software development [3], tools for solving these problems are well sought after. Over the years, a number of methods have been developed for solving this problem. They range from exact methods [4], which are mostly suitable for relatively small instances, to heuristic and meta-heuristic methods such as priority-rule based scheduling [1], truncated branch-and-bounds [3], genetic algorithms [5], particle swarm optimization [6] etc. among many others, which offer good but not necessarily optimal schedules. Some recent surveys of RCPSP and its variants can be found in Refs. [[7], [8], [9], [10], [11]].

In this paper, we focus on a particular approach for solving RCPSP, called the Rollout-Justification (RJ) procedure [12]. Rollout is a sequential decision making procedure which identifies the next activity to schedule based on the projected makespan that will result when using a certain priority rule. Justification [13] is a local search method which improves a schedule with iterative forward-backward scheduling. With RJ, at each decision stage, an activity is picked from the eligible set, based on makespan projections made using the priority rule and the subsequent justification. The RJ procedure is straightforward and simple in terms of implementation and use. The authors of [12] empirically demonstrated the benefit of this procedure using a set of existing priority rules.

The performance of the RJ procedure depends on two key aspects. First is the priority rule (or a set of priority rules) which is used to generate a schedule during the rollout. The second is the way in which the rule(s) is (are) integrated with RJ. In order to conveniently refer to each instantiation of a particular rule r (or a set of rules R) combined with a particular way of executing RJ procedure, we use the term meta-algorithm that was introduced in Ref. [14]. The authors of [14] used the term to denote “how the priority function is used” in a given scheduling environment. In Ref. [12], the authors explored some basic ways of utilizing the RJ procedure with some existing priority rules. This study attempts to substantially extend their study on two fronts.

  • Firstly, instead of using the limited set of existing human-designed priority rules, we evolve the priority rule component of the RJ procedure. Since each priority rule can be considered as a method to generate a schedule, it is also referred to as priority heuristic or simply heuristic. Thus, a method that automates the construction/evolution of these heuristics is termed as a hyper-heuristic. The use of genetic programming (GP) as a hyper-heuristic has been reported in a number of previous studies e.g. in job-shop scheduling [15,16], Arc Routing [17,18]. In a few recent works, GP has also been used for evolving heuristics for RCPSP. Studies from Chand et al. [19], Frankola et al. [20] and Šišejković [21] have investigated evolving priority rules for the classical (static) RCPSP. Chand et al. [22] have also extended this work into evolving priority rules under dynamic conditions.

  • Secondly, there remains a scope for studying more comprehensive set of possibilities in constructing the meta-algorithms. Towards this end, we propose and thoroughly evaluate a number of different meta-algorithms and benchmark their performance amongst themselves as well as other reported scheduling methods in the literature.

More specifically, the key intended contributions of this paper are:

  • 1.

    Introduction of new meta-algorithms which take advantage of bi-directional scheduling with the RJ procedure.

  • 2.

    Development and study of a GP framework to evolve rules for the different meta-algorithms (existing and new) considering limited and unlimited number of function (schedule) evaluations.

  • 3.

    Study of additional human-designed heuristics (that were not included in Ref. [12]) with RJ procedure.

  • 4.

    Benchmarking of the evolved heuristics with the existing human designed heuristics using different meta-algorithms on the standard PSPLib instances [23].

The remainder of the paper is organized as follows. Section 2 gives background on the problem and the existing literature. Section 3 gives details on the proposed GP approach for evolving heuristics. Section 4 gives details of the numerical experiments while Sections 5 Results: comparing the different meta-algorithms, 6 Results: comparison with base heuristics, 7 Results: comparison with existing methods in literature, 8 Results: overall discussion provide discussions and insights on the results obtained. Section 9 summarizes the findings of this paper and highlights some future research directions.

Section snippets

Problem definition

The RCPSP [24] involves a project with M activities which need to be scheduled while considering two types of constraints:

  • Precedence constraints: These represent the interdependence between the activities. If activity j is a successor of activity i then activity i must be completed before activity j can be started.

  • Resource constraints: These represent realistic limitations on resources such as manpower, budget, etc. Each project is assigned a set of K renewable resources where each resource k

Proposed GP framework for evolving priority rules

Our framework is composed of a number of important components which include the GP algorithm for evolving rules, a set of attributes and operators which are used for constructing the rules, a set of meta-algorithms for determining how a rule is utilized with the rollout-justification procedure and two schedule generation schemes which are used to determine the fitness for each candidate heuristic. These are individually outlined below.

Experimental setup

To evaluate the effectiveness of our approach, we used the problem instances from the project scheduling library (PSPLib) [23]. Note that whenever we mention evolved heuristics we refer to the combination of an evolved rule r or a set of evolved rules R with a particular meta-algorithm. The PSPLib contains instances of different sizes and complexities. We use the J30 instances for training and the J120 instances for testing the generalization capability of the evolved heuristics. We used the

Results: comparing the different meta-algorithms

In this section we compare the results for the different meta-algorithms across the 31 runs. The statistics presented are based on the final heuristic selected to represent the run which is done on the basis of (best) training performance. Here we focus on two key aspects. First, we summarize the performance of a meta-algorithm by calculating the stats (mean. median, etc) based on the test (J120 Set) fitness (Average Percentage Deviation from Lower Bounds) of the 31 heuristics chosen to

Results: comparison with base heuristics

In this sub-section we focus on selecting some of the evolved heuristics from each meta-algorithm and comparing them against a set of base-heuristics (utilizing the same meta-algorithm) which are either proposed by us or formerly introduced in Ref. [12]. This comparison is based on test performance. To compare, we choose two different heuristics from the 31 heuristics chosen to represent the 31 runs for each meta-algorithm. Across the 31 heuristics, we pick the two heuristics which are best on

Results: comparison with existing methods in literature

Table 16 provides a comparison between the selected evolved heuristics (for 1000 evaluations) and the state-of-the-art meta-heuristic algorithms within literature. The results indicate that our evolved heuristics are able to out-perform majority of the algorithms within literature for 1000 function evaluations. The two best selected evolved heuristics RJH.v2_DR_1000FEtest and RJH.v2_DR_1000FEtrain rank 4th and 5th, respectively, only being out-performed by MAOA [35], GA-MBX [5] and HGA [36].

Results: overall discussion

In the last three sections we discussed the results of our computational experiments. Some of the key findings are listed below:

  • GP operating on a dual-rule meta-algorithmic environment on average produces better heuristics than GP operating on a single-rule meta-algorithmic environment. Having multiple rules allows for better exploration of the search space.

  • Meta-algorithm RJH.v2_DR provides the best trade-off between performance and evaluations compared to the other meta-algorithms for the

Conclusion and future work

In this study we explored the use of GP for evolving heuristics utilizing the Rollout-Justification procedure for solving the classical RCPSP. We performed a number of systematic experiments and quantified the effects and the benefits of using: (a) single and multiple rules, (b) forward and backward rollout and (c) limited and unlimited number of function evaluations. Our evolved heuristics were able to out-perform heuristics utilizing human-designed priority rules. The heuristics evolved under

Acknowledgments

The first author would like to acknowledge PhD scholarship from UNSW Canberra in supporting this work.

References (50)

  • S. Chand et al.

    On the use of genetic programming to evolve priority rules for resource constrained project scheduling problems

    Inf. Sci.

    (2018)
  • S. Chand et al.

    Evolving heuristics for the resource constrained project scheduling problem with dynamic resource disruptions

    Swarm Evol. Comput.

    (2019)
  • R. Kolisch et al.

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

    Eur. J. Oper. Res.

    (1997)
  • R. Klein

    Bidirectional planning: improving priority rule-based heuristics for scheduling resource-constrained projects

    Eur. J. Oper. Res.

    (2000)
  • K. Li et al.

    An iterative scheduling technique for resource-constrained project scheduling

    Eur. J. Oper. Res.

    (1992)
  • V. Valls et al.

    Justification and rcpsp: a technique that pays

    Eur. J. Oper. Res.

    (2005)
  • X.-L. Zheng et al.

    A multi-agent optimization algorithm for resource constrained project scheduling problem

    Expert Syst. Appl.

    (2015)
  • V. Valls et al.

    A hybrid genetic algorithm for the resource-constrained project scheduling problem

    Eur. J. Oper. Res.

    (2008)
  • W. Chen et al.

    An efficient hybrid algorithm for resource-constrained project scheduling

    Inf. Sci.

    (2010)
  • A. Agarwal et al.

    A neurogenetic approach for the resource-constrained project scheduling problem

    Comput. Oper. Res.

    (2011)
  • C. Fang et al.

    An effective shuffled frog-leaping algorithm for resource-constrained project scheduling problem

    Comput. Oper. Res.

    (2012)
  • D. Debels et al.

    A hybrid scatter search/electromagnetism meta-heuristic for project scheduling

    Eur. J. Oper. Res.

    (2006)
  • L. Wang et al.

    A hybrid estimation of distribution algorithm for solving the resource-constrained project scheduling problem

    Expert Syst. Appl.

    (2012)
  • R.-M. Chen

    Particle swarm optimization with justification and designed mechanisms for resource-constrained project scheduling problem

    Expert Syst. Appl.

    (2011)
  • J. Mendes et al.

    A random key based genetic algorithm for the resource constrained project scheduling problem

    Comput. Oper. Res.

    (2009)
  • Cited by (16)

    • Using priority rules for resource-constrained project scheduling problem in static environment

      2022, Computers and Industrial Engineering
      Citation Excerpt :

      The most commonly used method for developing PRs is GP. The development of PRs using GP for the RCPSP is first mentioned in the work of Frankola et al. (2008) and has been studied more extensively in recent years (Ðumic et al., 2018; Chand et al., 2018; Chand, 2018; Chand et al., 2019; Ðumic & Jakobovic, 2021). Recently, PRs have been used for extended versions of RCPSP such as multi-skill RCPSP (Lin, Zhu, & Gao, 2020) and stochastic RCPSP (Chen, Ding, Qin, & Zhang, 2020).

    • Search space decomposition for resource-constrained project scheduling

      2022, Automation in Construction
      Citation Excerpt :

      Ðumića et al. considered the development of scheduling heuristics based on genetic programming to solve the problem [16]. Chand et al. explored the use of GP for evolving heuristics utilizing the Rollout-Justification procedure for solving the problem [8]. Adamu and Aromolaran presented a machine learning priority rule which assembles a set of priority rules, and uses machine learning strategies to choose the one with the best performance at every point in time to construct an activity list of a project [2].

    View all citing articles on Scopus
    View full text