Min-Max Regret Scheduling To Minimize the Total Weight of Late Jobs With Interval Uncertainty

TL;DR

This paper addresses robust scheduling for a single machine to minimize total weighted lateness under uncertain processing times, proposing a min-max regret approach and a heuristic algorithm evaluated via computational experiments.

Contribution

It introduces a novel min-max regret scheduling model for uncertain processing times and develops a heuristic algorithm based on mixed-integer linear programming.

Findings

The heuristic performs well in computational tests.

The min-max regret approach effectively handles processing time uncertainty.

The method provides robust schedules minimizing worst-case regret.

Abstract

We study the single machine scheduling problem with the objective to minimize the total weight of late jobs. It is assumed that the processing times of jobs are not exactly known at the time when a complete schedule must be dispatched. Instead, only interval bounds for these parameters are given. In contrast to the stochastic optimization approach, we consider the problem of finding a robust schedule, which minimizes the maximum regret of a solution. Heuristic algorithm based on mixed-integer linear programming is presented and examined through computational experiments.

Tables

Table 1. Table 1: Scheduling with the objective to minimize the (unweighted) number of late jobs.

	mid-point heuristic		proposed method
$n$	mean Z	std Z	mean Z	std Z	min time	mean time	max time
10	2.90	0.30	2.90	0.30	73.73	108.95	164.79
15	3.70	1.00	3.40	1.11	200.48	418.10	618.06
20	4.70	1.10	4.50	1.57	296.33	408.98	539.51
25	5.80	1.24	5.20	2.04	509.21	574.94	632.99
30	5.70	0.90	5.60	1.11	533.80	644.97	679.01

Table 2. Table 2: Scheduling with the objective to minimize the total weight of late jobs.

	mid-point heuristic		proposed method
$n$	mean Z	std Z	mean Z	std Z	min time	mean time	max time
10	140.90	34.65	94.00	33.74	66.46	77.06	101.70
15	195.00	47.04	111.80	50.24	187.39	419.93	886.15
20	243.20	67.79	142.56	72.19	281.25	564.59	637.19
25	464.50	118.42	155.50	80.31	668.37	728.07	850.91
30	444.80	113.36	149.67	58.38	695.58	914.52	1132.68

Equations

$$C(\mathbf{x},k)=\sum _{i=1}^k\sum _{j\in J}{x}_{ij}{p}_j.$$

$$\mathcal{U}=\{\mathbf{p}=(p_1,\dots ,p_n):{\forall }_{j\in J}{p}_j^{-}\le p_j\le p_j^{+}\}.$$

$$R(\mathbf{x},\mathbf{p})=F(\mathbf{x},\mathbf{p})-\underset{\mathbf{y}\in \mathcal{P}}{\min }F(\mathbf{y},\mathbf{p}).$$

$$Z(\mathbf{x})=\underset{\mathbf{p}\in \mathcal{U}}{\max }R(\mathbf{x},\mathbf{p}).$$

$$Z^{\ast }=Z({\mathbf{x}}^{\ast })=\underset{\mathbf{x}\in \mathcal{P}}{\min }Z(\mathbf{x}).$$

$$\text{maximize }\sum _{j\in J}{w}_j\left(z_j-q_j\right),$$

$$\sum _{j\in J}{v}_j\le d,$$

$${\forall }_{k=1,\dots ,n}$$

$${\forall }_{j\in J}$$

$$\text{minimize }\sum _{j\in J}\left(-d_{ϵ}{\lambda }_j^a+p_j^{+}{\lambda }_j^b-p_j^{-}{\lambda }_j^c+{\lambda }_j^d+{\lambda }_j^e+p_j^{+}{\lambda }_j^h\right)+d{\lambda }_0$$

$${\forall }_{j\in J}$$

$${\forall }_{i=1,\dots ,n}$$

$$x_{ij}\in \{0,1\}.$$

Full text

Keywords   robust optimization, mixed integer programming, uncertainty

1 Introduction

