New algorithm for analyzing performance of neighborhood strategies in solving job shop scheduling problems

Transcription

1 Journal of Scientific & Industrial Research ESWARAMURTHY: NEW ALGORITHM FOR ANALYZING PERFORMANCE OF NEIGHBORHOOD STRATEGIES 579 Vol. 67, August 2008, pp New algorithm for analyzing performance of neighborhood strategies in solving job shop scheduling problems V P Eswaramurthy* Department of Computer Applications, Kongu Engineering College, Erode Received 30 April 2007; revised 23 May 2008; accepted 27 May 2008 This paper presents tabu search to solve job shop scheduling problems. Various neighborhood strategies are introduced and an algorithm is developed to analyze performance of these strategies with new dynamic tabu length strategy. Performance of algorithm is tested using well-known benchmark problems and also compared with other algorithms. Keywords: Job shop scheduling, Makespan, Neighborhood structures, Pheromone trail, Tabu length, Tabu list Introduction Effective utilization of resources to improve efficiency of manufacturing system is complex combinatorial job shop scheduling problem (JSSP) 1. Obtaining exact solutions for such problems is computationally intractable 2. To solve combinatorial optimization problems like JSSP, several algorithms (Genetic algorithm, Ant Colony Optimization, Tabu Search and Simulated Annealing) have been used. Glover 3-5 presented fundamental principles of Tabu Search (TS), a meta-heuristic approach, for implementation of tabu conditions and dynamic move structure to ensure finiteness. Ferdinando Pezzella et al 6 proposed tabu search shifting bottleneck (TSSB) procedure to determine initial solution and subsequently to re-optimize locally for sequence of each machine belonging to the longest path in disjunctive path. Dynamic tabu length method in this approach uses constant division of intervals of total iterations irrespective of size of the problem. In the first and last intervals, length of tabu list is not dynamic, which causes the same effect as static tabu and hence full advantage of dynamic tabu effect cannot be achieved. Calderia et al 7 presented permutation with repetition (PWR), a Tabu- Hybrid approach, in which order of operations within permutation is considered as sequence for building a schedule solution. * eswar_murthy@yahoo.com This study presents development of an algorithm for analyzing performance of various neighborhood strategies in tabu search with new dynamic tabu length strategy. Tabu Search (TS) Neighbors and Neighborhood Structure Search space is the space of all possible solutions considered during search. In search space, a neighbor s i (0 < i < k) is defined by a pair (x, y), provided x and y are successive operations on a machine and on some critical path in graph G. Critical path is a longest path from node 0 to node ñ+1 corresponding to makespan of constructed solution. Let N(S) be set of neighbors that can be applied to current solution. Neighborhood denotes processing orders of operations during application of a neighbor s i to current solution. At each iteration, application of each neighbor s i N(S) defines a set of neighboring solutions in search space. Tabus Tabus are one of the important elements of TS and are used to prevent previously visited search space called as cycling. One can avoid cycling by declaring tabu moves that prevent application of recent neighbor. Tabus are stored in a short-term memory of the search (tabu list). In any given context, there are several possibilities regarding specific information recorded as tabu. One could record complete solutions, but this requires a lot of storage and makes it expensive to check whether a

