icaps 2009 Talk

The Fuzzy Job Shop Scheduling Problem Improved Local Search Experimental Results Conclusions References

Improved Local Search for Job Shop
Scheduling with Uncertain Durations

Inés González-Rodríguez1 Camino R. Vela2
Jorge Puente2 Alejandro Hernández-Arauzo2

1 Dept. of Mathematics, Statistics and Computing,
University of Cantabria (Spain)
2 Dept. of Computer Science and A.I. Centre,
University of Oviedo (Spain)

ICAPS 2009.


Starting Point

Previous work on job shop scheduling with uncertain durations:
using local search
very competitive makespan values :)
but with a high computational load :(

We would like to. . .
keep makespan quality while improving efﬁciency.


Outline

1 The Fuzzy Job Shop Scheduling Problem

2 Improved Local Search
Existing Approach
Makespan Calculation for Neighbours
Makespan Lower Bound
Reduced Neighbourhood

3 Experimental Results

4 Conclusions


Job Shop Scheduling Problem

J1

J2

J3


Motivation For Uncertainty

Classical JSP assumes complete knowledge! about
processing times. But. . .
what can we do if we only have incomplete knowledge?
(Un)fortunately, THE REAL WORLD IS FULL OF
UNCERTAINTY !!!


Triangular Fuzzy Numbers

Assume we only know:
an interval of possible values for the duration [a1 , a3 ],

a1 a3



Assume we only know:
an interval of possible values for the duration [a1 , a3 ],
the most likely duration a2 in this interval.

a1 a2 a3



This knowledge is represented by a triangular fuzzy number,
TFN, A = (a1 , a2 , a3 ):

a1 a2 a3


Working With Triangular Fuzzy Numbers

addition:

A + B = (a1 + b1 , a2 + b2 , a3 + b3 )

maximum:

max(A, B) ≈ (max{a1 , b1 }, max{a2 , b2 }, max{a3 , b3 })

expected value:

1 1
E[A] = (a + 2a2 + a3 )
4


Solution Graph With TFNs

A solution is represented by an acyclic graph:
(3, 4, 7)
1 2
(3, 4, 7) (1, 2, 3)

(4, 5, 6) (2, 3, 4)
0 3 4 7

(4, 5, 6) (1, 2, 6) (2, 3, 4)
(1, 2, 4)

5 6
(1, 2, 6)
or by a task processing order: π =(1 3 5 4 2 6).


Fuzzy? Schedule

What is fuzzy in this schedule?
Task starting and completion times and the makespan are
fuzzy.
But, the task processing order is precise.


Optimal Makespan

We want to minimise a fuzzy makespan. But. . .
Problem It is not clear when a TFN is less than another:


Optimal Makespan


Solution The expected value deﬁnes a total ordering;
A ≤E B iff E[A] ≤ E[B]:


Optimal Makespan


Solution The expected value deﬁnes a total ordering;
A ≤E B iff E[A] ≤ E[B]:

Objective for FJSP
Minimise the expected makespan E[Cmax ]


Criticality With Exact Durations

3
1 2
3 1

4 2
0 3 4 7

4 1 2
1

5 6
1
Critical path: (3, 4, 6); critical arcs: (4, 6); critical blocks:
(3), (4, 6).


Criticality With TFNs: Parallel Graphs

Solution Graph G:
(3, 4, 7)
1 2
(3, 4, 7) (1, 2, 3)

(4, 5, 6) (2, 3, 4)
0 3 4 7

(4, 5, 6) (1, 2, 6) (2, 3, 4)
(1, 2, 4)

5 6
(1, 2, 6)



Parallel Solution Graph G1 :
(3,4,7)
1 2
(3,4,7) (1,2,3)

(4,5,6) (2,3,4)
0 3 4 7

(4,5,6) (1,2,6) (2,3,4)
(1,2,4)

5 6
(1,2,6)
1
Critical path: 3,4,6; Cmax = 7



Solution Graph G:
(3, 4, 7)
1 2
(3, 4, 7) (1, 2, 3)

(4, 5, 6) (2, 3, 4)
0 3 4 7

(4, 5, 6) (1, 2, 6) (2, 3, 4)
(1, 2, 4)

5 6
(1, 2, 6)
Critical paths: [3,4,6], [3,5,6]; Cmax = (7, 10, 16)


Previous Neighbourhood

Idea: obtain neighbours by reversing every resource critical arc.
Deﬁnition
Take
a task processing order π
a resource arc v = (x, y ) in the associated solution graph
π(v ) , the order obtained from π after reversing arc v .
The neighbourhood structure obtained from π is:

H(π) = {π(v ) : v ∈ R(π) is critical}.



Solution Graph G(π), π=(1 3 5 4 2 6)
(3, 4, 7)
1 2
(3, 4, 7) (1, 2, 3)

(4, 5, 6) (2, 3, 4)
0 3 4 7

(4, 5, 6) (1, 2, 6) (2, 3, 4)
(1, 2, 4)

5 6
(1, 2, 6)
Critical paths: [3,4,6], [3,5,6]; Cmax = (7, 10, 16)



Neighbour Solution Graph G(σ), σ=(1 5 3 4 2 6)
(3, 4, 7)
1 2
(3, 4, 7) (1, 2, 3)
(4, 5, 6)
(4, 5, 6) (2, 3, 4)
0 3 4 7

(2, 3, 4)
(1, 2, 4)
(1, 2, 6)
5 6
(1, 2, 6)


Previous Neighbourhood: Properties

Good News :)
All neighbours in H are feasible solutions.
The reversal of a non-critical arc can never reduce
makespan.