We consider the following fundamental scheduling problem. A set of jobs is given to be processed on a single machine. Each job requires possibly different processing time to complete and cannot be interrupted or preempted. There is a fixed due-date until which the work should be finished. However, it is uncertain how much processing each of the task would exactly take. Before the schedule is dispatched on the machine, the only available data is the set of interval bounds, to which the actual processing requirements belong. The goal is to sequence the jobs, so that the number of the jobs that complete before the due-date is maximal (or, equivalently, the number of late jobs is minimal). In a more general problem variant, each job is associated with a weight (or cost), and the objective is to minimize the sum of weights of late jobs.

This problem arises in a many diverse application areas. For instance, this situation is experienced by a client who leases a fixed machine time (e.g., in a computing center) to carry out a number of tasks, but each of them requires unknown processing time; on the other hand, upper bounds on the processing times are set. This problem may also occur in a manufacturing process, when a fixed due-date is set for a batch of finished items to be delivered, but production time of each item may vary within known bounds.

The processing times uncertainty can be handled in a several different ways. One common approach is to use stochastic framework, and model the quantities of interest as random variables. This has its advantages in specific situations; however, it often brings the need for collecting data in order to estimate parameters. Moreover, in certain critical applications, the probabilistic guarantees, offered by such an approach, may not be sufficient. In this paper, we consider a robust optimization approach ben2009robust , goerigk2016algorithm . Each realization of uncertain parameters is treated as equally possible. Our aim is to come up with such a solution that degrades the least as compared to the best solution in every possible scenario. This measure of solution quality is reflected in the notion of maximum regret milnor1951games .

Most of the basic scheduling problems have been already considered within the robust optimization framework kasperskiminmax , aissi2009min , drwal2016complexity . The majority of these works concerns the more restrictive case of discrete uncertainty (a finitely many ways of parameter realizations). If the processing times were known precisely, the unweighted variant of the problem considered in this paper could be solved in polynomial time brucker2007scheduling . However, even for 2 processing times scenarios, it becomes NP-hard aloulou2008complexity . The case of interval processing times, described in the next section, appears to occur more naturally in practice. Although the number of processing times scenarios in such case is potentially infinite, solution algorithms may take the advantage of the structural information of uncertainty sets. Unfortunately, the problem with interval data is also NP-hard drwal2017b , even if all weights are equal. Moreover, deterministic variant with arbitrary weights is already NP-hard. A viable solution approach is the application of mathematical programming techniques, presented in this paper.

2 Problem Formulation

The deterministic version of the considered scheduling problem is denoted $1|d_{i}=d|\sum w_{i}U_{i}$. Given is the set of jobs $J=\{1,2,\ldots,n\}$. Each job $j\in J$ is described by the processing time $p_{j}$ and weight $w_{j}$. Let $d>0$ denote the due-date. A solution (schedule) is a permutation $\pi=(\pi(1),\pi(2),\ldots,\pi(n))$, where $\pi(k)$ is the index of job scheduled to be executed as $k$th from the start. Equivalently, we encode the solution as a binary matrix ${\bf x}$, where $x_{kj}=1$, iff $j$th job is scheduled on position $k$ from the start, and $x_{kj}=0$ otherwise. The completion time of job scheduled on position $k$ is defined as:

[TABLE]

We define $U({\bf x},k)=0$, iff $C({\bf x},k)\leq d$; we say that the job on position $k$ is on-time. Otherwise, $U({\bf x},k)=\sum_{j\in J}x_{kj}w_{j}$, and we say that the job on position $k$ is late. An optimal schedule is one that minimizes the weighted number of late jobs, $F({\bf x})=\sum_{k=1}^{n}U({\bf x},k)$. An important special case, when $w_{j}=1$ for all $j\in J$, is the problem of minimizing only the number of late jobs.

In an uncertain problem, for each $j\in J$, instead of exact processing times $p_{j}$, we are given interval bounds $p^{-}_{j},p^{+}_{j}$, so that the actual processing time can be any real number between them. A vector of processing times will be called a scenario. The set of all possible scenarios is defined as:

