Efficient repairs of infeasible job shop problems by evolutionary algorithms

https://doi.org/10.1016/j.engappai.2021.104368Get rights and content

Abstract

We address the task of repairing infeasibility in the context of infeasible job shop scheduling problems with a hard constraint on the maximum makespan allowed. For this purpose, we adopt a job-based view of repairs, that allows for dropping some of the jobs and so gives rise to the problem of computing the largest subset of jobs that can be scheduled under the makespan constraint. Recent work proposed a genetic algorithm for solving this problem, which integrates an efficient solution builder for defining the search space. In this paper, we build on this earlier work and make several contributions. We provide a formal analysis of both the search space and the solution builder. Then, we propose two important enhancements to the genetic algorithm: first, we develop a new solution builder aimed at reducing the number of feasibility tests, making the search process more efficient. In addition, we propose a more effective procedure for testing the feasibility of different subsets of jobs under the given makespan constraint based on the use of a light-weight genetic algorithm. Experimental results show that the proposed methods are effective at solving the problem, and that the enhancements bring significant improvements.

Introduction

Scheduling problems arise profusely in a wide range of areas, especially in manufacturing and engineering, where a proper organization of limited resources is usually necessary. In addition, these problems are often computationally intractable, what makes them a natural application domain for advanced artificial intelligence and operations research methods. As a consequence, scheduling problems have been thoroughly studied in the literature over the last decades, giving rise to a large body of solving approaches, both exact and approximate, e.g. (Brucker et al., 1994, Nowicki and Smutnicki, 2005, Beck, 2007, Zhang et al., 2008, Mencía et al., 2015, Peng et al., 2015, Deng et al., 2020).

Scheduling problems usually require computing schedules that optimize a given objective function. However, in some settings there can be constraints that make the problem infeasible, i.e., with no possible solution whatsoever. Such scenario may appear when, for instance, considering a hard constraint that imposes a limit on the maximum makespan allowed, enforcing all the jobs in the problem to be scheduled (and completed) by a given time limit. This kind of constraint is natural in practice, and infeasibility may easily arise under this constraint if the given scheduling horizon is too tight. Furthermore, a number of scheduling problems with a constraint on the makespan have been studied in the past, e.g. (Dawande et al., 2006, Allahverdi and Aydilek, 2014, Guyon et al., 2014, Choi, 2015). In this context, beyond detecting infeasibility, users may be interested in identifying its causes, or in finding possible ways of repairing it, so that being able to solve the problem to some extent.

In this paper, we address the task of repairing infeasible job shop scheduling problems with a hard constraint on the makespan. For this purpose, we adopt a job-based view of repairs, which enables dropping some of the jobs so that the remaining ones can be scheduled within the makespan constraint. This view was recently taken in Mencía et al. (2019), giving rise to different notions of repairs, such as feasible subsets of jobs (FSJs), set-wise maximal feasible subsets of jobs (MFSJs) and feasible subsets of jobs of maximum cardinality (maxFSJs), i.e., feasible subsets of jobs with the greatest possible number of jobs. These concepts are inspired in analogous notions in the analysis of inconsistency in logic, where repairing (or correcting) inconsistent formulas has been widely investigated (Marques-Silva and Mencía, 2020). In addition, Mencía et al. (2019) preliminarily addressed the problem of approximating maxFSJs, by means of a genetic algorithm. This algorithm looks for solutions in the search space of (approximations of) MFSJs, defined by a solution builder used in its decoding phase. The genetic algorithm was recently adapted to a weighted version of the problem and combined with a local search algorithm specifically tailored to the case that jobs have different weights (Mencía et al., 2020).

We focus on the problem of approximating maxFSJs, that is, computing the largest subsets of jobs that can be scheduled under the hard makespan constraint. Building on Mencía et al. (2019), we make several contributions:

  • We first provide a formal analysis of the search space of MFSJs and the solution builder, proving relevant properties.

  • The analysis gives rise to important enhancements to the genetic algorithm. In this respect, we propose a new solution builder that defines the same search space but in a more efficient way. By integrating a binary search phase, it aims at reducing the number of feasibility tests needed to compute a solution, what allows for saving time.

  • Furthermore, we propose a new (incomplete) procedure for testing the feasibility of different subsets of the jobs (i.e. deciding whether these can be scheduled within the given makespan limit), which is iteratively invoked by the solution builders. Whereas earlier work used a greedy algorithm for this purpose, the new procedure integrates a light-weight genetic algorithm which is more effective, leading to better results.