Previous Neighbourhood: Properties

Good News :)
All neighbours in H are feasible solutions.
The reversal of a non-critical arc can never reduce
makespan.

Bad News :(
In the fuzzy case, the neighbourhood has a considerable size,
with the consequent increase in computational cost.


Proposed Improvements

How can we improve the neighbourhood structure? Ideas:
1 More efﬁcient makespan calculation for neighbours.
2 Use inexpensive makespan lower bound to discard
neighbours.
3 Reduce neighbourhood.


Neighbour’s Makespan Calculation

Idea: avoid unnecesary calculations using available information
Makespan (and more) known for initial solution π;
Neighbour σ = πv differs from π “only” in the reversal of an
arc.


Heads and Tails

Deﬁnition
For a solution graph G(π) and a task x with processing time px :
The head of x is the starting time of x, denoted rx :

rx = max{rPJx + pPJx , rPνx + pPνx }

The tail of x is the time lag between x’s completion time
and the completion time of the last task, denoted qx :

qx = max{qSJx + pSJx , qSνx + pSνx }


Heads and Tails in the Neighbour

Pνx π Pνx σ = π(x,y )

PJx x SJx PJx x SJx

PJy y SJy PJy y SJy

Sνy Sνy

To calculate heads (tails) in σ, we need only re-calculate the
heads (tails) of tasks from x onwards (backwards) in G(σ).


Neighbour’s Makespan Lower Bound

Idea:
We are only interested in neighbours with improving
makespan.
Use makespan lower bound to discard non-improving
neighbours.
How can we calculate an inexpensive lower bound?


Makespan After a Move

Notation for a processing order π and tasks x and y :
D[P] a TFN where D i [P] is the length of the longest path in
a set of paths P of Gi , i = 1, 2, 3.
Pπ (x ∨ y ): set of all paths in the solution graph G(π)
containing x or y ;
Pπ (x ∧ y ): set of all paths in G(π) containing both x and y ;
Pπ (¬x): set of all paths in G(π) not containing x.

Proposition
For σ = π(v ) , where v = (x, y ) is an arc in G(π)

Cmax (σ) = max{D[Pπ (¬x)], D[Pσ (x ∨ y )]}


Lower Bound for Makespan After a Move

Consequence: D[Pσ (x ∨ y )] ≤E Cmax (σ). Using heads and
tails:
Corollary
Let rx (qx ) be the head (tail) of x in σ = π(x,y ) . The TFN

LBσ = max{rx + px + qx , ry + py + qy }

provides a lower bound for Cmax (σ).

If Cmax (π) ≤E LBσ , we already know the neighbour is not
improving.


Idea to Reduce Neighbourhood

In the crisp case, reversing arcs inside a critical block does
not improve the makespan.
Can we prove the same for the fuzzy job shop?



Deﬁnition
If V(π) is the set of all arcs in the extreme of a critical block, the
reduced neighbourhood structure for π is:

HR (π) = {π(v ) : v ∈ V(π)}.

Properties
HR (π) ⊂ H(π)
HR (π) contains only feasible schedules



The discarded neighbours from H(π) − HR (π) never improve
the makespan.
Theorem
For a feasible processing order π,

∀σ ∈ H(π) − HR (π), E[Cmax (π)] ≤ E[Cmax (σ)]



Sufﬁcient condition for optimality:
Proposition
If the neighbourhood HR (π) = ∅, then π is an optimal
processing order.

If the local search procedure stops because the neighbourhood
is empty, it has found a global optimum.


Experiment Setup

Goal
Evaluate empirically the contribution of our proposals to
improving local search efﬁciency.

Problem Instances
1 Take 12 crisp hard job shop benchmark problems;
2 Generate 10 fuzzy versions of each instance (durations:
TFNs with a2 = original value).
Total of 120 fuzzy job shop instances.


Experiment Setup

Solving Method
Based on memetic algorithm GVPV08 proposed in ICAPS
2008 [2] combining:
GA: Genetic algorithm
LS: Hill-climbing with H.
We plug 3 new proposals in the local search.


Experiment Setup

GVPV08 compared favourably with state-of-the-art
methods (SA [1] and GA [3]) in terms of makespan.
New improvements do not affect makespan, only
computational load of LS.
We know results will be “good” re. makespan; our aim is to
evaluate efﬁciency improvement.


Scheduling Neighbours With Heads and Tails

Problem Size GVPV08 (s) MA (s) Red%
FT10 10 × 10 801.2 588.2 26.59%
FT20 20 × 5 1693.9 682.1 59.73%
La21 15 × 10 1769.4 1072.8 39.37%
La24 15 × 10 1562.4 950.1 39.19%
La25 15 × 10 1722.8 993.7 42.32%
La27 20 × 10 4137.8 2242.8 45.80%
La29 20 × 10 3936.0 2071.7 47.37%
La38 15 × 15 3037,6 2556.7 15.83%
La40 15 × 15 3220.4 2652.2 17.64%
ABZ7 20 × 15 7396.1 5294.7 28.41%
ABZ8 20 × 15 8098.5 5780.9 28.62%
ABZ9 20 × 15 7308.0 5652.1 22.66%
Average CPU time reduction of 34.5% using MA


Makespan Estimate And Reduced Neighbourhood

Incorporate proposed improvements to MA (using heads and
tails):
1 MA(R)= MA using HR instead of H.
2 MA(LB) = MA using LB to estimate makespan.
3 MA(LB+R) = MA using both HR and LB.
We compare:
number of evaluated neighbours,
CPU time in seconds
(averaged across 30 executions and 10 fuzzy instances of each
problem).


Number Of Evaluated Neighbours

Problem MA MA(R) MA(LB) MA(R+LB)
FT10 2.83E+07 1.44E+07 6.25E+06 3.61E+06
FT20 6.78E+07 1.14E+07 2.25E+07 5.16E+06
La21 4.46E+07 1.93E+07 1.07E+07 5.76E+06
La24 3.87E+07 2.04E+07 9.00E+06 5.59E+06
La25 4.28E+07 1.78E+07 1.03E+07 5.75E+06
La27 8.37E+07 2.77E+07 2.53E+07 9.79E+06
La29 7.85E+07 2.44E+07 2.40E+07 8.90E+06
La38 5.16E+07 3.10E+07 1.11E+07 8.02E+06
La40 5.42E+07 3.03E+07 1.16E+07 8.42E+06
ABZ7 9.74E+07 4.07E+07 2.57E+07 1.30E+07
ABZ8 1.08E+08 4.60E+07 2.87E+07 1.48E+07
ABZ9 9.65E+07 4.43E+07 2.42E+07 1.33E+07
Av. Red. – 57% 75% 87%


CPU Time In Seconds

Problem MA MA(R) MA(LB) MA(R+LB)
FT10 588.2 372.90 179.3 166.5
FT20 682.1 283.1 295.4 211.0
La21 1072.8 610.9 327.8 292.2
La24 950.1 636.4 304.5 284.0
La25 993.7 555.3 322.4 289.5
La27 2242.8 1072.5 641.9 511.6
La29 2071.7 962.8 609.8 485.8
La38 2556.7 1732.8 546.7 514.0
La40 2652.2 1643.2 565.1 531.5
ABZ7 5294.7 2671.0 1073.8 898.4
ABZ8 5780.9 2936.5 1168.0 975.2
ABZ9 5652.1 3107.7 1078.5 925.8
Av. Red. – 45% 73% 76%


Conclusions

Previous work: good makespan but high computational cost.
Proposed improvements:
1 Simple but effective neighbour scheduling algorithm.
2 Makespan estimate: evaluate only 25% of neighbours.
3 Reduced neighbourhood structure: < 1/2 of original
neighbourhood.

Combined Use
Evaluate 13% of original neighbours in 23% of CPU time!!!


Future Work

Better neighbourhood structures to improve makespan.
Alternative meta-heuristics (taboo search, PSO,. . . ).
Alternative uncertainty models.


References I

Fortemps, P. (1997) Jobshop scheduling with imprecise
durations: a fuzzy approach.
IEEE Transactions of Fuzzy Systems 7:557–569.
González Rodríguez, I.; Vela, C. R.; Puente, J.; and Varela,
R. (2008) A new local search for the job shop problem with
uncertain durations.
In Proc. of ICAPS08, 124–131. Sidney: AAAI Press
Sakawa, M., and Kubota, R. (2000) Fuzzy programming for
multiobjective job shop scheduling with fuzzy processing
time and fuzzy duedate through genetic algorithms.
European Journal of Operational Research 120:393–407.


References II

Taillard, E. D. (1994) Parallel taboo search techniques for
the job shop scheduling problem.
ORSA Journal on Computing 6(2):108–117.
Van Laarhoven, P.; Aarts, E.; and Lenstra, K. (1992) Job
shop scheduling by simulated annealing.
Operations Research 40:113–125.

icaps 2009 Talk

Recommended

Recommended

More Related Content

Recently uploaded

Recently uploaded (20)

Featured

Featured (20)

icaps 2009 Talk