[TABLE]

The value of objective function in a scenario ${\bf p}\in\mathcal{U}$ will be denoted by $F({\bf x},{\bf p})$.

Let $\mathcal{P}$ be the set of all $n$-by-$n$ permutation matrices. Given a solution ${\bf x}\in\mathcal{P}$, and a scenario ${\bf p}\in\mathcal{U}$, we define the regret as:

[TABLE]

A schedule represented by matrix ${\bf y}$ in this context will be called an adversarial schedule. Then the maximum regret is denoted as:

[TABLE]

We will also use the notation $Z(\pi)$ to denote the maximum regret $Z({\bf x})$ of a matrix ${\bf x}$ equivalent to permutation ${\pi}$.

A scenario that maximizes the regret will be called a worst-case scenario. A robust optimal solution ${\bf x}^{*}$ is one that minimizes the maximum regret:

[TABLE]

3 Computation of Maximum Regret

An essential prerequisite for solving the robust problem (2) is the solution for the subproblem of regret maximization (1). Let us fix a schedule $\pi$. Since a due-date $d$ is common for all jobs, there exists a job on such a position $l$ in $\pi$, so that all jobs $\pi(1),\pi(2),\ldots,\pi(l-1)$, are on-time, while all jobs $\pi(l),\pi(l+1),\ldots,\pi(n)$, are late. Observe that worst-case scenario for $\pi$ is one for which the difference between the total weight of late jobs in $\pi$, and the total weight of late jobs in adversarial schedule is maximal. In the special case of equal weights, each late job contributes equally to the value of objective function, thus for any fixed scenario, an adversarial schedule is constructed by sorting all jobs with respect to nondecreasing processing times. This is not true for the case of general weights, where computing adversarial schedule for a fixed scenario is equivalent to solving an instance of knapsack problem.

Intuitively, in the worst-case schedules, the jobs that complete before the due-date $d$ would have the processing time closer to their respective upper bounds of uncertainty intervals. On the other hand, late jobs would generally have shorter worst-case processing times, closer to their lower bounds of uncertainty intervals. Such processing times allow for the late jobs to be early in the adversarial schedule, maximizing the number of on-time jobs.

Let us consider the following example problem instance with $n=3$ identical jobs. Each has the same processing time interval $[p_{j}^{-},p_{j}^{+}]=[1,3]$, for $j\in\{1,2,3\}$. Let the due-date be equal to 5. Since the jobs are identical, the maximum regret is the same for each schedule, thus let $\pi=(1,2,3)$. It can be seen that the following processing times constitute a worst-case scenario: $p_{1}=3$, $p_{2}=2+a$, for $a\in(0,1]$, and $p_{3}=1$. Only the first job completes on-time in schedule $\pi$. However, in an adversarial schedule $\pi^{\prime}=(2,3,1)$, jobs 2 and 3 complete on-time, while only job 1 is late, giving the regret value 1. As shown in the example, for a given solution there may be infinitely many worst-case scenarios.

For any fixed schedule $\pi$ we can write a mixed-integer linear program (MIP), which allows to compute the worst-case processing times, as well as the value of maximum regret. The program is the following:

[TABLE]

subject to:

[TABLE]

Binary decision variable $z_{j}$ assumes value 1 if and only if job $j$ is on-time in an adversarial schedule is the worst-case scenario, and binary decision variable $q_{j}$ assumes value 1 if and only if job $j$ is on-time in $\pi$ in the worst-case scenario. Decision variable $p_{j}$ represents the worst-case processing time of $j$th job. Values of these variables are determined due to the set of constraints (5). These constraints are satisfied when $q_{\pi(k)}=0$, for such $k$ that are on-time in $\pi$ in the worst-case scenario, and for $q_{\pi(k)}=1$ for such $k$ that are late. Constant $d_{\epsilon}=d+\epsilon$ in (5), where $\epsilon$ is a small positive value. Continuous variables $v_{j}$ are introduced to linearize the mixed terms $v_{j}=p_{j}z_{j}$, through the set of constraints (6)–(8), as required for the constraint (4) to be linear.

