The new golf neighborhood for the exible job shop problem.

Full text

Page 1

Procedia Computer Science 00 (2010) 1–8
Procedia Computer Science 1 (2010) 289–296
Procedia Computer
Science
International Conference on Computational Science, ICCS 2010
The new golf neighborhood for the flexible job shop problem$
Wojciech Bo˙ zejkoa, Mariusz Uchro´ nskia, Mieczysław Wodeckib,1,∗
aInstitute of Computer Engineering, Control and Robotics
Wrocław University of Technology, Janiszewskiego 11-17, 50-372 Wrocław, Poland
bInstitute of Computer Science
University of Wrocław
Joliot-Curie 15, 50-383 Wrocław, Poland
Abstract
In this paper we propose a new neighborhood for the flexible job shop problem. A main idea of the proposed
neighborhood is to execute a ’long shot’ of an operation from the current operation’s machine to another machine of
thesametype, andthentothemakeasmallmovebyusingalocaloptimizationalgorithmwithoutchangingoperations-
to-machines assignment. We call this method ’the golf neighborhood’. Computational experiments executed on the
benchmark instances from the literature show the efficiency of this solution.
Keywords: scheduling, flexible job shop, metaheuristics
PACS: 02.60.Pn, 02.70.-c
2000 MSC: 90B36, 90C35
1. Introduction
We consider here the flexible job shop problem (FJSP). The FJSP is a generalization of the classic job shop
problem as well as belongs to the strongly NP-hard class. Exact algorithms based on a disjunctive graph representation
of the solution have been developed (see Pinedo [22]) but they are not effective for instances with more than 20
jobs and 10 machines. However, many approximate algorithms, mainly metaheuristic, have been proposed. Hurink
[15] developed the tabu search method for this problem. Also Dauz` ere-P´ er` es and Pauli [9] used the tabu search
approach extending the disjunctive graph representation for the classic job shop problem to take into consideration
assigning operations to machines. Mastrolilli and Gambardella [18] proposed a tabu search procedure with effective
neighborhood functions for the FJSP. Many authors have proposed a method of assigning operations to machines and
then determined sequence of operations on each machines. Such an approach is followed by Brandimarte [7] and
Pauli [20]. These authors solved the assignment problem (i.e. using dispatching rules) and next used metaheuristics
to solve the job shop problem. Also genetic approaches have been adopted to solve the FJSP. Recent works are these
of Jia et al. [16], Ho and Tay [14], Kacem et al. [17] and Pezzella et al. [21]. Gao et al. [10] proposed the hybrid
genetic and variable neighborhood descent algorithm for this problem.
$The work was supported by MNiSW Poland, within the grant No. N N514 232237.
∗
Email address: mwd@ii.uni.wroc.pl (Mieczysław Wodecki)
1Corresponding author
c ? 2010 Published by Elsevier Ltd.
www.elsevier.com/locate/procedia
1877-0509 c ? 2010 Published by Elsevier Ltd.
doi:10.1016/j.procs.2010.04.032

Page 2

