UFDC Home  myUFDC Home  Help 



Full Text  
NEURAL NETWORKS BASED METAHEURISTICS FOR SOLVING OPTIMIZATION PROBLEMS By SELCUK COLAK A DISSERTATION PRESENTED TO THE GRADUATE SCHOOL OF THE UNIVERSITY OF FLORIDA IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF DOCTOR OF PHILOSOPHY UNIVERSITY OF FLORIDA 2006 Copyright 2006 by Selcuk Colak I dedicate this work to my lovely wife Sule and my adorable son Arda Bora. ACKNOWLEDGEMENTS I would first like to acknowledge my committee chairs Drs. S. Selcuk Erenguc and Anurag Agarwal. Without their guidance and encouragement, this dissertation could not have been completed successfully. I am especially grateful to Dr. Erenguc for recognizing my potential, giving me opportunities to study and research in this area and for providing the resources necessary to achieve my goals. I truly appreciate Dr. Agarwal's continuous guidance and motivation throughout this research. His experiences and insights were invaluable for the completion of this dissertation. I would also like to acknowledge my committee members Dr. Asoo J. Vakharia, also my department chair, and Dr. Joseph P. Geunes for their time and support. My educational experience as a doctoral student has also been enriched by the other faculty and doctoral students in our department. I am grateful to my wife Sule for her unconditional love, patience and encouragement, and also to my newborn son Arda Bora for his inspiration. And last but certainly not least, I am ever thankful to my parents, my brother and my sister for their continuous love and support. TABLE OF CONTENTS Page A CK N OW LED GM EN TS ................................................................ iv LIST OF TABLES ........................................ ........ viii LIST OF FIGURES ........... ............................. ... ..... x ABSTRACT ..................... ....................... .. xi C H A P T E R ......................................... 1 IN TR OD U CTION ............................... ...... ....... 1 2 OPEN SHOP SCHEDULING PROBLEM ...................................... 6 2 .1 Introdu action ................................................. .... 6 2.2 Literature R eview .................... ................. .......... ... 7 2.3 Heuristic Dispatching Rules ....................... ........ ........ 8 2.3.1 Job TRPT Machine PT Rule ....................... .............. 8 2.3.2 Job TRPT Machine PT Rule Non Greedy ............................ 8 2.3.3 Job TRPT Machine RPT Rule ..................................... 9 2.3.4 Job TRPT Machine RPT Rule Non Greedy ..................... 9 2.3.5 DS/LTRP Rule ..................... ........... ........ 9 2.3.6 DS/LTRP Rule Non Greedy with Job Slack .................... 10 2.3.7 DS/LTRP Rule Non Greedy with Machine Slack ..................... 10 2.3.8 DS/LTRPAM Rule ................................ ................ 11 2.3.9 DS/LTRPAM Rule Non Greedy with Job Slack ........................ 11 2.3.10 DS/LTRPAM Rule Non Greedy with Machine Slack .............. 11 2.4 Augmented Neural Network Formulation ....................................... 11 2.4.1 AugNN Functions .................................. ...................... 17 2.4.1.1 O operation nodes ......................................... ......... 17 2.4.1.1.1 Input functions .................................. ..... 17 2.4.1.1.2 Activation function ....................... ......... 18 2.4.1.1.3 Output functions ............................ ....... 18 2.4.1.2 M machine nodes ............................................. ......... 20 2.4.1.2.1 Input functions .......................... ......... 20 2.4.1.2.2 Activation function ....................... ......... 20 2.4.1.2.3 Output functions ........................ .......... 23 2.4.2 Search Strategy ................................. .......................... 24 2.4.3 Reinforcem ent ............................................................... 25 2.4.4 Backtracking ........................................................................ 25 2.4.5 End of Iteration Routines ................................................... 26 2.5 Computational Experiments and Results .................................... .... 26 2.6 Summary and Conclusions .................................. ................... 34 3 FLOW SHOP SCHEDULING PROBLEM ..................................................... 35 3 .1 In tro d u ctio n .................... ....................................... .... ......... .. 3 5 3.2 Literature Review .......................................................... ........ 36 3.3 The A daptive Learning Approach ........................................... ....... 37 3.3.1 N otation ................................... .................................... ........ 38 3.3.2 A lgorithm Steps .................................. ...................... 38 3.3.3 Search Strategy and Parameters ................................... ..... 40 3.3.3.1 Search coefficient ......................................... ....... 40 3.3.3.2 Reinforcem ent ................................. .................. 40 3.3.3.3 Backtracking (the TINI factor) ............................... 41 3.4 Computational Results .................................. ........................ 41 3.4.1 Datasets ....................................... ......... 41 3.4.2 Platform and Parameters ................................. ................. 42 3 .4 .3 R results ............. ..................... ..................................... ....... 42 3.5 Sum m ary and C conclusions ...................................................................... 44 4 RESOURCE CONSTRAINED PROJECT SCHEDULING PROBLEM ...... 51 4 .1 In tro du ctio n ......................... ........................................ 5 1 4.2 Literature Review ....................................................... 52 4.3 AugNN Framework for Parallel Schedule Generation ............................ 54 4.3.1 Mathematical Formulation and Algorithms Details ................... 56 4 .3 .1 .1 N o tatio n s ....................................................................... 5 6 4.3.1.2 Prelim inary steps .......................................... ....... 59 4.3.1.3 A ugN N functions ........................................... ....... 60 4.3.1.3.1 Activity nodes ................................ ... 60 4.3.1.3.1.1 Input function .......................... 60 4.3.1.3.1.2 Activation function .................... 60 4.3.1.3.1.3 Output function .......................... 61 4.3.1.3.2 Resource layer ................................. ..... 61 4.3.1.3.2.1 Input function .......................... 61 4.3.1.3.2.2 Activation function .................... 62 4.3.1.3.2.3 Output function .......................... 63 4.3.2 Search Strategy ................................. ........................ 64 4.3.3 Reinforcem ent .................................. ........................ 64 4.3.4 Backtracking ................................................... ................... 64 4.3.5 End of Iteration Routines ................................. 64 4.4 Adaptive Learning Approach for Serial Schedule Generation ................ 65 4.4.1 Notation ........................................ ....... 65 4 .4 .2 A lgorithm Steps ............................................... ..................... 66 4.5 Computational Experiments and Results .................................. ........ 68 4.6 Summary and Conclusions ................................. ..................... 73 5 MULTI MODE RESOURCE CONSTRAINED PROJECT SCHEDULING 74 PR O B LE M ................................................................... 5 .1 In tro d u ctio n ................... ...... .......... ............................ ... .... ...... 7 4 5.2 Literature Review .......................................................................... ........ 75 5.3 Problem Formulation .................................. ....................... .. 76 5.4 Heuristic Methods for MRCPSP ................................................ 77 5.4.1 Existing Heuristics ................................. ..................... 77 5.4.2 Proposed New Heuristics ................................. ................ 78 5.5 A daptive M etaheuristic .............................................. ........... ... .. 80 5.6 Computational Experiments and Results .................................. ..... 83 5.7 Summary and Conclusions ................................ ..................... 87 6 CONCLUSIONS AND FUTURE WORK ...................................................... 88 LIST OF REFERENCES .......................................................................... ........ 91 BIOGRAPHICAL SKETCH ............................... ................. 100 LIST OF TABLES Table page 2 .1 R results for T aillard's instances .................................................................................. 28 2.2 Results for Gueret and Prins instances .............. ...... ......................... ........... 29 2.3.1 Results for randomly generated problem instances (25x25 and 30x30) .............. 29 2.3.2 Results for randomly generated problem instances (50x50 and 100x100) ............ 30 2.4 Computational times (in seconds) and iterations ....................................... .......... 32 2.5 Comparison of AugNN with other techniques (Taillard's Instances) ....................... 32 2.6 Comparison of AugNN with other techniques (Gueret and Prins Instances) ............ 33 2.7 Comparison of average CPU time in seconds for Taillard's 15x15 and 20x20 problem sets ....... ..................................... ............... 34 3.1 Makespans and improvements for Taillard's 20job benchmark problems ............. 45 3.2 Makespans and improvements for Taillard's 50job benchmark problems ............. 46 3.3 Makespans and improvements for Taillard's 100job benchmark problems ............ 47 3.4 Makespans and improvements for Taillard's 200job and 500job benchmark problems ................... ........................... 48 3.5 Makespans and improvements for Carlier's and Reeves's benchmark problems .... 49 3.6 CPU Times (in seconds) for PALA, CDSALA, NEHALA, simulated annealing and tabu search ..... ........... ............................ 50 4.1 Average deviations from the optimal solution for J30 ............................................ 70 4.2 Average deviations from the critical path based lower bound for J60 .................. 71 4.3 Average deviations from the critical path based lower bound for J120 ................ 72 5.1 Comparison of proposed singlepass greedy and nongreedy heuristics (Average percentage deviation from the criticalpath based lower bound) ............................ 84 5.2 Comparison of singlepass heuristics (Average percentage deviation from the criticalpath based low er bound) ........................................ ..................... ..... 85 5.3 Comparison of singlepass heuristics (Maximum percentage deviation from the criticalpath based low er bound) ........................................ ..................... ..... 85 5.4 Comparison of singlepass heuristics (Minimum percentage deviation from the criticalpath based low er bound) ........................................ ..................... ..... 86 5.5 Comparison of metaheuristics (Average percentage deviation from the criticalpath based low er bound) .. .. ..... ............................ ........ ........... 86 LIST OF FIGURES Figure page 2.1. Neural network architecture for the AugNN approach for a 3x3 problem ............. 15 4.1. A simple example for a resourceconstrained project scheduling problem............... 55 4.2. Neural networks for the example problem of RCPSP .................... ............... 58 Abstract of Dissertation Presented to the Graduate School of the University of Florida in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy NEURAL NETWORKS BASED METAHEURISTICS FOR SOLVING OPTIMIZATION PROBLEMS By Selcuk Colak May 2006 Chair: Sahin Selcuk Erenguc Cochair: Anurag Agarwal Major Department: Decision and Information Sciences In this research, we propose two neural networksbased metaheuristic approaches for solving various wellknown optimization problems in the literature. The first metaheuristic is called Augmented Neural Networks (AugNN). In this approach, traditional neural networks are augmented to allow embedding domain and problem specific knowledge. The network architecture is problem specific and complex neural functions are used to (i) capture the constraints of the problem and (ii) apply a priority rulebased heuristic. Such an approach combines the advantages of known heuristics and the iterative learning of neural networks. We apply this approach to the classical open shop scheduling problem (OSSP) and to the parallel schedule generation of resource constrained project scheduling problem (RCPSP). The second metaheuristic that we propose is the Adaptive Learning Approach (ALA). This approach employs a onepass heuristic to give a good starting solution in the search space and uses a weight parameter to perturb the data of the original problem in order to obtain improved solutions. The weights are then adjusted employing a search strategy which involves reinforcement and backtracking. The random perturbation allows a nondeterministic local search. We apply the improvementheuristic approach to the flow shop scheduling problem (FSSP) in conjunction with three wellknown heuristics in the literature. We also use this approach for the serial schedule generation of the RCPSP and multimode resource constrained project scheduling problem (MRCPSP). We empirically test our proposed approaches for each problem type on several benchmark instances in the literature and on some new problem instances generated in this study. We compare our results with lowerbound and bestknown upper bound solutions. The results are extremely competitive with existing techniques such as genetic algorithms, simulated annealing, tabu search and ant colonies, in terms of both solution quality and computational times. CHAPTER 1 INTRODUCTION Managers in today's complex business organizations face many hard optimization problems at all levels of management. The competitive pressures organizations face continue to grow. To remain competitive, managers need fast and effective solution procedures for many different types of optimization problems. Due to the combinatorial nature, and consequently NPHard nature, of many of these problems, optimal solutions are difficult to obtain quickly. Heuristic procedures are quick but do not always provide nearoptimal solutions. To reduce the gap between the obtained and the optimal solution, metaheuristic approaches have become very popular over the last two to three decades. Genetic algorithms, simulated annealing, tabu search, and ant colony optimization are some examples of metaheuristic approaches that have been very successful for a variety of optimization problems. Neural networksbased metaheuristics have received very little attention in the literature. In this dissertation we propose and develop neural networks based metaheuristics and apply them to a variety of NPHard scheduling problems. Amongst the various optimization problems, managers in most manufacturing environments deal with scheduling problems most often. Problems such as the flowshop and openshop scheduling problem appear on a daily basis. Project management problems are faced by project managers on a regular basis. We therefore apply our proposed approaches to these scheduling problems. The first efforts towards developing neuralnetworks based metaheuristics were due to Hopfield and Tank [1985] who applied their approach to the traveling salesman problem. Their work was extended by Foo and Takefuji [1988], and Sabuncuoglu and Gurgun [1996] who applied the HT approach to various scheduling problems. However, these approaches (i) were not scalable to largesize problems and (ii) could not guarantee feasible solutions and thus fell out of favor in the literature. Recent efforts by Agarwal et al. [2003] revived interest in neural networks based metaheuristics. They combined the neuralnetwork approach with a heuristic approach. This approach scales well to large problems and guarantees feasible solutions. The underlying idea of this approach can be described by the following theorem [Agarwal, 2005]: Theorem 1: Given an optimization problem, p : 0 = f () s.t. / and a heuristic a which solves p approximately, there exists a weight vector w e 91" and a corresponding problem p': 0 = f(w, ) s.t. / such that the application of the heuristic c to p' gives the optimal solution opt to the original problem p. Here, p is the optimization problem, 0 is the objective function, x is the set of problem parameters, q is the set of constraints, w e 9" is a weight vector, p' is a corresponding problem and a is a singlepass heuristic that solves p. This theorem provides the framework which allows us to (i) convert a given optimization problem into a corresponding optimization problem in which the problem parameters are replaced by weighted parameters and (ii) replace the task of searching for the optimal solution in the solution space of the original problem to that of searching for the weight vector in the weight space, which in conjunction with the given heuristic provides the optimal solution to the original problem. The theorem guarantees that there exists such a weight vector. Traditional neural networks are good at precisely searching for the best weight vector in the weight search space using an iterative search technique. Therefore application of the neural network approach allows us to solve a given optimization problem in an iterative manner. In this dissertation, we focus on developing neural networks based metaheuristics to four types of scheduling problems: the openshop scheduling problem (OSSP), the flowshop scheduling problem (FSSP), the resourceconstrained project scheduling problem (RCPSP) and the multimode resourceconstrained project scheduling problem (MRCPSP). Two metaheuristic techniques, namely augmented neural networks (AugNN) and adaptive the learning approach (ALA), are developed for solving these scheduling problems. In the second chapter, we solve the openshop scheduling problem. We apply the AugNN approach for solving the OSSP. This approach is a hybrid of heuristics and neuralnetwork approaches. The traditional neural network is augmented in at least two ways to allow embedding of domain and problemspecific knowledge. First, the network architecture is problem specific; instead of the standard 3layered network, it is ap layered network, where depends on the problem structure. Second, the input, activation and output functions are complex functions, designed to (i) enforce the problem constraints, and (ii) apply a known heuristic. The AugNN approach thus allows incorporation of domain and problemspecific knowledge and affords the advantages of both the heuristic approaches, i.e., finding good solutions fast, and iterative approaches, i.e., finding better neighborhood solutions iteratively. The AugNN approach allows fast convergence, compared to other metaheuristics such as genetic algorithms, simulated annealing, tabu search and ant colonies. We test the AugNN approach on some wellknown OSSP heuristics in the literature and also explore several new heuristics to obtain better results in relatively few iterations. The third chapter of the dissertation focuses on the general flowshop scheduling problem. We propose an improvement heuristic, the adaptive learning approach (ALA), which is similar to neuralnetwork training. In this approach, weighted processing times are used instead of given processing times. The approach employs a known onepass heuristic to give a good initial solution in the search space. It then searches the local neighborhood by perturbing the original problem data using an intelligent perturbation strategy that involves a weight factor. We apply this approach to a variety of flowshop benchmark problems in the literature. We provide empirical results for these problems, and demonstrate the efficacy of the approach in finding fast optimal or nearoptimal solutions. The fourth chapter is on solving the nonpreemptive resourceconstrained project scheduling problem. The RCPSP involves minimizing the makespan of a project by scheduling the activities which are subject to precedence and resource constraints. For solving this problem, two schedule generation schemes, serial and parallel, are commonly used. In this chapter, we use the adaptive learning approach for serial and augmented neural networks for parallel schedule generation. We call this approach the hybrid neural approach (HNA). The adaptive learning approach was deemed suitable for serial schedule generation due to the similarity between serial schedule generation and permutation flowshop scheduling. The AugNN approach can be applied to the parallel generation scheme for the RCPSP. We implement and test the proposed hybrid neural approach on some wellknown RCPSP benchmark problem instances in the literature. Computational results show that this metaheuristic works very well for the resource constrained project scheduling problem. In the fifth chapter, we consider the multimode resourceconstrained project scheduling problem, a generalized case of RCPSP, with renewable resources only. We propose (i) two new nongreedy heuristics for prioritizing the execution modes and (ii) an adaptive metaheuristic. We test our proposed heuristics on benchmark problem instances. The results show that both our singlepass heuristics and the adaptive metaheuristic outperform the existing singlepass heuristics and metaheuristics in the literature, respectively. The last chapter provides a summary of the dissertation and gives possible future research ideas. CHAPTER 2 OPEN SHOP SCHEDULING PROBLEM 2.1 Introduction The classical openshop scheduling problem (OSSP) is a wellknown scheduling problem. It involves a collection of n jobs J1, J2, ..., Jn and m machines Mi, M2, ..., Mm. Each job J, requires m operations 0,1, 02, ..., 0,m where 0, has a processing time ofp, > 0 and has to be processed on machine M,. The operations in each job may be processed in any order. Each machine can process at most one operation at a time and each job can be processed by at most one machine at a time. Further, operations cannot be preempted; i.e., they must be processed without interruption. The objective is to obtain a feasible schedule with the minimum makespan. The OSSP, like many other scheduling problems, has received wide attention in the literature due to its applications in manufacturing. Algorithmic improvements in finding better solutions faster for these scheduling problems have cost savings implications for many types of manufacturing activities. We apply and test the AugNN approach on some wellknown existing heuristics for the OSSP and also explore several new heuristics to obtain very good results (optimal or nearoptimal) in relatively few iterations. Our results are based on some benchmark problems of sizes 15x15 and 20x20 by Taillard [1993] and 10x10 by Gueret and Prins [1998b], and also some new larger problems of sizes 25x25, 30x30, 50x50 and even 100x100 generated in this study. 2.2 Literature Review Gonzales and Sahni [1976] presented a polynomial time algorithm for solving the open shop scheduling problem for the case m = 2. They also showed that the non preemptive OSSP is NPHard for m > 3. Pinedo [1995] proposed the longest alternate processing time first dispatching rule that solves the twomachine problem optimally. A branchandbound method for the general OSSP is developed by Brucker et al. [1997]. Their method solved some benchmark problems to optimality for the first time in the literature. Gueret et al. [2000] improved the Brucker's algorithm by using an intelligent backtracking technique. Dorndorf et al. [2001] implemented another branchandbound algorithm based on constraintpropagation methods to reduce the search space. Branch andbound algorithms, in general, fail to provide good solutions for larger problem instances in reasonable time. To overcome the computational complexity of finding optimal solutions, a variety of heuristics have been proposed for finding good suboptimal solutions fast. The literature is replete with such heuristics for all types of scheduling problems including OSSP. Gueret and Prins [1998a] presented two heuristics (i) listscheduling algorithm with two priorities and (ii) based on the construction of matching in a bipartite graph. Brasel et al. [1993] implemented constructive insertion algorithms. Liaw [1998] developed an iterative improvement approach based on Bender's decomposition. Metaheuristic approaches such as tabu search, simulated annealing, genetic algorithms and ant colonies have also been used for the OSSP. For example, Taillard [1993] used tabu search to solve many openshop problems to optimality. Taillard has also developed many randomly generated scheduling problems for the OSSP, which are used as benchmark problems in the literature. Alcaide et al. [1997] proposed tabu search algorithm as well, which uses simple list scheduling algorithms to build the starting solutions. They have tested the algorithm on instances up to 50 machines and 100 jobs. Another tabu search algorithm for the OSSP is applied by Liaw [1999b]. He also introduced a neighborhoodsearch algorithm using simulated annealing [Liaw, 1999a]. Several genetic algorithms have been proposed for the OSSP by Khuri and Miryala [1999], Liaw [2000] and Prins [2000]. Blum [2003, 2005] developed antcolony optimization approaches for the OSSP. 2.3 Heuristic Dispatching Rules In this section we present the dispatching rules to find feasible solutions for the OSSP in each iteration of the AugNN approach. 2.3.1 Job TRPT Machine PT Rule If only one job is ready to start and machines are available for the unfinished operations of this job, then the machine with the highest processing time (PT) for this job is assigned to this job. If no machines are available for this job, the job waits. If more than one job is ready to start, then the job with the highest total remaining processing time (TRPT) is considered first. TRPT is also known in the literature as MWR (Most Work Remaining). If several machines are available for this job, then the job is assigned to the machine with the highest processing time (PT). 2.3.2 Job TRPT Machine PT Rule Non Greedy This is our nongreedy variation of the above heuristic. It works the same as above except that before making the assignment decision for the job with the highest TRPT and the machine with highest PT, we check whether the remaining slack on this job is greater than the time the next operation will be complete. If the next operation is due to complete before the remaining slack of the job in question, we wait till the other operation is complete. Slack for ajob is defined as the difference between the total processing time of the longest job and the job in question. So, the slack of the longest job is zero. Remaining slack for ajob is the difference between the original slack and the slack consumed by this job. 2.3.3 Job TRPT Machine RPT Rule If only one job is ready to start and machines are available for the unfinished operations of this job, then the machine with the highest remaining processing time (RPT) is assigned to this job. If no machines are available for this job, then the job waits. If more than one job is ready to start, then the job with the highest total remaining processing time (TRPT) is considered first. If several machines are available for this job, then the job is assigned to the machine with the highest remaining processing time (RPT). 2.3.4 Job TRPT Machine RPT Rule Non Greedy This is our nongreedy variation of the above heuristic. It works the same as above except that before making the assignment decision for the job with the highest TRPT and the machine with highest RPT, we check whether the remaining slack on this job is greater than the time the next operation will be complete. If the next operation is due to complete before the remaining slack of the job in question, we wait till the other operation is complete. 2.3.5 DS/LTRP Rule This rule is used by Liaw [1998,1999a,1999b]: Whenever a machine is idle, select among its available operations the operation belonging to the job that has the longest total remaining processing time on other machines (LTRPOM) for this job (i.e., excluding the operation on the machine in question) to process next. If there is no available operation, the machine remains idle until the next operation has been completed on some other machine. If more than one machine is idle at the same time, select the machine with the longest remaining processing time on that machine. 2.3.6 DS/LTRP Rule Non Greedy with Job Slack This is our nongreedy variation of the above heuristic. It works the same as above except that before making the assignment decision for the job with LTRPOM and the machine with highest RPT, we check whether the remaining slack on this job is greater than the time the next operation will be complete. If the next operation is due to complete before the remaining slack of the job in question, we wait till the other operation is complete. 2.3.7 DS/LTRP Rule Non Greedy with Machine Slack This is another nongreedy variation of the above heuristic. It works the same as the DS/LTRP heuristic except that before making the assignment decision for the job with LTRPOM and the machine with highest RPT, we check whether the remaining slack on this machine is greater than the time the next operation will be complete. If the next operation is due to complete before the remaining slack of the machine in question, we wait till the other operation is complete. Slack for a machine is defined as the difference between the total processing time on the longest processing time machine and machine in question. Remaining slack for a machine is the difference between the original slack for that machine and the slack consumed by it. 2.3.8 DS/LTRPAM Rule Whenever a machine is idle select, among its available operations, the operation belonging to the job that has the longest total remaining processing time (including the operation on the machine in question) to process next. If there is no available operation, the machine remains idle until the next operation has been completed on some other machine. If more than one machine is idle at the same time, select the machine with the longest remaining processing time on that machine. This is a new heuristic we are proposing in this study. 2.3.9 DS/LTRPAM Rule Non Greedy with Job Slack This heuristic is the same as above except that before making the assignment decision for the job with TRP and the machine with highest RPT, we check whether the remaining slack on this job is greater than the time the next operation will be complete. If the next operation is due to complete before the remaining slack of the job in question, we wait till the other operation is complete. 2.3.10 DS/LTRPAM Rule Non Greedy with Machine Slack This heuristic is the same as the DS/LTRPAMrule above except that before making the assignment decision for the job with TRP and the machine with highest RPT, we check whether the remaining slack on this machine is greater than the time the next operation will be complete. If the next operation is due to complete before the remaining slack of the machine in question, we wait till the other operation is complete. 2.4 Augmented Neural Network Formulation We now explain the formulation of the AugNN approach for the OSSP. The general idea of the AugNN formulation is that we first convert a given OSSP into a neural network, with input layer, hidden layers and output layer of neurons or processing elements (PEs). We define connections between these layers, characterized by weights. Input, activation and output functions are designed for each node so as to enforce the constraints of the problem and embed a heuristic to generate a feasible solution in one pass (iteration) of the neural network. An iteration consists of calculating all the functions of the network from the input up to the output layer. We then apply a search strategy to modify the weights on the connections such that a search takes place and better solutions are obtained in subsequent iterations. We will now describe, with the help of an example, how to convert a given problem into a neural network. We will take a simple 3x3 problem for this purpose. Figure 2.1 shows the neural network architecture for this problem. In a 3x3 problem, there are 3 jobs, each with 3 operations, for a total of 9 operations (011, 012, 013, 021, 022, 023, 031, 032 and 033). We create three operation layers, corresponding to the three operations of each job. Each operation layer has three nodes corresponding to each job. Note that for a more general n x m case, there would be m operation layers, each with n nodes. Following each operation layer is a machine layer with 9 nodes each. Each of the three operation nodes is connected to three machine nodes for a total of 9 machine nodes. For a more general n x m case, there would be nm machine nodes in each machine layer. So, for example, operation 021 is connected to three machine nodes labeled M211, M212 andM213. Operation layer 1 can be considered as the input layer of a neural network. The remaining operation layers and machine layers can be considered as hidden layers and a final node acts as the output layer. Connections between operation nodes and machine nodes are characterized by weights. These weights are all the same for the first iteration, but are modified for each subsequent iteration. There are also connections between machine nodes and subsequent operation nodes, which are not characterized by any weights. These connections serve to pass signals from one layer to the next to trigger some functions. There are three types of connections between machine nodes. In the first type, each machine node is connected to nodes of other machines for the same operation. For example, Mll1 is connected toM112 andM113. These connections are used to enforce the constraint that the same operation cannot be processed by more than one machine at the same time. In the second type, each machine node is connected to nodes of the same machine on other operations of other jobs. For example, Mll1 is connected toM211, M311, M221, M231, M321 and M331. These connections are used to enforce the constraint that the same machine cannot process more than one operation at the same time. In the third type, each machine node is connected to nodes of the same machine for other operations of the same job. So for example, Mill is connected to M121 and M131. These connections are used to ensure that the same machine is not assigned to the same job more than once. Machine nodes are also connected to the operation nodes in the reverse direction. Whenever a job is assigned to a machine, the machine node sends a signal to the operation node, indicating to the operation that it has been assigned. This signal changes the state of the operation node and triggers other functions. We now describe the input, activation and output functions for each node and the search strategy for the weights. We will need the following notation to describe our functions: N Number of jobs M Number of machines C Current iteration J Setof jobs= {1,..,n} J, Job i, i e J M Set of machines = {1,..,m} Mk Machine k, k E M O Set of operations = {1,...,m} Oj ijth operation node, i e J,je O Myk Node for machine k, connected from O,, i e J, j e O, k E M TRPj Total remaining processing time for job j, j e J coik Weight on the link from Oi* to Mi*k machine nodes, i e J, k E M com Weight on the links between machine nodes a Search coefficient ec Error in iteration c OF Final dummy operation node STijk Start time of Oij on Mk i J, j e O, k E M PTik Processing time of Ji on Mk, i e J, k E M Winij Winning status of Job Ji on machine Mj, i e J, j e M (coNG)ij Weight for waiting for operation Oij. NG stands for nongreedy T Elapsed time JPTi Job processing time for job i = sum of PT of all operations for job i CJPT Critical job processing time = Max of all JPTi, i e J JSLKi Slack for job i = CJPT JPTi, i e J MPTk Machine processing time for machine k = sum of PT of all operations on machine k CMPT Critical machine processing time = max of all MPTk, k E M MSLKk Slack for machine k = CMPT MPTk, k E M Output Layer d I I IOMMF I I I I I I I I I I I I I I I I ,~ I I, I I I I I I I I I OMR Input Layer Figure 2.1: Neural network architecture for the AugNN approach for a 3x3 problem Following are all functions of elapsed time t: IO,(t) IJOF(t) IMyk(t) OO,(t) OOF(t) OMFjkpq(t) OMFJkF(t) OMR,k(t) 0ofT (t) OMMkp(t) OM F,jkp(t) 00,(t) OMk(t) assign,k(t) S(t) JSLKU, (t) MSLKUk(t) RSJ,(t) RSMk(t) Input function value of operation node O,, i e J, j 0 Input function value of operation node OF Input function value of machine node k from operation O,, i eJ, j E O, keM Output function value of operation node O,, i eJ, j e 0 Output function value of operation node OF Output of Mc. node Myk to Opq in the forward direction, i,p J, j,q E O, ke M, q m Output of machine node Mk to OF in the forward direction, i e J, j=m, ke M Output of machine node Myk to O, in reverse direction, i e J, j 0, k eM Output of machine node Mjk to Mpqk in lateral direction, i,p e J, j q E 0, ke M, i p Output of machine node M,k to Mp in lateral direction, k,p eM, k p, i E J, j O Output of machine node Mjk to Mpk in forward direction, i e J, p,j e O, k e M,p >j Activation function of operation node O,, i eJ, j e 0 Activation function of machine node Mk, i e J, j E O, keM Operation O, assigned to machine Mk Set of operations that can start at time t. S(t) = {O, O0,(t)= 1} Slack of job i used up at time t, i eJ Slack of machine k used up at time t, keM Remaining slack of job i= JSLK, JSLKU,(t), i J Remaining slack on machine k = MSLKk MSLKUk(t), keM The neural network algorithm can be described with the help of the input functions, the activation functions and the output functions for the operation nodes and the machine nodes and the search strategy. 2.4.1 AugNN Functions 2.4.1.1 Operation nodes Input functions, activation states and output functions are now explained for the operation nodes. 2.4.1.1.1 Input functions IO,(0)= 1 V i eJ,j 1 (1) IO,(0) = 0 Vi E J, j O, j 1 (2) IOF() = 0 (3) These functions at time t = 0 provide initial signals to the operation layers. The first operation nodes (i.e. forj = 1) of all the jobs get a starting signal of 1 at time 0 (equation 1). The remaining operation layers get a signal of 0 (equation 2) and the final output layer also gets a signal of 0 (equation 3). For time t > 0, we have the following functions. For all other operations Vj > 1 A t > 0 IO,(t) = IO,(t1) + ZOMFjkpq(t) Vi,p EJ,i =p,j=q+l,j,qe O, k EM, qm (4) k IOF(t) = IOF(t1) + ZZOMFykF(t) j=m, Vk EM, iEJ, j O (5) pk IO, (equation 4), helps to enforce the constraint that a new operation of a job cannot start unless the current operation is complete. At t = 0, IO, is 0. When an operation node gets a signal from the machine node (OMF, described later), IO, becomes 1, which indicates that it is ready to start. IOF (equation 5) is the input of the final node. It gets an input from all the machines nodes of all the jobs. When IOF becomes n, we know that all jobs are done. 2.4.1.1.2 Activation function Operation nodes' Initial Activation State (i.e. at t=) is 1. Vi J, j EO, 1 ifIO,(t)= 0 0,,(t)= 2 if (00,(t1) = 1 v 2) A IO,(t) 1 3 if (00,j(t1) 2 v 3) A ZOMRk(t) = 1 k 4 if 0,j(t1) = 4 v (0,,(t1) = 3 A Y OMRyk(t) = 0) k State 1 above implies that operation O, is not ready to be assigned because input to this operation is still 0. State 2 implies that the operation is ready to be assigned to a machine because its input is 1. State 3 implies that the operation is in process because it is receiving a negative signal from a machine k that it is currently being processed. State 4 implies that the operation is complete and the negative signal from machine k is no longer there. 2.4.1.1.3 Output functions For all heuristics not using the Non Greedy scheme (heuristics 2.3.1, 2.3.3, 2.3.5, 2.3.8 of section 2.3), we have the following output function for the operation nodes: I 1 if0,(t) = 2 Vi eJ,jeO OOt) = S0 otherwise If an operation is ready to start (i.e. 00,,(t) = 2), then the operation node sends a unit signal to each machine node that it can be assigned. For all heuristics that use Non Greedy or Non Greedy Job Slack (heuristics 2.3.2, 2.3.4, 2.3.6 and 2.3.9 of section 2.3), we have the following functions. I 1 if 00,(t) = 2 A (WNG))k* RSJ, (t)< min {ST,* + PT, t}, i* i oo,(t) = 0 otherwise If an operation is ready to start (i.e. 00,(t) = 2) and the weighted remaining slack on the job is less than the least (start time + processing time elapsed time) of all other jobs, then the operation node sends a unit signal to each machine node that it can be assigned. For all heuristics that use Non Greedy Machine Slack (heuristics 2.3.7 and 2.3.10 of section 2.3), we have the following functions. 1 if 0,j(t) = 2 A (wNG),k* RSMj (t)< min {ST, + PT, t}, i* i} oo0 t) = 0 otherwise If an operation is ready to start (i.e. 0,(t) = 2) and the weighted remaining slack on the machine is less than the least (start time + processing time elapsed time) of all other jobs, then the operation node sends a unit signal to each machine node that it can be assigned. FNode t iflOF(t) n OOF(t)  S0 otherwise The final node outputs the makespan (t), the moment it receives n signals (one from each job) indicating that all jobs are complete. 2.4.1.2 Machine nodes Input, activation and output functions of machine nodes are now explained. 2.4.1.2.1 Input function I (t) = OO,(t) CO,k + Z OM2 L ,,(t) Co + Z O IA (t) con + Z OMMFiFkp(t) * S(t) k* p Vi EJ, j, pEO, k* k (6) There are four components oflMjk(t). The first component (OO,(t) )ik)is the weighted output from operation node O,j. Whenever it is positive, it means that machine k is being requested by operation O, for assignment. Remember OO,, becomes 1 when it is ready to be assigned. The second and third components are either zero or large negative. The second component becomes large negative whenever machine k is already busy with another operation. The third component becomes large negative whenever operation O, is assigned to another machine. oim is a fixed weight link between machines and is large negative to suppress the output of an operation if the machine is busy or assigned or the operation is assigned to another machine. The fourth component enforces the constraint that the same machine cannot operate on more than one operation of a job. 2.4.1.2.2 Activation function S1 if Max(IMjk(t) FirstHeuristicParameter) A Max(SecondHeuristicParameter) AIM11k(t)> 0) assignjk(t)= Vi eJ, j eO, keM 0 otherwise We have mentioned earlier that the AugNN functions, in addition to enforcing the constraints of the problem, also help embed a chosen heuristic into the problem. We have also seen how using the output of the operation node, the nongreedy aspect of a heuristic was implemented. Through the assign function, the rest of the heuristic is implemented. The assignment takes place if the product of Input of the machine node and the Heuristic dependent parameter, (such as PT or TRPT or RPT of Machine) is positive and highest. The requirement for it being positive is to honor the inhibitory signals. The requirement for highest is what enforces the chosen heuristic. First or SecondHeuristicParameter depends on the chosen heuristic. One of them is job dependent, and the other is machine dependent. They need to be evaluated in a given order. For a particular heuristic, there may not be a second parameter. Job dependent HeuristicParameters = TRPT, Total remaining proc time Machine dependent rRPTk Remaining proc time on machine k HeuristicParameters = lPT&k Proc time of job i on machine k If assignk(t) = 1, then STyk = t. Whenever an assignment takes place, we record the start time of the operation O, on machine k If S(t) I > 1 then if assignyk(t) = 1 then Wink = 1 The Wink term will be used later during the search strategy. We want to modify the weights of links based on whether a particular operation node won the competition in case there were more than one node competing for assignment. Machine nodes' Initial Activation State (i.e. at t=0) is 1. Vi EM, j ET, 1 : machine available 2 if(OMJk(t1) = 1 v OMk(t) = 1) A assign,~(t) 1 : machine busy (just assigned) 3 if (OM,(t1) = 2 v 3) A t < STk, + PT, :machine busy (processing) 4 ifOMk(t1)= 3 A t STk PTk :machine processed OM k(t) = 5 if OMIk(t1) =1 A Y 0 II (t) o,,,< 0 assigned to peS(t) anotherjob 6 if OMyk(t1)= 4 :machine k is finished process. O,. 1 if(OMk(t1) = v 5) A Z G1 (t) o,,, = 0 released by other job p CS(t) or not assigned to any other job S1 if OMk(t1) = 1 A I OM ,jk*k(t) o,,, < 0 :available but k* operation assigned to another machine At t=0, all machines are ready to start (State 1). When an assignment occurs on a machine, that machine enters state 2. State 2 turns into state 3 the following time unit and state 3 continues till the machine is processing a job. As soon as a machine is done processing it enters state 4. When a particular machine node is assigned to a job, all other nodes that represent the same machine are given state 5. For example, if machine node Mill is assigned to Operation Oil then machine nodes M211, M311 enter state 5. In state 5, they cannot be assigned to an operation. When a machine is finished processing an operation, it reaches state 6. A machine node enters the state of 1 from a state of 5 if it stops receiving a negative signal from other machine nodes. 2.4.1.2.3 Output functions r 1 if OMk(t)= 4 OMFjkpq(t) = V i,p EJ,j,q O,k EM, p= i+1 S0 if OM,f(t) = 1,2,3,5,6 Whenever a machine node is done processing an operation, i.e. it reaches state 4, it sends a signal to the operation ahead of it that it might start. r1 if OM, k(t)=2,3 Vi EJ, jEO,k eM OMRk(t) = L 0 if OM,k(t)= 1,4,5,6 Whenever a machine node is busy processing an operation (i.e. in states 2 or 3), it sends a negative signal to the operation node that it is processing. This helps switch the state of the operation node from 2 to a 3. S1 if OM k(t) 2,3 Vi,p eJ,j,q e O, k eM, p e S(t), p i of (t= t S0 if OM,Lk(t)= 1,4,5,6 Whenever a machine node is busy processing an operation (i.e. in states 2 or 3), it also sends a signal to the machine nodes corresponding to the same machine for other jobs in the same machine layer. This makes this machine ineligible to take up otherjobs, because these machine nodes receive a high negative IM. This scheme enforces the constraint that the same machine cannot operate on two jobs at the same time. [ 1 if OM, k (t) 2,3 01 f (t)= \ Vi J, jE O, k EM, k* k L 0 if OM,Lk(t) 1,4,5,6 Whenever a machine node is busy processing an operation (i.e. in states 2 or 3), it also sends a signal to other machine nodes in the same layer for the same job. This makes these other machine nodes ineligible to take up the same job, because the other machines receive a high negative IM. This scheme enforces the constraint that the same operation cannot be processed by more than one machine at the same time. S1 if 0M,! k(t) 2,3 OMMF kp(t) = V i e J, p,j O, k e M, p>j S0 if OMjk(t) 1,4,5,6 Whenever a machine node is busy processing an operation (i.e. in states 2 or 3), it also sends a signal to machine nodes corresponding to the same machine in other machine layers in the forward direction for the same job. This ensures that the same machine is not assigned to the same job more than once. The output ofF represents the makespan and the assignk(t) gives the schedule. If a machine is either assigned or released during a certain time unit, all functions need to be recalculated without incrementing the time clock. 2.4.2 Search Strategy A search strategy is required to modify the weights. The idea behind weight modification is that if the error is too high, then the probability of different machines being winners is higher during subsequent iteration. Since the machine with the highest value of IM, is the winner, an increase of weights will make the machine more likely to win and conversely a decrease of weight will make it less likely. The magnitude of change should be a function of the magnitude of the error and of some job parameter, such as processing time. Keeping these points in mind, the following search strategy is used for the weights on the links. Winning tasks: If Wink = 1 then ()ik)c+l = (aok)c a PTik c V i J, keM. Nonwinning Tasks: If Wink = 0 then (mo)k)c+l = (o)k)c + a PTk c V i eJ, keM. We modify the weights for nongreedy heuristics WNG as follows: ((WNG)lk)C+ 1 ((WNG)ik)c + a PTk c In addition to these weight changes in each iteration, we propose two additional features that govern search, namely, reinforcement and backtracking. These features are explained here briefly. 2.4.3 Reinforcement Neural networks use the concept of positive reinforcement of weights if the network performs well. We implement this idea of reinforcement by implementing the following rule. If in a particular iteration the makespan improves, the weight changes of that iteration with respect to the previous iteration are magnified by a factor called the reinforcement factor (RF). We test several reinforcement factors from 1 through 5 to see which factor works better overall. We found that an RF of 4 worked well for most problems. (0i)k)c+ 1= (Ok)c+l + RF ( (ik)c+l (Ok)c 2.4.4 Backtracking Sometimes it is possible to not obtain any improvement over several iterations. When this happens, it is best to abandon that path and start over from the previous best solution weights. We can parameterize how many iterations of no improvement to tolerate. This backtracking technique was part of our search strategy. In order to do this, we store the set of weights corresponding to the best solution obtained so far and revert back to it whenever solution does not improve for a specified number of iterations. 2.4.5 End of Iteration Routines 1. Calculate the gap (the difference between obtained makespan and the lower bound). Lower bound is the maximum amount of time that a job or machine requires. Lower Bound = max max PT k max PT 7k k L1 J k=l JJ The lower bound can be calculated once at the beginning. 2. Store the best solution so far. 3. If the number of iterations is equal to the lower bound or greater than a specified number, stop the program. 4. If continuing with the next iteration, modify weights using the search strategy. Apply backtracking and reinforcement, whenever necessary. 2.5 Computational Experiments and Results Three sets of problems are used to evaluate the performance of our algorithm. The first set consists of benchmark problems by Taillard [1993]. We focused on the larger problems (15x15 and 20x20). These square problems are harder to solve than the problems in which the number of jobs and the number of machines are different (Taillard [1993]). The second set of problems we use is from Gueret and Prins [1998b]. We focus on ten problem instances of size 10x10. The third set of problems was generated by us. These problems are of larger size 25x25, 30x30, 50x50 and 100x100. We generate ten problems of each size. The processing times were integers, generated using uniform distribution in the interval [1, 99]. The AugNN approach is coded in Visual Basic 6.0 running on WindowsXP operating system and implemented on a Celeron900 personal computer. In our implementation, the search coefficient ac is set to 0.001 and the weights are initialized at 1. An initial solution is generated using the dispatching rules given in Section 2.3. The weights are modified after each iteration using the search strategies explained in Section 4. The stopping criterion is to stop if the solution is equal to the lower bound or if a predetermined number of maximum iteration is reached. We set the maximum number of iterations to 1500 for Taillard's instances of size 15x15, and 20x20 and 5000 for the Gueret and Prins instances. For the new instances we run 500 iterations for 25x25, 30x30 and 50x50 and 200 for 100x100 problems. Table 2.1 shows the results for Taillard's benchmark problems. We ran AugNN in conjunction with all ten heuristics for all problems. So, for each problem instance, we have 10 results. In the interest of space, we report the best AugNN result. In addition, we report the results of 'DS/LTRPAM NonGreedy with Job Slack' heuristic, which performed the best amongst all ten heuristics. Note that DS/LTRPAM heuristic was proposed in this study. For each problem instance we report the lower bound (LB), the initial singlepass solution of the heuristic which gave the best result with AugNN, the best AugNN solution (AugNN Best), the solution gap from the lower bound in percentage (Solution Gap (Best)) = {((AugNN Best LB) / LB)*100}, and the percent improvement from the singlepass solution. We also report the DS/LTRPAM NonGreedy with Job Slack results and gaps. The optimal solutions appear in bold. As is seen in Table 2.1, 17 out of 20 problems were solved to optimality. Of the remaining 3 problems, the solution gap from the lower bound varies between 0.08 and 0.34 percent, an insignificant amount. The average solution gap for all 20 problems is only 0.032 percent. The computing time is relatively small. Average computing times and average number of iterations are given in Table 2.4. The AugNN DS/LTRPAM Non Greedy Job Slack heuristic performs the best for Taillard's, although almost all of the heuristics find optimal or near optimal solutions. The improvement due to the iterative approach of AugNN over the first pass solution ranged from 4.07% to 15.85% for the 15x15 problems and 0.80% to 14.36% for the 20x20 problems and averaged 8.64% for 15x15 and 5.50% for 20x20. Table 2.1. Results for Taillard's instances Solution Improv AugNN Solution Gap Souton from DS/LTRPAM with AugNN Problem Lower Single AugNN Gap DS/LTRPAM with AugNN Instance Bound Pass Best AugNN NG DS/LTRPAM Best Pass Best (%) P Job Slack NG JS (%) (%) tail5xl5a tail5xl5b tail5xl5c tail5x15d tail5xl5e tail5xl5f tail5xl5g tail5xl5h tail5xl5i tail5x15j tai20x20a tai20x20b tai20x20c tai20x20d tai20x20e tai20x20f tai20x20g tai20x20h tai20x20i tai20x20j 937 918 871 934 946 933 891 893 899 902 1155 1241 1257 1248 1256 1204 1294 1169 1289 1241 998 957 929 1033 1020 1101 939 971 989 1072 1249 1252 1285 1295 1296 1294 1511 1257 1321 1340 937 918 871 934 946 933 891 893 901 902 1155 1242 1257 1248 1256 1204 1294 1173 1289 1241 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.22 0.00 0.00 0.08 0.00 0.00 0.00 0.00 0.00 0.34 0.00 0.00 6.11 4.07 6.24 9.58 7.25 15.25 5.11 8.03 8.89 15.85 7.52 0.80 2.17 3.62 3.08 6.95 14.36 6.68 2.42 7.39 937 920 871 934 946 933 891 893 907 905 1155 1244 1257 1248 1256 1204 1298 1173 1289 1241 0.00 0.22 0.00 0.00 0.11 0.00 0.00 0.00 0.88 0.33 0.00 0.24 0.00 0.00 0.00 0.00 0.31 0.34 0.00 0.00 Table 2.2. Results for Gueret and Prins instances Sine Solution Improv AugNN Solution Gap Problem Lower nge AugNN Gap from DS/LTRPAM with AugNN Pass Instance Bound Bass Best AugNN Single NG DS/LTRPAM Best (%) Pass (%) Job Slack NG JS (%) gpl001 1059 1305 1113 5.10% 14.71% 1113 5.10% gpl002 1065 1328 1117 4.88% 15.89% 1117 4.88% gpl003 1046 1265 1104 5.54% 12.73% 1104 5.54% gpl004 1045 1210 1098 5.07% 9.26% 1098 5.07% gpl005 1044 1249 1095 4.89% 12.33% 1095 4.89% gpl006 1055 1301 1074 1.80% 17.45% 1074 1.80% gpl007 1075 1218 1084 0.84% 11.00% 1098 2.14% gpl008 1047 1264 1104 5.44% 12.66% 1105 5.54% gp1009 1065 1396 1130 6.10% 19.05% 1130 6.10% gpl010 1057 1353 1099 3.97% 18.77% 1099 3.97% Table 2.3.1. Results for randomly generated problem instances (25x25 and 30x30) Solution Improv AugNN Solution Gap Problem Lower Sgle AugNN Gap from DS/LTRPAM with AugNN Pass Instance Bound Best Best AugNN Single NG DS/LTRPAM Best (%) Pass (%) Mach. Slack NG MS (%) 25x25 a 1426 1644 1427 0.07 13.20 1427 0.07 25x25 b 1599 1720 1599 0.00 7.03 1599 0.00 25x25 c 1559 1662 1559 0.00 6.19 1559 0.00 25x25 d 1571 1690 1571 0.00 7.04 1571 0.00 25x25 e 1568 1660 1568 0.00 5.54 1568 0.00 25x25 f 1485 1632 1485 0.00 9.01 1485 0.00 25x25 g 1604 1717 1604 0.00 6.58 1604 0.00 25x25 h 1442 1563 1442 0.00 7.74 1442 0.00 25x25 i 1585 1739 1585 0.00 8.85 1585 0.00 25x25 j 1531 1640 1531 0.00 6.64 1531 0.00 30x30 a 1745 1891 1745 0.00 7.72 1745 0.00 30x30 b 1875 1994 1875 0.00 5.97 1875 0.00 30x30 c 1843 2024 1843 0.00 8.94 1843 0.00 30x30 d 1851 1977 1851 0.00 6.37 1851 0.00 30x30 e 1885 1998 1885 0.00 5.65 1885 0.00 30x30 f 1751 1853 1751 0.00 5.51 1751 0.00 30x30 g 1908 2075 1908 0.00 8.05 1909 0.05 30x30 h 1741 1893 1742 0.06 7.98 1746 0.29 30x30 i 1919 1980 1919 0.00 3.08 1919 0.00 30x30j 1824 1917 1824 0.00 4.85 1824 0.00 Table 2.2 gives the AugNN results for the ten Gueret and Prins hard instances of size 10x10. We report the best results from all ten heuristics and also for the DS/LTRPAM NonGreedy Job Slack heuristic. The improvement due to AugNN over singlepass heuristics ranged from 9.26% to 19.05% with an average improvement of 14.39%. The gaps from the lower bound ranged from 0.84% to 6.10%. Table 2.3.2 Results for randomly generated problem instances (50x50 and 100x100) Sine Solution Improv AugNN Solution Gap Problem Lower AugNN Gap from DS/LTRPAM with AugNN Pass Instance Bound Best Best AugNN Single NG DS/LTRPAM Best (%) Pass (%) Mach. Slack NG MS (%) 50x50a 50x50b 50x50c 50x50d 50x50e 50x50f 50x50g 50x50h 50x50i 50x50j O1xl00a O1xl00b 100xl00c O1xl00d 100xl00e 100xl00f O1xl00g O1xl00h 100x100i 100x100j 3029 3039 3128 3038 2964 2933 3011 3140 3032 2964 5759 5787 5643 5697 6023 5784 5667 5765 5630 5701 3157 3181 3280 3209 3105 3100 3160 3286 3087 3097 5875 5953 5958 5866 6248 5951 5875 5945 5712 5870 3029 3039 3129 3038 2966 2936 3011 3140 3032 2964 5762 5787 5647 5697 6023 5789 5669 5765 5635 5703 0.00 0.00 0.03 0.00 0.07 0.10 0.00 0.00 0.00 0.00 0.05 0.00 0.07 0.00 0.00 0.09 0.04 0.00 0.09 0.04 4.05 4.46 4.60 5.33 4.47 5.29 4.71 4.44 1.78 4.29 1.92 2.79 5.22 2.88 3.60 2.72 3.51 3.03 1.35 2.84 3029 3039 3129 3038 2966 2937 3011 3140 3033 2968 5765 5787 5647 5701 6023 5791 5673 5768 5636 5709 0.00 0.00 0.03 0.00 0.07 0.14 0.00 0.00 0.03 0.14 0.10 0.00 0.07 0.07 0.00 0.12 0.10 0.05 0.11 0.14 The results for the third set of problems are given in Table 2.3.1 and 2.3.2. The lower bound solution is found in 9 out of 10 instances for each of 25x25 and 30x30 problems. For the remaining two instances the solution gap is only 0.07 and 0.06 percent and the average solution gap is 0.0065 percent. The improvement due to the iterative approach of AugNN over the first pass solution ranged from 5.54% to 13.20% for the 25x25 problems and 3.08% to 8.94% for the 30x30 problems and average was 7.78% for 25x25, 6.41% for 30x30. For these problems DS/LTRPAM Non Greedy Machine Slack heuristic gave the best results. For the 50x50 problems, lowerbound solutions were obtained for seven out often instances, five of which were by our new heuristic DS/LTRPAM Non Greedy Machine Slack. The remaining 3 out of 10 problems were solved within 0.03 to 0.1 percent of the lower bound. The improvement due to AugNN's iterative approach over the singlepass heuristic was 1.78% to 5.33% with an average of 4.34%. For the 100x100 problems, four out often problems were solved to lower bound. The remaining six problems were solved within 0.04 to 0.09 percent of the lower bound. The improvement due to AugNN over singlepass heuristic ranged from 1.35% to 5.22% with an average of 2.98%. The average solution gap for all 50x50 and 100x100 problems was 0.029%. For these problems also, DS/LTRPAM Non Greedy Machine Slack heuristic gave the best results. Table 2.4 summarizes the computational times for the various sets of problems. It also provides the average number of iterations taken for the best solution. Table 2.5 shows comparative results of other metaheuristics that have been attempted on Taillard's benchmark problems of size 15x15 and 20x20. The problems that have not been solved to the lower bound are shaded. Our results (shown in the third column) appear to be quite competitive with the results of other techniques Table 2.4. Computational times (in seconds) and iterations Average Number of Average Computing Problem Instance Set averagee Couting Iterations for Best Time for Best Solution Solution Tai 15x15 17.3 118 Tai 20x20 28.6 143 GP 10x10 36.5 214 25x25 56.2 121 30x30 76.8 167 50x50 861 227 100x100 2847 116 Table 2.5. Comparison of AugNN with other techniques (Taillard's Instances) Domdorf Taillard Liaw Liaw Liaw Prins Blum Problem Lower Instance Bound AugNN [2000] [1993] [2000] [1999a] [1999b] [2000] [2003] B&B TS GA SA TS GA ANT tail5xl5 a 937 937 937 937 937 937 937 937 937 tail5xl5 b 918 918 NR' 918 918 "21" I 2" 918 918 tail5xl5 c 871 871 871 871 871 871 871 871 871 tail5xl5 d 934 934 934 934 934 934 934 934 934 tail5x5 e 946 946 946 'nI' 946 946 "4k 946 946 tail5xl5 f 933 933 933 933 933 933 933 933 933 tail5xl5 g 891 891 891 891 891 891 891 891 891 tail5xl5 h 893 893 893 893 893 893 893 893 893 tail5x 5 i 899 *'ii 899 **'i 899 "15 ^'I, 899 **'2 tail5xl5j 902 902 902 902 902 902 'l in 902 902 tai20x20a 1155 1155 1155 1155 1155 1155 1155 1155 1155 tai20x20 b 1241 242 NR 1244 1242 125 124h 1241 1247 tai20x20 c 1257 1257 1257 1257 1257 1257 1257 1257 1257 tai20x20d 1248 1248 NR 1248 1248 1248 1248 1248 1248 tai20x20e 1256 1256 1256 1256 1256 1256 1256 1256 1256 tai20x20 f 1204 1204 1204 121 It 1204 1204 1204 1204 1204 tai20x20 g 1294 1294 1294 1294 1294 1294 121 1294 12"h tai20x20h 1169 //11 NR 1173 1177 1 lSL 1 S4 1171 1177 tai20x20 i 1289 1289 1289 1289 1289 1289 1289 1289 1289 tai20x20 j 1241 1241 1241 1241 1241 1241 1241 1241 1241 1NR: Not reported Table 2.6 shows the comparative results for Gueret and Prins instances with other techniques found in the literature. Again, AugNN results appear to be very competitive with other techniques, although it is not the best. Blum's [2005] Beam Ant approach appears to be the best. However, it may be noted that they give the best results from runs and each run has a time limit of 1000 seconds for GP instances. Our average CPU time for the GP instances was 36.5 seconds. Table 2.7 shows the CPU times for AugNN and other metaheuristics for the Taillard's problems. Due to the differences in processor speeds, a direct comparison, of course, is difficult. Table 2.6. Comparison of AugNN with other techniques (Geuret and Prins Instances) Gueret Brucker Prins Blum [Prins,2000] Prins Blum Problem Lower AugNN et al. [2000] [2003] Longest [1998c] [2005] Instance Bound [1997] GA ANT Processing BBox Beam BBox B&B Time ANT gpl001 1059 1113 1151 1113 1108 1151 1145 1099 gpl002 1065 1117 1178 1120 1102 1477 1144 1101 gpl003 1046 1104 1162 1101 1097 1512 1160 1082 gplO04 1045 1098 1165 1090 1089 1244 1142 1093 gplO05 1044 1095 1125 1094 1091 1356 1125 1083 gplO06 1055 1074 1173 1074 1072 1448 1144 1088 gplO07 1075 1084 1172 1083 1081 1487 1138 1084 gpl008 1047 1104 1181 1098 1099 1313 1131 1099 gpl009 1065 1130 1184 1121 1124 1403 1148 1121 gpl010 1057 1099 1172 1095 1092 1237 1169 1097 Table 2.7. Comparison of average CPU time in seconds for Taillard's 15x15 and 20x20 sets. AugNN Dorndorf Taillard Liaw Liaw Liaw Prins Blum 1 B&B2 TS GA3 SA4 TS5 GA ANT6 Tai 15x15 17.3 600 NR 138 372 150 NR 137 Tai 20x20 28.6 3600 NR 465 1632 218 NR 349 1 used Celeron 900 MHz machine 2 used PentiumII 333 MHz machine 3 used PentiumII 266 MHz machine 4 used PentiumII machine 5 used Pentium 133 MHz machine 6 used AMD Athlon 1100 MHz machine NR: Not reported 2.6 Summary and Conclusions We have proposed and developed a formulation for applying the augmented neuralnetworks (AugNN) approach for solving the classical openshop scheduling problem (OSSP) and have tested the formulation on several benchmark problems from the literature and also on some new, larger problems. The computational tests show excellent results on all the problems, making this AugNN approach a strong contender to techniques such as tabu, simulated annealing, antcolonies and genetic algorithms, for solving the OSSP and other types of scheduling problems. The approach, which combines the benefits of singlepass heuristics approach and the iterative search approach, is able to give very good results in a short time, making it the technique of choice especially for tackling large instances. During the course of this study, we also developed a new singlepass heuristic (DS/LTRPAM). Non greedy versions of these heuristics were also developed. The nongreedy DS/LTRPAM in conjunction with AugNN gave better results than other heuristics. We also formalized some new search strategies such as reinforcement and backtracking to improve the search process and the solution quality. Large problem instances of sizes 25x25, 50x50 and 100x100 were also generated. CHAPTER 3 FLOW SHOP SCHEDULING PROBLEM 3.1 Introduction The general flowshop problem, denoted as n in Cnmax in the literature, involves n jobs, each requiring operations on m machines, in the same machine sequence. The processing time for each operation ispij, where i C {1,2,...,n} denotes a job andj C {1,2,...,m} a machine. The problem is to determine the sequence of these jobs that produces the smallest makespan assuming no preemption of operations. In the simplest case, all jobs are available and ready to start at time zero and the setup times on machines are assumed sequence independent and included inpij. In more realistic situations, however, jobs are released at different times, thus requiring dynamic scheduling and the setup times are sequence dependent. In this dissertation, we focus our attention to the simple case of constant setup times and availability of all jobs at time zero. We limit our study to only permutation schedules, i.e. the schedules in which the job sequence is the same on all machines. Permutation schedules are easier to implement and therefore preferred by the shopfloor manager. Further, the majority of the time, optimal schedules happens to be permutation schedules. The general flowshop problem is NPhard for m > 2, and has been studied extensively in the literature. We propose an improvement heuristic, based on the adaptive learning approach similar to neuralnetwork training. In this approach, weighted processing times are used instead of given processing times. Our approach employs a known onepass heuristic to give a good initial solution in the search space. It then searches the local neighborhood by perturbing the original problem data using an intelligent perturbation strategy that involves a weight factor. We apply this approach to a variety of flowshop benchmark problems in the literature. We provide empirical results for these problems, and demonstrate the efficacy of the approach in finding optimal or nearoptimal solutions fast. During the course of our empirical study, we matched the bestknown upperbound solution for many problems and found a new upper bound for one of the Taillard's benchmark problems of size 50x5. 3.2. Literature Review The scheduling literature is replete with solution procedures for the general flow shop scheduling problem for developing permutation schedules to minimize the makespan. Due to the NPhard (Garey et al., [1976]) nature of the problem, most of the solution procedures employ heuristic approaches to obtain nearoptimal sequences in reasonable time. Baker [1974] is an excellent reference for all types of scheduling heuristics and tutorials, including the flowshop problem. Johnson [1954] first presented an algorithm that yielded optimum sequencing for an njob, 2machine problem. Gupta and Darrow [1986] discussed optimality issues in sequencing 2machine problems for the case of sequence dependent setup times. Lomincki [1965] proposed a branchandbound technique to find the optimum permutation of jobs. Palmer [1965] proposed a sequencing approach using a measure called the slope index. Gupta [1971] presented an alternative approach for calculating the slope index. Campbell et al. [1970], proposed their CDS heuristic, which gave very good results. NEH (Nawaz et al., [1983]) algorithm is probably thebest constructive method used in permutational flowshop problems. In NEH, the basic idea is to first optimally schedule the two longest processing jobs using Johnson's rule. Then place the remaining jobs, in decreasing order of total processing times, one by one, in one of the slots between already scheduled jobs such that the total makespan is minimized at each step. Rajendran and Chaudhuri [1993] further modified NEH algorithm by introducing a weightedsum measure for prioritizing the jobs. Taillard [1990] studied constructive methods and found that NEH performs superior among other heuristics tested. Framinan et al. [2003] also provided solutions using NEH and its variant. Several improvementheuristic methods such as tabu search, genetic algorithm, simulated annealing, and ant colony approach have been used to solve the flow shop problem. Although simulated annealing (Ogbu and Smith, [1990]; Osman and Potts, [1989]) and ant colony approaches (Ying and Liao, [2004]) have been implemented, tabu search (Nowicki and Smutnicki, [1996]; Daya and AlFawzan, [1998]; Grabowski and Wodecki, [2002]), and genetic algorithm (Chen et al., [1995]; Reeves and Yamada, [1998]) techniques are most popular because of their good results. In addition to developing the problemspacebased search method, Leon and Ramamoorthy [1997] developed lower bounds for the flowshop problem. These lower bounds were improved later by Kurz and Askin [2001]. 3.3 The Adaptive Learning Approach (ALA) In this section we formally explain the details of the adaptive learning approach used to improve upon a given heuristic. Note that this approach will apply to any permutation schedule heuristic. The general idea is that we define a weight factor associated with each operation. We use weighted processing times instead of regular processing times when applying a given heuristic. Weights are modified using a certain strategy, described below. The new set of weights will produce a different schedule in the next iteration. We monitor improvements and reinforce the weights that lead to improvements and backtrack to the last set of best weights if no improvement occurs for a certain number of iterations. We now explain our approach mathematically. 3.3.1 Notation J :set of n jobs {1,2,...,n} M : set of m machines {1,2,... m 0,j : Operation ofithjob onjth machine, i J,j e M P, : Processing time of operation O,j W,j : Weight associated with the operation O, WP, : Weighted processing time of operation O,j k : Iteration number Kmax : Max number of iterations MSk : Makespan in the kth iteration RF : Reinforcement factor TINI : Tolerate Iterations with No Improvement a : Search Coefficient BMS : Best Makespan BW, : Best Weights 3.3.2 Algorithm Steps Step 1: Initialization Initialize W, = 1 Vi EJ,j eM Initialize the iteration counter k to 1. Step 2: Calculate weighted processing times Calculate WP, = Wj Pj Vi J,j eM Step 3: Apply Heuristic Apply any heuristic, such as Palmer, or CDS or NEH using WP, in place of P,, to obtain a makespan for this iteration or MSk. Step 4: Apply Search Strategy and Modify Weights a. If MSk is the best makespan so far, save the current weights as best weights (BW,,) and the makespan as the best makespan (BMS). b. If k = Kmax, go to Step 6. a. If k > 1, and if an improvement occurs, reinforce the weights as follows: (WI,)k = (W,)k + RF*(()k (W)k) If no improvement occurs in this iteration, continue. b. If k > TINI and if no improvement has occurred in the past TINI iterations then Set W, = BW, e. Modify the weights using the following strategy: Generate a random number RND between 0 and 1 using uniform distribution. IfRND > 0.5 then (Wi)k+l = (W,)k + RND*a *P, If RND <= 0.5 then (Wi)k+ = (W,)k RND*a *P, Step 5: Next iteration. Increment k by one. Go back to step 2. Step 6: Display Solution The BMS is the solution. Take the BW,j and generate the schedule using the heuristic. 3.3.3 Search Strategy and Parameters In Step 4 of section 3.1.2, there are three search parameters, namely, the search coefficient (a), the reinforcement factor (RF) and the "Tolerate Iterations with No Improvement" (TINI). We explain each of these parameters next. 3.3.3.1 Search coefficient The search coefficient is one of the parameters that controls the degree of change of weights in each iteration. A higher coefficient causes more change and vice versa. Intuitively, a smaller search coefficient would search a smaller neighborhood, i.e., local search and vice versa. Therefore the granularity of the search can be controlled using a. A smaller a does a finer search than a larger a. We want to keep the search coefficient neither too small, because then the convergence will be too slow, nor too high because then the solution will jump all over the search space and there will never be convergence. With some empirical trial and error, we found that a rate of 0.05 worked well for all the problems. The results were sensitive to search coefficient especially in the range between 0.1 through 0.5. In the range 0.04 to 0.06 they were not very sensitive and the results were better, so we chose 0.05 as our search coefficient. 3.3.3.2 Reinforcement In Step 4c of section 3.1.2, we reinforce weights on iterations when improvement occurs. This idea is similar to neural network learning and also bears resemblance to the idea of short term memory of lists in Tabu search approaches. By reinforcing the weight changes of the previous iterations using a reinforcement factor, we essentially retain the relative weights for a few iterations, increasing the probability of finding better weight combinations in the next few iterations. The selection of the best reinforcement factor (RF) was performed empirically. Intuitively, it shouldn't be too small, because then the reinforcement is not strong enough, and it cannot be too high either, because then it will be hard to get out of the current set of relative weights. We find that an RF of 4 gave us the best results. Since different RF values gave different results, it appears that the reinforcement strategy makes a difference. 3.3.3.3 Backtracking (The TINI Factor) We also build a backtracking mechanism in our search strategy, using the TINI (Tolerate Iterations with No Improvement) factor. This factor is used to backtrack to the previous best iteration if no improvement occurs for TINI number of iterations. We backtrack by simply setting the current weights to the best weights found so far. Empirically we find that a TINI of 30 worked well for most of the problems. 3.4 Computational Results 3.4.1 Datasets For empirical testing we ran our experiments on four different benchmark problem sets, namely, Taillard's, Carlier's, Heller's and Reeves'. These datasets were obtained from the OR Library (http://mscmga.ms.ic.ac.uk/info.html). There were 120 instances from Taillard's datasets, 10 each of sizes 20x5, 50x5, 100x5, 20x10, 50x10, 100x10, 200x10, 20x20, 50x20, 100x20, 200x20 and 500x20. There were 8 instances from Carlier's dataset, 2 from Heller and 42 from Reeves' datasets. The Carlier's dataset had problems of sizes, ranging from 7 to 13 jobs and 4 to 9 machines. Reeves' dataset had 20 to 50 jobs and 5 to 10 machines. Best known upper bounds for these problems were used for comparison purposes. The two problems of Heller were of size 20x10 and 100x10, and we could not find the best reported upper bounds for these problems. 3.4.2 Platform and Parameters We coded Palmer, CDS, NEH algorithms in Visual Basic 6.0, running on 933 MHz PC. We created a user interface that allowed us to select and vary our search parameters, such as search coefficient, reinforcement factor and TINI. We were also able to select whether to run the heuristic by itself or in conjunction with ALA. We ran the ALA algorithm for 2000 iterations for each problem for Palmer and CDS. For NEH, we ran 1000 iterations for smaller problems, 500 iterations for 100 job problems, 250 iterations for 200 job problems and 50 for 500 job problems. We set the search coefficient at 0.05, RF at 4 and TINI at 30. 3.4.3 Results We will refer to the ALA version of the three heuristics as PALA (PalmerALA), CDSALA and NEHALA. Tables 3.1 through 3.4 summarize the results for Taillard's 120 instances. Table 3.5 shows the results for Carlier's, Heller's and Reeves' problems. In each of these tables we display the results for Palmer alone, CDS alone, NEH alone, P ALA, CDSALA and NEHALA. We also show percent improvement of ALA over single pass heuristic. We also show the best known upper bounds and percent gap from the best known upper bound for the best ALA result. Overall NEHALA performed better than PALA and CDSALA, although at the expense of more computing time. For Taillard's 5 machine problems, i.e., 50 x 5, 100 x 5 and 200 x 5 size problems, NEHALA matched the best known upper bound for 24 of the 30 problems. For the remaining 5 problems the average gap was 0.26 percent. So, ALA performed very well on the 5 machine problems. For 10 machine problems, i.e., 50 x 10, 100 x 10, 200 x 10 and 200 x 10 size problems, NEHALA matched the best known upper bound solutions for 2 instances and the average gap was 1.18%. For the 20 machine problems, ALA's results varied by the overall size of the problem. For example the 20x20 problems were solved to within an average of 0.38% gap, while the 50x20 problems came at an average gap of 5.29%, 100 x 20 at 4.97%, 200 x 20 at 3.61% and 500 x 20 at 1.85%. All the eight Carlier problems were solved to the best known upper bound, very fast by NEHALA. Consequently, the average gap was zero. NEH single pass matched the best upper bound for 3 of the problems. PALA and CDSALA solved 4 and 3 problems to upper bound respectively. We could not find the upper bounds for the two Heller problems, but NEHALA gave the best results: 136 for the 20 x 10 problem and 516 for the 100 x 10 problem. For the 42 Reeves' problems, NEHALA dominated the results. For six of these problems NEHALA matched the best upper bound. For all 42 problems, the average gap was only 1.52%. The average CPU times for each size of the problem are summarized in Table 3.6. The computation times of course vary by the size of the problem. Instead of displaying the times for each problem individually, we grouped the average CPU for each size of the problem. The variance, within a size was not significant. The Carlier problems were the smallest and therefore took the least time. PALA for 2000 iterations took between 0.9 to 1.8 seconds. CDSALA for 1000 iterations took from 1.7 to 3.4 seconds and NEHALA from 2.6 to 10.7 seconds. Reeves' problems varied a lot in size: 20x5 to 75x20 and the CPU time for NEH varied from 17 seconds to 2876 seconds. Taillard's problems varied the most in size and consequently the CPU times varied the most. We obtained the CPU times taken for Simulated Annealing and Tabu Search in Daya and Fawzan (1998). We show those CPU times in Table 3.6 as well for comparison purposes. 3.5 Summary and Conclusions An improvement heuristic based on adaptive learning approach (ALA) is proposed and applied to the general flowshop problem. The ALA approach was used to improve upon three heuristics, namely, Palmer, CDS and NEH. For all three heuristics, ALA showed significant improvements and compared well with the bestknown upper bounds. Empirical testing on 172 benchmark problems drawn from four datasets (Taillard, Carlier, Heller and Reeves) produced some very good results. For 43 of the problems, the best upper bound solution was matched and for 1 a new upper bound solution was found. The average gap from the best known upper bound was 1.74% for all Taillard's problems, 0% for Carlier's and 1.52% for Reeves' problems. 45 Table 3.1. Makespans and improvements1 for Taillard's 20 job benchmark problems Palmer CDS NEH Problem UB Single Single CDS 0 Single NEH %.Impr. Best 0 Gap P PALA0 %mpr. ALA Taillard Instance Taillard Pass ALA Impr.ALA Pass ALA mp. Pass ALA ALA ALA Ta ALA UB 20x5 A 1278 1384 1297 6.29% 1390 1305 6.12% 1286 1278 0.62% 1278 0.00% B 1359 1439 1367 5.00% 1424 1367 4.00% 1365 1359 0.44% 1359 0.00% C 1081 1162 1103 5.08% 1249 1114 10.81% 1159 1081 6.73% 1081 0.00% D 1293 1490 1336 10.34% 1418 1336 5.78% 1325 1293 2.42% 1293 0.00% E 1235 1360 1272 6.47% 1323 1253 5.29% 1305 1235 5.36% 1235 0.00% F 1195 1344 1224 8.93% 1312 1210 7.77% 1228 1195 2.69% 1195 0.00% G 1239 1400 1259 10.07% 1393 1251 10.19% 1278 1239 3.05% 1239 0.00% H 1206 1313 1231 6.25% 1341 1240 7.53% 1223 1206 1.39% 1206 0.00% I 1230 1426 1266 11.22% 1360 1263 7.13% 1291 1230 4.73% 1230 0.00% J 1108 1229 1150 6.43% 1164 1127 3.18% 1151 1108 3.74% 1108 0.00% 20x10 A 1582 1790 1649 7.88% 1757 1680 4.38% 1680 1583 5.77% 1583 0.06% B 1659 1948 1795 7.85% 1854 1753 5.45% 1729 1669 3.47% 1669 0.60% C 1496 1729 1634 5.49% 1645 1598 2.86% 1557 1507 3.21% 1507 0.74% D 1377 1585 1484 6.37% 1547 1493 3.49% 1439 1379 4.17% 1379 0.15% E 1419 1648 1542 6.43% 1558 1551 0.45% 1502 1419 5.53% 1419 0.00% F 1397 1527 1512 0.98% 1591 1512 4.97% 1453 1406 3.23% 1406 0.64% G 1484 1735 1569 9.57% 1630 1560 4.29% 1562 1484 4.99% 1484 0.00% H 1538 1763 1655 6.13% 1788 1668 6.71% 1609 1550 3.67% 1550 0.78% I 1593 1836 1735 5.50% 1720 1679 2.38% 1647 1600 2.85% 1600 0.44% J 1591 1898 1731 8.80% 1884 1712 9.13% 1653 1598 3.33% 1598 0.44% 20x20 A 2297 2818 2433 13.66% 2559 2437 4.77% 2410 2298 4.65% 2298 0.04% B 2099 2331 2235 4.12% 2285 2216 3.02% 2150 2101 2.28% 2101 0.10% C 2326 2678 2545 4.97% 2565 2452 4.41% 2411 2343 2.82% 2343 0.73% D 2223 2629 2388 9.17% 2434 2380 2.22% 2262 2223 1.72% 2223 0.00% E 2291 2704 2453 9.28% 2506 2438 2.71% 2397 2302 3.96% 2302 0.48% F 2226 2572 2358 8.32% 2422 2349 3.01% 2349 2246 4.38% 2246 0.90% G 2273 2456 2438 0.73% 2489 2397 3.70% 2362 2281 3.43% 2281 0.35% H 2200 2435 2342 3.82% 2362 2330 1.35% 2249 2216 1.47% 2216 0.73% I 2237 2754 2419 12.16% 2414 2390 0.99% 2320 2245 3.23% 2245 0.36% J 2178 2633 2391 9.19% 2469 2316 6.20% 2277 2181 4.22% 2181 0.14% Averages 7.22% 4.81% 3.45% 0.26% 1 Matched or new upper bound solutions are shaded Table 3.2. Makespans and improvements2 for Taillard's 50job benchmark problems Palmer CDS NEH Problem UB Single PALA % Impr. Single CDS % Impr Single NEH %.Impr. Best % Gap Instance Taillard Pass ALA Pass ALA ALA Pass ALA ALA ALA TaillardB 50x5 A B C D E F G H I J 50x10 A B C D E F G H I J 50x20 2774 2751 0.83% 3041 2934 3.52% 2777 2716 2.20% 2860 2860 0.00% 2963 2899 2.16% 3090 2929 5.21% 2845 2841 0.14% 2826 2821 0.18% 2733 2631 3.73% 2915 2832 2.85% 3478 3285 5.55% 3313 3310 0.09% 3321 3269 1.57% 3511 3376 3.85% 3427 3366 1.78% 3323 3323 0.00% 3457 3314 4.14% 3356 3244 3.34% 3414 3104 9.08% 3404 3375 0.85% 4272 4272 0.00% 4303 4241 1.44% 4210 4210 0.00% 4233 4233 0.00% 4376 4158 4.98% 4312 4163 3.46% 4306 4147 3.69% 4310 4255 1.28% 4547 4312 5.17% 4197 4197 0.00% s 2.37% Nic\% upper bound solution is enclosed in a rectangle. Matched upper bound solutions are shaded 2816 2726 3.20% 3032 2911 3.99% 2703 2682 0.78% 2884 2825 2.05% 3038 2874 5.40% 3031 2908 4.06% 2969 2813 5.25% 2835 2758 2.72% 2784 2618 5.96% 2942 774 5.71% 3421 3358 1.84% 3246 3188 1.79% 3280 3126 4.70% 3393 3286 3.15% 3375 3300 2.22% 3400 3274 3.71% 3520 3443 2.19% 3387 3256 3.87% 3251 3152 3.05% 3429 3378 1.49% 4328 4328 0.00% 4216 4192 0.57% 4189 4189 0.00% 4280 4246 0.79% 4122 4122 0.00% 4267 4222 1.05% 4134 4134 0.00% 4262 4262 0.00% 4212 4212 0.00% 4270 4261 0.21% 2.32% 3771 3668 3591 3635 3553 3667 3672 3627 3645 3696 Average 2733 2724 2843 2838 2640 2621 2782 2753 2868 2863 2850 2829 2758 2725 2721 2683 2576 2552 2790 2782 3135 3086 3032 2963 2986 2940 3198 3110 3160 3065 3178 3079 3277 3172 3123 3072 3002 2962 3257 3150 4082 3971 3921 3843 3927 3788 3969 3839 3835 3763 3914 3797 3952 3857 3938 3825 3952 3874 4079 3898 0.33% 0.18% 0.72% 1.04% 0.17% 0.74% 1.20% 1.40% 0.93% 0.29% 1.56% 2.28% 1.54% 2.75% 3.01% 3.12% 3.20% 1.63% 1.33% 3.29% 2.72% 1.99% 3.54% 3.28% 1.88% 2.99% 2.40% 2.87% 1.97% 4.44% 1.96% 2724 2838 2621 2753 2863 2829 2725 2683 2552 2774 3086 2963 2940 3110 3065 3079 3172 3072 2962 3150 3971 3843 3788 3839 3763 3797 3857 3825 3874 3898 0.00% 0.14% 0.00% 0.07% 0.00% 0.00% 0.00% 0.00% 0.00% 0.29% 3.18% 3.35% 3.56% 1.53% 2.99% 2.43% 2.55% 1.15% 2.24% 2.77% 5.30% 4.77% 5.49% 5.61% 5.91% 3.55% 5.04% 5.46% 6.28% 5.47% 2.62% 47 Table 3.3. Makespans and improvements3 for Taillard's 100job benchmark problems Palmer CDS NEH Problem UB Single PALA % Impr. Single CDS % Impr Single NEH %.Impr. Best % Gap Instance Taillard Pass ALA Pass ALA ALA Pass ALA ALA ALA TaillardB 100x5 100x10 100x20 5493 5268 5175 5014 5250 5135 5246 5034 5448 5322 5770 5349 5676 5781 5467 5303 5595 5617 5871 5845 6106 6183 6252 6254 6262 6302 6184 6315 6204 6404 5749 5523 5316 5316 5325 5275 5049 5049 5317 5317 5274 5188 5376 5305 5263 5174 5606 5511 5427 5427 6161 6161 5889 5734 6127 6016 6313 6170 6070 5861 5870 5642 6442 5933 6168 6021 6081 6081 6259 6213 7075 7075 7058 6996 7221 7039 7039 7039 7259 7259 7109 7109 7279 7279 7561 7234 7271 7165 7305 7069 3.93% 0.00% 0.94% 0.00% 0.00% 1.63% 1.32% 1.69% 1.69% 0.00% 0.00% 2.63% 1.81% 2.27% 3.44% 3.88% 7.90% 2.38% 0.00% 0.73% 0.00% 0.88% 2.52% 0.00% 0.00% 0.00% 0.00% 4.32% 1.46% 3.23% 5592 5592 0.00% 5563 5390 3.11% 5493 5364 2.35% 5273 5157 2.20% 5461 5422 0.71% 5259 5252 0.13% 5557 5412 2.61% 5387 5247 2.60% 5758 5626 2.29% 5723 5454 4.70% 6209 6209 0.00% 5873 5812 1.04% 6024 6024 0.00% 6377 6377 0.00% 6018 6013 0.08% 5744 5744 0.00% 6201 6087 1.84% 6234 6156 1.25% 6349 6267 1.29% 6387 6229 2.47% 6920 6920 0.00% 6977 6977 0.00% 7229 7132 1.34% 7062 7062 0.00% 7113 7113 0.00% 7283 7283 0.00% 7147 7147 0.00% 7235 7235 0.00% 7196 7195 0.01% 7164 7164 0.00% 5519 5493 0.47% 5348 5268 1.50% 5219 5175 0.84% 5023 5018 0.10% 5266 5250 0.30% 5139 5135 0.08% 5259 5246 0.25% 5120 5082 0.74% 5489 5448 0.75% 5341 5327 0.26% 5846 5803 0.74% 5453 5396 1.05% 5824 5697 2.18% 5929 5899 0.51% 5679 5557 2.15% 5375 5328 0.87% 5704 5635 1.21% 5760 5698 1.08% 6032 5946 1.43% 5918 5895 0.39% 6541 6467 1.13% 6523 6424 1.52% 6639 6495 2.17% 6557 6511 0.70% 6695 6579 1.73% 6664 6634 0.45% 6632 6534 1.48% 6739 6708 0.46% 6677 6558 1.78% 6677 6660 0.25% 5493 0.00% 5268 0.00% 5175 0.00% 5018 0.08% 5250 0.00% 5135 0.00% 5246 0.00% 5082 0.95% 5448 0.00% 5327 0.09% 5803 0.57% 5396 0.88% 5697 0.37% 5899 2.04% 5557 1.65% 5328 0.47% 5635 0.71% 5698 1.44% 5946 1.28% 5895 0.86% 6467 5.91% 6424 3.90% 6495 3.89% 6511 4.11% 6579 5.06% 6634 5.27% 6534 5.66% 6708 6.22% 6558 5.71% 6660 4.00% 3 Matched upper bound solutions are shaded Averages 1.62% 1.00% 0.95% 2.04% 48 Table 3.4. Makespans and improvements for Taillard's 200job and 500job benchmark problems Palmer CDS NEH UB Single PALA % Impr. Taillard Pass ALA Problem Instance 200x10 A B C D E F G H I J 200x20 A B C D E F G H I 500x20 A B C D E F G H I j 10862 10480 10922 10889 10525 10329 10854 10730 10438 10675 11152 11143 11281 11275 11259 11176 11337 11301 11145 11284 26040 26500 26371 26456 26334 26469 26389 26560 26005 26457 11443 10986 11336 11221 11125 10865 11303 11275 11184 11333 13042 12813 12846 13053 12827 12404 12584 12824 12523 12642 28227 29441 28087 28109 27768 28516 27878 28296 27734 28313 11288 10986 11336 11084 11125 10865 11303 11209 11184 11063 12430 12542 12557 12647 12470 12404 12584 12666 12523 12642 28227 28447 28087 28109 27768 28516 27878 28296 27734 28313 Single CDS % Impr Pass ALA ALA 1.35% 0.00% 0.00% 1.22% 0.00% 0.00% 0.00% 0.59% 0.00% 2.38% 4.69% 2.12% 2.25% 3.11% 2.78% 0.00% 0.00% 1.23% 0.00% 0.00% 0.00% 3.38% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 11609 11357 11669 11379 11352 11318 11608 11501 11252 11509 12432 12542 12783 12631 12538 12498 12711 12610 12639 12949 28246 29131 28618 29029 28234 28687 28322 28897 28294 27710 11456 11357 11608 11355 11338 11133 11608 11477 11252 11447 12432 12542 12774 12631 12538 12498 12711 12610 12639 12800 28246 28598 28618 29029 28234 28687 28322 28897 28294 27710 Single NEH %.Impr. Pass ALA ALA 1.32% 0.00% 0.52% 0.21% 0.12% 1.63% 0.00% 0.21% 0.00% 0.54% 0.00% 0.00% 0.07% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 1.15% 0.00% 1.83% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 10942 10716 11025 11057 10645 10458 10989 10829 10574 10807 11625 11675 11852 11803 11685 11629 11833 11913 11673 11869 26670 27232 26848 27055 26727 26992 26797 27138 26631 26984 10905 10633 11025 10921 10580 10396 10945 10828 10484 10778 11548 11633 11736 11670 11571 11543 11732 11699 11589 11683 26569 27113 26848 26925 26727 26981 26767 27076 26535 26910 Best % Gap Taillard ALA UB 0.34% 0.77% 0.00% 1.23% 0.61% 0.59% 0.40% 0.01% 0.85% 0.27% 0.66% 0.36% 0.98% 1.13% 0.98% 0.74% 0.85% 1.80% 0.72% 1.57% 0.38% 0.44% 0.00% 0.48% 0.00% 0.04% 0.11% 0.23% 0.36% 0.27% 10905 10633 11025 10921 10580 10396 10945 10828 10484 10778 11548 11633 11736 11670 11571 11543 11732 11699 11589 11683 26569 27113 26848 26925 26727 26981 26767 27076 26535 26910 0.84% 0.25% 0.40% 1.46% 0.94% 0.29% 0.52% 0.65% 0.84% 0.91% 0.44% 0.96% 3.55% 4.40% 4.03% 3.50% 2.77% 3.28% 3.48% 3.52% 3.98% 3.54% 2.03% 2.31% 1.81% 1.77% 1.49% 1.93% 1.43% 1.94% 2.04% 1.71% Averages 0.57% 2.07% 49 Table 3.5: Makespans and improvements for Carlier's4 and Reeves' benchmark problems Palmer Upper Single ALA % Imprv Single Bound Pass ALA Pass CDS ALA 7472 7038 5.81% 7940 7166 9.75% 7725 7400 4.21% 8423 8003 4.99% 8520 7821 8.20% 9487 8570 9.67% 7043 6590 6.43% 8825 8420 4.59% 6.71% Problem Instance Carlier Carlllx5 Car213x4 Car312x5 Car412x4 Car510x6 Car68x9 Car77x7 Car88x8 Heller Heller20xlC Heller 100x10 Reeves % Imprv Single ALA Pass NEH ALA 2.28% 0.46% 0.00% 4.99% 9.83% 4.04% 2.51% 4.76% 3.61% 150 142 561 % Imprv Best % Gap ALA ALA from UB 0.00% 2.85% 1.18% 0.00% 1.47% 3.05% 0.00% 2.31% 1.36% 5.33% 141 136 3.55% 136 540 3.74% 518 516 0.39% Averages 3.56% 4.54% 1.97% N/A 1247 1391 1334 4.10% 1399 1287 8.01% 1303 1249 4.14% 1249 0.16% 1247 1391 1356 2.52% 1399 1274 8.93% 1303 1249 4.14% 1249 0.16% 1109 1198 1133 5.43% 1273 1146 9.98% 1132 1109 2.03% 1109 0.00% 1109 1198 1170 2.34% 1277 1145 10.34% 1132 1109 2.03% 1109 0.00% 1242 1298 1266 2.47% 1361 1273 6.47% 1281 1244 2.89% 1244 0.16% 1242 1298 1298 0.00% 1361 1281 5.88% 1281 1245 2.81% 1245 0.24% Averages 2.81% 8.27% 3.01% 0.12% 1566 1701 1595 6.23% 1696 1597 5.84% 1626 1584 2.58% 1584 1.15% 1566 1701 1650 3.00% 1696 1589 6.31% 1626 1584 2.58% 1584 1.15% 1537 1896 1657 12.61% 1639 1639 0.00% 1583 1538 2.84% 1538 0.07% 1537 1891 1687 10.79% 1610 1610 0.00% 1594 1539 3.45% 1539 0.13% 1431 1670 1540 7.78% 1595 1523 4.51% 1550 1431 7.68% 1431 0.00% 1431 1670 1584 5.15% 1586 1498 5.55% 1550 1431 7.68% 1431 0.00% Averages 7.59% 3.70% 4.47% 0.42% 1930 2163 2108 2.54% 2067 2017 2.42% 2002 1940 3.10% 1940 0.52% 1930 2163 2077 3.98% 2075 2022 2.55% 2002 1939 3.15% 1939 0.47% 1950 2145 2128 0.79% 2095 2069 1.24% 2013 1962 2.53% 1962 0.62% 1950 2145 2108 1.72% 2098 2076 1.05% 2025 1960 3.21% 1960 0.51% 1902 2164 2120 2.03% 2094 2067 1.29% 2019 1925 4.66% 1925 1.21% 1902 2164 2098 3.05% 2094 2072 1.05% 2062 1927 6.55% 1927 1.31% Averages 2.35% 1.60% 3.86% 0.77% 2093 2477 2330 5.93% 2385 2290 3.98% 2185 2122 2.88% 2122 1.39% 2093 2486 2353 5.35% 2422 2323 4.09% 2185 2121 2.93% 2121 1.34% 2017 2303 2144 6.90% 2358 2197 6.83% 2131 2046 3.99% 2046 1.44% 2017 2303 2238 2.82% 2358 2210 6.28% 2131 2050 3.80% 2050 1.64% 2011 2371 2207 6.92% 2273 2210 2.77% 2155 2047 5.01% 2047 1.79% 2011 2371 2209 6.83% 2273 2226 2.07% 2155 2042 5.24% 2042 1.54% Averages 5.79% 4.34% 3.98% 1.52% 2513 2902 2810 3.17% 2780 2770 0.36% 2644 2562 3.10% 2562 1.95% 2513 2902 2819 2.86% 2747 2747 0.00% 2675 2569 3.96% 2569 2.23% 2373 2706 2590 4.29% 2620 2605 0.57% 2498 2418 3.20% 2418 1.90% 2373 2706 2649 2.11% 2620 2604 0.61% 2494 2420 2.97% 2420 1.98% 2287 2623 2598 0.95% 2602 2522 3.07% 2391 2321 2.93% 2321 1.49% 2287 2623 2623 0.00% 2650 2574 2.87% 2391 2308 3.47% 2308 0.92% Averages 2.23% 1.25% 3.27% 1.74% 3045 3618 3382 6.52% 3489 3344 4.16% 3173 3124 1.54% 3124 2.59% 3045 3618 3493 3.45% 3498 3445 1.52% 3179 3129 1.57% 3129 2.76% 3114 3442 3268 5.06% 3424 3268 4.56% 3241 3139 3.15% 3139 0.80% 3114 3433 3393 1.17% 3424 3333 2.66% 3237 3140 3.00% 3140 0.83% 3277 3623 3313 8.56% 3523 3418 2.98% 3313 3277 1.09% 3277 0.00% 3277 3623 3495 3.53% 3523 3516 0.20% 3383 3277 3.13% 3277 0.00% Averages 4.71% 2.68% 2.25% 1.17% 4890 5885 5625 4.42% 5735 5663 1.26% 5227 5167 1.15% 5167 5.66% 4890 5885 5680 3.48% 5735 5659 1.33% 5268 5167 1.92% 5167 5.66% 5043 5939 5792 2.48% 5841 5746 1.63% 5308 5234 1.39% 5234 3.79% 5043 5939 5797 2.39% 5841 5753 1.51% 5336 5243 1.74% 5243 3.97% 4910 5762 5762 0.00% 5805 5723 1.41% 5292 5154 2.61% 5154 4.97% 4910 5762 5676 1.49% 5805 5731 1.27% 5317 5173 2.71% 5173 5.36% Averages 2.38% 1.40% 1.92% 4.90% 4 Matched upper bounds are shaded 7038 7166 7312 8003 7720 8505 6590 8366 Averages 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 152 145 4.61% 555 541 2.52% Rec0120x5 Rec0220x5 Rec0320x5 Rec0420x5 Rec0520x5 Rec0620x5 Rec0720x10 Rec0820x10 Rec0920x10 Rec1020x10 Recll20x10 Recl220x10 Rec1320x15 Rec1420x15 Rec1520x15 Rec1620x15 Rec1720x15 Rec1820x15 Rec1930x10 Rec2030xl0 Rec2130x10 Rec2230x10 Rec2330x10 Rec2430x10 Rec2530x15 Rec2630x15 Rec2730x15 Rec2830x15 Rec2930x15 Rec3030x15 Rec3150x10 Rec3250x10 Rec3350x10 Rec3450x10 Rec3550x10 Rec3650x10 Rec3775x20 Rec3875x20 Rec3975x20 Rec4075x20 Rec4175x20 Rec4275x20 i I Table 3.6: CPU Times (in annealing and tabu search seconds) for PALA, CDSALA, NEHALA, simulated # of PALA CDSALA NEHALA Simulated Tabu Problem Instance Instances Anneal1 Search1 for size Taillard 20x5 Taillard 20x10 Taillard 20x20 Taillard 50x5 Taillard 50x10 Taillard 50x20 Taillard 100x5 Taillard 100x10 Taillard 100x20 Taillard 200x10 Taillard 200x20 Taillard 500x20 Carlier 11x5 Carlier 13x4 Carlier 12x5 Carlier 14x4 Carlier 10x6 Carlier 8x9 Carlier 7x7 Carlier 8x8 Reeves 20x5 Reeves 20x10 Reeves 20x15 Reeves 30x10 Reeves 30x15 Reeves 50x10 Reeves 75x20 Heller 20x10 Heller 100x10 10 10 10 10 10 10 10 10 10 10 10 10 3.0 4.8 8.8 8.6 13.9 24.8 19.8 31.2 55.1 39.1 42.5 242.2 1.1 1.0 1.3 1.2 0.9 1.8 0.9 1.7 1.6 2.8 4.3 4.2 5.7 6.8 19.9 4.4 27.4 7.9 19.8 55.1 32.5 78.9 194.7 119.7 253.8 297.9 429.6 976.5 3009.5 1.8 1.7 2.0 2.1 2.4 3.4 1.7 2.3 8.1 19.2 35.8 35.6 61.1 79.4 399.3 29.8 428.5 34.2 74.1 152.3 487.8 983.0 2750.3 3736.0 3837.0 8853.5 16607.4 34590.0 69977.5 6.6 2.6 8.6 10.7 6.0 6.4 2.8 4.5 16.5 34.6 49.6 94.9 144.3 423.7 2876.0 94.0 2565.0 390.0 408.0 588.0 2052.0 2784.0 3354.0 8802.0 11358.0 13092.0 24816.0 35484.0 72972.0 504.0 534.0 564.0 2940.0 3780.0 4860.0 12300.0 15660.0 18720.0 35100.0 44400.0 108840.0 1 These times are obtained from Daya used a 486, 33MHz machine. and Fawzan (1998) converted in seconds by us. They NA: Not available CHAPTER 4 RESOURCE CONSTRAINED PROJECT SCHEDULING PROBLEM 4.1. Introduction The resource constrained project scheduling problem (RCPSP) is a wellknown NPHard problem in scheduling [Blazewicz et al., 1983]. It is a classical problem in operations research with broad applicability in project management and production scheduling. It has received the attention of many researchers for well over four decades and continues to receive attention even today. The RCPSP involves minimizing the makespan of a project by scheduling its activities that are subject to precedence and resource constraints. The amounts of available resources are fixed and known in advance. Resource requirements and processing times for each activity are deterministic and also known in advance and preemption of activities is not allowed. For solving this problem, two schedule generation schemes are commonly used serial and parallel. In this work, we propose, develop and test a new hybrid metaheuristic approach based on the principles of neural networks. We use adaptive learning approach for serial and augmented neural networks for parallel schedule generation. We call this approach the hybrid neural approach (HNA). The adaptive learning was deemed suitable for serial schedule generation due to the similarity between serial schedule generation and permutation flowshop scheduling. Similarly the AugNN approach can be applied to the parallel generation scheme for the RCPSP. In this study, forwardbackward improvement steps are also integrated within this framework of hybrid neural approach. We test our proposed hybrid neural approach on standard problem instances from the Project Scheduling Problem Library (PSPLIB). The results are very encouraging. Recently, with so many new metaheuristics emerging for this problem, the competition has become very stiff. Although we don't beat the best results in the literature for all the problem sets, we are close to the best depending on the problem set. Given that this approach is relatively new, it seems to hold a lot of promise; perhaps in future studies, it can be used in conjunction with other successful techniques, such as genetic algorithms, to give improved results. 4.2. Literature Review The research literature for the RCPSP is quite large. We refer the readers to the review papers by Icmeli et al. [1993], Ozdamar and Ulusoy [1995], Herroelen et al. [1998], Brucker et al. [1999], Hartmann and Kolisch [2000], Kolisch and Padman [2001]. The various exact methods applied to the RCPSP can be classified into three categories: dynamic programming, zeroone programming and implicit enumeration with branch and bound. Carruthers and Battersby [1966] applied a dynamic programming approach. Pritsker et al. [1969], Patterson and Huber [1974], Patterson and Roth [1976] proposed zeroone programming methods. Exact approaches based on implicit enumeration with branch and bound have been widely used: Davis and Heidorn [1971] Talbot and Patterson [1978], Christofides et al. [1987], Demeulemeester and Herroelen [1992, 1997], Brucker et al. [1998], Mingozzi et al. [1998], Dorndorf et al. [2000]. Blazewich et al. [1983] showed that the RCPSP is a generalization of the wellknown jobshopscheduling problem and is NPHard. While exact solution methods are able to solve smaller problems, heuristic and metaheuristic approaches are needed for larger problem instances. Priorityrule based heuristics combine one or more priority rules and schedule generation schemes (serial, parallel or both) in order to construct one or more schedules (Hartmann and Kolisch [2000]). If only one schedule is generated, it is called a single pass method and if more than one schedule is generated, it is called an Xpass (or multi pass) method. Although, priorityrule based heuristics are easy to implement and fast in terms of the computational effort, they are not very effective with respect to the average deviation from the optimal solution. A variety of priority singlepass methods have been widely used to solve the RCPSP: Davis and Patterson [1975], Cooper [1976], Alvares Valdes and Tamarit [1989], Boctor [1990], Ozdamar and Ulusoy [1994], Kolish [1996a]. Multipass methods can be categorized as multipriority rule methods, forwardbackward scheduling methods and sampling methods. Multipriority rule methods combine the schedule generation scheme with a different priority rule at each iteration (Ulusoy and Ozdamar [1989], Boctor [1990], Thomas and Salhi [1997]). Forwardbackward scheduling methods first construct the initial schedule and then move the activities to get a better schedule (Li and Willis [1992], Ozdamar and Ulusoy [1996]). Sampling methods uses a serial generation scheme and a priority rule to obtain the first schedule. Then they bias the order obtained by the priority rule by using a random device: Cooper [1976], AlvaresValdes and Tamarit [1989], Drexl [1991], Kolish [1996a, 1996b], Kolisch and Drexl [ 1996], Schirmer and Riesenberg [1998], Schirmer [2000]. Many metaheuristic methods have been applied to solve the resource constrained project scheduling problem. Metaheuristics based on GA are the most common: Leon and Ramamoorthy [1995], Lee and Kim [1996], Hartmann [1998, 2002], Alcaraz and Maroto [2001], Coelho and Tavares [2003], Hindi et. al [2002], Toklu [2002], Valls et al. [2003]. Simulated annealing algorithms which can handle nonpreemptive resource constrained project scheduling problem are presented by Boctor [1996b], Cho and Kim [1997], Bouleimen and Lecocq [2003]. Tabu search based metaheuristics are proposed by Pinson et al. [1994], Baar et al. [1997], Nonobe and Ibaraki [2002] and Thomas and Salhi [1998]. Merkle et al. proposed an ant colony approach to the RCPSP. In addition to applying these heuristics and metaheuristics, forwardbackward improvement (FBI) steps are suggested by Tormos and Lava [2001, 2003] and Valls et al. [2005]. This step is also called double justification technique. In FBI, a given schedule is compressed by eliminating unnecessary pockets of slack on a Gantt Chart. 4.3 AugNN Framework for Parallel Schedule Generation Two types of schedule generation schemes are used in resource constrained project scheduling problem, viz., serial and parallel. In parallel schedule generation, the order in which the activities are going to be scheduled is not decided at time t = 0. The scheduling decisions are made on a clock timer, at times when activities can start and resources are available. We describe the AugNN framework with the help of a simple RCPS problem shown in Figure 4.1. In this problem, there are six activities plus two zerotime dummy activities for the initial and final activities. There are three renewable resource types R1, R2 and R3. Each activity's duration and resource requirements are also shown in Figure 4.1. In this problem, the longest path has 5 activities A2, A5, A6 and the two dummy activities. S4 D 1 Resources Available: Dur: 4 Dur: 10 I R: 3 R: 5 R : 10 R2: 5 / R2:7 R2: 12 R3: 2 Al A4 R3: 5 R3: 8 Activity A2 A5 yur: 2 A6 Final Rl: 6 Dur: 6 Dummy R2: 3 R1: 2 Dur: 2 Activity R3: 4 R2:5 R1:3 R3:7 R2:3 Dur: 5 A3 R3: 1 R1: 4 R2: 8 R3:3 Figure 4.1. A simple example for a resourceconstrained project scheduling problem In the AugNN approach, the project graph of Figure 4.1 is framed as an nlayered neural network as shown in Figure 4.2. n, in this case is 8, which is 2(51), because 5 is the number of activities on the longest path. The set of activities at each level are placed in an activity layer. Each activity layer, except the dummy activity layers, is followed by a resource layer. The resource layer represents all the available resources. Input, activation and output functions for activity and resource layers are designed to capture the constraints of the problem. We will briefly describe the purpose of these functions. Input Functions The activity nodes get their input from the initial dummy node and resource layers. These functions are used to enforce the precedence constraints. When an activity node receives as many signals as the number of preceding activities, the activity is considered ready to be assigned. The resource layer gets its input from the activity nodes preceding it. When it gets an input, it knows that the activity is ready to start and that resources, if available, can be assigned. Activation Functions The activation functions of the activity nodes maintain the state of each activity. The activation functions of the resource layer keep track of resource availability and assignment of resources to activities. The priority rule is applied through these activation functions. Output Functions The output function of the activity node sends a signal to the resource layer when it is ready to be assigned. The output function of the resource layer signals the end of the activity. 4.3.1 Mathematical Formulation and Algorithm Details 4.3.1.1 Notations n : Number of activities r :Number of resource types A :Set of activities = {1,..,n} R :Set of resource types = {1,...,r} rik : Amount of resource of type k required by activity i, k e R, i e A bk : Total availability of resource type k. k : Current iteration A, :jth activity node, j e A RLj : Node for resource layer connected from A,, j e A TS : Total number of successors ofAj, j e A TRPT : Total remaining processing time ofAj, j e A SLK : Slack for activity Aj, j e A oj Weight on the link from A, to resource layer a : Search coefficient sk : Error in iteration k I Initial dummy activity node F :Final dummy activity node Tj : Threshold value of A = # of tasks t : Elapsed time in the current iteration immediately preceding Aj, j cA uF ST : Start time of activity. PT : Processing time of activity LST : Latest start time of activity LFT : Latest finish fime of activity PR : Set of tasks that immediately precede taskj, j eA VF SU : Set of tasks that immediately succeed taskj, j cA Win, Winning status of A, j e A SCP Set of tasks currently in process. Following are all functions of elapsed time t: IA(t) : Input function value of activity nodej,j EI uA uVF IRLA,(t) : Input function value of Resource layer from activity nodej, j A IRLRLk(t) : Input function value of Resource layer j from other resource layers for each resource type k, jE A, k R 58 Activity I I Resource Layer Activity layer A6 Activity layer A4 A5 Resource Layer ._ Resource Layer ___ Resource Layer Activity layer Al A2 A3n link Weight on links between activity and Dimmv Initial resource layers Figure 4.2. Neural networks for the example problem of RCPSP OAj(t) : Output function value of activity nodejj E I uA uF ORLFjp(t) :Output of RL, to activity node Ap in the forward direction, j A, p e SUj ORLR(t) : Output of Resource layer RL, to activity node A, in reverse directions c A ORLLjp(t) Output of Resource layer RL, to RLp in lateral direction, j,p A, j p p OAj(t) :Activation function of activity nodej,j EA ORL,(t) : Activation function of Resource layer RL,, j E T assign (t) :Activityj assigned at time t S(t) :Set of activities that can start at time t. S(t) = {A OAj(t)= 1} RAvk(t) Number of resources of type k available at time t 4.3.1.2 Preliminary steps 1. Calculate the Lower Bound, which is the same as the critical path duration under infinite resource availability assumption. 2. Initialize weights (oo,) at 10.00. The value 10 was arrived at after some computational experience. The value of the initial weights should be such that after subsequent modification to weights, the value should remain positive. The choice of the value of initial weight therefore also depends on the value of the search coefficient used. 3. Calculate the threshold of each task rj. The threshold of activity is defined as the number of tasks immediately preceding taskj. The threshold value is used to determine when a task is ready to start. The neural network algorithm can be described with the help of the search strategy and the input functions, the activation functions and the output functions for the task nodes and the machine nodes. 4.3.1.3 AugNN functions: 4.3.1.3.1 Activity nodes Input functions, activation states and output functions are now explained for the activity nodes. 4.3.1.3.1.1 Input function IA(O) =0 Vj A uF IAj(O) = 1 Vj E I (the starting signal of the initial dummy node is 1) IA,(t) = IA,(t1) + ORLF, (t) V q PR j e T uF q IA, helps to enforce precedence constraint. When IA, becomes equal to 0,, the activity can be assigned. 4.3.1.3.1.2 Activation function Activity nodes' Initial Activation State (i.e. at t=) is 1. Vj E 7T S1 if lA (t)< j OAj(t)= 2 if (0A,(t1) = 1 v 2) A IAj(t) = j 3 if (0Aj(t1) = 2 v 3)A ORLR,(t) < 0 4 if A(t1) = 4 v (0A,(t1) = 3 A ORLR,(t) = 0 Note: For the initial dummy node, = 1 State 1 above implies that activity is not ready to be assigned because input to activity is less than its threshold r. State 2 implies that activity is ready to be assigned because its input equals its threshold. State 3 implies that the activity is in process because it is receiving a negative signal from the resource layer that it is currently being processed. State 4 implies that the activity is complete and the negative signal from the resource layer is no longer there. 4.3.1.3.1.3 Output function I 1 if A,(t) = 4 OA(t) = S0 otherwise If an activity is ready to start but not assigned yet, it sends a unit signal to the resource layer. FNode St iflAF(t) = F OAF(t)= 10 otherwise The final node outputs the makespan t, the moment its threshold point is reached. 4.3.1.3.2 Resource layer Input, activation and output functions of resource layers are now explained. 4.3.1.3.2.1 Input function IRLA,(t) = OA,(t) o, V j A This is the weighted output from activity nodej. Whenever it is positive, it means that the resources are being requested by activity for assignment. IRLRLjk(t) = ORLLpk V j E A, k ER pESCP 4.3.1.3.2.2 Activation function Let Xj(t) =IRLj(t) TaskHeuristicParameterj Let RAv,(t) : Whether resourcesfor activity are available or not S1 if (bk IRLRLjk) >= rjk V k E R RAv,(t) = otherwise Max[X(t) IVAjES(t)]Al(t) >0 VjeA assign (t) S0 otherwise The assignment takes place if the product of Input of the resource layer and the Heuristic dependent activity parameter is positive and highest and if the resources are available. The requirement for highest is what enforces the chosen heuristic. TaskHeuristicParameter is a task parameter dependent on the chosen heuristic. TaskHeuristicParameter STSj TRPT LFT IEFT SRND for MTS heuristic for Highest TRPT heuristic for Highest LFT heuristic for Highest EFT heuristic for Random heuristic [ 1 ifRAv,(t) = 1 A X, (t) If assign(t) = 1, then ST, = t. If IS(t)l > 1 then Win = 1 Resource layers' Initial Activation State (i.e. at t=0) is 1. 1 ifRAvj(t)= 1 2 if(ORL,(t1) = 1 v ORL(t) = 1) A assign ORL(t) =t 3 if (RL,(t1) = 2 v 3) A t < ST, + PT, S4 if ORL(t1) = 3 A t STj + PT, Vi EM, j eT : resources available ) = 1 : resources busy (just assigned) :resources busy (processing) : resources just released 4.3.1.3.2.3 Output function S1 ORLFp(t) Lo ri f1 ORLR,(t) if ORL (t) if ORLj(t) if ORL (t) if ORLj(t) if ORL,(t) 4 1,2,3 Vj eA, Vp eSUj Vj EA Vj,p eA, k eR,p j ORLLpjk(t)) if ORL(t) = 1,4 (t/ The output ofF represents the makespan and the assign(t) gives the schedule. If a resource is either assigned or released during a certain time unit, all functions need to be recalculated without incrementing the time period. 4.3.2 Search Strategy A search strategy is required to modify the weights. In this study we used the following search strategy: Winning activities: If Winj = 1 then (oj)k+1 = (co)k a TaskParameterj Sk Vj E A Nonwinning activities: If Win, = 0 then (cj)k+1 = (coj)k + a TaskParameterj Sk VjEA In addition to these weight changes in each iteration, we propose two additional features that govern search, namely, reinforcement and backtracking. These features are explained here briefly. 4.3.3 Reinforcement If in a particular iteration the makespan improves, the weight changes of that iteration with respect to the previous iteration are magnified by a factor called the reinforcement factor (RF). (wk)k+ = (ik+J + RF (k (wk)k+ (wi)k) 4.3.4 Backtracking Sometimes it is possible to not obtain any improvement over several iterations. When this happens, it is best to abandon that search path and start over from the previous best solution weights. We can parameterize how many iterations of no improvement to tolerate. This backtracking technique was part of our search strategy. In order to do this, we store the set of weights corresponding to the best solution obtained so far and revert back to it whenever solution does not improve for some iteration. 4.3.5 End of Iteration Routines 1. Calculate the gap which is the difference between obtained makespan and the lower bound 2. Store the best solution so far. 3. If the number of iterations is equal to a prespecified number or the lower bound solution is found, stop the program. 4. If continuing with the next iteration, modify weights using the search strategy. Apply backtracking and reinforcement, whenever necessary. 4.4 Adaptive Learning Approach for Serial Schedule Generation In the serial scheduling scheme, a priority list of activities is determined at time zero. This list is based on some heuristic such as latest finish time (LFT). The ordering of activities in a given priority list must, of course, follow precedence constraints, but is independent of the resource constraints. Given a priority list, activities are scheduled in the given order at the earliest possible clock time at which the precedence constraints are satisfied and the resources are available. This type of scheduling is similar to the permutation flowshop scheduling in which the order of jobs is fixed a priori and scheduling occurs at the earliest possible clock time depending on resource availability and precedence constraints. Due to the similarities between these two problems, we chose to apply the ALA approach to the serial schedule generation. 4.4.1 Notation A : Set of activities = {1,..,n} Aj :jth activity node, j A z :Current iteration PTj : Processing time of activity Wj : Weight associated with the Activity A, WPTj : Weighted processing time of Activity A, ESTj : Earliest start time of activity LST, : Latest start time of activity Z.ma : Max number of iterations MSz Makespan in the zth iteration RF : Reinforcement factor TINI Tolerate iterations with no improvement a Search coefficient BMS : Best makespan BWj : Best weights 4.4.2 Algorithm Steps Step 1: Initialization Initialize W, = 1 Vj EA Initialize the iteration counter z to 1. Step 2: Calculate weighted processing times Calculate WPT, = Wj*PTj V j EA Step 3: Determine priority list Determine the priority list using a heuristic such as earliest finish time (EST) or latest finish time (LST), where EST or LST are calculated using WPT, instead of PTj. Step 4: Determine makespan Find a feasible schedule using the priority list. In other words, schedule each activity at its earliest possible time given precedence and resource constraints. This schedule gives us the makespan MSz. Step 5: Apply search strategy and modify weights a. If MSz is the best makespan so far, save the current weights as best weights (BWj) and the makespan as the best makespan (BMS). b. Ifz = Zmax, go to Step 7. c. If z > 1, and if an improvement occurs, reinforce the weights as follows: (W) = (W) + RF*((W (W) )). If no improvement occurs in this iteration, continue. d. Ifz > TINI and if no improvement has occurred in the past TINI iterations Set W = BWj e. Modify the weights using the following strategy: Generate a random number RND between 0 and 1 using uniform distribution. IfRND > 0.5 then (Wj),+ = (Wj), + RND*a *PTj IfRND <= 0.5 then (Wj),+ = (Wj), RND*a *PTj Step 6: Next iteration. Increment z by one and go to step 2. Step 7: Display Solution The BMS is the solution. Use BW, heuristic to generate the schedule. The search coefficient (a) used in Step 5e determines the degree of weight change per iteration. A higher coefficient leads to a greater change and vice versa. One could therefore control the granularity of the search by varying a. The search coefficient should neither be too low nor too high. A low a will slow down convergence and make it difficult to jump local minima, while a high a will render the search too erratic or volatile to afford convergence. With some empirical trial and error, we found that 0.001 worked well for all the problems. The reinforcement factor, RF, used in Step 5c is used to reinforce weights during iterations that show improved results. Intuitively, such reinforcement search helps the search process by allowing the search to explore the newly discovered good neighborhood for a few extra iterations. Empirically, we found a positive RF give better results than a zero RF. Backtracking used in step 5d is used to backtrack to the previous best set of weights if no improvement occurs in a given number of iterations. 4.5. Computational Experiments and Results In this section we present the result of the computational tests and comparisons with the best published algorithms. The approach is coded in Visual Basic 6.0 and run on a Celeron 2300 MHz personal computer. Well known Kolisch and Hartmann [1996] benchmark problem instance sets are used to evaluate the algorithm (PSPLIB, http://www.bwl.unikiel.de/Prod/psplib/index.html). The sets j30, j60 consists of 480 problem instances with four resource types and 30 and 60 activities, respectively. The set j 120 consists of 600 problem instances with four resource type and 120 activities. In our implementation, the search coefficient ac is set to 0.001 and the weights are initialized at 10. An initial solution is generated using a priority rule such as LFT. The weights are modified after each iteration using the search strategy. The stopping criterion is to stop if the solution is equal to the lower bound or if a predetermined number of maximum schedules is reached. We set this number to 1000 and 5000, respectively. Table 4.14.3 display the results obtained by our algorithm and other tested heuristics for 1,000 and 5,000 schedules, respectively. In these tables we present the type of heuristics, the type of schedule generation scheme used, the authors of each heuristic and the average deviation from the critical path based lower bound (from the optimal solution forj30 instances) for 1000 and 5000 schedules, respectively. In each table, the heuristics are sorted according to descending performance with respect to 5000 iterations. Table 4.1 presents the percentage deviations from the optimal makespan for the instance set j30 in which all problem instances have been solved to optimality by Demeulemeester and Herroelen's branch and bound procedure. Our algorithm solved 448 out of 480 problems to optimality and the average deviation from the optimal solution is just 0.29 and 0.11 percent for 1000 schedules and 5000 schedules respectively. For j60 and j90 problems set, some of the optimal solutions are not known, so we measure the average percentage deviation from the critical path based lower bound for comparison purposes. Table 4.2 summarizes the results forj60 test instances. 295 out of 480 instances are solved to critical path based lower bound. The average deviation from the critical path based lower bound is 11.72 and 11.39 percent for 1000 and 5000 schedules, respectively which outperforms all the currently available heuristics and metaheuristics except genetic algorithm of Valls et al.[2005]. Table 4.3 summarizes the results for j 120 set. 155 out of 600 problems matched the critical path based lower bound. The average deviations from the critical path based lower bounds are 34.94 and 34.57 percent respectively. Our algorithm outperforms all the currently available heuristics and metaheuristics except genetic algorithm of Valls et al. [2005]. Table 4.1. Average deviations from the optimal solution for J30 # of Schedules Algorithm SGS Reference 1,000 5,000 HNN GA Activity list Sampling LFT FBI Sampling LFT FBI TS Activity List GA FBI GA Self adapting SA Activity List GA Activity List Sampling FBI GA Adaptive Sampling TS Adaptive Sampling Sampling Global GA Random Key Sampling random GA Priority Rule Sampling WCS Sampling LFT Sampling random GA both serial both both serial serial both serial serial serial serial both both serial serial serial serial parallel parallel parallel this paper Alcaraz and Maroto [2001] Tormos and Lova [2003] Tormos and Lova [2001] Nonobe and Ibaraki [2002] Valls et al. [2005] Hartmann [2002] Bouleimen and Lecocq [2003] Hartmann [1998] Valls et al. [2005] Coelho and Tavares [2003] Schirmer [2000] Baar et al. [1998] Kolisch and Drexl [1996] Coelho and Tavares [2003] Hartmann [1998] Kolisch [1995] Hartmann [1998] Kolisch [1996] Kolisch [1996] Kolisch [1995] Leon and Rammoorthy [1995] 0.29 0.33 0.23 0.25 0.46 0.34 0.38 0.38 0.54 0.46 0.74 0.65 0.86 0.74 0.81 1.03 1.44 1.38 1.40 1.40 1.77 2.08 0.11 0.12 0.14 0.15 0.16 0.20 0.22 0.23 0.25 0.28 0.33 0.44 0.44 0.52 0.54 0.56 1.00 1.12 1.28 1.29 1.48 1.59 Table 4.2. Average deviations from the critical path based lower bound for J60 # of Schedules Algorithm SGS Reference 1,000 5,000 GA FBI HNN GA Self adapting Sampling LFT FBI Sampling LFT FBI GA Activity list GA Activity List SA Activity List TS Activity List Sampling FBI Adaptive Sampling GA GA Priority Rule Adaptive Sampling Sampling WCS Sampling LFT Sampling Global GA Random Key TS GA Sampling random Sampling random serial both both both both serial serial serial serial serial both serial serial both parallel parallel serial serial parallel serial Valls et al. [2005] this paper Hartmann [2002] Tormos and Lova [2003] Tormos and Lova [2001] Alcaraz and Maroto [2001] Hartmann [1998] Bouleimen and Lecocq [2003] Nonobe and Ibaraki [2002] Valls et al. [2005] Schirmer [2000] Coelho and Tavares [2003] Hartmann [1998] Kolisch and Drexl [1996] Kolisch [1996] Kolisch [1996] Coelho and Tavares [2003] Hartmann [1998] Baar et al. [1998] Leon and Rammoorthy [1995] Kolisch [1995] Kolisch [1995] 12.21 11.72 12.21 12.04 12.11 12.57 12.68 12.75 12.97 12.73 12.94 13.28 13.30 13.51 13.66 13.59 13.80 14.68 13.80 14.33 14.89 15.94 11.27 11.39 11.70 11.72 11.82 11.86 11.89 11.90 12.18 12.35 12.59 12.63 12.74 13.06 13.21 13.23 13.31 13.32 13.48 13.49 14.30 15.17 Table 4.3. Average deviations from the critical path based lower bound for J120 # of Schedules Algorithm SGS Reference 1,000 5,000 GA FBI HNN Sampling LFT FBI GA Self adapting Ant Colony Sampling LFT FBI GA Activity list GA Activity List Sampling FBI SA Activity List TS Activity List GA GA Priority Rule Adaptive Sampling Sampling LFT Sampling WCS Adaptive Sampling Sampling Global GA Sampling LFT Sampling random GA Random Key Sampling random serial Vails et al. [2005] both this paper both Tormos and Lova [2003] both Hartmann [2002] serial Merkle et al. [2002] both Tormos and Lova [2001] serial Alcaraz and Maroto [2001] serial Hartmann [1998] serial Valls et al. [2005] serial Bouleimen and Lecocq [2003] serial Nonobe and Ibaraki [2002] serial Coelho and Tavares [2003] serial Hartmann [1998] both Schirmer [2000] parallel Kolisch [1996] parallel Kolisch [1996] both Kolisch and Drexl [1996] serial Coelho and Tavares [2003] Leon and Rammoorthy [1995] serial Kolisch [1996] parallel Kolisch [1995] serial Hartmann [1998] serial Kolisch [1995] 35.39 34.94 35.98 37.19 36.32 39.36 39.37 38.21 42.81 40.86 39.97 39.93 39.85 39.60 39.65 41.37 41.36 42.91 42.84 44.36 45.82 49.25 33.24 34.57 35.30 35.39 35.43 35.62 36.57 36.74 37.47 37.68 37.88 38.41 38.49 38.70 38.75 38.77 40.45 40.46 40.69 41.84 43.05 45.25 47.61 4.6. Summary and Conclusions We propose, develop and test a new hybrid metaheuristic approach based on the principles of neural networks. We use augmented neural networks approach for parallel schedule generation and adaptive learning approach for serial schedule generation scheme. We call this approach the hybrid neural approach (HNN). We implement and test our proposed hybrid neural approach on some wellknown RCPSP benchmark problem instances in the literature. The computational results are very encouraging and make this new HNN approach a strong contender to techniques such as tabu search, simulated annealing, ant colonies and genetic algorithms. The approach, which combines the benefits of priority rules and the iterative learning approaches, is able to give very good results in a short time and in relatively small number of iterations. CHAPTER 5 MULTIMODE RESOURCE CONSTRAINED PROJECT SCHEDULING PROBLEM 5.1. Introduction The multimode resourceconstrained project scheduling problem (MRCPSP) is a generalized case of the classical (RCPSP). In the MRCPSP, each activity can be performed in one of several execution modes where each mode requires different amounts of resources resulting in different activity durations. In general, the more the resources employed the shorter the activity duration. Activities are subject to precedence and resource constraints and preemption is not allowed. In the most general MRCPSP, there are renewable, nonrenewable and doublyconstrained types of resources [Slowinski, 1980]. Renewable resources are available in limited quantities for each time period and are renewable from period to period (e.g. labor, machines). Nonrenewable resources are limited for the entire project such as project budget. Doublyconstrained resources are limited both for each period and for the entire project. This type of resources is not considered explicitly since they can be incorporated by enlarging the sets of the renewable and nonrenewable resources. The objective is to find the execution mode and start time of each activity in order to minimize the project completion time while satisfying the precedence and resource constraints. MRCPSP is a strongly NP Hard problem as a generalization of the RCPSP. We consider the MRCPS with renewable resources only and propose (i) two new nongreedy heuristics for mode selection and (ii) an adaptive metaheuristic. We test our proposed heuristics on benchmark problem instances. The results show that both our singlepass heuristics and the adaptive metaheuristic outperform the existing singlepass heuristics and metaheuristics in the literature, respectively. 5.2. Literature Review A variety of exact and heuristic methods have been applied to solve multimode resourceconstrained project scheduling problem. Talbot [1982] was the first to propose an exact solution method for the nonpreemptive MRCPSP. Patterson et al. [1989, 1990] presented a more powerful backtracking procedure for solving the problem. These approaches were unable to solve instances with more than 15 activities in a reasonable computation time. Sprecher et al. [1990] extended the branchandbound procedure of Demeulemeester and Herroelen [1992] for RCPSP to MRCPSP. Hartman and Drexl [1998] compared the existing branchandbound algorithms and presented an alternative exact approach based on the concepts of mode and extension alternatives. Sprecher and Drexl [1998] proposed an exact solution procedure by extending the precedence tree guided enumeration scheme of Patterson et al. [1989, 1990]. Although their approach was the most powerful procedure, it was unable to solve the highly resource constrained problems (more than 20 activities and two modes per activity) in reasonable computational times. Several heuristics have been proposed in the MRCPSP literature. The MRCPSP with renewable resources only involves two decisions one for activity selection and the other for mode selection. The heuristic approach for this problem involves a combination of two heuristics working in tandem, one for deciding which activity to assign and the other for mode selection. Boctor [1993] considered the MRCPS problem with renewable resources only and developed 21 different heuristic combinations, seven for activity priority and three for mode selection. In a followup study, he proposed backward/forward scheduling to improve the results and also proposed a new heuristic [Boctor 1996a]. The new heuristic, although very complex, gave better results. Drexl and Grunewald [1993] presented a stochastic scheduling method. Ozdamar and Ulusoy [1994] proposed a local constraint based approach that selects the activities and their respective modes locally at every decision point. Kolisch and Drexl [1997] developed a local search method that first finds a feasible solution and then performs a neighborhood search on the set of feasible mode assignments. Different genetic algorithms for solving the MRCPSP have been developed by Mori and Tseng [1997], Ozdamar [1999], Hartmann [2001] and Alcaraz et al.[2003]. Simulated annealing algorithms are one of the most common heuristic procedures applied to MRCPSP. Slowinski et al.[1994], Boctor [1996b], Bouleimen and Lecocq [2003] and Jozefowska et al. [2001] have suggested simulated annealing algorithms. Nonobe and Ibaraki [2002] proposed a tabu search procedure for this problem. 5.3. Problem Formulation We consider the nonpreemptive multimode resourceconstrained project scheduling problem with only renewable resources. The objective is to obtain a precedence and resourcefeasible schedule with the minimum makespan. The problem can be formulated as follows: A project consists of N activities A A2, ..., AN (activity AN is the terminal activity with no successors) and for each activity Ai, possible M1, M2, ..., MM execution modes. Each activity Ai can be performed in one of the Mj execution modes and once a mode has been chosen for an activity, it must be finished without changing the mode. The duration of activity Ai executed in mode Mj is dij. We consider only nonpreemptive cases in which if an activity Ai initiated in mode Mj, it must be executed for dij consecutive time units without interruption. Activity Ai cannot start before all of its predecessors have been completed. We assume that there are R1, R2,..., RR renewable resources. Activity Ai executed in mode Mj requires rijk resource units per period for resource type Rk. The total availability of resource type Rk for each period is given by RAk. The activity durations, resource availabilities and resource requirements per activity are nonnegative integers. In the next section, we will briefly describe the heuristic algorithms that have been used to solve MRCPSP problem and explain our nongreedy heuristics. 5.4. Heuristic Methods for MRCPSP 5.4.1 Existing Heuristics The heuristics for the MRCPSP with only renewable resources involve two heuristics working in tandem one for prioritizing the activities and one for prioritizing execution modes. The first heuristic is used for selecting the next activity to schedule. We move to the next time period where there are some nonallocated resources. At this point, we find the schedulable activities (all of whose predecessors already scheduled) and select the one with the highest priority value. Once an activity is selected, we use the second heuristic to choose the feasible execution mode. Boctor [1993] used seven heuristics for prioritizing the activities: minimum total slack (MINSLK), minimum latest finish time (MINLFT), maximum number of immediate successors (MAXNIS), maximum remaining work (MAXRWK), maximum processing time (MAXPTM), minimum processing time (MINPTM) and maximum number of subsequent candidates (MAXCAN) and three for prioritizing the execution modes: shortest feasible mode (SFM), least criticality ratio (LCR) and least resource proportion (LRP) resulting in twenty one heuristic combinations. The four best heuristic combinations were MIN SLK/SFM, MAXRWK/SFM, MAXCAN/SFM and MINLFT/SFM. Boctor [1996] focused on these four best combos and improved the results by solving twice: forward and backward. A new heuristic was also proposed which we will call Boct96Heur, which gave the best results. This new heuristic attempted to prioritize execution mode based on certain conditions of nondominated activitymode combination. This heuristic is very complex to implement, although it gives good results. 5.4.2 Proposed New Heuristics There are two schedule generation schemes (SGS) for constructing a feasible schedule, namely, parallel (PSGS) and serial (SSGS). In PSGS, precedence feasible activities compete for available resources and a heuristic determines the priority of activities. In SSGS, the priority order for all activities is predetermined using a heuristic and assignment of activities occurs in that order at the first possible resource and precedence feasible opportunity. Previous heuristics have employed PSGS. We propose SSGS as it tends to give better results. We also do backwardforward scheduling. In backward scheduling the precedence relationship of all activities is reversed. In other words, the directions of arrows on the PERT chart are reversed and scheduling performed normally. For the backward problem, using the same heuristic a better schedule is obtained for about half the problems. So better of forwardbackward schedule is recommended. We also use forwardbackward improvement (BFI). In BFI, once a schedule is generated, an attempt is made to reduce empty space in the Gantt chart. Once the forward schedule is generated using some heuristic combination, backward scheduling is performed using the heuristic of maximum finish time during the forward schedule. This is followed by another forward scheduling based on minimum start time during the backward schedule. As far as heuristics for prioritizing activities, we use two wellknown heuristics, namely, maximum remaining work (MAXRWK) and minimum latest start time MIN LST. The MAXRWK heuristic was one of the best four heuristics used in Boctor [1993,1996]. We tried the MINLST heuristic, which gave better results than the other three heuristics used in Boctor [1996]. For prioritizing execution modes we propose two new, nongreedy (NG) heuristics. The NG heuristics differ from existing greedy heuristics in that, a precedencefeasible activity may not be scheduled in spite of being resource feasible for some execution mode. In the first NG heuristic, if the feasible execution mode is not the fastest execution mode, the heuristic takes into account the time the activity would have to wait for the resources for the fastest mode and the difference between the activity durations between the fastest and the feasible modes. Clearly, if it has to wait less than the difference between the activity durations, it makes sense to wait. The waiting strategy is what makes the heuristic nongreedy. In the second NG heuristic, a precedencefeasible activity considers all modes faster than the feasible mode and checks against each one the difference between the activity durations and the amount of waiting. If the fastest mode is not worth waiting perhaps the next fastest mode might be worth waiting. The first NG heuristic would not wait for the second fastest mode but the second one would. We call the first NG heuristic for prioritizing execution mode the "Shortest Feasible Mode with Conditional Wait for the Fastest Mode (SFMCWFM), and the second the "Shortest Feasible Mode with Conditional Wait for a Better Mode (SFM CWBM). We call our heuristics ACE (Agarwal, Colak and Erenguc) heuristics. The single pass heuristics are called ACESP, while the adaptive metaheuristics are called ACE AM, which gives the best of six heuristic combos: MAX RWK/SFM, MAX RWK/SFM CWFM, MAX RWK/SFMCWBM, MIN LST/SFM, MIN LST/SFMCWFM, MIN LST/SFMCWBM. Included in ACESP and ACEAM is the concept of backward forward improvement and better of forward and backward schedule. All ACE heuristics involve serial schedule generation schemes. 5.5. Adaptive Metaheuristic We also propose an adaptive metaheuristic in conjunction with each of the six heuristic combinations to obtain a further reduction in the gap from the lower bound. In this approach, we add a weight factor to each of the activity durations and apply the basic heuristic combination such as MAXRWK/SFM. We start with the same weights for all activities, so the first iteration gives the same solution as the singlepass heuristic. In subsequent iterations, the weights are modified, but the same heuristic is applied. We use weighted processing times instead of regular processing times when applying the heuristic. This approach allows a nondeterministic local search in the neighborhood of the heuristic solution. The basic idea in this approach is similar to neural networks where a weight vector is used as the means for nondeterministic local search in data mining type of problems. The weight vector is modified using a weight modification strategy to find improved neighborhood solution in subsequent iterations. Using this adaptive learning approach, the gaps are reduced. We now explain the adaptive metaheuristic mathematically. We use the following notations: A : Set of activities = {Ai, A2,... An} A, : ith activity M : Set of modes = {Mi, M2,..., Mm} M : jth mode k : Iteration counter d, : Processing time of activity A, executed in mode Mj w, : Weight associated with the Activity A, w11' : Weighted activity duration of Activity A, executed in mode Mj EST, : Earliest start time of activity A, LST, : Latest start time of activity A, RWK, : Maximum remaining work for activity A, kmax : Max number of iterations mSk : Makespan in the current iteration a : Search coefficient Bms : Best makespan Bw : Best weights Step 1: Initialization Initialize w, = 1 VA, Initialize the iteration counter k to 1. Step 2: Calculate weighted processing times Step 3: Determine priority list Calculate wirb = w, d, VA, Determine the priority list for prioritizing the activities using a heuristic such as minimum latest finish time (MIN LST) or maximum remaining work (MAX RWK), where MIN LST and MAK RWK are calculated using 11wd instead of d,. Also, determine the shortest feasible mode for each activity A, for prioritizing the activity modes. Step 4: Determine makespan Find a feasible schedule using serial schedule generation scheme, using the priority list. In other words, schedule each activity at its earliest possible time given precedence and resource constraints. This schedule gives the makespan msk. Step 5: Apply search modification strategy and modify weights a. If msk is the best makespan so far, save the current weights as best weights (Bw,) and the makespan as the best makespan (Bms). b. If k = kmx, go to Step 7. c. Modify the weights using the following strategy: Generate a random number RND between 0 and 1 using uniform distribution. IfRND > 0.5 then (w,)k+l = (w,)k + RND a error If RND <= 0.5 then (w,)k+l = (w,)k RND a error error is the difference between the current makespan (msk) and the lower bound (LB) for the problem in question. Step 6: Next iteration. Increment k by one and go to step 2. Step 7: Display Solution The Bns is the solution. The schedule is generated using the Bw. The search coefficient (a) used in Step 5c determines the degree of weight change per iteration. A low a will slow down convergence and make it difficult to jump local minima, while a high a will render the search too erratic or volatile to afford convergence. With some empirical trial and error, we found that a rate of 0.01 worked well for all the problems. 5.6. Computational Experiments and Results Boctor's 240 benchmark problems are used to evaluate the performance of our proposed heuristics and adaptive metaheuristic. These problems are generated randomly and involve two main subsets 120 fiftyactivity instances and 120 one hundredactivity instances. For these problems, the average number of immediate successors is 2. In each subset, there are 40 problems involving respectively 1, 2 and 4 resource types. The number of execution modes is uniformly generated from 1 to 4. Our heuristics were coded in Visual Basic 6.0 running on WindowsXP operating system and implemented on a Pentium4 PC. The search coefficient ais set to 0.01 and the weights are initialized at 1. We ran our algorithm for 1000 and 5000 iterations. Average CPU times of our adaptive metaheuristic with MIN LST is 11.2 and 48.7 seconds for 1000 and 5000 iterations, respectively. Similarly CPU times for MAX RWK are 14.6 and 58.4 seconds for 1000 and 5000 iterations, respectively We use the average percentage deviation from the critical path based lower bound which is calculated using the shortest mode for each activity as the main evaluation criterion. Other evaluation criterions are the maximum and minimum percentage deviations from the critical path based lower bound. The results obtained are summarized in the following tables. Table 5.1 shows the results of singlepass greedy heuristic with the two nongreedy heuristics for mode selection. The average percent gap from the critical path based lower bound obtained by the nongreedy heuristics is slightly better (32.88 to 32.93) compared to greedy heuristic (33.23 to 3.31). It is obvious from the results that as the number of activities and number of resource types increases, the average percentage deviation from the critical path based lower bound also increases. Table 5.2 compares the results of Boctor's singlepass heuristics with our singlepass heuristics. Based on these results we can see that the proposed heuristics outperform the existing heuristics (31.4 vs. 34.4 to 36.8). In Tables 5.3 and 5.4 we present the maximum and minimum percentage deviation from critical path, respectively. On both these measures, the proposed singlepass heuristics are outperforming existing heuristics. Table 5.1. Comparison of proposed singlepass greedy and nongreedy heuristics (Average percentage deviation from the criticalpath based lower bound) MAX MIN MIN MIN MAX MAX M Num Num of MIN L MAX RW RWK LST LST LST RWK RWK of Res. LST RWK Best oRes LST SFM SFM Best of K SFM SFM Activities Types SFM CWFM CWBM Three SFM CWFM CWBM of CWFM CWBM Three CWFM CWBM Three 50 1 18.46 17.81 17.86 16.99 18.66 18.19 18.19 17.44 50 2 33.50 33.85 33.68 32.32 33.59 33.94 33.75 32.36 50 4 45.08 45.79 45.87 44.31 45.38 45.72 45.79 44.48 100 1 18.31 17.25 17.27 16.91 18.15 17.38 17.35 16.95 100 2 36.68 36.23 36.23 35.50 37.05 36.29 36.29 35.84 100 4 47.38 46.39 46.39 45.96 47.02 46.07 46.04 45.65 All probs. 33.23 32.89 32.88 32.00 33.31 32.93 32.90 32.12 Table 5.2. Comparison of singlepass heuristics (Average percentage deviation from the criticalpath based lower bound) Num of Activities 50 50 50 100 100 100 Num of Resource Types 1 2 4 1 2 4 Boctor [1996a] MIN SLK SFM 21.9 36.3 49.2 22.7 40.3 50.6 Boctor [1996a] MAX RWK SFM 22.8 35.6 48.1 22.9 40.5 50.3 Boctor [1996a] Boct96 Heur 20.2 33.9 46.4 20.4 37.4 47.8 ACESP MIN LST 17.0 32.3 44.3 16.9 35.5 46.0 ACESP MAX RWK 17.4 32.4 44.5 17.0 35.8 45.6 ACESP Best of Two 16.7 31.7 43.6 16.5 35.0 45.1 All 36.8 36.7 34.4 32.0 32.1 31.4 probs. Table 5.3. Comparison of singlepass heuristics (Maximum percentage deviation from the criticalpath based lower bound) Num of Activities 50 50 50 100 100 100 All probs. Num of Resource Types 1 2 4 1 2 4 Boctor [1996a] MIN SLK SFM 35.9 50.5 67.9 33.4 55.0 66.7 67.9 Boctor [1996a] MAX RWK SFM 41.8 52.6 59.8 34.3 54.3 69.3 69.3 Boctor [1996a] Boct96 Heur 30.4 46.0 60.3 31.1 48.5 60.2 60.3 ACESP MIN LST 28.0 48.8 57.8 25.9 52.4 59.0 59.0 ACESP MAX RWK 29.1 47.3 57.4 27.1 53.3 58.2 58.2 Table 5.4. Comparison of singlepass heuristics (Minimum percentage deviation from the criticalpath based lower bound) Boctor Boctor Boctor ACESP ACESP [1996a] [1996a] [1996a] Num of MIN MAX um of N m o Boct96 MIN MAX Resource SLK RWK Activities ce S Heur LST RWK Types SFM SFM 50 1 10.9 8.9 11.3 5.7 7.2 50 2 22.5 18.2 18.8 17.3 18.6 50 4 35.6 35.6 32.8 32.3 31.9 100 1 14.1 14.9 12.8 8.6 8.2 100 2 28.0 27.4 27.4 21.4 23.5 100 4 41.2 41.3 39.7 37.9 37.0 All probs. 10.9 8.9 11.3 5.7 7.2 Table 5.5. Comparison of metaheuristics (Average percentage deviation from the criticalpath based lower bound) Boctor Alcaraz et al or az e a ACEAM ACEAM ACEAM ACEAM ACEAM [1996b] [2003] S Num of Sim d GA LST RWK LST RWK B Num of Simulated Best of a s resourcety g 5000 1000 1000 5000 5000 all activities Annealing all pes iterations iterations iterations iterations iterations 50 1 14.1 NA 12.3 12.1 11.6 11.6 11.2 50 2 25.9 NA 23.3 23.1 22.3 22.1 21.5 50 4 37.1 NA 34.5 34.4 33.2 32.4 32.0 All 50 25.7 26.5 23.3 23.2 2.4 22.0 21.6 100 1 14.2 NA 13.2 13.3 12.9 12.5 12.4 100 2 29.4 NA 29.9 29.9 29.2 28.9 28.6 100 4 38.0 NA 39.4 39.2 38.7 38.4 38.0 All 100 27.2 29.2 27.5 27.5 26.9 26.6 26.3 All 26.5 27.8 25. 4 25. 3 24. 6 24. 3 23.9 problems In table 5.5 we compare our adaptive metaheuristic (ACEAM) results with the simulated annealing approach of Boctor [1996] and genetic algorithm of Alcaraz et al. [2003]. ACEAM metaheuristic performs the best. For the whole 240 problems it gives 23.9% deviation over the critical path while the deviation for simulated annealing and genetic algorithms are 26.5% and 27.8%, respectively. Even if we do not consider the best of Min LST and Max RWK and best of 1000 and 5000 iterations, each of the proposed heuristics outperforms the existing heuristics. Some of the improvement is due to the backwardforward improvement. 5.7 Summary and Conclusions In this study we have proposed (i) two nongreedy heuristics for prioritizing execution modes and (ii) an adaptive metaheuristic for solving the nonpreemptive multi mode resourceconstrained project scheduling problem with renewable resources only. The nongreedy heuristics uses a waiting strategy, in which, a precedencefeasible activity may not be scheduled in spite of being resource feasible for some execution modes and waits for the fastest or one of the faster resource modes if worth it. The adaptive metaheuristic uses a weight parameter which is the same for all activities for the first iteration. In subsequent iterations these weights are modified and the same heuristics are applied using weighted processing times instead of original processing times. The algorithm is tested on benchmark problems from the literature. The results shows that the nongreedy heuristics are slightly better than the greedy heuristics and the adaptive metaheuristic outperforms the simulated annealing algorithm of Boctor and genetic algorithm of Alcaraz et al. CHAPTER 6 CONCLUSIONS AND FUTURE WORK In this dissertation, we have proposed and developed two neural network based metaheuristics, namely, the adaptive learning approach and the augmented neural network approach for four classes of scheduling problems: the openshop scheduling problem, the flowshop scheduling problem, the resourceconstrained project scheduling problem and the multimode resourceconstrained project scheduling problem. We found that these neural network based metaheuristics were very effective in solving these problems and compared very well with other metaheuristics such as genetic algorithms, tabu search, simulated annealing and ant colonies. In these techniques, we made use of domain and problemspecific knowledge, which helped in obtaining better quality solutions. In the first model we formulated and applied an augmented neural networks approach to the open shop scheduling problem. We tested this approach on benchmark problems in the literature and also on some larger problems generated in this study. The results show that our approach is able to give very good and competitive results in a short time, permitting solutions of larger problems hitherto not attempted due to excessive computational requirements. During the course of this study, we also developed a new singlepass heuristic (DS/LTRPAM) and nongreedy variations for the new and existing heuristics. The nongreedy DS/LTRPAM heuristic in conjunction with AugNN gives better results than other heuristics. 