We conducted an extensive experimental study to evaluate the proposed algorithms over a large set of instances with different sizes and characteristics. The experimental results reveal that genetic algorithms are successful at solving the problem and confirm that the new methods bring significant improvements in practice.

The remainder of the paper is structured as follows: Section 2 introduces the necessary background and notation, including the definition of the problem. Section 3 reviews related work. Section 4 presents a formal analysis of the search space and the solution builder from Mencía et al. (2019), and describes the new solution builder that exploits binary search. The main components of the genetic algorithm are presented in Section 5. The new procedure for testing the feasibility of a given subset of jobs is described in Section 6. Section 7 is devoted to the experimental study. Finally, we summarize the main conclusions and outline ideas for future research in Section 8.

Section snippets

Preliminaries

In the classical job shop scheduling problem (JSP) we are given a set of n jobs J={J1,,Jn} that must be scheduled on a set of m resources or machines M={M1,,Mm}. Job JiJ consists of a sequence of m tasks or operations (θi1,,θim), and each of its operations θij requires a particular machine M(θij)M during a (positive integer) processing time pθij. Besides, without loss of generality, it is commonly assumed that any two operations of the same job require different machines.

A schedule S is an

Related work

The problem studied in this paper was first addressed in Mencía et al. (2019). In this previous work, the notions of MFSJ and maxFSJ were proposed as a means to repairing infeasibility in the context of job shop scheduling problems with a hard constraint on the makespan. These definitions are based on concepts commonly used in the field of Boolean satisfiability in the analysis of unsatisfiable propositional formulas. For approximating maxFSJs, Mencía et al. (2019) proposed a genetic algorithm

Search space

The definition of a search space is a fundamental step towards solving hard combinatorial problems. Ideally, the search space would exhibit some desirable properties, such as being of reasonable size and containing high-quality solutions to the problem, including optimal ones.

When facing scheduling problems, the use of so-called schedule builders is common for this purpose, e.g. (Giffler and Thompson, 1960, Kolisch, 1996, Artigues et al., 2005, Palacios et al., 2014, Mencía et al., 2015).

Genetic algorithm