/ Procedia Computer Science 00 (2010) 1–8
W. Bo˙ zejko et al./Procedia Computer Science 1 (2010) 289–296
2
2. Flexible job shop problem
The flexible job shop problem (FJSP), also called the general job shop problem with parallel machines, can be
formulated as follows. Let J = {1,2,...,n} be a set of jobs which have to be executed on machines from the set
M = {1,2,...,m}. There exists a partition of the set of machines into types, i.e. subsets of machines with the same
functional properties. A job constitutes a sequence of some operations. Each operation has to be executed on an
adequate type of machine (nest) within a fixed time. The problem consists in the jobs allocation to machines from the
adequate type and the schedule of jobs execution determination on each machine to minimize the total jobs finishing
time. The following constrains have to be fulfilled:
(i) each job has to be executed on only one machine of a determined type in each moment of time,
(ii) machines must not execute more than one job in each moment of time,
(iii) there are no idle times (i.e. the job execution must not be broken),
(iv) the technological order has to be obeyed.
Let O = {1,2,...,o} be the set of all operations. This set can be partitioned into sequences which correspond to
jobs where the job j ∈ J is a sequence of ojoperations which have to be executed in an order on dedicated machines
(i.e. in so-called technological order). Operations are indexed by numbers (lj−1+ 1,...,lj−1+ oj) where lj=?j
The set of machines M = {1,2,...,m} can be partitioned into q subsets of the same type (nests) where i-th
(i = 1,2,...,q)typeMiincludesmimachineswhichareindexedbynumbers(ti−1+1,...,ti−1+mi), whereti=?i
An operation v ∈ O has to be executed on the machines type μ(v), i.e. on one of the machines from the set (nest)
Mμ(v)in the time pv,jwhere j ∈ Mμ(v).
Let
Ok= {v ∈ O : μ(v) = k}
be a set of operations executed in the k-th nest (k = 1,2,...,q). A sequence of operations sets
i=1oi
is the number of operations of the first j jobs, j = 1,2,...,n, where l0= 0 and o =?n
i=1oi.
j=1mj
is the number of machines in the first i types, i = 1,2,...,q, where t0= 0 and m =?q
j=1mj.
Q = [Q1,Q2,...,Qm],
such that for each k = 1,2,...,q
Ok=
tk−1+mk
?
i=tk−1+1
Qiand Qi∩ Qj= ∅, i ? j, i, j = 1,2,...,m,
we call an assignment of operations from the set O to machines from the set M (or shortly, operations to machines
assignment).
A sequence [Qtk−1+1,Qtk−1+2,...,Qtk−1+mk] is an assignment of operations to machines in the i-th nest (shortly,
assignment in the i-th nest). In a special case a machine can execute no operations and then a set of operations
assigned to be executed by this machine is an empty set.
If the assignment of operations to machines has been carried out, then the optimal schedule of operations execution
determination (including a sequence of operations execution on machines) simplifies to solve the classic scheduling
problem, it means the job shop problem (Grabowski, Wodecki [12]).
Let K = [K1,K2,...,Km] be a sequence of sets where Ki∈ 2Oi, i = 1,2,...,m (in particular case elements of this
sequence can constitute empty sets). By K we denote the set of all such sequences. The number of elements of the
set K is 2|O1|· 2|O2|· ... · 2|Om|.
If Q is an assignment of operations to machines then Q ∈ K (of course, the set K includes also sequences which
are not feasible; that is such sequences do not constitute assignments of operations to machines).
For any sequence of sets K = [K1,K2,...,Km] (K ∈ K) by Πi(K) we denote the set of all permutations of elements
from Ki. Thereafter, let
π(K) = (π1(K),π2(K),...,πm(K))
290

Page 3