2 580 J SCI IND RES VOL 67 AUGUST 2008 Job Table 1 Processing time and operation sequence for a 4x3 instance Processing sequence J1 (1,2)(2,3)(3,4) J2 (3,4)(2,4)(1,1) J3 (2,2)(3,2)(1,3) J4 (1,3)(3,3)(2,1) potential move is tabu or not; it is therefore seldom used. Most commonly used tabus involve recording the last few neighbors which are not applied for transformations performed on the current solution and prohibiting reverse transformations. Variable Tabu List Size Fixed length tabus cannot prevent cycling 4,5. If length of list is too small, cycling cannot be prevented and long size tabu creates many restrictions so as to increase mean value of visited solutions. An effective way of removing this complexity is to use a tabu list with variable size according to the current iteration number. The length of tabu list is initially assigned according to size of the problem and it will be increased and decreased during construction of the solution so as to achieve better exploration of search space. Aspiration and Termination Criteria While central to TS, tabus are sometimes too powerful that they may prohibit attractive moves, even when there is no danger of cycling, or they may lead to an overall stagnation of searching process. It is thus necessary to use algorithmic devices that will allow one to cancel tabus. These are called aspiration criteria. Simplest and most commonly used aspiration criterion consists in allowing a move, if it results in a solution with an objective value better than that of the current best-known solution or the old one in tabu. More complicated aspiration criteria have been successfully implemented 8,9, but they are rarely used. Ideally, search could go on forever, unless optimal value of the problem at hand is known beforehand. In practice, search has to be stopped at some point. Most commonly used stopping criteria in TS are: i) A fixed number of iterations; ii) After some number of iterations without an improvement in the objective function value; and iii) When objective reaches a pre-specified threshold value. Problem Definition and Notation Standard model of job shop problem is denoted by n/m/g/c max, where n= total number of jobs, m= total number of machines, and G= technological matrix denoting processing order of machines for different jobs. G can be represented as M 2 M 3 M 1 G = M 1 M 2 M 3 M 3 M 1 M 2 Each row of G represents a job to be processed on different machines. C max is makespan representing completion time of the last operation in job shop. Each job consists of a sequence of operations, each of which has to be performed on a given machine for a given time. A schedule is an allocation of operations to time intervals on machines. Processing of an operation i on a machine j is denoted by u ij forming a relation u ip u iq representing u iq is directly immediate to u ip. Let η ij be processing time of operation u ij. C ij = C ik +η ij denotes completion time of u ij in u ik u ij. Completion time of all C ij will be found. Then C max is calculated as C max = max (C ij ) (1) all u ij V Objective is to minimize C max value. Let J = set of jobs {1,2,,n}, M =set machines {1,2,,m} and V = set of nodes {0,1,2,,ñ+1}, where 0 and ñ+1 are dummy nodes representing start and finish operations respectively. It is useful to represent job shop scheduling problem in terms of a disjunctive graph D = (V, A, E). A is a set of conjunctive arcs representing precedence of operations in the job and E is a set of disjunctive edges with no direction representing possible precedence constraints among operations belonging to different machines. Consider an example of JSSP with 4 jobs and 3 machines (Table 1). Job shop scheduling problem has 4 jobs, 3 machines and 12 operations. Processing sequence for each job is a set of items (l, t), where l = machine number and t =execution time of operation on machine l. Above problem can be represented by a disjunctive graph (Fig. 1), where vertices drawn as circles represent tasks. Conjunctive arcs, directed lines, represent precedence constraints among tasks of the same job. Disjunctive arcs, undirected lines, represent possible precedence constraints among tasks belonging to different jobs being performed on same machine. Two additional vertices

3 ESWARAMURTHY: NEW ALGORITHM FOR ANALYZING PERFORMANCE OF NEIGHBORHOOD STRATEGIES 581 iteration number (CYCNO), range, d1, d2, r and u are given as inputs. The range, d1 and d2 are calculated as given in Eqs (2), (3) and (4) respectively. Integer parts of these variables are used for processing. r and u are control variables used to find the position of current iteration within range interval. Fig 1 Disjunctive graph representation for 4 X 3 problem in Table 1 (0 and 13) are drawn to represent start and end of a schedule. Proposed Algorithm Dynamic Tabu Length Tabu length is changed during the solution construction phase to increase exploration of search space. This strategy called dynamic tabu length strategy is applied in proposed algorithm. Procedure Dtabu() shows for pseudo code to find tabu length dynamically according to iteration number. Current range = MAXCYCNO/(2*m) (2) d1= range/(m+n) (3) d2 = (d1+2*m)/(m+n) (4) Number of jobs n and number of machines m is also given as inputs. Tabu length (TL) is m+n for first range of iterations. For even and odd range intervals, TL value is increased and decreased respectively by the value of d2 with subsequent interval value of d1. This strategy improves performance of tabu search during construction of solution. Change of tabu length value is illustrated in Fig. 2. Procedure: DTabu( ) Inputs: CYCNO Current iteration number OLDL Tabu length from previous iteration range Range of iterations within total iterations d1, d2 Control variables to change tabu length r Control variable to find the position of range within total iterations u Control variable to find the position of the current iteration within a range of iterations Output: TL Tabu length for next iteration u Updated control variable Begin If CYCNO < range Then //Check for first range Assign OLDL to TL Assign false to set While (set = false) //Check for subsequent u ranges If CYCNO >= (r * range) and CYCNO < (r * range + u * d1) Then Compute TL = OLDL + u * d2 //Increment TL by d2 unit Assign true to set Increment u by 1 //Go to next u th range EndWhile End