Note that although standard solution algorithms for this program may require time increasing exponentially in $n$, in practice it can be solved very quickly. Computational experiments indicate, for example, that for $n=100$ optimal solutions can be computed in about one second on a modern computer, while even for thousands of jobs optimal solutions can be found within few minutes.

4 Finding Robust Solutions

We present a heuristic method that allows to determine solutions with low maximum regret for the problem (2). The method consists of two phases. In the first phase we try to determine a good initial solution, and in the second phase we use randomized local search in order to improve the initial solution.

The first phase is accomplished by solving a mixed-integer linear program that approximates the value of optimal robust solution. Let us consider a fixed schedule given by a permutation matrix ${\bf x}$. Since the optimization direction for robust schedule is the minimization, as opposed to the subproblem of maximization of regret (1), we form a dual program of the linear programming relaxation of (3)–(10). After relaxing (10) to $0\leq z_{j}\leq 1$ and $0\leq q_{j}\leq 1$, for all $j\in J$, we can write:

[TABLE]

subject to:

[TABLE]

Dual variable $\lambda_{0}$ corresponds to the constraint (4), while the subsequent sets of dual variables $\boldsymbol{\lambda}^{a}$ through $\boldsymbol{\lambda}^{h}$ correspond to the constraints (5)–(10).

Since this is minimization program, we can also treat the matrix ${\bf x}$ as a decision variable, and solve this program for unknown ${\bf x}$, along with $\boldsymbol{\lambda}$, after adding the matching constraints:

[TABLE]

Observe that in this case constraints (12) and (13) contain products of decision variables $x_{ij}$ and $\lambda_{k}^{a}$. However, since $x_{ij}$ are binary, and $\lambda_{k}^{a}$ are nonnegative continuous, we can linearize these products in a standard way, by substituting new variables $u_{kij}=\lambda_{k}^{a}x_{ij}$, and adding three sets of constraints, similar to (6)–(8).

An optimal solution ${\bf x}$ of (11)–(18) corresponds to an adversarial solution with fractional values of $z_{j}$ and $q_{j}$ (these are dual variables corresponding to (13)–(14)). In result, we get an upper bound on the optimal solution. This solution can be sometimes easily improved by rounding $z_{j}$ and $q_{j}$ to 0-1 values, and determining the corresponding ${\bf x}$ that satisfies (4)–(10). We use the resulting binary matrix ${\bf x}$ as an initial solution passed to the second phase of the method.

In the second phase, we apply a randomized local search heuristic. Given a permutation $\pi$, represented by a binary matrix ${\bf x}$, we compute the maximum regret $Z({\bf x})$ using program (3)–(10). In consecutive iterations, we swap two randomly selected jobs in $\pi$, obtaining a permutation $\pi^{\prime}$, and compute the corresponding maximum regret $Z(\pi^{\prime})$. Keeping track of the lowest value of maximum regret encountered so far, we either repeat the procedure by swapping the next pair of randomly selected jobs, if the new value is no higher than the current one, or otherwise we retract to the previous permutation $\pi$, by returning the previously swapped jobs to their previous positions.

The two-phase procedure can be summarized as follows:

*(phase 1) * Solve the mixed-integer program (11)–(18), obtaining fractional $\tilde{{\bf z}}$ and $\tilde{\bf q}$, and binary ${\bf x}_{0}$. 2. 2.

Repeat for $M$ iterations:

1. (a)

Round $z_{j}=1$ with probability $\tilde{z}_{j}$, and $q_{j}=1$ with probability $\tilde{q_{j}}$. 2. (b)

For binary ${\bf z}$ and ${\bf q}$ determine ${\bf x}$ feasible for the set of constraints (4)–(10). 3. (c)

If $Z({\bf x})<Z({\bf x}_{0})$ then put ${\bf x}_{0}\leftarrow{\bf x}$. 3. 3.