In this section, we describe a genetic algorithm for the problem of approximating maxFSJs, whose main structure is shown in Algorithm 4. The input to the GA is a problem instance P (which in this case consists of an infeasible job shop problem instance given by a pair (J,C)), and it has four parameters: crossover and mutation probabilities (Pc and Pm), number of generations (#gen) and population size (popsize). As output, the GA returns the largest feasible subset of the jobs in J (under the

Improving the effectiveness of the decoding algorithms

The decoding algorithms used by the GA aim at under-approximating an MFSJ efficiently by using the greedy G&T algorithm to test the feasibility of subsequent subsets of jobs. Arguably, using a greedy algorithm for this purpose represents the most efficient approach possible but, in turn, the approximations produced may not always be accurate. If only effectiveness is sought for, one could use a complete decision procedure; however, as already pointed out, using an exact algorithm, e.g. (Brucker

Experimental results

An experimental study was conducted to evaluate the methods proposed in this work. For this purpose, we coded a prototype in C++ implementing the algorithms and ran experiments on a Linux machine (Intel Xeon 2.26 GHz. 128 GB RAM).

The experiments were carried out over a set of infeasible instances derived from classical JSP benchmarks from the OR-library (Beasley, 1990) as well as larger Taillard’s instances (Taillard, 1993). The benchmark set consists of instances of different sizes n×m with a

Conclusions

Repairing infeasibility in scheduling constitutes a useful (and challenging) task. In this paper, we target infeasible job shop problems with a hard constraint on makespan and focus on the task of computing the largest subset of jobs that can be scheduled under such constraint.

This problem was tackled in Mencía et al. (2019) by means of an efficient genetic algorithm. This algorithm relies on a solution builder that defines the search space. Building on this approach, we provide a formal

CRediT authorship contribution statement

Raúl Mencía: Conceptualization, Software, Validation, Investigation, Writing - original draft, Writing - review & editing. Carlos Mencía: Conceptualization, Formal analysis, Investigation, Writing - original draft, Writing - review & editing. Ramiro Varela: Conceptualization, Validation, Investigation, 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.

Acknowledgments

This research is supported by the Spanish Government under projects TIN2016-79190-R and PID2019-106263RB-I00, and by the Principality of Asturias, Spain under grant IDI/2018/000176.

References (57)

  • DengG. et al.

    A population-based iterated greedy algorithm for no-wait job shop scheduling with total flow time criterion

    Eng. Appl. Artif. Intell.

    (2020)
  • GallardoJ.E. et al.

    A GRASP-based memetic algorithm with path relinking for the far from most string problem

    Eng. Appl. Artif. Intell.

    (2015)
  • GarcíaS. et al.

    Advanced nonparametric tests for multiple comparisons in the design of experiments in computational intelligence and data mining: Experimental analysis of power

    Inform. Sci.

    (2010)
  • GonçalvesJ.F. et al.

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

    European J. Oper. Res.

    (2008)
  • GongG. et al.

    An effective memetic algorithm for multi-objective job-shop scheduling

    Knowl.-Based Syst.

    (2019)
  • GrahamR. et al.

    Optimization and approximation in deterministic sequencing and scheduling: a survey

    Ann. Discrete Math.

    (1979)
  • KolischR.

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

    European J. Oper. Res.

    (1996)
  • KundakcıN. et al.

    Hybrid genetic algorithms for minimizing makespan in dynamic job shop scheduling problem

    Comput. Ind. Eng.

    (2016)
  • KurdiM.

    A new hybrid island model genetic algorithm for job shop scheduling problem

    Comput. Ind. Eng.

    (2015)
  • LeeC.

    A review of applications of genetic algorithms in operations management

    Eng. Appl. Artif. Intell.

    (2018)
  • MencíaR. et al.

    Memetic algorithms for the job shop scheduling problem with operators

    Appl. Soft Comput.

    (2015)
  • MustuS. et al.

    The single machine scheduling problem with sequence-dependent setup times and a learning effect on processing times

    Appl. Soft Comput.

    (2018)
  • PengB. et al.

    A tabu search/path relinking algorithm to solve the job shop scheduling problem

    Comput. Oper. Res.

    (2015)
  • TaillardE.

    Benchmarks for basic scheduling problems

    European J. Oper. Res.

    (1993)
  • ValladaE. et al.

    A genetic algorithm for the unrelated parallel machine scheduling problem with sequence dependent setup times

    European J. Oper. Res.

    (2011)
  • ZhangG. et al.

    An improved genetic algorithm for the flexible job shop scheduling problem with multiple time constraints

    Swarm Evol. Comput.

    (2020)
  • ZhangC.Y. et al.

    A very fast TS/SA algorithm for the job shop scheduling problem

    Comput. Oper. Res.

    (2008)
  • ArtiguesC. et al.

    Schedule generation schemes for the job shop problem with sequence-dependent setup times: Dominance properties and computational analysis

    Ann. Oper. Res.

    (2005)
  • Cited by (3)

    • Auction-based approach with improved disjunctive graph model for job shop scheduling problem with parallel batch processing

      2022, Engineering Applications of Artificial Intelligence
      Citation Excerpt :

      Li and Lei (2021) developed an imperialist competitive algorithm with feedback to solve FJSP with sequence-dependent setup times, transportation, and energy efficiency. Mencia et al. (2021) proposed GA to address the task of repairing infeasibility in the context of infeasible JSSP under a limited make-span. The p-BPSP is usually approached by solving three decision steps: batch forming, machine assignment, and batch sequencing (Abedi et al., 2015), where a batch consists of jobs.

    • Efficient Reasoning about Infeasible One Machine Sequencing

      2023, Proceedings International Conference on Automated Planning and Scheduling, ICAPS
    View full text