4 582 J SCI IND RES VOL 67 AUGUST 2008 Fig 2 Illustration of dynamic tabu length Neighborhood Structures Let N(S) be the set of neighbors for current solution S. Block is defined as the set of operations on a critical path belonging to same machine. Blocks are constructed from N(S) and different neighborhood strategies are used to select appropriate set of neighbors N (S) for each iteration. Four variations (Table 2) of neighborhood strategies are as follows: First and Last Neighbors (FLN) FLN strategy selects only first and last neighbors in a block. Procedure firstlastneighbors( ) shows pseudo Procedure firstlastneighbors() Inputs: numblock[i] number of blocks of i th machine block[i][j] j th block of i th machine block[i][j].count number of nodes in j th block of i th machine block[i][j].node[k] k th operation in j th block of i th machine Output: N (S) Set having first and last neighbors in each block Begin Let N (S) = φ, Initialize k by 1 For i = 1 to m do //Repeat for number of machine// /*Repeat for number of blocks in i th machine*/ For j = 1 to numblock[i] do /*Assign first node of first neighbor*/ Let strat[k] = block[i][j].node[1] /*Assign second node of first neighbor*/ Let end[k] = block[i][j].node[2] Add (strat[k], end[k]) to N (S), Increment k by 1 If block[i][j].count > 2 Then //Check for more neighbor /*Assign first node of last neighbor*/ Let start[k] = block[i][j].node[block[i][j].count-1] /*Assign second node of last neighbor*/ Let end[k] = block[i][j].node[block[i][j].count] Add (start[k], end[k]) to N (S), Increment k by 1 End

5 ESWARAMURTHY: NEW ALGORITHM FOR ANALYZING PERFORMANCE OF NEIGHBORHOOD STRATEGIES 583 code for FLN strategy. If a block contains a set of nodes {1, 2, 3, 4, 5}, N (S) contains a set of neighbors {(1, 2), (4, 5)}. If number of nodes in a block <3, all nodes are considered for construction of neighbors. Thus, if a block contains a set of nodes {1, 2, 3}, N (S) contains a set of neighbors {(1, 2), (2, 3)}. Middle Neighbours (MN) MN strategy selects only middle neighbors in a block. Pseudo code for this strategy is given in the procedure middleneighbors( ). If a block contains a set of nodes {1, 2, 3, 4, 5}, N (S) contains a set of neighbors {(2, 3), (3, 4)}. If number of nodes in a block is <3, all nodes are considered for construction of neighbors. Thus, if a block contains a set of nodes {1, 2, 3}, N (S) contains a set of neighbors {(1, 2), (2, 3)}. Procedure middleneighbors() Inputs: numblock[i] number of blocks in i th machine block[i][j] j th block of i th machine block[i][j].count number of nodes in j th block of i th machine block[i][j].node[k] k th operation in j th block of i th machine Output: N (S) Set having middle neighbors in each block Begin Let N (S) = φ Initialize k by 1 /*Repeat for number of machine*/ For i = 1 to m do /*Repeat for number of blocks in i th machine*/ For j = 1 to numblock[i] do /*Check for number of neighbors in j th block of i th machine*/ If block[i][j].count <= 3 Then /*Find first neighbor from first two nodes in case of total nodes in the block is equal to two*/ Let start[k] = block[i][j].node[1] Let end[k] = block[i][j].node[2] Add (start[k], end[k]) to N (S), Increment k by 1 /*Find second neighbor from last two nodes in case to total nodes in the block is = 3*/ If block[i][j].count = 3 Then Let start[k] = block[i][j].node[2] Let end[k] = block[i][j].node[3] Add (start[k], end[k]) to N (S), Increment k by 1 /*Find set of neighbors by omitting first and last nodes in the block in case of total nodes in the block is >3*/ For p = 2 to block[i][j].count 1 do Let start[k] = block[i][j].node[p] Let end[k] = block[i][j].node[p+1] Add (start[k], end[k]) to N (S), Increment k by 1 End