*(phase 2) * Let $\pi$ be a permutation corresponding to ${\bf x}_{0}$. Let $S=\{\pi\}$ and $\pi^{*}\leftarrow\pi$. 4. 4.

Repeat for $N$ iterations:

1. (a)

Create a schedule $\pi^{\prime}$ by swapping two randomly selected jobs $i,j$ in $\pi$:

$\pi^{\prime}(i)=\pi(j)$, $\pi^{\prime}(j)=\pi(i)$, and $\pi^{\prime}(k)=\pi(k)$ for all $k\neq i,j$. 2. (b)

If $\pi^{\prime}\in S$ then discard $\pi^{\prime}$ and repeat the above step by taking another pair of random $i,j$. Otherwise, $S\leftarrow S\cup\{\pi^{\prime}\}$. 3. (c)

If $Z(\pi^{\prime})<Z(\pi)$ then $\pi^{*}\leftarrow\pi^{\prime}$. 4. (d)

If $Z(\pi^{\prime})\leq Z(\pi)$ then $\pi\leftarrow\pi^{\prime}$. Otherwise, generate a random real number $r\in[0,1]$. If $r>\alpha$, then $\pi\leftarrow\pi^{\prime}$. 5. 5.

Return the schedule $\pi^{*}$.

The set $S$ is maintained in order to prevent cycling during the search. The parameter $\alpha\in[0,1]$ controls the likelihood of proceeding from a worse than previous solution on the search path, and is intended to help avoiding local minima. This procedure can be run for prespecified number of iterations $N$, depending on the available computer resources, and can be easily parallelized. Note, however that for large number of jobs, as $N\ll n!$, this methods examines only a very small fraction of the search space.

5 Experimental Results

We have examined the solution technique presented in the previous section by comparing it with a simple mid-point heuristic, which is a standard method for tackling min-max regret problems with interval uncertainty goerigk2016algorithm . This heuristic outputs a solution of the deterministic counterpart problem with a scenario fixed to interval middle points, $\tilde{p}_{i}=p_{i}^{-}+\frac{1}{2}(p_{i}^{+}-p_{i}^{-})$. Note that for the problem variant with arbitrary weights, this requires solving a knapsack problem.

In each experiment we have generated 10 problem instances for each value of the number of jobs $n$. Each such instance consisted of jobs with processing time intervals generated by taking the lower bound $p_{j}^{-}$ as an uniformly random integer between $5$ and $10$, and the upper bound $p_{j}^{+}$ by adding to $p_{j}^{-}$ and uniformly random integer between [math] and $20$. Due-dates were uniformly random integers between $5n$ and $10n$. We have considered both unweighted ($w_{j}=1$ for all $j\in J$) and weighted cases. In the latter, weights are uniformly random integers between $1$ and $100$.

The MIPs used by the solution method were implemented in CPLEX 12.6 software. For larger problem instances the program (11)–(18) in the phase 1 was usually not solved to optimality; instead, the best feasible solution was returned after running the solver for 60 seconds. However, for all the considered problem instances, program (3)–(10) was solved to optimality for every fixed permutation.

For each experiment we report the mean value and the standard deviation of the objective function, estimated from 10 problem instances. Values for both the mid-point scenario heuristic and the proposed method are given. We also report the computation time statistics for our method. Note that these depend on parameters that we have set: $M=100$ in step 2, $N=1000$ and $\alpha=0.1$ in step 4.

The results are presented in Tables 1 and 2. We conclude that the proposed method is consistently better than the mid-point scenario heuristic, especially for the variant of the problem with arbitrary weights.

6 Conclusions

Single machine scheduling to minimize the total weight of late jobs with arbitrary processing times and a common due-date is an example of combinatorial problem which is easy to solve if exact values of parameters are known. In practice, this assumption is rarely valid. It turns out that interval data min-max regret variant of this problem is much more difficult to solve to optimality. We have examined a MIP-based heuristic solution method that successfully handles medium-sized problem instances, and appears to significantly improve on the standard mid-point heuristic. One of the future research directions is the design of efficient approximation methods for the class of problems in question.