/ Procedia Computer Science 00 (2010) 1–8
W. Bo˙ zejko et al./Procedia Computer Science 1 (2010) 289–296
3
be a concatenation m sequences (permutations), where πi(K) ∈ Πi(K). Therefore
π(K) ∈ Π(K) = Π1(K) × Π2(K)×,...,Πm(K).
It is easy to observe that if K = [K1,K2,...,Km] is an assignment of operations to machines then the set πi(K) (i =
1,2,...,m) includes all permutations (possible sequences of execution) of operations from the set Kion the machine i.
Further, let
Φ = {(K,π(K)) : K ∈ K ∧ π(K) ∈ Π(K)}
be a set of pairs, where the first element is a sequence set and the second – a concatenation of permutations of these
sets elements. Any feasible solution of the FJSP is a pair (Q,π(Q)) ∈ Φ where Q is an assignment of operations to
machines and π(Q) is a permutations concatenation determining the operations execution sequence which are assigned
the each machine fulfilling constrains (i-iv).
3. Solution method
There is an exponential number of possible jobs to machines assignments, due to the number of operations. Each
feasible assignment generates a NP-hard problem (job shop) whose solution consists in determining an optimal jobs
execution order on machines. One has to solve exponential number of NP-hard problems to solve the FJSP.
Therefore, we will apply an approximate algorithm based of the tabu search method. The main element of this
approach is a neighborhood – subsets of all the feasible solution set, generated from the current solution by transfor-
mations called moves.Searching a neighborhood we choose an element with the lowest cost function value, which we
take as a new current solution in the next iteration of the algorithm. From the fixed solution it is possible to generate
another solution by executing a move which consists in:
• an operation moving (transferring) from a machine into another machine in the same nest (of the same type),or
• changing operations execution order on a machines.
In the further part of the paper we describe in details both these moves.
Let Θ = (Q,π(Q)) be a feasible solution for the FJSP, where Q = [Q1,Q2,...,Qm] is an operations to machines
assignment, ?iis a number of operations executed on a machine Mi(i.e. ?i= |Qi|) and
π(Q) = (π1(Q),π2(Q),...,πm(Q))
is a concatenation of m permutations. A permutation πi(Q) determines an order of operations from the set Qiwhich
have to be executed on the machine Mi(i = 1,2,...,m). By Cmax(Θ) we define the cost function value for a solution
Θ, i.e. the time of all the operations execution finishing time.
In the further part of this section we will omit operations assignment Q as permutations parameter in these places
where it does not follow to a contradiction. Therefore π(Q) = (π1(Q), π2(Q),... ,πm(Q)) will be written in the shorter
form of π = (π1,π2,...,πm).
3.1. Transfer type moves
Byti
k in a permutation πi(i.e. operation πi(k)) into position l in a permutation πj(k) (together with moving operations from
position k, k + 1,... with a single position to the right – so called insert type move). Execution of the move ti
generates from Θ = (Q,π) the new solution Θ?= (Q?,π?) such, that
π?
v= πv,
v ? i, j, v = 1,2,...,m
j(k,l)wedefineatransfer typemoves(shortlyt-move)whichconsistsinmovinganoperationfromtheposition
j(k,l)
(1)
and
π?
i= (πi(1),πi(2),...,πi(k-1),πi(k+1),...,πi(?i− 1),
j= (πj(1),πi(2),...,πi(l-1),πi(k),πj(l),...,πi(?j+ 1).
(2)
π?
(3)
291

Page 4

/ Procedia Computer Science 00 (2010) 1–8
W. Bo˙ zejko et al./Procedia Computer Science 1 (2010) 289–296
4
Execution of this move causes moving the operation πi(k) from the set Qi(i.e. from the machine Mi) to the set Qj(i.e.
to the machines Mj). Therefore,
Q?v= Qv,
and
Q?i= Qi\ {πi(k)}, Q?j= Qj∪ {πi(k)}.
A move ti
Computational complexity of the t-move execution is O(n). An execution of a t-move causes moving an operation
from a machine into another one, i.e. a new operations to machines assignment in a nest. Therefore, from any solution
(operations to machines assignment) by executing t-moves it is possible to obtain any other operations to machines
assignment, i.e. partition of operations sets in particular nests.
If τ is a t-move, then we define a solution generated from Θ by executing the τ move by τ(Θ). It is possible that
the solution τ(Θ) is not feasible.
Let Θ be a feasible solution. The set
v ? i, j, v = 1,2,...,m
j(k,l) such that i = j and k = l we call a neutral t-move.
Ti
j(Θ) = {ti
j(k,l) : k ∈ Qiand l ∈ Qj
includes all t-moves which transfer operations from a machine Miinto a machine Mjand
T(Θ) =
m
?
i,j
Ti
j(Θ)
includes all t-moves for the solution Θ. The number of elements of this set has an upper bound O(qm2o2).
3.2. Insert type moves
To simplify let us assume that a permutation π = (π(1),π(2),...,π(t)) determines an operations execution order
on a machine.
Insert type move ik
tation ik
⎧⎪⎪⎪⎨⎪⎪⎪⎩
This type of move we will call shortly an i-move. Its computational complexity is O(1). The number of all such moves
(for a determined machines) is t(t − 1).
For a fixed feasible solution Θ, let Ik(Θ) be a set of all i-moves for the machine Mk∈ M and let
?
be a set of all i-moves on all machines. It is easy to notice that not all moves from this set generate a feasible solution.
l(INS) moves an elementπ(k) (from the position k in π) into the position l, generating a permu-
l. If l ≥ k therefore:
π(i),
if i < k ∨ i > l,
π(i + 1),
if k ≤ i < l,
π(k),
if i = l.
l(π) = πk
πk
l(i) =
A similar case appears when k > l.
I(Θ) =
m
k=1
Ik(Θ)
3.3. Golf neighborhood
A transfer type move is like a long shot in golf: it moves an operation into another machines. In turn, an insert
type move makes only a little modification of operation sequences on machines. The inspiration of this research was
a paper of Bo˙ zejko and Wodecki [4] which considered multimoves.
Let Θ be a feasible solution and let T(Θ) be a set of all t-moves. We consider the move ti
transfers an operation from the position k-th on the machine Miinto a position l-th on the machine Mj. This move
generates the solution Θ?= ti
– i-moves defines on operations executed on the machine Mj. Let is
a new solution Θ??= is
j(k,l) ∈ T(Θ). It
j(k,l)(Θ). The set I(Θ?) includes all i-moves connected with a solution Θ?and Ij(Θ?)
t∈ Ij(Θ?) be an i-move. Its execution generates
t(Θ?) from the Θ?. The transformation which generates a solution Θ??from the Θ we call an
292

Page 5

/ Procedia Computer Science 00 (2010) 1–8
W. Bo˙ zejko et al./Procedia Computer Science 1 (2010) 289–296
5
it-multimove. It constitutes a product of the t-move ti
Therefore, Θ??= is
By I◦T(Θ) we denote a set of all it-multimoves determined for a solution Θ. The golf neighborhood Θ is the set
N(Θ) = {λ(Θ) : λ ∈ I◦T(Θ)}.
In the paper Bo˙ zejko et al. [6] so-called elimination criterion was proved. It allows us to eliminate all i-moves and
t-moves which generate unfeasible solutions. Moreover multimoves generating solutions, for which the cost function
value is not less than Cmax(Θ), are also eliminated. Such determined golf neighborhood will be applied to the tabu
search algorithm.
If we consider neutral t-moves only then the golf neighborhood ((4) simplifies to moves applied in the best approx-
imate algorithm of the job shop problem solving (Nowicki and Smutnicki [19], Grabowski and Wodecki [12]). The
survey of tabu search method approach for the classic job shop problem can be found in [19]. A TSAB [19] algorithm
is used as a local optimization method.
j(k,l) and i-move is
t. We will denote this move shortly as is
t◦ti
j(k,l).
t◦ti
j(k,l)(Θ).
(4)
4. Computational results
Proposed methods were tested on the Hewlett-Packard server with two Dual-Core AMD 1.0 GHz Opteron pro-
cessors, 1 MB cache memory and 8 GB RAM working under 64-bit Linux Debian 5.0 operating system. Algorithms
were tested on the set of benchmark problem instances taken from Brandimarte [7].
problem
Mk01
Mk02
Mk03
Mk04
Mk05
Mk06
Mk07
Mk08
Mk09
Mk10
n × m
10 × 6
10 × 6
15 × 8
15 × 8
15 × 4
10 × 15
20 × 5
20 × 10
20 × 10
20 × 15
TS1
17.50%
42.31%
7.35 %
35.00%
11.05%
53.45%
42.45%
15.11%
39.09%
62.44%
32.57%
TS2
30.00%
46.15%
21.57%
33.33%
8.14%
55.17%
26.62%
12.62%
30.29%
55.33%
31.92%
TS3
2.50%
15.38%
0.00 %
8.33 %
1.16 %
22.41%
6.47 %
5.35 %
33.55%
35.53%
13.07%
TS4
5.00 %
23.08%
19.12%
8.33 %
1.74 %
20.69%
11.51%
3.63 %
8.79 %
9.64%
11.15%
TSTSAB
0.00 %
7.69 %
0.00 %
0.00 %
0.58 %
17.24%
10.07%
0.00 %
0.00 %
6.60 %
4.22 %Average
Table 1: The percentage relative deviation to the best known solution for Brandimarte [7] benchmark instances for a fixed number of iterations.
problem
Mk01
Mk02
Mk03
Mk04
Mk05
Mk06
Mk07
Mk08
Mk09
Mk10
n × m
10 × 6
10 × 6
15 × 8
15 × 8
15 × 4
10 × 15
20 × 5
20 × 10
20 × 10
20 × 15
TS1
17.50%
42.31%
7.35 %
35.00%
11.05%
53.45%
42.45%
14.91%
39.09%
62.44%
32.55%
TS2
30.00%
46.15%
24.01%
33.33%
8.14%
55.17%
20.86%
13.77%
34.53%
60.91%
32.69%
TS3
2.50%
15.38%
0.00 %
8.53 %
1.16 %
25.86%
6.48 %
5.35 %
33.55%
35.53%
13.42%
TS4
5.00 %
23.08%
19.11%
8.33 %
1.74 %
22.41%
8.63%
3.63 %
28.34 %
15.23%
13.55%Average
Table 2: The percentage relative deviation to the best known solution for Brandimarte [7] benchmark instances for fixed computational time.
In the Table 1 and 2 particular columns mean:
293