6 584 J SCI IND RES VOL 67 AUGUST 2008 All Neighbors (ALL) ALL strategy selects all neighbors in a block. The procedure for this strategy is given below: Procedure allneighbors() Inputs: numblock[i] number of blocks in i th machine block[i][j] j th block of i th machine block[i][j].count number of nodes in j th block of i th machine block[i][j].node[k] k th operation in j th block of i th machine Output: N (S) Set having all neighbors in each block Begin Let N (S) = φ, Initialize k by 1 /*Repeat for number of machine*/ For i = 1 to m do /*Repeat for number of blocks in i th machine*/ For j = 1 to numblock[i] do /*Find set of neighbors from all nodes in the block*/ For p = 1 to block[i][j].count-1 do Let start[k] = block[i][j].node[p] Let end[k] = block[i][j].node[p+1] Add (start[k], end[k]) to N (S) Increment k by 1 End Procedure allneighbors( ) selects all neighbors in each block. Thus, if a block contains a set of nodes {1, 2, 3, 4}, N (S) contains a set of neighbors {(1, 2), (2, 3), (3, 4)}. Table 2 Optimal values produced for well known problem instances using different neighborhood strategies Problem instance Optimal value FLN strategy MN strategy ALL strategy NWC strategy FT FT LA LA LA LA LA LA LA LA ABZ ABZ ABZ ABZ ABZ

7 ESWARAMURTHY: NEW ALGORITHM FOR ANALYZING PERFORMANCE OF NEIGHBORHOOD STRATEGIES 585 Neighbors with Cycles (NWC) Procedure neighborswithcyles( ) shows pseudo code for NWC strategy, which constructs a set of neighbors with a set of nodes in a block according to current iteration number and a variation parameter v 0. For odd cycle, odd neighbors and for even cycle, even neighbors are selected from a block. Thus, if a block contains a set of nodes {1, 2, 3, 4, 5, 6}, a set of neighbors from this block has been found as {(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)}. A set with odd neighbors is {(1, 2), (3, 4), (5, 6)} and has elements corresponding to locations of first, third and fifth in original set. A set with even neighbors is {(2, 3), (4, 5)} and has elements corresponding to locations of second and fourth in original set. Procedure neighborswithcyles( ) Inputs: CYCNO current iteration number v 0 variation parameter (The value between 0 and 10) numblock[i] number of blocks in i th machine block[i][j] j th block of i th machine block[i][j].count number of nodes in j th block of i th machine block[i][j].node[k] k th operation in j th block of i th machine Output: N (S) Set having neighbors in each block according to iteration number and variation parameter Begin Get CYCNO, v 0, Let N (S) = φ If CYCNO % v 0 = 0 Then //Check for once in a variation parameter Call All_lneighbors( ) Initialize k by 1 For i = 1 to m do /* For no. of machine*/ For j = 1 to numblock[i] do /*For no. of blocks in i th machine*/ /*Check for no. of neighbors in j th block of i th machine*/ If block[i][j].count <3 Then /*Find first neighbor from first two nodes*/ Let start[k] = block[i][j].node[1], Let end[k] = block[i][j].node[2] Add (start[k], end[k]) to N (S), Increment k by 1 If CYCNO % 2 = 0 Then //Check for even or odd cycle position = 2 //Even position is assigned for even cycle position = 1 //Odd position is assigned for odd cycle p = posistion /*Find even or odd neighbors according to position value*/ While ( p < block[i][j].count) Let start[k] = block[i][j].node[p], Let end[k] = block[i][j].node[p+1] Add (start[k], end[k]) to N (S), Increment k and p by 1 EndWhile End According to the value of variation parameter v 0, all neighbors are selected in particular iteration. Thus, once in v 0 number of iterations, all nodes in a block are considered for construction of a set of neighbors so that original set of neighbors is produced for current iteration.

8 586 J SCI IND RES VOL 67 AUGUST 2008 Constructing Solution Initial solution S* is constructed using shortest processing time (SPT) priority rule. S* is improved by applying dynamic tabu length strategy and neighborhood strategies. Pseudo code for proposed algorithm is as follows: Algorithm: ConstructSolution() 1 CYCNO = 0, TP = 0, T = 0 r = 1, u = 1 Initialize MAXCYCNO, MAXT, IL Find range, d1, d2 as in equations (2), (3) and (4) TL = IL, Generate initial solution S* Set makespan for S* to f(s*) 2 Call DTabu() //To change the tabu length value If TP > TL Then TP = 0 3 Call any of the neighborhood strategy //To find list of valid neighbors Let N (S) = {s 1,s 2,.s k } //Found from any one of neighborhood strategies Find the suitable neighbor s i N (S) Add s i to Tabu in position TP 4 Apply neighbor of the Tabu in the position TP and find the current solution S If f(s) < f(s*) Then S* = S, f(s) = f(s*), T = 0 CYCNO = CYCNO + 1, T = T + 1, TP = TP Assign TL to OLDL If CYCNO % range = 0 Then Increment r by 1 Assign 1 to u Assign -d2 = d2 //Negate d2 6 If CYCNO > MAXCYCNO or T > MAXT Then Go to Step 7 Go to Step 2 7 Print S* and f(s*) Stop MAXCYCNO and IL represent total number of iterations and initial length of tabu list respectively. MAXT represents max. number of times, for which improvement is not made during construction of the solution. Set of valid neighbors N (S) is found from any of the neighborhood strategies (FLN, MN, ALL or NWC) and these neighbors are applied to constructed solution. During construction of the solution, length of tabu list is dynamically changed by using procedure DTabu() according to current iteration number. If selected neighbor s i (0 < i < k) is not in tabu or aspiration criteria is met, neighbor s i is added to tabu. Aspiration criterion is used to check the condition f(s) < f(s*), where f(s) is makespan of neighborhood solution S produced by the application of neighbor s i, which is already in tabu. If neighbor cannot be added to tabu, all tabu restrictions are removed. This process is repeated to meet a termination criterion, which is either reaching max.

9 ESWARAMURTHY: NEW ALGORITHM FOR ANALYZING PERFORMANCE OF NEIGHBORHOOD STRATEGIES 587 Makespan Iterations Fig 3 Comparison of makespan vs iterations Table 3 Comparison of optimal values produced by different algorithms Problem instance Optima TSSB Tabu- Hybrid i-tsab TS with dynamic tabu length and value NWC strategy FT FT LA LA LA LA LA LA LA LA ABZ ABZ ABZ ABZ ABZ iterations or no improvements of constructed solution for a MAXT number of iterations. Results and Discussion Computational results are given for JSSP instances with the initial tabu length as m+n and variation parameter value as 5. Proposed method is coded in C++ programming language on Linux platform with AMD Athlon 2600+, 2GHz and 512 RAM. Tabu search with dynamic tabu length and NWC strategy (Table 2) has succeeded in getting best solutions for some problems and also in improving upper bound values compared with other methods. Tabu search with dynamic tabu length and NWC strategy (Table 3) has produced superior results when compared with other methods. Optimal value of problem LA15 is reached at 3818 th iteration (Fig. 3). Conclusions This paper presented an algorithm for analyzing performance of various neighborhood strategies in tabu search with new dynamic tabu length and NWC strategy. Four variations of neighborhood strategies, first and last, middle, all and neighbors with cycles, were analyzed to determine quality of the solution by applying new dynamic tabu length strategy. Performance tests carried out by using proposed method were superior as compared with results of other competing algorithms. References 1 Garey M R, Johnson D S & Sethi R, The complexity of flow shop and job shop scheduling Math Operat Res, 1 (1976) Garey M R & Johnson D S, Computers and Intractability, A Guide to the Theory of NP-Completeness, (WH Freeman and Company, New York) 1979,

10 588 J SCI IND RES VOL 67 AUGUST Glover F, Future paths for integer programming and links to artificial intelligence, Comput Operat Res, 13 (1986) Glover F, Tabu search Part I, ORSA J Comput, 1 (1989) Glover F, Tabu search Part II, ORSA J Comput, 2 (1990) Ferdinando Pezzella & Emanuela Merelli, A Tabu search method guided by shifting bottleneck for the job shop scheduling problem, Eur J Operat Res, 120 (2000) Calderia J P, Melicio F & Rosa A, Using a hybrid evolutionarytaboo algorithm to solve job shop problem, ACM Symp on Appl Computing, Nicosia, Cyprus, 2004, de Werra D & Hertz A, Tabu Search Techniques: A tutorial and an application to neural networks, OR Spektrum, 11 (1989) Hertz A & de Werra D, The tabu search metaheuristic: How we used it, Ann Math Artific Intelligence, 1 (1991)