Metaheuristics:: Progress as Real Problem Solvers

METAHEURISTICS: Progress as Real Problem Solvers INTERFACES SERIES Series Editors Professor Ramesh Sharda Prof. Dr. ...

Author: Toshihide Ibaraki | Koji Nonobe | Mutsunori Yagiura

98 downloads 1370 Views 15MB Size Report

This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Report copyright / DMCA form

DOWNLOAD PDF

METAHEURISTICS: Progress as Real Problem Solvers

INTERFACES SERIES Series Editors Professor Ramesh Sharda

Prof. Dr. Stefan VoB

Oklahoma State Univetsity

Univetsitat Hamburg

Other published titles in the series: Greenberg /A Computer-AssistedAnalysis Systemfor Mathematical Programming Models and Solutions: A User's Guidefor ANALYZE Greenberg / Modeling by Object-Driven Linear Elemental Relations: A Users Guidefor MODLER Brown & Scherer / Intelligent Scheduling Systems Nash & Sofer / The Impact of Emerging Technologies on Computer Science & Operations Research Barth / Logic-Based 0-1 Constraint Programming Jones I Visualization and Optimization B a n , Helgason & Kennington / Interfaces in Computer Science & Operations Research: Advances in Metaheuristics, Optimization, & Stochastic Modeling Technologies Ellacott, Mason & Anderson / Mathematics of Neural Networks: Models, Algorithms & Applications W o o d r u f fI Advances in Computational & Stochastic Optimization, Logic Programming, and Heuristic Search Klein I Scheduling of Resource-ConstrainedProjects Bierwirth /Adaptive Search and the Management of Logistics Systems Laguna & GonzBlez-Velarde 1 Computing Toolsfor Modeling, Optimization and Simulation Stilman I Linguistic Geometry: From Search to Construction Sakawa I Genetic Algorithms and Fuzzy Multiobjective Optimization Ribeiro & Hansen I Essays and Surveys in Metaheuristics Holsapple, Jacob & Rao I Business Modelling: MultidisciplinaryApproaches - Economics, Operational and Information Systems Perspectives Sleezer, Wentling & CudelHuman Resource Development And Information Technology: Making Global Connections VoR & W o o d r u f f/ Optimization Soflware Class Libraries Upadhyaya et a1 / Mobile Computing: Implementing Pervasive Information and Communications Technologies Reeves & R o w e / Genetic Algorithms-Principles and Perspectives: A Guide to GA Theory Bhargava & Y e / ComputationalModeling And Problem Solving In The Networked World: Interfaces in Computer Science & Operations Research W o o d r u f f/ Network Interdiction And Stochastic Integer Programming Anandalingam & Raghavan / TelecommunicationsNetwork Design And Management Laguna & Marti / Scatter Search: Methodology And Implementations In C Gosavi/Simulation-Based Optimization: Parametric Optimization Techniques and Reinforcement Learning Koutsoukis & Mitra 1Decision Modelling And Information Systems: The Information Value Chain Milano / ConstraintAnd Integer Programming: Toward a Un@ed Methodology W i l s o n & Nuzzolo I Schedule-Based Dynamic Transit Modeling: Theory and Applications Golden, Raghavan & Wasil / The Next Wave In Computing, Optimization,And Decision Technologies Rego & Alidaeel Metaheuristics Optimization Via Memory and Evolution: Tabu Search and Scatter Search Kitamura & Kuwaharal Simulation Approaches in TransportationAnalysis: Recent Advances and Challenges

METAHEURISTICS: Progress as Real Problem Solvers

edited by

Toshihide Ibaraki Koji Nonobe Mutsunori Yagiura

a- Springer

Toshihide Ibaraki Kyoto University Japan

Koji Nonobe Kyoto University Japan

Mutsunori Yagiura Kyoto University Japan

Library of Congress Cataloging-in-Publication Data A C.I.P. Catalogue record for this book is available from the Library of Congress.

ISBN-10: 0-387-25382-3 ISBN-13: 9780387253824

e-ISBN: 0-387-25383-1

Printed on acid-free paper.

Copyright O 2005 by Springer Science+Business Media, Inc. All rights reserved. This work may not be translated or copied in whole or in part without the written permission of the publisher (Springer Science + Business Media, Inc., 233 Spring Street, New York, NY 10013, USA), except for brief excerpts in connection with reviews or scholarly analysis. Use in connection with any form of information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now know or hereafter developed is forbidden. The use in this publication of trade names, trademarks, service marks and similar terms, even if the are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. Printed in the United States of America. 9 8 7 6 5 4 3 2 1

SPIN 11053361

Contents

Preface Part I Invited Paper 1 Metaheuristic Agent Processes (MAPS) Red Glover and Gary Kochenberger

Part I1 Tutorial Paper 2 GRASP with Path-Relinking: Recent Advances and Applications Mauricio G.C. Resende and Celso C. Ribeiro

Part I11 Papers on Problem Solving

3 A Tabu Search Heuristic for a University Timetabling Problem Halvard Arntzen and Arne Lflkketangen An Investigation of Automated Planograms Using a Simulated Annealing Based Hyper-Heuristic Ruibin Bai and Graham Kendall 5 Validation and Optimization of an Elevator Simulation Model with Modern Search Heuristics Thomas Bartz-Beielstein, Mike Preuss and Sandor Markon 6 Multi-Objective Hyper-Heuristic Approaches for Space Allocation and Timetabling Edmund K. Burke, J. Dario Landa Silva and Eric Soubeiga

7 Theory and Practice of the Minimum Shift Design Problem Luca Di Gaspero, Johannes Gartner, Guy Kortsarz, Nysret Musliu, Andrea Schaerf and Wolfgang Slany

65

87

109

129

159

vi

Metaheuristics: Progress as Real Problem Solvers

8 Local Search Algorithms for the Two-Dimensional Cutting Stock Problem with a Given Number of Different Patterns Shinji Imahori, Mutsunori Yagiura, Shunji Umetani, Shinya Adachi and Toshihide Ibaraki

181

9 A Generic Object-Oriented Tabu Search Framework Hoong C. Lau, Xiaomin Jia and Wee C. W a n 10 Bi-Objective Sequencing of Cutting Patterns: An application for the paper industry Ana Respicio and M. Eugdnia Captivo 11 243 Metaheuristics Approach for Rule Acquisition in Flexible Shop Scheduling Problems Kazutoshi Sakakibara, Hisashi Tamaki, Hajime Murao and Shinzo Kitamura 12 Predicting Colorectal Cancer Recurrence: A Hybrid Neural NetworksBased Approach Rob Smithies, Said Salhi and Nut Queen 13 A Constructive Genetic Approach to Point-Feature Cartographic Label Placement Missae Yamamoto and Luiz A.N. Lorena Part

IV Papers on Methodologies

14 Parallel Strategies for GRASP with Path-Relinking Renata M. Aiex and Mauricio G. C. Resende 15 Speeding Up Local Search Neighborhood Evaluation for a MultiDimensional Knapsack Problem Ross J. W . James

16 Computationally Difficult Instances for the Uncapacitated Facility Location Problem Yuri Kochetov and Dmitry Ivanenko

259

287

Contents

vii

17 Consistent Neighbourhood in a Tabu Search Michel Vasquez, Audrey Dupont and Djamal Habet

369

18 Constraint Oriented Neighbourhoods - A New Search Strategy in Metaheuristics Ana Vzana, Jorge P. Sousa and Manuel A. Matos

389

Preface

Facing many computationally hard problems in real-world applications, the framework of metaheuristics is becoming one of the most powerful panaceas, as it can produce robust and efficient algorithms that compute approximate solutions of high quality in realistic computation time. Algorithms in metaheuristics may be simply viewed as the repetition of the following two basic steps: (1) Generation of solutions and (2) its improvement by local search. Extensive generalizations and sophistications of these two steps, however, have been proposed and tested. The solution generation may reflect the past computational history; e.g., they may be generated by randomized selections from the promising solution areas, by modifications of good solutions currently available, and by crossover or path relinking operations applied to a pool of candidate solutions compiled by then. The local search may also be realized in different ways; e.g., the search in the neighborhood may be done deterministically or probabilistically, moves to worse solutions may be accepted under certain circumstances, the evaluation function that guides the search can be adaptively modified, the size of neighborhood may change depending on the current status of computation, and so forth. Furthermore the repetition of two basic steps can be controlled by various strategies. As outcomes of these, we see many algorithms with different names such as simulated annealing, tabu search, genetic algorithms, evolutionary computation, genetic local search, greedy randomized adaptive search procedures (GRASP), scatter search, ant system, variable neighborhood search, guided local search, iterated local search, noising methods, threshold accepting, memetic algorithms, neural networks, and their hybrids. Perhaps, the field of metaheuristics has been matured enough to a certain level, and main focus is now being shifted to their applications as real problem solving tools. This is why the title of this volume has the subtitle, Progress as Real Problem Solvers. This book is a collection of selected papers from those presented at the Fifth Metaheuristic International Conference (MIC2003), held in

x


Kyoto, Japan, 25-28 August 2003. All papers were peer-reviewed according to a tight standard, and as a result only eighteen papers could survive. Among those eighteen papers, there is one invited paper written by F. Glover and G. Kochenberger, which proposes the concept of metaheuristic agent processes. There is one tutorial paper by M. G.C. Resende and C. C. Ribeiro discussing GRASP with path-relinking. Other papers are classified as those of problem solving and those of methodologies. The problems discussed in problem solving papers include timetabling, automated planograms, elevators, space allocation, shift design, cutting stock, flexible shop scheduling, colorectal cancer and cartography. Methodology papers try to clarify various aspects of metaheuristics mainly from computational view point. We believe that all the papers represent the current cutting edges of the metaheuristics study as problem solvers. As editors of this volume, we wish to thank all the anonymous reviewers who contributed their time to make this volume of very high quality. The cooperation from the members of Organizing Committee and Program Committee of MIC2003 was essential for the success of this project, whose lists are given in the next page. From the financial side, we particularly appreciate the support given by the Kyoto University foundation, and the supports given by the Telecommunications Advancement Foundation and Kayamori Foundation of Informational Science Advancement. Finally the supports from the Operations Research Society of Japan and scheduling Society of Japan are gratefully acknowledged. Kyoto, November 2004 Toshihide Ibaraki Koji Nonobe Mutsunori Yagiura

Preface

COMMITTEES OF MIC2003 Organizing committee Masao F'ukushima (Kyoto University) Toshihide Ibaraki (Kyoto University), Chair Hiroaki Ishii (Osaka University) Kazuo Iwama (Kyoto University) Naoki Katoh (Kyoto University) Hiroshi Kise (Kyoto Institute of Technology) Koji Nonobe (Kyoto University) Nobuo Sannomiya (Kyoto Institute of Technology) Hisashi Tamaki (Kobe University) Mutsunori Yagiura (Kyoto University) Yasunari Yoshitomi (Kyoto Prefectural University), Cochair

Program committee Takao Asano (Japan) Hajime Ase (Japan) Jacek Blazewicz (Poland) Endre Boros (USA) Peter Brucker (Germany) Edmund Burke (UK) Philippe Codognet (France) Josk S. Ferreira(Portuga1) Nobuo Funabiki (Japan) Michel Gendreau (Canada) Fred Glover (USA) Peter Greistorfer (Austria) Pierre Hansen (Canada) Jin-Kao Hao (France) Tomio Hirata (Japan) Hitoshi Iba (Japan) Toshihide Ibaraki (Japan), Chair Andrzej Jaszkiewicz (Poland) Taichi Kaji (Japan) Kengo Katayama (Japan) Hajime Kita (Japan) Shigenobu Kobayashi (Japan) Nobuyuki Konishi (Japan) Mikio Kubo (Japan) Andrea Lodi (Italy) Arne L~kketangen(Norway)

Helena R. Lourenqo (Spain) Silvano Martello (Italy) Pablo Moscato (Australia) Azuma Ohuchi (Japan) Josk F. Oliveira (Portugal) Isao Ono (Japan) Ibrahim Osman (Lebanon) Erwin Pesch (Germany) Gkrard Plateau (France) Cksar Rego (USA) Mauricio Resende (USA) Celso C. Ribeiro (Brazil) Catherine Roucairol (France) Hussain A. Saleh (Belgium) Marc Sevaux (France) Jorge P. Sousa (Portugal) ~ r i Taillard c (Switzerland) Jacques Teghem (Belgium) Paolo Toth (Italy) Katsuji Uosaki (Japan) Vicente Valls (Spain) Stefan Vo8 (Germany) Mutsunori Yagiura (Japan), Cochair Takeshi Yamada (Japan) Masayuki Yamamura (Japan) Ming-Jong Yao (Taiwan)

Chapter 1 METAHEURISTIC AGENT PROCESSES (MAPS)

Fred

lover' and Gary ~ o c h e n b e r ~ e r ~

Leeds School of Business, University of ColoradoBoulder,Colorado80309-0419 [email protected]

school of Business Administration, University of Colorado Denver, Colorado 80217-3364 [email protected]

Abstract: Agent-based models have had a remarkable impact in many areas of science, engineering and business. To achieve their full potential, however, these models must be extended to meet challenges of optimization that have so far been sidestepped or left unattended. Because classical optimization procedures are incapable of handling the complex problems that give rise to this challenge, a need arises for agent-based models to draw support from the field of metaheuristics. Accordingly, this situation motivates the creation of Metaheuristic Agent Processes (MAPs) that integrate agent-based models with metaheuristic procedures, and thereby offer a means for achieving further advances through the use of agent-based technology. In this paper, we demonstrate that fundamental metaheuristic strategies already encompass inherent agentbased components, providing a natural foundation for the form of integration necessary to produce MAPs. In addition, we identify a particular class of discrete optimization models that exhibits useful links to agent-based systems, and whose successful applications invite further exploration within the MAP context.

1.1

INTRODUCTION: AGENT-BASED MODELS AND OPTIMIZATION

Agent-based Models (ABMs) are gaining widespread recognition for their role in analyzing complex activities. The underlying structure of ABMs varies, but they are generally conceived to consist of autonomous software objects that interact within an environment. Agents are often described as having behaviors and missions by which they may affect the environment as

2


well as each other, and they are notably subject to being combined to create interactive simulations and models. Abstract characterizations of ABMs, however, may be viewed chiefly as "after-the-fact" attempts to group together ideas that are intuitively conveyed by the agent terminology. While a thoroughly precise and universally agreed-upon definition of agent-based models may not exist, the relevance of ABMs in science and industry is manifested in its diverse applications. These include explorations into the transmission of diseases, the operation of ecosystems, the dynamics of supply chains, the fluctuations and trends of financial markets, the behavior of economic sectors, the patterns of migrations, the flows of metropolitan traffic and the interactions of chemical and bio-physical processes. Within these numerous and varied systems, two essential elements come conspicuously to the fore: the need for complex simulations and the need for highly adaptive optimization. The relevance of complex simulations' has been long been recognized, and has received extensive attention in agentbased modeling - as evidenced by the existence of public domain libraries for generating simulations from an agent-based per~pective.~ On the other hand, the relevance of optimization has been significantly underplayed. No doubt this is because the structure of many agent-based systems cannot easily be captured by classical optimization models, due to conditions of non-linearity, discreteness andor uncertainty that are often present in these systems. In fact, the current role of optimization in agent-based modeling is entirely analogous to the role it assumed within the general field of simulation only a few years ago, as a result of these same factors - inapplicability of classical models, non-linearity, combinatorial complexity and uncertainty. Within the simulation industry, practitioners struggled for years in an attempt to handle the compelling issues of optimization simply by means of trial-and-error analysis. The simulation literature often claimed to have "optimized" various system components, based on nothing more than a series of guesses and brute force re-trials. Today, this picture has dramatically changed, thanks to the newly-emerged metaheuristic procedures that are now routinely being used in the simulation industry, and that are creating solutions of vastly greater quality and utility than were previously possible. The leading

'

Complexity in this case is manifested in the outcomes of the simulation, though not necessarily in the elements and operations that compose it. A prominent example is the Swarm Simulation System (www.swarm.org). An awardwinning commercial authoring tool for creating agent-based models is provided by Agentsheets (www.agentsheets.com).

Metaheuristic Agent Processes (MAPS)

3

provider of this technology to the simulation industry, OptTek Systems, reports over 50,000 applications of its metaheuristic search software (e.g., see www.opttek.com). In the same way as occurred in the earlier applications of optimization in the simulation area, optimization within agent-based models is still approached for the most part by resorting to a series of educated guesses about the values of various input control parameters and decision variables. There is no globally coordinated mechanism for identifying parameter values that yield outcomes of high quality. In particular, the possibility of conducting an intelligent search for high quality solutions by using an appropriate metaheuristic framework is still largely unrecognized.

1.2

METAHEURISTIC AGENT PROCESSES

A significant opportunity exists to expand the scope and power of agentbased models by integrating them with metaheuristics. We refer to the result of such integration as Metaheuristic Agent Processes (MAPS). From a strictly technical point of view, the creation of MAPs involves nothing revolutionary, since it corresponds to the same type of advance already made in the realm of simulation. Such a development is all the more natural because of the close alliance between simulation and agent-based models, where simulation is pervasively used to capture the dynamics and investigate the implications of many forms of ABMs. Taking advantage of this fact by creating metaheuristic agent processes to improve the quality and value of information derived from agent-based models would mark a significant step forward. The integration required to produce effective MAPs rests on principles already well-known and applied within many segments of the metaheuristic community. Indeed, some metaheuristic procedures are founded on metaphors that call to mind the notions and terminology of agent-based systems, and some proponents of these metaheuristics have already sought to have their work viewed as a contribution to the ABM area.3However, such contributions are still limited in scope, and contributions of a more

These metaheuristics are grouped by the label of "swarm intelligence" or "particle swarm optimization," and widely portrayed by the metaphor of bees swarming about a hive. Interesting and perhaps unexpected bonds to certain other types of methods are evidenced by the fact that this search metaphor was originally introduced in the literature of tabu search and adaptive memory programming (see, eg., Glover (1996) and Glover and Laguna (1997)). A website on particle swarm optimization can be found at www.particleswarm.com.

4


substantial nature are not only possible but greatly needed. The opportunity to make gains by the creation of MAPs rests on the same types of metaheuristic advances that have made it possible to handle the complex conditions of non-linearity, discreteness and uncertainty in other realms. Our thesis is that MAPS include agent-based processes of solving problems (i.e., agent-based algorithms) and also agent-based representatives of complex systems we try to optimize. The next sections set out to accomplish three things. First, we demonstrate an intimate connection whereby certain long-standing metaheuristic strategies may be viewed as instances of agent-based processes themselves. From this standpoint, there are compelling precedents for a broader integration of metaheuristics and agent-based models to produce MAPs. Second, within this development we also identify recent innovations that hold promise for further enriching the realm of metaheuristic agent processes. Within this context, we discuss the opportunity for next steps that can usefully expand the application of agent-based models by their integration with metaheuristics. Finally, we demonstrate that a class of 0-1 quadratic optimization models has close ties to agent-based systems, and observe that the highly successful application of these models motivates a fuller exploration of their connection with ABMs.

1.3

METAHEURISTIC PROCESSES CONCEIVED AS AGENT-BASED SYSTEMS

We illustrate a few selected metaheuristic strategies that have conspicuous interpretations as agent-based systems. Notably, the first two of these strategies we discuss emerged long before the notions of agent-based models were popularized. On the basis of these interpretations, it will be clear that many other metaheuristic strategies can likewise be viewed as instances of an agent-based framework. Thus, while agent-based modeling and optimization have up to now remained somewhat insulated from each other, the two fields can productively be viewed as interrelated through the design of metaheuristics and, in particular, through the realm of MAPs. We begin by stepping back in time to examine a set of strategies from the 1960s that has motivated the development of more recent ideas. In their original form, these strategies were designed to generate solutions within the setting of job shop scheduling by creating improved local decision rules. The first of these approaches (Crowston, et al., 1963) sought to create improved rules by selecting probabilistically from a collection of known rules so that


5

different rules will be applied at different decision points throughout the process of generating a schedule constructively. As complete solutions (schedules) are produced by this approach, the decision rules that are more ofien used to create the solutions of higher quality receive greater increases in the probabilities for applying them in future passes. The process can be viewed from as a metaheuristic agent process as shown in Fig. 1.1. The decision rules (of which there may be many) operate as agents, and at each step of constructing a solution the agents enter into a "probabilistic competition" to determine which rule is allowed to augment the current solution to create an expanded solution for the next stage. The process repeats until completing the generation a new solution, whereupon the updated probabilities are calculated and the procedure begins once more with the null solution, to launch another construction. (For simplicity, we do not try to show all connections in this or subsequent figures, or to identify stopping rules, as typically based on numbers of iterations and/or quality of solutions obtained.) Agents

Interaction

Environment Change

Set of

Probabilistic Competition

Winning Rule Augments Current Solution

Solution : Completed

Learn new Probabilities Start Fresh Solution)

Interaction Change + Reset environment Figure 1.1. Probabilistic Decision Learning MAP

It is to be noted that this type of approach can readily be applied in many other settings, as a multi-start metaheuristic. Also, in the case where different decision rules are used to choose among alternative neighborhoods, the approach can be envisioned as an instance of a probabilistic form of strategic oscillation (Glover and Laguna, 1997; Gendreau, 2003) or as a variable neighborhood search procedure (Hansen and Mladenovic, 2003).

6


A related, but somewhat more effective method (Glover, 1963) replaces the approach of probabilistically choosing among a basic collection of rules by instead creating new rules that are explicitly different from all members of the collection, using a process of parametric combination. The basic rules are first re-expressed to yield an evaluation metric compatible with the notion of creating a weighted combination, and then each new pass systematically modifies the weights used to combine rules on preceding passes. The design of this approach later became encapsulated in surrogate constraint methods, by combining constraints instead of decision rules, and also more recently embodied in scatter search procedures (see the surveys respectively of Glover (2003) and Glover, Laguna and Marti (2000)). From the perspective of a metaheuristic agent process, the rules to be combined may again be viewed as the agents. The diagrammatic outline in Fig. 1.2 also refers to the more general form of the process that includes surrogate constraint and evolutionary scatter search approaches, by allowing constraints and solutions to be agents instead of decision rules. In this type of process we may conceive of an additional agent entering the picture (a "marriage agent") as the means for creating the weighted combination of the components. Another generalization operates here, because the procedure is not only concerned with augmenting partial solutions (in successive stages of construction), but also with transforming complete solutions directly into other complete solutions. The augmentation repeats until creating a complete solution, while the direct transformation creates a new solution at each step. At this point, the new weights are produced for the next pass, and the procedure iterates until satisfiing a chosen stopping criterion. An instance of this approach called a "ghost image process" has produced the best known solutions for an extensive test-bed of fixed charge transportation problems (Amini, 2003). There are evidently a variety of possible variations that likewise fit within the same agent-based design, such as permitting different weights to be applied at different stages of construction or according to different environments. Likewise, as in the case of the process depicted in Fig. 1.1, the decision rules can refer to rules for choosing neighborhoods and the approach can also be used as a schematic for a multi-start method. Finally, we observe that the approaches of Fig. 1.1 and Fig. 1.2 can be merged, to create a probabilistic variation of a parametric combination process. Within the framework of evolutionary approaches, an important extension of scatter search procedures is represented by path relinking methods (see, e.g.,

Metaheuristic Agent Processes ( M P s )

Agents

Interaction

Agent and Environment Change

Marriage Agent:

Combined Rule Augments or Transforms Current Solution

*

Interaction Change

+ Reset environment Figure 1.2. Parametric Decision Combination MAP

Glover, Laguna and Marti (2000) and Yagiura, Ibaraki and Glover (2002), Ribeiro and Resende (2005)). Path relinking combines solutions by generating paths in neighborhood spaces instead of Euclidean spaces as occurs in scatter search. To provide fuller generality, we treat rules and solutions alike as agents, thereby encompassing path relinking methods that use both transitional and constructive neighborhoods. (Transitional neighborhoods define moves that transform complete solutions into other complete solutions, while constructive neighborhoods define moves that transform incomplete (partial) solutions into more nearly complete solutions.) The same representation, under appropriate qualification, can also capture the approach of referent domain optimization (Glover and Laguna (1997) and Mautor and Michelon (1998)). The depiction of these approaches as metaheuristic agent processes is given in Fig. 1.3. Path relinking using transitional neighborhoods is embodied in this diagram by focusing on solutions as agents. At each step, a subset selection process is applied (which can also be viewed as performed by an agent), and the solutions in the subset are joined by moving fiom selected initiating solutions through neighborhood space toward other members of the subset, which provide guiding solutions for determining the trajectory. New solutions are culled from this procedure by an intermediate selection step and subjected to an improvement process. Finally, an evaluation filter decides which of the resulting solutions enters the set of agents to be considered for the next round, by replacing previous agents that are


Agents Set of Rules and

Interaction

Subset Selection

Interactive Solution Combination (via neighborhoods )

Solutions

Figure 1.3. Path Relinking 1 Referent Domain MAP

dominated according to intensification and diversification criteria. (As previously noted, not all connections are shown, in order to keep the diagrams from being cluttered.) Applications of this approach are surveyed in Glover, Laguna and Marti (2000,2003). A slightly altered focus where rules also take the role of agents occurs in a form of path relinking involving the use of constructive neighborhoods. In this case, solutions and rules are intermingled, by a design where the guiding solutions provide "votes" (i.e., components of an overall evaluation) that determine which solution element is the next in sequence to be added by the constructive process. Destructive as well as constructive neighborhoods are typically incorporated in such designs. This type of approach has recently been applied effectively in the context of satisfiability problems by Hao, Lardeux and Saubion (2003), yielding new best solutions to a number of benchmark problems. A variant applied in conjunction with ejection chain neighborhoods by Yagiura et al. (2002) succeeds in generating solutions for generalized assignment problems that are not matched by any other procedure. Referent Domain Optimization is captured by this diagram under the condition where the new solutions produced by the solution combination mechanism are subdivided into components (domains), and the improvement process tightly constrains some of these components while subjecting the


Agents

Fan (Transformation)

f

\

Solution Pool

.' f

Evaluation (Quality 62 Diversity)

L

Filter C

\

/'

r

Neighborhood Descendants

'.

J

\

f

J

'.

Collective Adaptive Memory

J

\

f

J

.'

Filter B

\

Individual Adaptive Memory J

Filter A

Figure 1.4. Filter-and-Fan MAP

remaining problem to an intensified improvement procedure, typically an exact solution method. Other forms of referent domain optimization sketc hed in Glover and Laguna (1997) can be represented by straightforward modifications of the diagram. Our final illustration of a metaheuristic from the standpoint of an agentbased process concerns the Filter-and-Fan procedure (Glover, 1998; Greistorfer, Rego and Alidaee, 2003). This approach operates with solutions as agents to produce the MAP representation shown in Fig. 1.4, which portrays a single iterative stage of the procedure. Each iteration begins by performing a fan step whereby each agent (solution) generates a subset of descendants in its neighborhood. The solutions carry individual memories (of the type customarily used in tabu search) which are used to separate and remove certain descendants (Filter A). The system as a whole also carries an associated global memory that removes additional descendants (Filter B). Finally, evaluation criteria based on intensification and diversification eliminate certain remaining solutions (Filter C), and those solutions that survive the gauntlet generate an updated solution pool for re-applying the process. After a chosen number of steps, the method recovers a restricted subset of solutions from earlier steps that resulted in the best solution(s) in the final pool. The recovered solutions then compose the starting solution pool for the next stage of the process. The investigation of Greistorfer, Rego and Alidaee (2003) discloses that this approach proves exceedingly effective for solving facility location problems.

10

1.4


GENERAL OBSERVATIONS O N M A P REPRESENTATIONS

The representations of metaheuristics as MAPs illustrated in the preceding section are intended to be suggestive rather than exhaustive. Evidently, their form can be adapted to create agent-based representations of a variety of other metaheuristic approaches. For example, we may conceive associated constructions for representing processes that might be called Neural MAPs, Genetic MAPs, Evolutionary MAPs, Ant Colony MAPs, Variable Neighborhood MAPs, and so forth. The depiction of metaheuristics as MAPS has the benefit of clarifLing the connection that already exists between metaheuristic procedures and the realm of agent-based models. On the other hand, these representations also suffer a significant limitation, by embodying a level of abstraction that loses track of details that are critical for producing the most effective methods. Among a wide range of procedures that might be portrayed within the same representational framework, only a small subset will reach or surmount the level of performance achieved by the methods that have motivated these MAP diagrams. The foregoing representations are also incomplete in another respect, resulting from their restricted focus on metaheuristics in isolation from other types of agent-based processes. The methods produced by this restricted focus might be called "antecedent MAPs," or a-MAPS, to distinguish them from the more ambitious MAPs that integrate metaheuristics with agentbased models of other forms. It is worth re-emphasizing that this integration is essential to accomplish the goal of bringing optimization to bear on ABMs. Notably, an important step toward creating fully integrated MAPs has been effected by the creation of a library of functions, called the OptQuest Engine, that integrates optimization with simulations that have an entirely general form. The library is not limited to serving as a tool for academic research, but has been widely used in practical applications and has been adopted by nearly all major providers of commercial simulation software. (For background on these developments, see April et al. (2003a, 2003b), Laguna and Marti (2002), Kelly and Laguna (1999).) Consequently, it is a natural next step to structure such metaheuristic processes to handle the specific manifestations of simulation that occur in agent-based modeling. Adaptations of this form can be tailored to yield integrated MAPs that exploit the features of different classes of applications, thereby increasing their usefulness. The resulting higher-order MAPs afford the opportunity to


11

significantly extend the capabilities of current agent-based methods, by making it possible to deal more effectively and comprehensively with environments attended by uncertain events, and to perform improved analyses of systems involving agents that behave according to probabilistically defined parameters. The ability of metaheuristics to handle complex nonlinearities and combinatorial relationships provides additional motivation for creating MAPs that go beyond the current "grope-in-thedark" applications of what-if analysis in ABMs, and opens the door to the benefits of advanced optimization capabilities for agent-based modeling.

1.5

A FUNDAMENTALAGENT-BASED OPTIMIZATION MODEL

We briefly sketch an optimization model that has a natural link to agentbased models, and that can be used to capture interactions of a variety of agent-based systems. The model, called the binary quadratic programming (BQP) problem, can be expressed as follows. Given an n x n matrix Q of constants, we seek an n-dimensional vector x of variables to BQP: Minimize (or maximize) x,

= xQx

subject to x binary Although there are no constraints other than the binary restriction on x, standard transformations make it possible to include many types of constraints (including linear equality constraints) directly in the objective function by modifying the entries of Q. Well known applications of the BQP model include Quadratic Assignment Problems, Capital Budgeting Problems, Multi-dimensional Knapsack Problems, Task Allocation Problems (distributed computer systems), Maximum Diversity Problems, P-Median Problems, Asymmetric Assignment Problems, Symmetric Assignment Problems, Side Constrained Assignment Problems, Quadratic Knapsack Problems, Constraint Satisfaction Problems (CSPs), Set Partitioning Problems, Fixed Charge Warehouse Location Problems, Maximum Clique Problems, Maximum Independent Set Problems, Maximum Cut Problems, Graph Coloring Problems, Graph Partitioning Problems and a variety of others. Note that in speaking of the BQP model as a MAP model, we are introducing a concept that goes beyond the customary notion of an agent-based process, which is restricted to refer to a type of algorithm or computational design.

12


From the current point of view, we consider that a model deserves (or benefits from) an agent-based interpretation if it can be expressed in a natural way as the outcome of an interaction among agents. The BQP model provides an "idealized form" of a MAP model in the following sense. First, in a simplified form, the model is concerned with possible behaviors of agents we index by the symbol j, whose actions are represented by a policy set that consists of two alternatives, coded by the values 0 and 1. The choice among these alternatives in this situation is represented by the assignment xj = 0 and xj = 1, respectively. The result of interaction among agents is captured in the Q matrix. More precisely, the Q matrix is the evaluator for all possible interactions. We seek a policy by each agent from its policy set that yields the best outcome according to the objective function. Actually, the interactions specified in the Q matrix imply that the policy set for each agent is more general that suggested by the preceding simplified description. To identify this broader interpretation, we may consider a policy set PC) for each agent j that consists of multiple options i E PCj), where agent j chooses policy i if and only if q j = 1. In this case the x vector consists of the binary variables q j and for each j the problem contains the additional multiple choice restriction

The choice by agent j of a specific policy from PCj) determines the response to each possible policy choice by every other agent according to the entries of the Q matrix. The effects of all possible pairwise interactions among policy choices receive consideration in this manner. The resulting model can also be viewed in the context of game theory as a Discrete Option Game. The additional multiple choice restrictions, to handle the situation where some players can choose among more than two policies, have a form that permits them to be embedded within the Q matrix in a straightforward way to yield an instance of the BQP model that can be solved highly efficiently. The interpretation of the BQP model in the agent-based setting, where it provides a fundamental class of agent-based models, is useful in relation to the discussion of MAPS in the preceding sections. (We caution that the term "agent based model" has acquired the connotation of not being a model at all in the sense we speak of here, since it refers simply to a way of characterizing a computational scheme.) Specifically, the agent-based interpretation attached to the BQP model establishes a connection that enhances the relevance of integrating metaheuristic processes with agentbased designs to produce MAPS for several reasons. First, metaheuristic


13

methods have proved by far the most effective methods for solving BQP problems (see, e.g., Kochenberger et al., (2004)). Moreover, the typical perspective regarding agent-based approaches, which does not envision the possibility of optimizing over the range of agent behaviors, becomes greatly broadened by means of the BQP model, for which optimization is meaningful and achievable within a practical sense. Finally, we note that the BQP model provides a framework that captures key problem areas that many efforts previously described as "agent-based modeling," have sought to address. Applications in such diverse areas as organization change, team building, and the study of international conflicts (see for example the works of Levinthal (1997), Solow, et. al. (2002) and Axelrod and Bennett (1993)) which have typically been modeled in terms of Rugged Landscapes can alternatively be modeled and analyzed via BQP. Finally, there is another way in which the agent-based interpretation of the BQP model is relevant to our present concerns. As we will show shortly, the method we have used to solve the BQP model itself has a convenient description as a metaheuristic agent process. Before proceeding to such a description, however, we elaborate on features of the BQP model (and the outcomes of solving it) that further motivate its consideration as a fundamental class of models. Robustness of BQP The application potential of BQP is extraordinarily robust due to reformulation methods that enable certain constrained models to be re-cast in the form of BQP. Boris and Hammer (1991, 2002), Hammer and Rudeanu (1968), Hansen (1979), and Hansen et. al. (1993) show that any quadratic (or linear) objective in bounded integer variables and constrained by linear equations can be reformulated as a BQP model. This recasting into BQP is accomplished by imposing quadratic infeasibility penalties in place of the linear constraints as described below: Transformation to the BQP Form Many practical combinatorial optimization problems can be modeled as constrained optimization problems of the form

minx, = xQx subject to

Ax = b, x binary The foregoing model accommodates both quadratic and linear objective functions since the linear case results when Q is a diagonal matrix

14


(observing that xj2= xj when xj is a 0-1 variable). Problems with inequality constraints can also be put into this form by introducing bounded slack variables to convert the inequalities into equations, and representing these slack variables by corresponding binary expansions. The constrained quadratic optimization models are then converted into equivalent BQP models by adding a quadratic infeasibility penalty function to the objective function as an alternative to explicitly imposing the constraints Ax = b . The general approach to such re-casting, which we call Transformation 1, is given below: Transformation I . Let P be a positive scalar penalty value, to yield

=xQx+c where the matrix D and the additive constant c result directly from the matrix multiplication indicated. Upon dropping the additive constant, the equivalent unconstrained version of our constrained problem becomes

BQP(PEN) :rnin XQX,x binary From a theoretical standpoint, a suitable choice of the penalty scalar P can always be chosen so that the optimal solution to BQP(PEN) is the optimal solution to the original constrained problem. As reported in Kochenberger, et. al. (2004), valid and computationally stable penalty values can be found without difficulty for many classes of problems, and a wide range of such values work well. In addition to the modeling possibilities introduced by Transformation 1, a very important special class of constraints that arise in many applications can be handled by an alternative approach, given below. Transformation 2. This approach is convenient for problems with considerations that isolate two specific alternatives and prohibit both from being chosen. That is, for a given pair of alternatives, one or the other but not both may be chosen. If xj and xk are binary variables denoting whether or not alternatives j and k are chosen, the standard constraint that allows one choice but precludes both is:

Xj+Xk I 1 Then, adding the penalty function Px .x to the objective function is a k. simple alternative to imposing the constramt in a traditional manner. For J


15

problems with a linear objective function having all nonnegative coefficients, at least one positive, the scalar P (with respect to Transformation 2) can be chosen as small as the largest objective function coefficient [5]. This penalty function has sometimes been used by to convert certain optimization problems on graphs into an equivalent BQP model (see Pardalos and Xue (1994)). Its potential application, however, goes far beyond these settings as demonstrated in this paper. Variable upper bound constraints of the form xij I yi can be accommodated by Transformation 2 by first replacing each yi variable by 1 - yi', where yi' is the complementary variable that equals 1 when yi = 0 and equals 0 when yi = 1. The opportunity to employ this modeling device in the context of Transformation 2 makes it possible to conveniently model a variety of additional problem types. The constraint associated with Transformation 2 appears in many important applications which leads us to single it our here as an important alternative to Transformation 1. We note, however, that many other problem-specific special cases exist that yield quadratic equivalent representations. We illustrate this later in the paper when we discuss results we have obtained for the max 2-SAT problem. Examples Before highlighting some of the solution methods reported in the literature for BQP, we give two small examples from classical NP-hard problem settings to provide concrete illustrations. Example 1: Set Partitioning The classical set partitioning problem is found in applications that range from vehicle routing to crew scheduling. As an illustration, consider the following small example:

minx, = 3x1+ 2x, + x, + x, + 3x5 + 2x6 subject to

all xj binary.

16


Applying Transformation 1 with P =10 gives the equivalent BQP model: A

BQP(PEN) :min xQx, x binary where the additive constant, c, is 40 and

This simple example of BQP(PEN) can be solved by any of a variety of methods. (The illustrative problems of this paper are solved by the Tabu Search method of Glover et al. [11,12], and solution statistics for benchmark test problems are cited later.) In this case an optimal solution is given by x, = x, = 1 , (all other variables equal to 0) for which x, = 6 . In the straightforward application of Transformation 1 to this example, it is to be noted that the replacement of the original problem formulation by the BQP(PEN) model did not involve the introduction of new variables. In many applications, Transformation 1 and Transformation 2 can be used in concert to produce an equivalent BQP model, as demonstrated next. Example 2: The K-Coloring Problem

Vertex coloring problems seek to assign colors to nodes of a graph such that adjacent nodes are assigned different colors. The K-coloring problem attempts to find such a coloring using exactly K colors. A wide range of applications ranging from frequency assignment problems to printed circuit board design problems can be represented by the K-coloring model. Such problems can be modeled as satisfiability problems using the assignment variables as follows: Let Xij to be 1 if node i is assigned color j, and to be 0 otherwise. Since each node must be colored, we have

17

Metaheuristic Agent Processes ( M P s )

where n is the number of nodes in the graph. A feasible coloring requires that adjacent nodes are assigned different colors. This is accomplished by imposing the constraints x ZP . + x j p 5 1 p = 1 , ...,K (14 for all adjacent nodes (ij)in the graph. This problem can be re-cast into the form of BQP by using Transformation 1 on the assignment constraints of (1.1) and Transformation 2 on the adjacency constraints of (1.2). No new variables are required. Since the model consisting of (1.1) and (1.2) has no explicit objective function, any positive value for the penalty P will do. The following example gives a concrete illustration of the re-formulation process. Consider the following graph and assume we want find a feasible coloring of the nodes using 3 colors.

Our satisfiablity problem is that of finding a feasible binary solution to:

X,+Xjp

Sl

p=1,3

(1.4)

(for all adjacent nodes i and j) In this traditional form, the model has 15 variables and 26 constraints. To

18


recast this problem into the form of BQP, we use Transformation 1 on the equations of (1.3) and Transformation 2 on the inequalities of (1.4). Arbitrarily choosing the penalty P to be 4, we get the equivalent problem:

BQP(Pen) :min XQX A

where the

Q matrix is:

A

Solving this unconstrained model, xQx ,yields the feasible coloring:

This approach to coloring problems has proven to be very effective for a wide variety of coloring instances from the literature. An extensive presentation of the xQx approach to a variety of coloring problems, including a generalization of the K-coloring problem considered here, is given in Kochenberger, Glover, Alidaee and Rego (2002) Solution Approaches to BQP Due to its computational challenge and application potential, BQP has been the focus of a considerable number of research studies in recent years, including both exact and heuristic solution approaches. Recent papers report on the branch and bound (exact) approaches as well as a variety of modern


19

heuristic methods including simulated annealing, genetic algorithms, tabu search, and scatter search. (See Kochenberger, et. al. (2004) for references to these and other works.) Each of these approaches exhibits some degree of success. However, the exact methods degrade rapidly with problem size, and have meaningful application to general BQP problems with no more than 100 variables. (A notable exception to this for the Ising spin glass problem is discussed in De Simone, et. al. (1995). For larger problems, heuristic methods are usually required. Several proposed heuristics, including the DDT method of Boros, Hammer and Sun (1989) and the "one-pass" procedures of Glover, Alidaee, Rego and Kochenberger (2002) have proven to be effective in certain instances. Two methods we have found to be particularly successM for a wide variety of problems are based on tabu search (see Glover and Laguna (1997), Glover, et. al. (1999) and Glover, et. al. (1998)) and on the related evolutionary strategy scatter search of Glover (1998). In the following section we highlight our tabu search approach which was used to produce the computational results referenced later in this paper. Although not pursued by us here, we note that an alternative approach is to solve BQP as a continuous non-linear optimization problem within the unit cube. This allows other heuristic/approximation methods based on continuous optimization methodologies to be applied (see Boris and Hammer (1991), Boris and Prekopa (1989) and Rosenberg (1972)). Tabu Search Overview as a MAP process Our TS method for BQP is centered around the use of strategic oscillation, which constitutes one of the primary strategies of tabu search. We offer the description below as an example of a MAP solution process that operates via the interaction of several functional agents. The method alternates between constructive phases that progressively set variables to 1 (whose steps we call "add moves") and destructive phases that progressively set variables to 0 (whose steps we call "drops moves"). The add moves are created by a "constructive agent" who identifies high quality potential add moves from an environment of available options. In a similar fashion, drop moves are created and managed by a "destructive agent." To control the underlying search process, we use a memory structure that is updated at critical events, characterized by conditions that generate a subclass of locally optimal solutions. Solutions corresponding to critical events are called critical solutions. These functions are handled by a "critical

20


event agent" that identifies when critical events occur and then performs the appropriate updates of memory. A parameter span is used to indicate the amplitude of oscillation about a

critical event. The operations involving this parameter are managed by a "span agent" that begins by setting span equal to 1 and gradually increases it to some limiting value. For each value of span, the span agent directs the constructive and destructive agents to perform a series of constructive and destructive phases, in alternation, before progressing to the next value. When span reached its limiting point, its guiding agent reverses the process so that span is gradually decreased in value, once again accompanied by invoking a series of alternating constructive and destructive phases. When span reaches a value of 1, a complete span cycle has been completed and the span agent launches the next cycle. Information stored at critical events is used by a "tabu neighborhood restriction agent" (or simply "tabu agent," for short) to influence the search process by penalizing potentially attractive add moves during a constructive phase and inducing drop moves during a destructive phase. These penalties and inducements are associated with assignments of values to variables in recent critical solutions. The tabu agent also uses cumulative critical event information to introduce a subtle long term bias into the search process by means of additional penalties and inducements similar to those discussed above. The activities of these agents are orchestrated by the direction of a "macro managing agent" that provides the coordination required for a successful search process. A complete description of the framework for our metaheuristic method is given in Glover, Kochenberger, Alidaee and Amini (1999). Relevance of the MAP Interpretation for the BQP Problem

Evidently, the tabu search procedure for the BQP problem can be described without reference to a MAP framework, as in the case of other metaheuristic agent processes, and indeed as in the case of agent-based processes generally, which can readily be formulated as distributed computational designs where the activities of the agents are simply the functions of various subroutines. However, there is a virtue in the agent-based formulation that comes from its emphasis on processes that have a natural interpretation as being carried out by certain guiding entities that the literature has come to label with the agent terminology. Such an emphasis invites the designers of the associated methods to organize them in certain modularly structured ways that proves

Metaheuristic Agent Processes ( ' P s )

21

useful for visualizing their function and for extending them to create more advanced versions. For example, a new function can be provided by introducing a new agent, together with rules for interacting with the problem environment and selected other agents. (The agent-based literature often refers to agent-based processes as if the agents operate in complete autonomy from each other. This is an oversimplification that applies only under restricted circumstances.) The advantages that come from using an agent-based orientation to describe and structure various computational processes lead us to anticipate that advantages may also accrue to ferreting out structures within mathematical models that can be interpreted from an agent-based perspective, as we have done with the BQP model. We now describe the outcomes that further suggest the BQP model may occupy a privileged position among the realm of models to which an agent-based interpretation can be usefilly applied. Computational Experience Our results of applying the tabu search and associated scatter search metaheuristics to combinatorial problems recast in BQP form have been uniformly attractive in terms of both solution quality and computation times. Although our methods are designed for the completely general form of BQP, without any specialization to take advantage of particular types of problems reformulated in this general representation, our outcomes have typically proved competitive with or even superior to those of specialized methods designed for the specific problem structure at hand. By way of illustration, we present some representative results for a set of max 2-SAT test problems taken from the literature. Details of our experience with other problems will appear in future papers. Max 2-SAT Results Several authors (Hammer and Rudeanu (1968), Hansen and Jaumard (1990), Boros and Hammer (2002)) have established the connection between SAT problems and nonlinear penalty functions. The special case of Max 2-SAT is particularly well suited for this approach as it leads naturally to an xQx representation. Our experience, as shown below, indicates that this is a very attractive way to approach this class of problems. For a 2-SAT problem, a given clause can have zero, one, or two negations, each with a corresponding (classical) linear constraint. Each linear constraint, in turn, has an exact quadratic penalty that serves as an alternative to the


linear constraint. The three possibilities and their constraint/penalty pairs are: (a) No negations: Classical constraint: xi + xj 2 1 Exact Penalty: (1 - xi - x j + xixj) (b) One negation: Classical constraint: xi + Tj 2 1 Exact Penalty: (xj - xixj) (c) Two negations: Classical constraint: Ti + 5 2 1 Exact Penalty: (xixj ) It is easy to see that the quadratic penalties shown are zero for feasible solutions and positive for infeasible solutions. Thus, these special penalties can be used to readily construct a penalty function of the form of xQx simply by adding the penalties together. We have found this approach to be very effective. Table 1.1 shows the results we obtained via this approach on a set of test problems from the literature.

As shown in the table, by re-casting each Max 2-SAT instance into the form of xQx and solving the resulting unconstrained quadratic binary program with our Tabu Search heuristic, we were able to find best known solutions very quickly to all test problems considered. By way of contrast, the method of Borchers and Furman took a very long time on several problems and was unable to find best known results for several instances in the allotted 12 hour time limit. In addition to the problems of Table 1.1 above, we have successfully applied this approach to randomly generated problems with as many as 1000 variables and more than 10,000 clauses where best known results are found in roughly one minute of computation time. The results shown in Table 1.1 above serve as strong evidence of the attractiveness of the xQx approach for the problems considered. Considering both solution quality and the time taken to produce these solutions, this approach is very competitive with special purpose methods constructed specifically for max 2-Sat problems. We note in passing that similar performance relative to special purpose methods has been obtained for the other problem classes singled out earlier in the paper as well.

Metaheuristic Agent Processes ( ' P s ) Table 1.1. Problems from Borchers & Furman (1999)

n

m

Best known solution

xQx solution

xQx time

ax sat^ solution

Maxsat time

Remarks: All times in seconds unless noted otherwise. Maxsat is an exact method developed by Borchers & Furman Maxsat results obtained on IBM RS/6000-590 xQx results obtained on a 1.6 MHz PC. Each xQx run was for 50 SPAN cycles Problem 100-600 was previously unsolved.

Summary We have demonstrated how a variety of disparate combinatorial problems can be solved by first re-casting them into the common modeling framework of the unconstrained quadratic binary program. Once in this unified form, the problems can be solved effectively by adaptive memory tabu search metaheuristics and associated evolutionary (scatter search) procedures. We are currently solving problems via BQP with more than 50,000 variables in the quadratic representation and are working on enhancements that will permit larger instances to be solved.

24


Our findings challenge the conventional wisdom that places high priority on preserving linearity and exploiting specific structure. Although the merits of such a priority are well-founded in many cases, the BQP domain appears to offer a partial exception. In forming BQP(PEN), we destroy any linearity that the original problem may have exhibited. Moreover, any exploitable structure that may have existed originally is "folded into" the Q matrix, and the general solution procedure we apply takes no advantage of it. Nonetheless, our solution outcomes have been remarkably successful, yielding results that rival the effectiveness of the best specialized methods. This combined modeling/solution approach provides a unifying theme that can be applied in principle to all linearly constrained quadratic and linear programs in bounded integer variables, and the computational findings for a broad spectrum of problem classes raises the possibility that similarly successful results may be obtained for even wider ranges of problems. As our methods for BQP continue to improve with ongoing research, the BQP model offers a representational tool of particular promise. The novel fact that this model has a natural connection with agent-based systems, and provides an idealized instance of a MAP model, invites its exploration within alternative contexts that exploit the links to agent-based processes in additional ways.

REFERENCES Amini, M. (2003) "Computational Study of Solving Fixed Charge Transportation Problems Using Ghost Image Processes," School of Business, University of Memphis, TN. Axelrod, R, and Bennett, S, "A Landscape Theory of Aggregation," British Journal of Political Science, 1993,23,211-233. April, J., F. Glover and J. Kelly (2003a) "Optfolio - A Simulation Optimization System for Project Portfolio Planning," Proceedings of the 2003 Winter Simulation Conference, S. Chick, F. Sanchez, D. Ferrin and D. Morrice, eds. April, J., F. Glover, J. Kelly and M. Laguna (2003b) "Practical Introduction to Simulation Optimization," Proceedings of the 2003 Winter Simulation Conference, S. Chick, F. Sanchez, D. Ferrin and D. Morrice, eds.

MetaheuristicAgent Processes ( ' P s )

25

Borchers, B. and J. Furman, "A Two-Phase Exact Algorithm for Max-SAT and Weighted Max SAT," J. of Combinatorial Optimization, 2,299306 (1999). Boros, E., and P. Hammer, "The Max-Cut Problem and Quadratic 0-1 Optimization, Polyhedral Aspects, Relaxations and Bounds," Annals of OR, 33, 151-225 (1991). Boros, E. and P. Hammer, " Pseudo-Boolean Optimization," Discrete Applied Mathematics, l23(1-3), 155-225 (2002). Boros, E, P. Hammer, and X, Sun, "The DDT Method for Quadratic 0-1 Minimization," RUTCOR Research Center, RRR 39-89, 1989. Boros, E. and A. Prekopa, "Probabilistic Bounds and Algorithms for the Maximum Satisfiability Problem," Annals of OR, 21 (1989), pp. 109-126. Crainic, T.G. and M. Toulouse (2003) "Parallel Strategies for MetaHeuristics," Chapter 17 of Handbook of Metaheuristics, G. Kochenberger and F. Glover, eds., Kluwer Academic Publishers. Crowston, W., F. Glover, G. Thompson and J. Trawick (1963) "Probabilistic and Parametric Learning Combinations of Local Job Shop Scheduling Rules," ONR Research Memorandum No. 117, GSIA, Carnegie-Mellon University, Pittsburgh, PA. De Simone, C. M. Diehl, M. Junger, P. Mutzel, G. Reinelt, and G. Rinaldi, "Exact Ground State4s of Ising Spin Glasses: New Experimental Results with a Branch and Cut Algorithm," Journal of Statistical Physics, 80,487-496 (1995). Dorigo, M. and T. Stutzle (2003). "The Ant Colony Optimization Metaheuristic: Algorithms, Applications, and Advances," Chapter 9 of Handbook of Metaheuristics, G. Kochenberger and F. Glover, eds., Kluwer Academic Publishers. Gendreau, M. (2003) "An Introduction to Tabu Search," Chapter 2 of Handbook of Metaheuristics, G. Kochenberger and F. Glover, eds., Kluwer Academic Publishers. Glover, F, and M. Laguna, "Tabu Search," Kluwer Academic Publishers, 1997. Glover, F., "A Template for Scatter Search and Path Relinking," School of Business, University of Colorado, Technical Report, February 1998.

26


Glover, F., B. Alidaee, C. Rego, and G. Kochenberger, "One-Pass Heuristics for Large-Scale Unconstrained Binary Quadratic Programs," EJOR 137, pp. 272-287,2002. Glover, F., G. Kochenberger, B. Alidaee, and M.M. Amini, "Tabu with Search Critical Event Memory: An Enhanced Application for Binary Quadratic Programs," In: MetaHeuristics: Advances and Trends in Local Search Paradigms for Optimization, (Eds.) S. Voss, S. Martello, I. Osman, and C. Roucairol. Kluwer Academic Publisher, Boston, 1999. Glover, F., G. Kochenberger., and B. Alidaee, "Adaptive Memory Tabu Search for Binary Quadratic Programs," Management Science, 44:3, 336-345, 1998. Glover, F. (1963) "Parametric Combinations of Local Job Shop Scheduling Rules," Chapter IV, ONR Research Memorandum No. 117, GSIA, Carnegie-Mellon University, Pittsburgh, PA. Glover, F. (1996) "Tabu Search and Adaptive Memory Programming Advances, Applications and Challenges," Interfaces in Computer Science and Operations Research, R. Barr, R. Helgason and J. Kennington (eds.). Kluwer Academic Publishers, pp. 1-75. Glover, F. (1998) "A Template for Scatter Search and Path Relinking," Artificial Evolution, Lecture Notes in Computer Science, 1363, J.-K. Hao, E. Lutton, E. Ronald , M. Schoenauer and D. Snyers, Eds. Springer, pp. 13-54. Glover, F. (2003) "Tutorial on Surrogate Constraint Approaches for Optimization in Graphs," Journal of Heuristics, Volume 9, No. 3., pp. 175-227. Glover, F. and M. Laguna (1997) Tabu Search. Kluwer Academic Publishers. Glover, F., M. Laguna and R. Marti (2000) "Fundamentals of Scatter Search and Path Relinking," Control and Cybernetics, Volume 29, No 3, pp. 653-684. Glover, F., M. Laguna and R. Marti (2003) "Scatter Search and Path Relinking: Advances and Applications," Chapter 1 of Handbook of Metaheuristics, G. Kochenberger and F. Glover, eds., Kluwer Academic Publishers. Greistorfer, P., C. Rego and B. Alidaee (2003) "A Filter-and-Fan Aproach for the Facility Location Problem," Proceedings of M7C2OO3.

Metaheuristic Agent Processes (&UPS)

27

Hammer, P., and S. Rudeanu, Boolean Methods in Operations Research, Springer-Verlag,New York, 1968. Hansen, P.B., "Methods of Nonlinear 0-1 Programming," Annals Discrete Math, vol. 5, pp.53-70, 1979. Hansen, P, B. Jaumard., and V. Mathon, "Constrained Nonlinear 0-1 Programming," INFORMS Journal on Computing, 5 :2, 97- 119, 1993. Hansen, P. and B. Jaumard, "Algorithms for the Maximum Satisfiability Problem," Computing, 44,279-303 (1990). Hansen, P. and M. Mladenovic (2003) "Variable Neighborhood Search," Chapter 6 of Handbook of Metaheuristics, G. Kochenberger and F. Glover, eds., Kluwer Academic Publishers. Hao, J.K., F. Lardeux and F. Saubion (2003) "Evolutionary Computing for the Satisfiability Problem," Lecture Notes in Computer Science, Volume 261 1, pp. 258-268, Springer. Kelly, J. and M. Laguna (1999) "New Advances Wedding Simulation and Optimization," Proceedings of the 1999 Winter Simulation Conference, D. Kelton, ed. Kochenberger, G., F. Glover, B. Alidaee, and C. Rego, "A Unified Modeling and Solution Framework for Combinatorial Optimization Problems," OR Spectrum, 26, pp. 237-250, (2004). Kochenberger, G., F. Glover, B. Alidaee, and C. Rego, " An Unconstrained Quadratic Binary Programming Approach to the Vertex Coloring Problem," Working Paper, University of Colorado at Denver, 2002. Kochenberger, G., F. Glover, B. Alidaee and C. Rego (2003) "Solving Combinatorial Optimization Problems via Reformulation and Adaptive Memory Metaheuristics," Revolutionary Visions in Evolutionary Computation, A. Menon and D. Doldberg, eds., Kluwer Academic Publishers, forthcoming. Laguna, M. and R. Marti (2002) "The OptQuest Callable Library," Optimization Sofiare Class Libraries, Stefan Voss and David L. Woodruff (eds.), Kluwer Academic Publishers, Boston, pp. 193-2 18. Levinthal, D (1997) "Adaptation on Rugged Landscapes," Management Science, 43,934-950. Mautor, T, and P. Michelon (1998) "A neglected meta-heuristic: Referent Domain Optimization", 16th European Conference on Operational

Metaheuristics: Progress as Real Problem Solvers Research (EURO XVI), Bmelles. Pardalos, P, and J. Xue, "The Maximum Clique Problem," The Journal of Global Optimization, 4,301-328, 1994. Resende, M.G.C. and C.C. Ribeiro (2005) "GRASP with path relinking: recent advances and applications," Metaheuristics: Progress as Real Problem Solvers, T. Ibaraki, K. Nonobe and M. Yagiura, (Eds.), Kluwer Academic Publishers. Rosenberg, I.G., "0-1 Optimization and Non-linear Programming." Revue Francaise d 'Automatique, d'lnformatiqu et de Rescherche Operationnelle, (Serie Blueu) 2,95-97, (1972). Solow, D, Vairaktarakis,G, Piderti, S.K, Tsai, M-C, " Managerial Insights into the Effects of Interactions on Replacing Members of a Team," Management Science, 2002,48, 1060-107. Yagiura, M., T. Ibaraki and F. Glover (2002) "A Path Relinking Approach for the Generalized Assignment Problem," Proc. Int. Sym. on Scheduling, pp. 105-108 (longer version available from http://www-or.amp.i.kyoto-u.ac.jp/-yagiudpapers/prgap~abst.html).

Chapter 2

GRASP WITH PATH-RELINKING: RECENT ADVANCES AND APPLICATIONS Mauricio G.C. Resende1 and Celso C. Ribeiro2

'internet and Network Systems Research, AT&T Labs Research, 180 Park Avenue, Room C241, Florham Park, NJ 07932 USA. ' ~ e ~ a r t m e of n tComputer Science, Catholic University of Rio de Janeiro, Rua Marques de Sio Vicente, 225, Rio de Janeiro, RJ 22453-900 Brazil [email protected]

Abstract: Path-relinking is a major enhancement to the basic greedy randomized adaptive search procedure (GRASP), leading to significant improvements in solution time and quality. Path-relinking adds a memory mechanism to GRASP by providing an intensification strategy that explores trajectories connecting GRASP solutions and the best elite solutions previously produced during the search. This paper reviews recent advances and applications of GRASP with path-relinking. A brief review of GRASP is given. This is followed by a description of path-relinking and how it is incorporated into GRASP. Several recent applications of GRASP with path-relinking are reviewed. The paper concludes with a discussion of extensions to this strategy, concerning in particular parallel implementations and applications of path-relinking with other metaheuristics. Keywords: Metaheuristics, GRASP, path-relinking.

2.1

INTRODUCTION

GRASP (Greedy Randomized Adaptive Search Procedure) is a metaheuristic for finding approximate solutions to combinatorial optimization problems formulated as min f ( x ) subject to x E X,

30


where f (.) is an objective function to be minimized and X is a discrete set of feasible solutions. It was first introduced by Feo and Resende [14] in a paper describing a probabilistic heuristic for set covering. Since then, GRASP has experienced continued development [15,431 and has been applied in a wide range of problem areas [18].

2.1.1

Multi-start local search

GRASP can be thought of as a search method that repeatedly applies local search from different starting solutions in X. At each step of local search, the neighborhood N(x) of the current solution x is searched for a solution y E N(x) such that f (y) < f (x). If such an improving solution is found, it is made the current solution and another step of local search is done. If no improving solution is found, the procedure stops with x as a locally optimal solution. An obvious initial solution for local search is a solution generated by a greedy algorithm. Greedy algorithms construct a solution one element at a time. For example, a tree is built one edge at a time; a schedule is built one operation at a time; a vertex partition is built one vertex at a time. At each step of a greedy algorithm, a set of candidate elements C contains all elements that can be added to extend the partial solution. Greedy algorithms make use of a greedy function g(e) that measures the incremental cost of adding element e E C to the current partial solution. For a minimization problem, the element e* = argmin{g(e) : e E C) is chosen to be added to the partial solution. The addition of e* to the partial solution usually restricts the set of candidates elements, which is reflected by the reduction of its cardinality. The procedure ends when a complete solution is built, i.e. when C = 0. The drawback of using a greedy algorithm as an initial solution for local search is that if a deterministic rule is used to break ties, a greedy algorithm will produce a single solution and therefore local search can only be applied once. Even when a probabilistic tie breaking rule is used, the diversity of purely greedy solutions is usually low. The other extreme is to repeatedly start local search from randomly generated solutions. Though this approach produces a high level of diversity in the starting solutions, the average quality of these random solutions is usually much worse than that of a greedy solution. F'urthermore, the time local search takes to converge to a locally optimal solution is, on average, much longer than when a greedy initial solution is used. GRASP blends greedy and random construction either by using greediness to build a restricted candidate list (RCL) and randomness to select

GRASP with path-relinking

31

an element from the list, or by using randomness to build the list and greediness for selection. Candidate elements e E C are sorted according to their greedy function value g(e). In a cardinality-based RCL, the latter is made up by the k top-ranked elements. In a value-based construction, the RCL consists of the elements in the set {e E C : g* g(e) g*+a.(g*-g,)), where g, = min{g(e) : e E C), g* = max{g(e) : e E C), and a is a parameter satisfying 0 5 a 5 1. Since the best value for a is often difficult to determine, it is often assigned a random value for each GRASP iteration. Algorithm 2.1 shows the pseudo-code for a pure greedy randomized adaptive search procedure. The value of the best solution is stored in f * and i, GRASP iterations are done. Each iteration consists of a greedy randomized construction phase, followed by a local search phase, starting from the greedy randomized solution. If the solution resulting from the local search improves the best solution so far, it is stored in x*.

&

&

gi).

gj

(G,

-

~ q + g 5 ~ ~ ( ~,..., : ~ q j , e i ,...,$ 3% . ) + ( x $3 1 -237

. - - -%j> 2 Zji, - - - > -3% 2.). 7

(2.4) The enforcement of the constraints that limit the number of P V C ~ routed through each trunk may lead to unroutable demand pairs. In this case, the current solution is discarded and a new construction phase starts. Each solution built in the first phase may be viewed as a set of routes, one for each PVC. The local search procedure seeks to improve each

44


route in the current solution. For each PVC k E K , start by removing units of flow from each edge in its current route. Next, compute incremental edge weights associated with routing this demand through each trunk (i,j ) E E according to (2.4). A tentative new shortest path route is computed using the incremental edge weights. If the new route improves the solution, it replaces the current route of PVC k. This is continued until no improving route can be found. In the proposed path-relinking strategy, the set of moves corresponding to the symmetric difference A(xl, x2) between any pair {xl, x2) of solutions is the subset K,,,,, C K of PVCs routed through different routes in xl and 2 2 . Without loss of generality, suppose that pathrelinking starts from any elite solution z in the pool and uses the locally optimal solution y as the guiding solution. The best solution jj along the new path to be constructed is initialized with z. For each PVC k E K,,,, the same shortest path computations described for construction and local search are used to evaluate the cost of the new solution obtained by rerouting the demand associated with PVC k through the route used in the guiding solution y instead of that used in the current solution originated from z. The best move is selected and removed from Ky,z. The new solution obtained by rerouting the above selected PVC is computed, the incumbent jj is updated, and a new iteration resumes. These steps are repeated, until the guiding solution y is reached. The incumbent jj is returned as the best solution found by path-relinking and inserted into the pool if it is better than the worst solution currently in the pool. Figure 2.6 illustrates the comparison of the four algorithms: pure GRASP (GRASP), GRASP with forward path-relinking (GRASP+PRf, in which a locally optimal solution is used as the initial solution), GRASP with backward path-relinking (GRASP+PRb, in which an elite solution is used as the initial solution), and GRASP with backward and forward path-relinking (GRASP+PRfb, in which path-relinking is performed in both directions) on PVC routing instance f ri'5Oa (60 nodes, 498 arcs, and 750 commodities). For a given computation time, the probability of finding a solution at least as good as the target value increases from GRASP to GRASP+PRf, from GRASP+PRf to GRASP+PRfb, and from GRASP+PRfb to GRASP+PRb. For example, there is 9.25% probability for GRASP+PRfb to find a target solution in less than 100 seconds, while this probability increases to 28.75% for GRASP+PRb. For GRASP, there is a 8.33% probability of finding a target solution within 2000 seconds, while for GRASP+PRf this probability increases to 65.25%. GRASP+PRb finds a target solution in at most 129 seconds with 50% probability. For the

rk


J 10

100

1000 I0000 time to target value (seconds)

100000

le+06

Figure 2.6. Empirical distributions of time to target solution for GRASP, GRASP with forward path-relinking, GRASP with backward path-relinking, and GRASP with back and forward path-relinking for private virtual circuit routing instance fr750a. Two hundred independent runs were done for each algorithm. Target solution value used was 479000.

same probability, this time increases to 172, 1727, and 10933 seconds, respectively, for variants GRASP+PRfb, GRASP+PRf, and GRASP. These results suggest that variant GRASP+PRb, which performs pathrelinking backward from an elite solution to a locally optimal solution, is the most effective. Another experiment comparing the four variants was done on PVC routing instance att (90 nodes, 274 trunks, 272 commodities). Ten independent runs of each algorithm were done for 100 seconds on a 196 MHz SGI Challenge computer. Table 2.1 summarizes these results. For each variant, this table lists the best and average solution values found after 10 seconds and after 100 seconds. The results point to GRASP+PRb and GRASP+PRfb as the two best heuristics. It is interesting to note that even if given 100 seconds, GRASP finds solutions of worse quality than those found by GRASP+PRb and GRASP+PRfb in only 10 seconds.

2.4.2

2-path network design

Let G = (V, E) be a connected undirected graph, where V is the set of nodes and E is the set of edges. A k-path between nodes s,t E V is a sequence of at most k edges connecting them. Given a non-negative

46


Table 2.1. Comparison of GRASP, GRASP with forward path-relinking, GRASP with backward path-relinking, and GRASP with back and forward path-relinking for private virtual circuit routing instance att. Ten independent runs of 100 seconds were done for each algorithm. 10 runs Variant

GRASP

10 seconds best average 126603 1 126695

1

100 seconds best I average 126228 1 126558

weight function w : E -+ R+ associated with the edges of G and a set D of pairs of origin-destination nodes, the 2-path network design problem (2PNDP) consists in finding a minimum weighted subset of edges E' G E containing a 2-path between every origin-destination pair. Applications can be found in the design of communication networks, in which paths with few edges are sought to enforce high reliability and small delays. Dahl and Johannessen [13] proved that the decision version of 2PNDP is NP-complete. Rosseti [52] and Ribeiro and Rosseti [48] described sequential and parallel implementations of GRASP with path relinking for the 2-path network design. The construction of a new solution begins by the initialization of modified edge weights with the original edge weights. Each iteration of the construction phase starts by the random selection of an origin-destination pair still in D. A shortest 2-path between the extremities of this pair is computed, using the modified edge weights. The weights of the edges in this 2-path are set to zero until the end of the construction procedure, the origin-destination pair is removed from D, and a new iteration resumes. The construction phase stops when 2-paths have been computed for all origin-destination pairs. The local search phase seeks to improve each solution built in the construction phase. Each solution may be viewed as a set of 2-paths, one for each origin-destination pair in D. To introduce some diversity by driving different applications of the local search to different local optima, the origin-destination pairs are investigated at each GRASP iteration in a circular order defined by a different random permutation of their original indices. Each 2-path in the current solution is tentatively eliminated. The weights of the edges used by other 2-paths are temporarily set to zero, while those which are not used by other 2-paths in the current solution are restored to their original values. A new shortest 2-path be-

GRASP with path-relinlcing

47

tween the extremities of the origin-destination pair under investigation is computed, using the modified weights. If the new 2-path improves the current solution, then the latter is modified; otherwise the previous 2-path is restored. The search stops if the current solution was not improved after a sequence of ID\iterations along which all 2-paths have been investigated. Otherwise, the next 2-path in the current solution is investigated for substitution and a new iteration resumes. Each GRASP iteration performs an intensification phase using pathrelinking, in which the newly generated solution obtained at the end of the local search phase is combined with a randomly selected solution from the pool of elite solutions. Path-relinking starts by determining all origin-destination pairs whose associated 2-paths are different in the two solutions. These computations amount to determining the set of moves which should be applied to the initial solution to reach the guiding one. Each move is characterized by a pair of 2-paths, one to be inserted and the other to be eliminated from the current solution. At each pathrelinking iteration the best yet unselected move is applied to the current solution and the best solution found along the path connecting the two solutions is updated. The incumbent best solution found along the pathrelinking step is inserted into the pool if it is better than the worst solution currently in the pool. Several strategies for the implementation of the path-relinking step have been investigated in [49, 521: pure GRASP (GRASP), GRASP with forward path-relinking (GRASP+PR~, in which a locally optimal solution is used as the initial solution), GRASP with backward path-relinking (GRASP+PR~, in which an elite solution is used as the initial solution), GRASP with backward and forward path-relinking (GRASP+PRfb, in which path-relinking is performed twice, once in each direction), and GRASP with mixed path-relinking (GRASP+ PRm, in which two paths in opposite directions are simultaneously explored). The results displayed in Table 2.2 illustrate the behavior of these five variants on randomly generated instances [52] on complete graphs with 100, 200, 300, 400, and 500 nodes. For each instance, we give the best and average solution values found over ten independent runs of each algorithm. For each problem size, the processing time is limited at that observed for 200 iterations of the pure GRASP procedure on the first instance in the group. Algorithms GRASP+PRfb and GRASP+PRm performed better than the other variants, as far as together they found the best solutions and the best average solutions for all instances in the table. GRASP with backward path-relinking usually performs better than the forward path-relinking variant, due to the fact that it starts


48

Table 2.2. Results for ten runs of each algorithm on randomly generated instances of 2-path network design problems with limited processing time. GRASP best avg. 779 784.3 762 769.6 773 779.2 746 752.0 756 762.3 1606 1614.7 1601 1608.8 1564 1578.2 1578 1585.6 1577 1599.6 2459 2481.9 2520 2527.7 2448 2463.5 2462 2482.1 2450 2458.8 3355 3363.8 3393 3417.5 3388 3394.4 3396 3406.0 3416 3429.3 4338 4350.1 4353 4369.6 4347 4360.7 4317 4333.8 4362 4370.4

GRASP+PRf best avg. 760 772.8 730 749.4 762 769.3 732 738.4 742 749.7 1571 1584.4 1557 1572.8 1523 1541.9 1531 1553.3 1567 1575.4 2408 2425.0 2453 2469.7 2381 2403.1 2413 2436.2 2364 2402.5 3267 3285.5 3324 3338.2 3311 3322.4 3316 3326.5 3335 3365.5 4209 4247.1 4261 4278.6 4239 4257.8 4222 4238.6 4263 4292.0

GRASP+PRb best avg. 763 769.3 735 746.0 756 766.1 723 736.7 739 746.5 1540 1568.0 1559 1567.9 1516 1531.9 1518 1538.1 1543 1563.5 2377 2401.3 2419 2449.1 2339 2373.8 2373 2409.3 2328 2368.6 3238 3257.0 3283 3306.8 3268 3291.9 3249 3292.0 3267 3327.7 4176 4207.6 4180 4233.7 4187 4224.8 4157 4197.4 4203 4294.0

GRASP+PRfb best avg. 749 762.7 729 741.7 757 763.6 719 730.4 737 742.9 1526 1562.0 1537 1558.9 1508 1519.9 1510 1532.2 1529 1556.3 2355 2399.2 2413 2438.9 2356 2375.3 2369 2400.9 2347 2373.9 3221 3239.4 3220 3292.2 3227 3275.1 3256 3284.8 3270 3313.9 4152 4196.1 4166 4219.6 4170 4201.9 4156 4182.2 4211 4236.8

GRASP+PRm best avg. 755 765.3 736 745.7 754 765.1 717 732.2 728 743.7 1538 1564.3 1545 1563.3 1509 1528.7 1513 1534.7 1531 1556.1 2366 2393.6 2405 2439.4 2338 2370.3 2350 2401.0 2322 2365.4 3231 3252.2 3271 3301.4 3257 3273.2 3246 3287.9 3259 3323.5 4175 4206.2 4175 4226.3 4187 4217.9 4159 4197.1 4200 4240.2

from an elite solution that is often better than the current local optimum, fully exploring the neighborhood of the former. The results observed for variant GRASP+PRm are very encouraging: this algorithm found better solutions than the other variants for 40% of the instances. To further illustrate and compare these five variants, we display in Figure 2.7 a plot of the empirical probability distribution of the time to target solution value for each algorithm, computed from 200 independent runs. These plots show that the probability of finding a solution at least as good as a target value increases from GRASP to GRASP+PRf to GRASP+PRb to GRASP+PRfb, and finally to GRASP+PRm. These results confirms an observation first noticed by Ribeiro et al. [50] and later by Resende and Ribeiro [42],suggesting that the backward strategy performs


49

a major role in successful implementations of path-relinking. Moreover, they also indicate that the mixed path-relinking strategy proposed by Rosseti [52] is very effective.

Figure 2.7. Empirical distributions of time to target solution for GRASP, GRASP with forward path-relinking, GRASP with backward path-relinking, GRASP with back and forward path-relinking, and GRASP with mixed path-relinking for a 2-path network design instance with 80 nodes. Two hundred independent runs were done for each algorithm. Target solution value used was 588.

2.4.3

p-median problem

In the pmedian problem, we are given a set F of m potential facilities, a set U of n users (or customers), a distance function d : U x F t R, and a constant p 5 m, and want to determine which p facilities to open so as to minimize the sum of the distances from each user to its closest open facility. It is a well-known NP-hard problem [27]. Resende and Werneck [45] describe a GRASP with path-relinking for the pmedian problem. Empirical results on instances from the literature show that the algorithm is robust and that it performs at least as well as other methods, and often better in terms of both running time and solution quality. In all cases the solutions obtained by the GRASP with path-relinking were within 0.1% of the best known upper bounds. For a large number of instances new best known solutions were produced by the new algorithm.

50


The standard greedy algorithm for the pmedian problem [lo, 551 starts with an empty solution and adds facilities one at a time, choosing the most profitable in each iteration (the one whose insertion causes the greatest drop in solution cost). The construction procedure proposed in [45] is similar to the greedy algorithm, but instead of selecting the best among all possible options, it only considers q < m possible insertions (chosen uniformly at random) in each iteration. The most profitable among those is selected. The running time of the algorithm is O(m pqn). The idea is to make q small enough so as to significantly reduce the running time of the algorithm (when compared to the pure greedy one) and to ensure a fair degree of randomization. In tests, the value q = rlog2(m/p)l was determined to be suitable. The standard local search procedure for the pmedian problem, originally proposed by Teitz and Bart [54], is based on swapping facilities. Given an initial solution S, the procedure determines, for each facility f @ S, which facility g E S (if any) would improve the solution the most iff and g were interchanged (i.e., iff were opened and g closed). If there is one such improving move, f and g are interchanged. The procedure continues until no improving interchange can be made, in which case a local minimum will have been found. The complexity of this swap-based local search is O(pmn) per iteration. Whitaker [55] proposed an efficient implementation of this method, which he called fast interchange, for which the bound on the running time of each iteration is reduced to O(mn). Resende and Werneck [35] have recently proposed an alternative implementation. Although it has the same worst-case complexity as Whitaker's, it can be substantially faster in practice. The speedup (of up to three orders of magnitude) results from the use of information gathered in early iterations of the algorithm to reduce the amount of computation performed in later stages. Though this implementation can require a greater amount of memory, with the use of some programming techniques (e.g. sparse matrix representation and cache), the additional memory requirements can be minimized. Intensification (via path-relinking) occurs in two different stages. First, every GRASP iteration contains an intensification step, in which the newly generated solution is combined with a solution from the pool. Then, in the post-optimization phase, solutions in the pool are combined among themselves. Let S1 and S2 be two valid solutions, interpreted as sets of (open) facilities. The path-relinking procedure starts with one of the solutions (say, Sl) and gradually transforms it into the other (S2)by swapping in elements from Sz\ S1and swapping out elements from S1\ S2.The total number of swaps made is I S2\ S1I, which is equal to IS1\ S2I . The choice

+


51

of which swap to make in each stage is greedy: the most profitable (or least costly) move is made. The outcome of path-relinking is the best local minimum in the path. A local minimum in this context is a solution that is both succeeded (immediately) and preceded (either immediately or through a series of same-value solutions) in the path by strictly worse solutions. If the path has no local minima, one of the original solutions (S1or S2)is returned with equal probability. When there is an improving solution in the path, this criterion matches the traditional one exactly: it simply returns the best element in the path. It is different only when the standard pathrelinking is unsuccessful, in which case it tries to increase diversity by selecting a solution other than the extremes of the path. Note that path-relinking is very similar to the local search procedure described earlier, with two main differences. First, the number of allowed moves is restricted: only elements in S2 \ Slcan be inserted, and only those in S1\ S2can be removed. Second, non-improving moves are allowed. These differences are easily incorporated into the basic implementation of the local search procedure. The intensification procedure is augmented by performing a full local search on the solution produced by path-relinking. Because this solution is usually very close to a local optimum, this application tends to be much faster than on a solution generated by the randomized constructive algorithm. A side effect of applying local search at this point is increased diversity, since one is free to use facilities that did not belong to any of the original solutions. The plots in Figure 2.8 compare GRASP with path-relinking and pure GRASP on the 1400-facility, 1400-user TSPLIB instance f11400. The plot on the left shows quality of the best solution found as a fraction of the average value of the first solution for GRASP with path-relinking and pure GRASP for p = 500. Times are given as multiples of the average time required to perform one multi-start iteration. Smaller values are better. The plot on the right shows ratios between partial solutions found with and without path-relinking for different values of p. Ratios smaller than 1.000 favor the use of path-relinking. The plots show that GRASP benefits from path-relinking, in particular for large values of p.

2.4.4

Three index assignment problem

The three-index assignment problem (AP3) was introduced by Pierskalla [33] as an extension of the classical two-dimensional assignment problem. Consider a complete tripartite graph Kn,,,, = (IU J U K , (Ix J) U (I x K ) U (J x K)),where I,J, and K are disjoint sets of size n.


10 centers 25 centers ....... 50 centers ........ 75 centers ........... 100 centers 250 centers .... 500 centers ........ 1.002 1.001

f

,a -

: .--- -- - ----.

1.000

m

.

u

_ __ .._.. ... .. . . 0.997

........

.....................

..

i

.......:........ .:

%

........................................................................... "

I"

..,, . .. ... .. ....'..... .......................................................

,

o.998

0.995

2

20

40

60

.............

.......................... 80

100

relative time

Figure 2.8. GRASP with path-relinking versus pure GRASP on TSPLIB instance f11400.

If a cost ~ , j , kis associated with each triplet (i,j , k) E I x J x K , then the AP3 consists of finding a subset A E I x J x K of n triplets such that every element of I U J U K occurs in exactly one triplet of A, and the sum of the costs of the chosen triplets is minimized. The AP3 is

GRASP with path-relinlcing NP-hard [21, 221. A permutation-based formulation for AP3 is

where TN denotes the set of all permutations of the set of integers N = {1,2,.. . ,n}. Aiex [I] and Aiex et al. [3] describe a GRASP with path-relinking for AP3. Computational results show clearly that this GRASP for AP3 benefits from path-relinking and compares well with previously proposed heuristics for this problem. GRASP with path-relinking was able to improve the solution quality of heuristics proposed by Balas and Saltzman [6], Burkard et al. [8], and Crama and Spieksma [ll]on all instances proposed in those papers. The GRASP construction phase builds a feasible solution S by selecting n triplets, one at a time. The solution S is initially empty and the set C of candidate triplets is initially the set of all triplets. To select the pth triplet (p = 1,. . . ,n - 1) to be added to the solution, a restricted candidate list C' is defined to include all triplets (i,j, k) in the candidate c a(E- c), where set C having cost cijk I

+

c = min{cijk -

I (i,j, k) E C)

I

and E = max{cijk (i,j, k) E C).

Triplet (i,, j,, k,) E C' is chosen at random and is added to the solution, i.e. S = SU{(i,, j,, k,)). Once (i,, j,, k,) is selected, the set of candidate triplets must be adjusted to take into account that (i,, j,, Ic,) is part of the solution. Any triplet (i, j, k) such that i = i, or j = j, or k = kp is removed from the current set of candidate triplets. After n - 1 triplets have been selected, the set C of candidate triplets contains one last triplet which is added to S, thus completing the construction phase. In the local search procedure, the current solution is improved by searching its neighborhood for a better solution. The solution of the AP3 can be represented by a pair of permutations (p, q). For a solution p, q E TN, the 2-exchange neighborhood is N2(p,q) = {p', q' I d(p,pl) d(q, q') = 2)) where d(s, s') = I {i I s(i) # sl(i))l. In the local search, each cost of a neighborhood solution is compared with the cost of the current solution. If the cost of the neighbor is lower, then the solution is updated, the search is halted, and a search in the new neighborhood is initialized. The local search ends when no neighbor of the current solution has a lower cost than the current solution. Path-relinking is done between an initial solution

+

54


and a guiding solution

Let the symmetric difference between S and T be defined by the following two sets of indices:

and

S K = { i = 1,..., n

I @#@}.

An intermediate solution of the path is visited at each step of pathrelinking. Two elementary types of moves can be carried out. In a type-one move, triplets

are replaced by triplets

In a type-two move, triplets

Set S J guides type-one moves, while SK guides type-two moves. For all i E SJ, let q be such that j: = j f . A type-one move replaces triplets

For all i E SK, let q be such that IC? = @. A type-two move replaces triplets -s S .S s {(i,& M q J q ,kq)}

At each step, the move that produces the least costly solution is selected and the corresponding index is deleted from either S J or SK. This process continues until there are only two move indices left in one of the sets S J or SK. At this stage, any of these two moves results in the

GRASP with path-relinking Balas 8 Salhman24.1

time (seconds) Balas 8 Salkman 24.1

time (seconds)

Figure 2.9. The plot of the left shows empirical probability distributions of time to target value for GRASP and GRASP with path-relinking (random selection of one guiding solution from elite set). The plot of the right shows empirical probability distributions of time to target value for different variants of GRASP with path-relinking.

guiding solution and, therefore, are not carried out. The best solution found in the path is returned by the procedure. The plots in Figure 2.9 illustrate how GRASP with path-relinking compares with pure GRASP and how different variants of GRASP with path-relinking compare. The variants of GRASP with path-relinking tested were: random selection of one guiding solution [GPR(RAND)]; random selection of one guiding solution and periodic relinking of all elements in pool [GPR(RAND,INT)];selection of all pool elements as guid-

56


ing solutions [GPR(ALL)]; and selection of all pool elements as guiding solutions with periodic relinking of all elements in pool [GPR(ALL,INT)]. The algorithms were run 200 times (using different initial seeds for the random number generator) on instance 24.1 of Balas and Saltzman [6], stopping when a solution value better than a given target value was found. The experiment comparing pure GRASP with GRASP with path-relinking used a target value of 17, while the one comparing the different variants of GRASP with path-relinking used a more difficult target value of 7. The plot on the left shows the benefit of using pathrelinking in GRASP. The plot on the right shows that the variants using path-relinking with all elite solutions have a higher probability of finding a target solution in a given amount of time than the variants that use path-relinking with a single randomly selected elite solution. The use of periodic intensification does not appear to influence the distributions as much.

2.5

CONCLUSIONS AND EXTENSIONS

This paper reviewed recent advances and applications of GRASP with path-relinking. By providing a short discussion of each component of GRASP with path-relinking and showing examples of how such heuristics can be implemented for combinatorial optimization problems such as PVC routing, 2-path network design, 3-index assignment, and pmedian, we hope this paper will serve as a guide for the reader to put together other GRASP with path-relinking heuristics. Path-relinking is a major enhancement to the basic greedy randomized adaptive search procedure (GRASP), leading to significant improvements in both solution time and quality. It adds an effective memory mechanism to GRASP by providing an intensification strategy that explores trajectories connecting GRASP solutions and the best elite solutions previously produced during the search. The numerical results summarized for the four problems listed above clearly illustrate the benefits obtained by the combination of GRASP with path relinking. In evolutionary path-relinkzng used in the post-optimization intensification phase, a new generation of elite solutions is generated from the current population in the pool of elite solutions by applying pathrelinking between all pairs of solutions in this population. Solutions obtained by each path-relinking operation are tested for inclusion in the population of the next generation following the usual rules used in pool management. This strategy was successfully used for the Steiner problem in graphs by Ribeiro et al. 1501, for the pmedian problem by Resende

G R A S P with path-relinking

57

and Werneck [44], and for the uncapacitated facility location problem by Resende and Werneck [46]. Path-relinking may also be used as a solution extractor for population methods. In particular, path-relinking was recently successfully applied as a generalized crossover strategy to generate optimized offsprings in the context of a genetic algorithm for the phylogeny problem [51]. The fact that the computation time to find a target solution value using GRASP with path-relinking fits a two-parameter exponential distribution (cf. Section 2.3, see [I,2, 41) has a major consequence in parallel implementations of GRASP with path-relinking: linear speedups proportional to the number of processors can be easily observed in parallel independent strategies. Additionally, path-relinking offers a very effective mechanism for the implementation of parallel cooperative strategies [12]. In this case, inter-processor cooperation is enforced by a master processor which stores and handles a common pool of elite solutions which is shared by all slave processors performing GRASP with path-relinking. Careful implementations making appropriate use of the computer resources may lead to even larger speedups and to very robust parallel algorithms, see e.g. [31, 48, 49, 521. Results obtained for the 2-path network design problem are illustrated in Figure 2.10, showing the speedup obtained by the cooperative strategy with respect to the independent one on a cluster of eight processors. Much larger improvements can be obtained with more processors. Finally, we notice that path-relinking can also be successfully used in conjunction with implementations of other metaheuristics such as VNS and ant colonies, as recently reported e.g. in [5, 171.

ACKNOWLEDGMENTS Most of this work is part of their dissertations and was jointly done with the following currently and former M.Sc. and Ph.D. students from the Catholic University of Rio de Janeiro, Brazil, which are all gratefully acknowledged: R.M. Aiex, S.A. Canuto, S.L. Martins, M. Prais, I. Rosseti, M.C. Souza, E. Uchoa, D.S. Vianna, and R.F. Werneck.

REFERENCES [I] R.M. Aiex. Uma investigap?~experimental da distribui@io de probabilidade de tempo de s o l u ~ 6 oe m heum'sticas G R A S P e sua aplicapZo nu ancilise de implementa~6esparalelas. PhD thesis, Department

58


Figure 2.10. Probability distributions of time-to-target-value on an instance of the 2-path network design problem for cooperative and independent parallel implementations of GRASP with path-relinking on a Linux cluster with eight processors.

of Computer Science, Catholic University of Rio de Janeiro, Rio de Janeiro, Brazil, 2002. [2] R.M. Aiex, S. Binato, and M.G.C. Resende. Parallel GRASP with path-relinking for job shop scheduling. Parallel Computing, 29:393430, 2003. [3] R.M. Aiex, M.G.C. Resende, P.M. Pardalos, and G. Toraldo. GRASP with path relinking for the three-index assignment problem. Technical report, AT&T Labs Research, Florham Park, NJ 07733, 2000. To appear in INFORMS J. on Computing. [4] R.M. Aiex, M.G.C. Resende, and C.C. Ribeiro. Probability distribution of solution time in GRASP: An experimental investigation. Journal of Heuristics, 8:343-373, 2002. [5] D.J. Aloise, D. Aloise, C.T.M. Rocha, C.C. Ribeiro, Jos6 C. Ribeiro Filho, and Luiz S.S. Moura. Scheduling workover rigs for onshore oil production. Discrete Applied Mathematics, to appear. [6] E. Balas and M.J. Saltzman. An algorithm for the three-index assignment problem. Oper. Res., 39: 150-161, 1991.


59

[7] S. Binato, H. Faria Jr., and M.G.C. Resende. Greedy randomized adaptive path relinking. In J.P. Sousa, editor, Proceedings of the I V Metaheuristics International Conference, pages 393-397, 2001. [8] R.E. Burkard, R. Rudolf, and G.J. Woeginger. Three-dimensional axial assignment problems with decomposible cost coefficients. Discrete Applied Mathematics, 65:123-139, 1996. [9] S.A. Canuto, M.G.C. Resende, and C.C. Ribeiro. Local search with perturbation for the prize-collecting Steiner tree problems in graphs. Networks, 38:50-58, 2001. [lo] G. Cornuejols, M. L. Fisher, and G. L. Nemhauser. Location of bank accounts to optimize float: An analytical study of exact and approximate algorithms. Management Science, 23:789-810, 1977. [ll]Y. Crama and F.C.R. Spieksma. Approximation algorithms for

three-dimensional assignment problems with triangle inequalities. European Journal of Operational Research, 60:273-279, 1992. [12] V.-D. Cung, S.L. Martins, C.C. Ribeiro, and C. Roucairol. Strategies for the parallel implementation of metaheuristics. In C.C. Ribeiro and P. Hansen, editors, Essays and Surveys in Metaheuristics, pages 263-308. Kluwer Academic Publishers, 2002. [13] G. Dahl and B. Johannessen. The 2-path network problem. Networks, 43:190-199, 2004. [14] T.A. Feo and M.G.C. Resende. A probabilistic heuristic for a computationally difficult set covering problem. Operations Research Letters, 8:67-71, 1989. [15] T.A. Feo and M.G.C. Resende. Greedy randomized adaptive search procedures. Journal of Global Optimization, 6:109-133, 1995. [16] T.A. Feo, M.G.C. Resende, and S.H. Smith. A greedy randomized adaptive search procedure for maximum independent set. Operations Research, 42:860-878, 1994. [17] P. Festa, P.M. Pardalos, M.G.C. Resende, and C.C. Ribeiro. Randomized heuristics for the max-cut problem. Optimization Methods and Software, 7:1033-1058, 2002. [18] P. Festa and M.G.C. Resende. GRASP: An annotated bibliography. In C.C. Ribeiro and P. Hansen, editors, Essays and surveys on metaheuristics, pages 325-367. Kluwer Academic Publishers, 2002. [19] C. Fleurent and F. Glover. Improved constructive multistart strategies for the quadratic assignment problem using adaptive memory. INFORMS Journal on Computing, 11:198-204, 1999.

60


[20] B. Fortz and M. Thorup. Internet traffic engineering by optimizing ospf weights. In Proc. IEEE INFOCOM 2000 - The Conference on Computer Communications, pages 519-528, 2000. [21] A.M. Frieze. Complexity of a 3-dimensional assignment problem. European Journal of Operational Research, 13:161-164, 1983. [22] M.R. Garey and D.S. Johnson. Computers and intractability - A guide to the theory of NP-completeness. W.H. Freeman and Company, 1979. [23] F. Glover. Tabu search and adaptive memory programing - Advances, applications and challenges. In R.S. Barr, R.V. Helgason, and J.L. Kennington, editors, Interfaces in Computer Science and Operations Research, pages 1-75. Kluwer, 1996. [24] F. Glover. Multi-start and strategic oscillation methods - Principles t o exploit adaptive memory. In M. Laguna and J.L. GonzblesVelarde, editors, Computing Tools for Modeling, Optimization and Simulation: Interfaces in Computer Science and Operations Research, pages 1-24. Kluwer, 2000. [25] F. Glover and M. Laguna. Tabu Search. Kluwer, 1997. [26] F. Glover, M. Laguna, and R. Marti. Fundamentals of scatter search and path relinking. Control and Cybernetics, 39:653%684, 2000. [27] 0. Kariv and L. Hakimi. An algorithmic approach to nework location problems, Part 11: The pmedians. SIAM Journal of Applied Mathematics, 37:539-560, 1979. [28] M. Laguna and R. Marti. GRASP and path relinking for 2-layer straight line crossing minimization. INFORMS Journal on Computing, 11:44-52, 1999. [29] Y. Li, P.M. Pardalos, and M.G.C. Resende. A greedy randomized adaptive search procedure for the quadratic assignment problem. In P.M. Pardalos and H. Wolkowicz, editors, Quadratic assignment and related problems, volume 16 of DIMACS Series on Discrete Mathematics and Theoretical Computer Science, pages 237-261. American Mathematical Society, 1994. [30] S.L. Martins, P.M. Pardalos, M.G.C. Resende, and C.C. Ribeiro. Greedy randomized adaptive search procedures for the steiner problem in graphs. In P.M. Pardalos, S. Rajasekaran, and J. Rolim, editors, Randomization methods in algorithmic design, volume 43 of DIMACS Series on Discrete Mathematics and Theoretical Computer Science, pages 133-145. American Mathematical Society, 1999.


61

[31] S.L. Martins, C.C. Ribeiro, and I. Rosseti. Applications and parallel implementations of metaheuristics in network design and routing. Lecture Notes in Computer Science, 3285:205-213, 2004. [32] C.A. Oliveira, P.M. Pardalos, and M.G.C. Resende. GRASP with path-relinking for the QAP. In Toshihide Ibaraki and Yasunari Yoshitomi, editors, Proceedings of the Fifth Metaheuristics International Conference, pages 57-1 - 57-6, 2003. [33] W.P. Pierskalla. The tri-subsitution method for the threemultidimensional assignment problem. CORS J., 5:71-81, 1967. [34] M. Prais and C.C. Ribeiro. Reactive GRASP: An application to a matrix decomposition problem in TDMA traffic assignment. INFORMS Journal on Computing, 12:164-176, 2000. [35] M. G. C. Resende and R. F. Werneck. On the implementation of a swap-based local search procedure for the pmedian problem. In R. E. Ladner, editor, Proceedings of the Fifth Workshop on Algorithm Engineering and Experiments (ALENEX'O3), pages 119-127. SIAM, 2003. [36] M.G.C. Resende. Computing approximate solutions of the maximum covering problem using GRASP. Journal of Heuristics, 4:161171, 1998. [37] M.G.C. Resende, T.A. Feo, and S.H. Smith. Algorithm 787: Fortran subroutines for approximate solution of maximum independent set problems using GRASP. ACM Transactions on Mathematical Software, 24:386-394, 1998. [38] M.G.C. Resende, P.M. Pardalos, and Y. Li. Algorithm 754: Fortran subroutines for approximate solution of dense quadratic assignment problems using GRASP. ACM Transactions on Mathematical Software, 22:104-118, 1996. [39] M.G.C. Resende, L.S. Pitsoulis, and P.M. Pardalos. Fortran subroutines for computing approximate solutions of MAX-SAT problems using GRASP. Discrete Applied Mathematics, 100:95-113, 2000. [40] M.G.C. Resende and C.C. Ribeiro. A GRASP for graph planarization. Networks, 29:173-189, 1997. [41] M.G.C. Resende and C.C. Ribeiro. A GRASP with path-relinking for private virtual circuit routing. Networks, 41:104-114, 2003. [42] M.G.C. Resende and C.C. Ribeiro. GRASP and path-relinking: Recent advances and applications. In Toshihide Ibaraki and Yasunari Yoshitomi, editors, Proceedings of the Fifth Metaheuristics International Conference, pages T6-1 - T6-6, 2003.

62


[43] M.G.C. Resende and C.C. Ribeiro. Greedy randomized adaptive search procedures. In F. Glover and G. Kochenberger, editors, Handbook of Metaheuristics, pages 219-249. Kluwer Academic Publishers, 2003. [44] M.G.C. Resende and R.F. Werneck. A GRASP with path-relinking for the p-median problem. Technical Report TD-5E53XL, AT&T Labs Research, 2002. [45] M.G.C. Resende and R.F. Werneck. A hybrid heuristic for the pmedian problem. Journal of Heuristics, 10:59-88, 2004. [46] M.G.C. Resende and R.F. Werneck. A hybrid multistart heuristic for the uncapacitated facility location problem. European Journal of Operational Research, to appear. [47] C.C. Ribeiro and M.G.C. Resende. Algorithm 797: Fortran subroutines for approximate solution of graph planarization problems using GRASP. ACM Dansactions on Mathematical Software, 25:341352, 1999. [48] C.C. Ribeiro and I. Rosseti. A parallel GRASP for the 2-path network design problem. Lecture Notes in Computer Science, 2004:922-926, 2002. [49] C.C. Ribeiro and I. Rosseti. Efficient parallel cooperative implementations of GRASP heuristics. Technical report, Catholic University of Rio de Janeiro, Rio de Janeiro, Brazil, 2005. [50] C.C. Ribeiro, E. Uchoa, and R.F. Werneck. A hybrid GRASP with perturbations for the Steiner problem in graphs. INFORMS Journal on Computing, 14:228-246, 2002. [51] C.C. Ribeiro and D.S. Vianna. A genetic algorithm for the phylogeny problem using an optimized crossover strategy based on path-relinking. Revista Tecnologia da Informaqa"~,3(2):67-70,2003. [52] I. Rosseti. Heum'sticas para o problema de sintese de redes a 2caminhos. PhD thesis, Department of Computer Science, Catholic University of Rio de Janeiro, Rio de Janeiro, Brazil, July 2003. [53] M.C. Souza, C. Duhamel, and C.C. Ribeiro. A GRASP with pathrelinking heuristic for the capacitated minimum spanning tree problem. In M.G.C. Resende and J. Souza, editors, Metaheuristics: Computer Decision Making, pages 627-658. Kluwer Academic Publishers, 2003. [54] M. B. Teitz and P. Bart. Heuristic methods for estimating the generalized vertex median of a weighted graph. Operations Research, 16:955-961, 1968.


63

[55] R. Whitaker. A fast algorithm for the greedy interchange of largescale clustering and median location prolems. INFOR, 21:95-108, 1983.

Chapter 3

A TABU SEARCH HEURISTIC FOR A UNIVERSITY TIMETABLING PROBLEM Halvard Arntzen and Arne Lokketangen Department of Informatics, Molde College, Box 2110, 6402 Molde, Norway (halvard.arntzen,arne.lokketangen)@hirnolde.no

Abstract: This paper describes a heuristic algorithm designed in connection with the 2003 International Timetabling Competition organized by the Metaheuristics Network. The problem posed in the competition was to develop an algorithm for solving university timetabling problems as described below. 20 test instances were provided and the competing algorithms were evaluated according to the overall performance on these 20 cases. Our algorithm uses an adaptive memory search to improve the quality of an initial solution. The search is guided by adaptive tabu search mechanisms. In addition to a description of our method we focus on the observed effectiveness of some of the mechanisms that we employ. Behavioral aspects and computational results are reported.

Keywords: Timetabling, combinatorial optimization, tabu search.

3.1

INTRODUCTION

Practical scheduling and timetabling problems frequently lead to very hard combinatorial optimization problems, where one has to rely on heuristic solution methods. Tabu search (Glover and Laguna (1997)) has been used successfully in a variety of timetabling problems. General references to various practical and theoretical aspects of timetabling are the proceedings from the PATAT conferences, edited by Burke et. al. The 2003 timetabling competition was announced in 2002 by the Metaheuristics Network (http://www.metaheuristics.net/). The given challenge was to develop an algorithm for solving instances from a class of course timetabling problems within a fixed time limit. Ten test in-

66


stances were available from the beginning, and another ten were released two weeks before the deadline. All details about the competition and the test instances can be found on the competition homepage: http://www.idsia.ch/Files/ttcomp2002/. There were 21 participants who succeeded in finding feasible solutions to all test instances. The results we submitted gave us the fifth place in the competition, but we were at that time not satisfied with the performance of the algorithm. In this paper we present a strongly improved algorithm for the same problem and new results for the 20 test instances. The presentation focuses on a description of the method and a study of certain aspects of the behavior of the method. In particular, we have tested the efficiency of two particular local search mechanisms, and report results of these tests. The paper is organized as follows. Section 3.2 specifies the general form of the problem. Section 3.3 overviews the method we use. In section 3.4 a description of an initial solver is given together with some results on the behavior of this solver. In section 3.5 the different components of the tabu search method is presented. We present results from tests of two mechanisms in section 3.6, and general computational results are given in section 3.7. Finally there are concluding remarks in section 3.8.

3.2

PROBLEM DESCRIPTION

The problem we consider is to find a best possible (to be made precise after the definition~below) timetable within the following framework. There are 45 available timeslots, TI, T2,. . . ,Td5, nine for each day in a five day week. At any timeslot, there are NR available rooms R1, R2,. . . ,RNR . Each room has a given size, which is the maximum number of students the room can take. We are given a set of NE events El, E2,.. . ,ENE.Each event Ej has a set of attending students, Sj . Finally there is a set of room features Fl,F2,. . . ,FNF.Each room possesses some of these features, whereas each event requires some features. We will use the term place when we speak of a timeslot/room combination, i.e. a place is a pair P = (Tk,Rj). With this terminology, we seek to assign each event to a suitable place. We have a feasible solution to the problem if we have assigned all events to places, such that the following four hard constraints are satisfied: (Cl) No student attends more than one event in the same timeslot. (C2) No event has more students than allowed in the chosen room. (C3) All features required by an event are possessed by the chosen room. (C4) No place has more than one event assigned to it.

Tabu search for timetabling problem

67

To measure the quality of a feasible solution there are three soft constraints. Each violation of each of these gives a penalty point to the solution. The three possible violations are

(Vl) A student has a class in the last timeslot on a day. (V2) A student has more than two classes in a row. (V3) A student has only a single class in a day. Concerning (V2), a student has " k classes in a row" if the student attends events assigned to k consecutive timeslots. Violations of type (V2) are counted as follows. If we have a solution where a student somewhere has three classes in a row we count this as one violation. If a student somewhere has four classes in a row we count this as two violations etc. We will refer to the three types of violations as lastslot violations, serial violations, and once-in-a-day violations. The value of a feasible solution is the total number of soft constraint violations in the solution. This of course means that a solution with a lower value is better. The problem may now be precisely formulated: Given rooms, events, etc. as described above, find the best possible feasible solution within a given time limit. The rest of this paper describes a heuristic algorithm designed to solve this timetabling problem, and some computational results obtained with it.

Test instances. In the contest instances there are typically 10 rooms, hence there are 450 available places. There are typically 350400 events, 5 -10 features and 200 - 300 students. In some instances all rooms are almost equal in size and in some others the sizes vary much, for example ranging from 3 to 43 in one instance. Data for some of the test instances are given in table 3.1. Here NE,NS,NR and NF denotes the number of events, students, rooms and features respectively. Some of the events in some instances are empty, i.e. without students. It was known in advance that all the test instances has solutions with no soft constraint violations.

3.3

SOLUTION ALGORITHM

The algorithm consists basically of two parts. The first part builds a feasible solution from scratch. After an initial feasible solution is found, we employ an adaptive tabu search method to improve the solution quality by moving events around.

68


Table 3.1. Data for some test instances.

Definitions. The following definitions are used when we describe the details of the algorithm. For a given event E we say that a place P = (T,R) is a possible place for E, if E can be assigned to P without violating any hard constraints. For a given place P we say that an event E is a fitting event for P if E can be assigned to P without violating any of the three first hard constraints. This of course means that P is a possible place for E if and only if E is a fitting event for P and P is not occupied by another event.

3.4

CONSTRUCTIVE SOLVER

Our method requires that we must first find an initial feasible solution as a starting point for the local search. The initial solution is constructed by sequential assignment of events to places. The most important aspect of this phase is to obtain feasibility, although the constructive method also have a focus on solution quality. In particular we found that which kind of soft constraint violation was dominant in the initial solution could be controlled to some extent by changing the parameter settings used for the initial solver. The scheme for the construction is as follows.

1. Make a list L containing all unassigned events. (At first L contains all events.) 2. Pick the event E in L with fewest possible places. If there is not a unique event having fewest possible places, choose randomly among the events with fewest possible places. 3. Find a place for E. This is done as follows. Let K be the list of all possible places for E. for each P E K let q = (ql, 92,. . . ,q5) be defined as follows: ql = The number of unassigned fitting events for P. q:! = The number of taken rooms in the same timeslot as P.

Tabu search for timetabling problem q3 = The change in the number of lastslot violations created by assigning E to P. q4 = The change in the number of serial violations created by assigning E to P. q5 = The change in the number of once-in-a-day violations created by assigning E to P. One should note that q5 may be negative, since assigning E to P may actually remove once-in-a-day violations. The other numbers qj will always be nonnegative. For a vector w = (wl, w2,. . . ,w5) of weights, pick the place P E K that minimizes

If no unique P minimizes wq, a random selection is made from the minimizing places. 4. Assign E to the chosen place P. Update information about possible places and fitting events. Remove E from the list L. If L is not empty, return to step 2. If L is empty, we have a feasible solution.

5. If the process outlined in steps 1-4 fails, in the sense that at some point we have an unassigned event E with no possible place, the process is restarted, with a different random seed. The weights used in the selection above gives some control on the sequence of assignments made. Note that the weights fall naturally in two categories. The first two, wl, w2 are related to feasibility of the resulting solution, whereas wg, wq, w5 are related to the quality of the solution. We use the terms guidance weights for wl, w2 and penalty weights for w3, w4, w5.

Deciding parameter values. The values of the solutions found with the initial solver is strongly dependent on the parameter values used, so some testing was done to find parameter values that give good initial solutions for all the 20 test cases. First a test was conducted to determine values for the penalty weights w3, w4, w5. With wl = w2 = 1 fixed we varied the penalty weights using every combination of the values 0,1,3,7,30,100, lo4, lo6. For each combination, 10 runs were executed with different random seed. This was repeated on a selection of test cases. In all cases we observed large variation of the resulting values. The general pattern we saw was that better values tended to come in runs where w3 and w4 was both larger than 30 while ws was less than 10% of

70


the smallest of w3 and w4. For the runs where ws = 1 we tended to get very similar results with the other two weights being either 30,100, lo4 or lo6. Based on this we decided to use values 50, 50, 1 for w3, w4, ws. Then a similar test was used to determine good values for the guidance weights, and we ended up with wl = 1 and w2 = 0. The parameter w2 could not be seen to have any significant impact on the value of the initial solution, thus we decided on the value w2 = 0. It could well be that this parameter turns out to be important if the initial solver is tried on denser test cases, where the feasibility problem is harder. This is one reason for keeping the parameter in the method, even though it was not important for the given test cases.

General results on the initial solver. The scheme outlined above usually finds a feasible solution in less than a second. A restart of the method is required in less than 5% of the runs. There is one reason why the initial solver is so successful in finding feasible solutions. Note that all test instances has feasible solutions not using the last-in-a-day timeslots at all. Hence, when initially we allow the use of all timeslots, we have a feasibility problem which is usually much easier. For denser or more constrained problems there is a possibility to modify the initial solver so that information gathered in a failed attempt at creating a complete timetable can be used in subsequent restarts. See LQkketangenand Glover (1997) for examples of such strategies. With the parameter settings above, the value of our initial solutions range from approximately 350 for the easier instances up to about 700 for the harder ones. When performing many runs with different random seed on the same test instance we find solution values varying about a mean, with a standard deviation less than 10% of this mean value. The distribution of penalties between the three types of violations is also instance dependent. We find that the contribution from lastslot violations ranges from 5 to 50%, serial violations contribute with 40 to 70% and once-in-a-day violations contribute with 5 to 20% of the total penalty in the initial solution. Moreover, when a series of runs are performed on a fixed instance with different random seed, there is still large difference between the distribution of violations for different solutions. Figure 3.1 shows the observed proportions of penalties due to the three kinds of violations for 20 runs on each of the first 8 test instances. The plots show how these proportions vary between the instances, and also between individual runs. For the sake of comparison, also a plot of these proportions in solutions obtained after 480 seconds of local search is included in figure 3.2. There is on the average a slightly larger proportion of serial violations in the final solutions, and slightly lower proportions

Tabu search for timetabling problem Pmpmtion of b l o t violations in initial solution

Propmiion of&l initial solution

I

71 violations in

0,8

propdon o f o m m a d a y violations

I

Figure 3.1. Proportions of soft constraint violations in the initial solution. Pmpoaionof b l o t violationsin final solution

f,

Pmpmtim of mcsin-aday violations infinal solutim

Propntionof serial violations in 1#

, final solutim

I

I

,: ' :

0.1

! :

0.0 1

2

3

4

5

0

1

8

Ins$nce

Figure 3.2. Proportions of soft constraint violations in the final solution.

of lastslot- and once-in-a-day violations. The proportions seems to be even more variable in the final solution when comparing different runs on the same instance.

Using parameters to control violations. The fact that the weights w3, w4, w5 directly penalizes the creation of each of the three types of violations gives an option to control to some extent the distribution of the violation types by playing with these parameters. As a simple illustration of this we used the constructive solver on instance 4 using first w3 = 30, w4 = 1 and then w3 = 30, w4 = 10000, in both cases keeping the other three weights fixed at low values. In figure 3.3 the distribution of lastslot violations in the initial solution is shown for a series of runs. The left histogram corresponds to w3 = 30, w4 = 1 and the right one corresponds to w3 = 30, w4 = 10000. In figure 3.4 we show the distribution of serial violations, where the left and right histogram corresponds to the same parameter values as in figure 3.3. We see that the ratio between the parameters w3 and w4 has substantial impact on the presence of the two kinds of violations in the initial solution found. The measure of solution quality that we use gives exactly the same penalty for all three kinds of violation, but one can easily


I

lastslot violations

lastslot violations

Figure 3.3. Lastslot violations. Left: w3 = 30, w4 = 1, right: w3 = 30, w4 = lo4

imagine that other (real world) problems involve a measure of solution quality where penalties are different for the different type of violation, based on the preferences or needs of the decision maker. In such problems it would of course be desirable to try to avoid in particular the hardest penalized violation. We have in fact obtained initial solutions completely free from lastslot violations, but only in a very few runs on one of the instances. Another use of this option to control the distribution of violation type is that it makes it possible to rapidly produce a set of initial solutions, containing substantially different solutions. This could be useful for multistart approaches, and possibly also for population based methods where it can be important to have a diverse initial population. Scatter search (Laguna and Marti (2003)) and genetic algorithms are examples of population based methods. For applications of genetic algorithms to course timetabling see Carrasco and Pato (2000) and Erben and Keppler (1995). Let us finally remark that hard penalizing of the once-in-a-day violations by using a large value for w5, tend to give significantly poorer solutions, compared to using moderate or no penalizing. In particular, also the number of once-in-a-day violations increases substantially when w5 is the dominant weight. Relation between initial and final values. One may ask whether the value of the initial solution really affects the value of the overall best solution found after the local search phase. For our method there seems to be very little dependency between the initial and final value if we let the search go on for some time. The plot in figure 3.5 shows values of the best solution found after 90 seconds of local search plotted against the values for the corresponding initial solution, for test instance nr. 1.


I

serial violations

serial violations

Figure 3.4. Serial violations. Left: ws = 30, w4 = 1, right: w3 = 30, w4 = lo4

Final values versus initial values 1901

LL --. 2

300

400

500

600

700

I

8

800

900

-___,-A 1000

1100

1200

Initial value

Figure 3.5. Instance 1.

The large difference in initial values here is due to the use of a variety of values for the parameters of the initial solver. The plot shows that there are virtually no dependence between the initial values and values after 90 seconds of local search. The reason for this is that the first phase of the local search rapidly improves solution quality even for the best initial solutions we find. As an example, for test instance 1,we get initial values ranging from 350 up to 1300. When applying the local search, we see that solution values are quickly decreasing to about 200, where there seems to be a limit for the very rapid improvement of solution quality. This behavior is typical regardless of initial value, the only difference is of course that it takes some more time to go from 1300 to 200 than from 350 to 200.

74


3.5

LOCAL SEARCH

To improve upon the initial solution we use an adaptive tabu search variant. We use two types of moves, and a reactive procedure to adjust the tabu tenure. The overall structure of the search is as follows. 1 Start with an initial solution s.

2 Examine solutions s' in a neighborhood N ( s ) of s. 3 Move to a selected solution s' E N ( s ) .

4 Set s = s' and register if s is the best solution found so far. 5 Regularly inspect the recent history of the search to detect signs of stagnation or rapid fluctuation in solution values. Adjust the tabu tenure based on what signs are found. If the process runs for a long time without making improvements, adjust other relevant search parameters. 6 If there is more time left, return to step 2.

7 At the end of the time limit, return to the best found solution and do a greedy search from there. The various components of the method are discussed in the following paragraphs.

Moves and move neighborhood. We denote by s a feasible solution to the problem, that is, a complete timetable satisfying all hard constraints. To examine a part of the solution space surrounding s we use the following types of moves. Relocate move: Take one event E and move to a different place. Swap move: Take two events Ei,Ej and interchange their places.

A move is then either a relocate move or a swap move. Only moves preserving feasibility are considered throughout the search. For a solution s we have different neighborhoods:

Nrel( s ) ,consisting of all solutions reachable from s by one relocate move. NSwq(s),consisting of all solutions reachable from s by one swap move, and N ( s ) = Nrel( s )U Nswq ( s )consisting of all solutions reachable from s by one move of either type.


75

Let V(s) denote the value of a solution s. When performing a move, we get a different solution sf. The value of the move is the change in solution value i.e. V(sl) - V(s). This means for example that a move with value -1 slightly improves solution quality.

Tabu criterion. To keep the search process from getting stuck in local minima we employ a tabu criterion for events using a variable tabu tenure. One basic component of this is what we call the dynamic tabu tenure Td. This value is adjusted frequently, using rules discussed below. If an event E is involved in a relocate move we assign to it an event specijk tabu tenure TE which is simply TE = Td + r where r is a random integer in the range [-10,101. If two events Ei,Ej are involved in a swap move, we assign to them event specific tabu tenures by the rule TEi = Td r, TEj = Td - r. When the event E is given the tabu tenure TE, we mark the event as tabu until TE new moves are performed. The tabu status is used to exclude recently moved events from being involved in new moves in the following way.

+

Relocate move: If an event E is marked tabu, it can not be involved in a relocate move, unless a relocate move leads to a new overall best solution. Swap move: If both events Ei,Ej are marked tabu, they can not be swapped. This means that relocate moves can be selected by the aspiration criterion of finding a new best solution, and that a tabu marked event Ei can be involved in a swap move only if it swaps with a nontabu event Ej.

Move selection. At each iteration we select what move(s) to do as follows. (Here "best move" means the move with lowest move value) 1 For each event E evaluate all possible relocate moves involving E and register the best relocate move for E. Ignore moves that place E in the last timeslot of a day. If more than one move gives the best value, make a random choice between the best moves. 2 Make a list RelocCand containing, for each event, the best relocate move found. This list normally also contains moves with events marked tabu.

3 For each event E evaluate all possible swap moves involving E and register the best swap move for E. If more than one move gives the best value, make a random choice between the best moves.

Metaheuristics: Progress as Real Problem Solvers 4 Make a list SwapCand containing for each event, the best possible swap move found. This list contains only swaps with at most one event marked tabu. 5 Select a relocate move BestRelMove from RelocCand. This is either the overall best move in RelocCand, if this improves on the current best solution value. Otherwise it is the best move in RelocCand involving a nontabu event. (Using random selection if there are several equally good moves.)

6 Select a swap move BestSwapMove from SwapCand. This is simply the best move in SwapCand. (Using random selection if there are several equally good moves.) 7 There are two places Pfr, and Ptoassociated with BestRelMove and two places PA,PB associated with BestSwapMove. If Pfrom and Pto are in other days than PA,PB, select both moves. If the days collide, select BestSwapMove if it is strictly better than BestRelMove. Otherwise select BestRelMove.

Remark: The move selection scheme implements two particular mechanisms to possibly improve the efficiency of the search. In point 1, note that any relocate move taking an event to a timeslot in the end of a day is prohibited. We call this lastslot locking. In point 7, note that under certain circumstances we perform two moves after one round of move evaluations. We call this a double move option. If the two moves involve separate days, it is easy to update solution value based on the values of the two moves, otherwise the whole resulting solution would have to be (timeconsumingly) re-evaluated. This is the reason for not always performing both moves. Each time a move is performed, an iteration counter is increased by 1, and when the double move option is used, the iteration counter is increased by 2.

Adjusting the dynamic tabu tenure. The value of the dynamic tabu tenure Td is updated every Ntt iterations, and the adjustment is based on the behavior of the search for the last Ntt iterations. The idea is simply that we increase Td if the variation of solution values seen over the last Ntt moves is smaller than some limit, otherwise we decrease Td. The basic motivation for this strategy is simply that a small variation of solution values over a time interval indicates that the search is stagnating, possibly cycling near a local minimum or exploring a "flat" region of the solution space. Increasing the tabu tenure can force the search to be less repetitive in its behavior, possibly escaping local minima. On the other hand, if the variation in solution values is large, we have an


77

indication that the search is in a phase where solution values are either deteriorating rapidly or improving rapidly. In any case, something interesting is going on, and the tabu tenure is reduced to help focus the search in this phase. It is not at all clear what should be taken as a "small" or "large" variation in this setting. The adjustment procedure below implements a dynamic limit between "small" and "large" variation. This limit depends on the current best solution value found, the number of tabu tenure adjustments already performed and also on eventual long term stagnation of the search. One very important result of using this adaptive procedure is that it allows the average tabu tenure used on different test instances to be very different, typically it can be 40 for one instance and 90 for another one. This seems to be highly important, as all our experiments with a fixed tabu tenure gives very poor performance on some of the test instances. Some definitions are appropriate to explain the method. To ease the reading of this, we give some approximate values for certain parameters. The actual values given are not a part of the definition of the method, but they should give the reader a better idea of what the different parameters are for. Ntt x 200 is the number of iterations between tabu tenure adjustments. span is the difference between the highest and lowest solution value seen in the last Ntt iterations. (See figure 3.6) Nu is the number of times Td has been updated. M and m are fixed limits for the span, m x 20, M x 100. L, is the limit for the span used in the current update. a x 0.2,P x 0.9, y x %,Tadd x 10 and TWlt x 0.75 are fixed parameters for the search.

Cb is the current best solution value found. The adjustment is carried out as follows. At the start of the search, Td is assigned an initial value Tinit = 80. Every Ntt iterations, 1 Calculate the span

2 Compute the number Lo = Cba(l

+ yPNu).

3 Let L, = max(m, min(Lo, M)). (i.e. if m 5 Lo 5 M we get L, = Lo.)


l rooo

200

400

Iterations 1600

8W

1000

0 12w

Figure 3.6. Visualizing the span.

+

4 If span < L, let Td= Td Tadd(increase). Otherwise, let Td= TmultTd (reduce).

Remark. The limit Lo is a certain percentage of Cb,and this percentage is reduced gradually as Nu increases. The motivation for this is that in the start of the search we have a relatively poor solution, and we want the search to bypass all local minima close to this solution. Thus, we initially try to force the search to exhibit large variation in the values of visited solutions. After some time we are hopefully in more promising regions of the solution space where we want to focus the search. This we try to achieve by reducing the limit Lo gradually as described. If a large number NStag of iterations are seen without improvement of the solution value, Nu is reset to 0, and the percentage starts at its original value again. This is assumed to help diversifying the search. Parameter values for the local search. A series of tests were performed in order to tune the parameter values. These tests are simple in the sense that each test consists of performing a number of runs varying a few of the parameters, and then fixing values for these parameters that gives the best average behavior of the search. In this way parameter values are determined successively, based on other already fixed parameter values. This method of testing may leave some potentially good combinations of parameter values untested, but our preliminary testing and experience with the algorithm together with the tuning tests indicate that the found parameter values are not far from optimal. One should also bear in mind that the determination of parameter values for


79

the algorithm is a problem that depends heavily on the time limit used. The parameter values given below are all based on tests with a time limit of 300 seconds. These are the values resulting from the testing.

Looking back at the adjustment scheme, the chosen parameter values determine the important value Lo which is used as a limit for the observed span. At the start of the search, we get Lo = Cb0.15(1+2) = 0.45Cb. After 2500 moves we have Nu = 10 and Lo is now Cb0.15(1 2 . (0.90)'~)= 0.255Cb. For each 250 iterations Lo is reduced, until we see Nstag= 5000 moves without improvement of the current best solution found. Then Lo is set back to 0.45Cb and the search goes on with a call for larger variation in the values of visited solutions.

+

Typical search behaviour. The two graphs in figure 3.7 and 3.8 are included to give an illustration of the progress of the local search. These are runs of 15 minutes which is about twice the time allowed for the competition. The trajectory in figure 3.7 is very typical. At first there is a steep descent stopping at some instance specific level after about 500 - 1000 moves. Thereafter the search may have to climb uphill a bit to find new promising areas. For the next 10 000 moves or so improvement comes in smaller chunks, until stagnation sets in. In the specific run shown, the stagnation limit at 5000 nonimproving moves is reached at about 14 000 iterations. At this point the adjustment method is reset to call for greater variation in solution values. After a climb going above the initial stagnation value, some new better solutions are found. The trajectory in figure 3.8 is less typical in that improvement in small chunks goes on for a relatively long time. There are several high climbs, and the climbs at about 15 000 and 27 000 moves are preceded by a reset of the adjustment method due to long term stagnation. These climbs are eventually followed by some improvement in solution value.

3.6

COMPARING EFFICIENCY

This section contains results of tests carried out in order to examine the efficiency of some of the implemented mechanisms.


80

Figure 3.7. Instance 2, 15 min.

Figure 3.8. Instance 5, 15 min.

Table 3.2. Mean values withlwithout double move, 300 sec. Instance DMoff DMon Gain in %

1 98.6 92.0 6.7

2 82.7 72.2 12.6

4 261.5 242.8 7.2

Double move option.

5 270.2 239.4 1.3

6 146.4 138.7 5.2

7 157.1 134.1 14.6

12 190.6 172.4 9.5

17 182.7 179.6 1.7

In the paragraph on move selection above, an option to execute both a relocate move and a swap move, based on one round of move evaluation is described. The simple idea behind this is that both the selected moves will normally be "good" moves, and the double move option thus allows the execution of more moves in a fixed time. It is not obvious that this has any positive effect, hence testing is appropriate. For investigation, 8 of the test instances were chosen for this test, which simply consisted in running the search a number of times with the option enabled or disabled, and comparing the resulting values. It is also conceivable that the option may be effective when the time limit is short, but not when there is more time available. Thus the tests were performed with time limits 60, 300 and 600 seconds. For each instance and each time limit5 10 runs with and 10 without the double move option were executed. The results clearly shows that the double move option is significantly improving the search efficiency for all the three time limits tried. Table 3.2 shows the mean of the values obtained in 10 runs, using 300 seconds as the time limit. Here "DM off' are the runs without the double move option, "DM on" are the runs with it. The last row shows the improvement in mean values given in percent.

Tabu search for timetabling problem Double move

+ Not used

+

I

'

I

5 6 instance

Figure 3.9. Effect of using double move option in runs of 300 seconds.

In figure 3.9 the values from the individual runs on the 8 instances are shown. The mean values in table 3.2 are based on these individual values.

Lastslot locking. When selecting a relocate move, the move selection procedure described above implements what we call lastslot locking. This means that any relocate move attempting to move an event to the last timeslot of a day is prohibited, unless the event has no students. The motivation for this mechanism is simply that the moves we prohibit in this way are always giving a solution with more lastslot violations, and by excluding these moves directly we save some time on move evaluation, and in addition we ensure that no more lastslot violations are created. On the other hand, lastslot locking clearly gives fewer relocate moves to choose between, and we risk to lose efficiency by making the search less flexible. To examine the effect of lastslot locking, a test similar to what we did for the double move option was conducted. With the same 8 instances, the search was run for 300 seconds, 10 times with lastslot locking, and 10 times without. The values we obtained does not show any significant difference in the performance of the search when the lastslot locking is enabled or disabled. Thus it appears that this mechanism has little or no impact on search efficiency for our method. From experiments we find that the number of moves executed in a fixed time is usually higher with lastslot locking enabled, but it also happens that even when starting from the same initial solution, more moves are executed when running with lastslot locking disabled. This means that the lastslot locking can actually slow down the search, which is the opposite of one of the main motivations for using it in the first place.

82


We also examined whether the use of the lastslot locking had any impact on the proportion of lastslot violations in the final solution. Again it was not possible to find significant difference in this proportion, when comparing solutions obtained with and without the locking enabled. A reasonable explanation for this is that when the locking is enabled, there is an active prohibition against creating new lastslot violations, but there is no extra effort set in to remove existing such violations.

3.7

COMPUTATIONAL RESULTS

We present results from our algorithm together with the best results reported in the timetabling competition. The participants in the competition were allowed to run their algorithm on each instance as many times they wanted with different random seed and report their best result. This clearly makes comparison of the quality of the algorithms difficult, since the competition results are in effect the results obtained by using a multi-start algorithm with no limit on (or report of) the total running time. Our results here are obtained as follows. The algorithm was run 20 times on each of the 20 test instances, with fixed parameter settings as given above. Each run was performed on a PC with a 2.6 Ghz pentium IV processor, and the time limit was set to 8 minutes, the same as for the competition runs. We report the best result and the mean result obtained on each instance with the present version of our algorithm in these 20 runs. We believe this is a meaningful way of reporting results, not exploiting the possibility of improving results by conforming to the competition rules. The winning algorithm uses an initial solver based on graph coloring techniques, followed by a local search using a variant of simulated annealing for guidance. It was developed by Philip Kostuch at the University of Oxford. On 13 of the 20 instances his algorithm found the best result of all participants. Descriptions of his and other algorithms can be found on the competition homepage. In second place came an algorithm developed by Jean-Franqois Cordeau, Brigitte Jaumard and Rodrigo .Morales (JCM). They use an initial solver developed by Jonker and Volgenant for general assignment problems. Then, to improve on the initial solution they use a tabu search which contrary to our method also allows visiting infeasible solutions. The third place was taken by Yuri Bykov, using an algorithm called "The great deluge local search", and the fourth place was occupied by Luca Di Gaspero and Andrea Schaerf (GS), who also used a tabu search method with a dynamic tabu tenure. Also results comparable to those of Kostuch was found by a group connected to the metaheuristic network, who were not allowed

Tabu search for timetabling problem Table 3.3. Best results, instance for instance.

Table 3.4. Mean scores. Method Mean score

I 1

Kostuch 50

1 1

JCM 76

I Bykov I

GS

77

106

1

1

I AL 1

97

to participate, being too closely associated with the organization of the contest. Table 3.3 shows results instance for instance for Kostuch and JCM, compared to our new results (AL). The table also includes our mean result on the 20 runs on each instance (AL mean). Table 3.4 shows the mean result for all 20 test instances obtained with the different algorithms, and figure 3.10 shows all results for the five algorithms mentioned.

3.8

CONCLUSIONS

We have implemented and tested a tabu search heuristic for a class of timetabling problems. For the 20 test instances we obtain good solutions, comparable to the other tabu search algorithms in the competition. The best known results for the test cases are still substantially better than ours. Our initial solver has proven to be reliable and fast for finding feasible initial solutions. We see that the internal distribution of violation types in the initial solution can be controlled by selecting the right parameter value combination. Some potential benefits from this are mentioned in section 3.4. The local search method we propose is able to improve significantly on solution quality, and it is successful in escaping poor local optima. The search method is robust in the sense that finding a good final solution is not dependent on having a good initial solution. The implementation of an adaptive adjustment scheme for a dynamic tabu tenure makes the search perform well on all test instances, in particular


Comparison of results

JCM Kostuch

I

I

I

I

I

I

I

I

I

I

I

I

I

I

I

I

I

I

I

I

~

1 2 3 4 5 6 7 8 91011121314151617181920

Instance Figure 3.10. Overall results

it allows the average tabu tenure during the search to be different for different instances. More experimental research remains to be done to find possibly more effective and robust schemes for adjusting the tabu tenure. We have specifically tested two components of the search method. These tests revealed that the option to the execute two noninterfering moves in one iteration step had a significant effect on search efficiency. The use of an active prohibition against moving events to end-of-a-day timeslots could not be seen to have any effect on search efficiency.

REFERENCES Burke, E., Carter, M. De Causemacker, P., Erben, W. and Ross, P. (Eds.): Proceedings of the International Conference on the Practice and Theory of Automated Timetabling I-IV, (4 vols.), Springer Verlag. Carrasco M. P. and Pato, M. V. (2000): A Multiobjective Genetic Algorithm for the Class/Teacher Timetabling Problem. In: Proceedings of the 3rd International Conference on the Practice and Theory of automated Timetabling, Springer Verlag, pp. 3-17. Erben W. and Keppler J. (1995): A Genetic Algorithm Solving a Weekly Course-Timetabling Problem. In: Proceedings of the 1st International Conference on the Practice and Theory of automated Timetabling, Springer Verlag, pp. 198-211.


85

Glover, F. and Laguna, M. (1997): Tabu Search. Kluwer Academic Publishers. Laguna M. and Marti R. (2003): Scatter Search - Methodology and Implementations in C. Kluwer Academic Publishers. Lgkketangen, A. and Glover F. (1997) Surrogate Constraint Analysis - New Heuristics and Learning Schemes for Satisfiability Problems. In: Satisfiability problems: Theory and Applications. DIMACS Series in Discrete Mathematics and Theoretical Computer Science, vol. 35.

Chapter 4 AN INVESTIGATION OF AUTOMATED PLANOGRAMS USING A SIMULATED ANNEALING BASED HYPER-HEURISTIC

Ruibin Bai and Graham Kendall Automated Scheduling, Optimisation and Planning (ASAP) Research Group, School of Computer Science & IT, University of Nottingham Nottingham NG8 IBB, UK

Abstract: This paper formulates the shelf space allocation problem as a non-linear function of the product net profit and store-inventory. We show that this model is an extension of multi-knapsack problem, which is itself an NP-hard problem. A two-stage relaxation is carried out to get an upper bound of the model. A simulated annealing based hyper-heuristic algorithm is proposed to solve several problem instances with different problem sizes and space ratios. The results show that the simulated annealing hyper-heuristic significantly outperforms two conventional simulated annealing algorithms and other hyper-heuristics for all problem instances. The experimental results show that our approach is a robust and efficient approach for the shelf space allocation problem. Key words:

Hyper-heuristics, simulated annealing, shelf space allocation, planograms.

4.1 INTRODUCTION The retailing sector in the UK is an extremely competitive arena. We only need to consider some high profile companies to show that this is the case. A particular example is provided by the recent decline of Marks and Spencer, who were the leading high street retailer (and in recent years they are starting to show an improvement in their profitability). A M h e r example is given by C&A's decision to close all of its high street outlets. Yet another example is the decline of J Sainsburys from its position as the

88


leading food retailer in the UK in the 1990's (in 1996, Tesco opened up a 2% lead over their rivals and continue to maintain an advantage). Asda, after merging with Wal-Mart, increased its market share dramatically and overtook Sainsbury's as the second biggest supermarket in the UK. In July 2003, Asda had gained 17% of market share, while Sainsbury's had slipped from 17.1% to 16.2%. Tesco retains the top spot with 27% of the overall market share. Finally, there was a battle over Safeways, which was recently up for sale. This level of competitiveness is unlikely to decline. On the contrary, the high street (or more likely, out of town shopping centres) is likely to become even more competitive. b ,

. ~

,-

,

. -'.

.-I'

..

-

.-... '--.,,,,,: ~

'

:....I

1 ..-.I.,

1

~~-

.- -. --

,

*.," ,.,. ,

~.,.....,.~,~.,",x, ..,.,,,,.... "," . - , -3

*,.,w"

~

~

~

.

p i r r r l m =

.c-u..: .v4- --.. -

-

.

''

.

&--I

-,-

-

Figure 4.1. An example of a simple planogram

Several factors are used to influence consumers' purchases, including product assortment (which merchandise to sell), store layout and space planning, merchandise pricing, services offered, advertising and other promotional programs [21]. Store layout and space planning focuses on the improvement of the visual effect of the shopping environment and space productivity. Planograms (see figure 4.1 for an example) are used to show exactly where and how many facings of each item should physically be placed onto the store shelves. Due to the limited shelf space, planograms are one of the most important aspects that are used to improve financial performance [31]. Electronic planograms can be also used for inventory control and vendor relation improvement [21]. However, generating planograms is a challenging and time-consuming process because the simplest form of planogram problem (ignoring all marketing and retailing variables) is already a multi-knapsack problem, a well-known NP-hard problem which is very difficult to solve. The difficulty is further increased when we consider other merchandise, such as fresh food, clothing and frozen food. This is due to their special display requirements and the fact that they do not use standard shelf fitments. Currently, producing planograms is largely a manual process (there is software assistance available (e.g.

Investigation of automatedplanograms using SA based hyper-heuristic

89

Galaxxi) but it involves significant human interaction and does not provide any guidance or suggestions in deciding a good quality layout) and the shelf space allocation is mainly based on historical market share. However, this approach may lose substantial sales [2] as the display space may have different sales influence with respect to different items [ l l , 12, 14, 201. Using the same display space, different items may obtain different sales and hence affect the profits of the organisation. A recent publication [31] conducted a survey of the area. This work demonstrated the lack of academic work that has been conducted in this domain. Only twelve references were cited. Five of these date back to the 197OYs,four were drawn from the 1980's and only three were from the 1990's. It seems timely that this area should receive research attention, given the recent advances in A1 search techniques. At present, commercial systems use simple heuristic rules to allow retailers to plan their shelf space allocation [32]. Some research [2, 261 has proposed models which integrate product assortment, inventory control management and shelf space allocation. However, these models are too complicated to put into practice. Yang [30] used a model based on a knapsack problem and presented a heuristic to solve some numerical instances of shelf space allocation problems. However, the linear objective function assumption does not fit well with the real world retailing environment. Planograms are a subset of the wider domain of space planning which includes more well known research areas such as bin packing and knapsack problems [31]. Some of techniques that have already been successfully applied to problems within this wider domain may also be promising to shelf space allocation problems.

4.2 RELATED WORK 4.2.1

Experiments and studies

Due to the scarcity of space within stores, some researchers have concentrated on studying the relationship between the space allocated to an item and the sales of that item. Most have reached a common conclusion that a weak link exists between them and the significance depended on the type of items [l 1, 12, 14, 16, 201. Earlier, in 1969, Kotzan and Evanson [20] began to investigate the relationship between the shelf space allocated to an item and the sales of that item and found that a significant relationship existed within the three tested drug stores. Cox's research [ l l ] found that

90


this relationship was very weak and depended on the category of products. However, his experimental results may be affected by limited experiment brand samples (only two brands are measured for each of the two categories). Curhan [12] defined the space elasticity as "the ratio of relative change in unit sales to relative change in shelfspace" and argued that there existed a small, positive space elasticity for each item but the value depended on the products, stores and in-store layout [13]. Drkze et al. [16] carried out a series of experiments to evaluate the effectiveness of shelf space management and cross-category merchandise reorganisation. The shelf space manipulation included changing product facings, deletion of slow moving items, changes of shelf height, etc. Cross-category merchandise reorganisation included manipulation to enhance the complementary shopping within merchandise assortment and easier shopping. The results showed that, compared with the number of facings assigned to a brand, location had a larger impact as long as a minimum inventory (to avoid outof-stocks) was guaranteed. On the contrary, recent research [14] showed that direct space elasticities were significantly non-zero and varied considerably through different categories. Costume jewellery, fruit and vegetables, underwear, shoes were among the highest space elasticities while textile, kitchen and do-it-yourself products had low values. If the products are always available and the consumers would never switch to another brand, the change of space allocated to an item has no effect on its sales [2]. However, in fact, nearly half of the consumers would switch to other stores or change their previous choice to an alternative brand if their first choice is out-of-stock [28]. On the other hand, the purchase of some merchandise could increase the possibility of buying other merchandise with the complementary h c t i o n s (for example, a customer who bought a toothbrush may also buy toothpaste). Cross elasticities were introduced to evaluate the interdependence between two different items in Corstjens and Doyle's model [7]. Borin et al. [2] and Urban [26] also used cross elasticities in their models but with different definitions. In Borin et al.'s model, the cross elasticities were in the range [-I, 01. Urban extended the range of cross elasticities to [-I, 11. It was positive if two items were complementary and negative if they could be substituted for each other. Although cross elasticities are helpful in revealing the relationships between different items, it is quite difficult to obtain a reliable estimation of so many values ( n x n for n items) due to the complicated merchandise relationships. Therefore, recent researchers disregarded it in their models [14,27]. Display location is another factor that has been studied. Campo et al. [5] investigated the impact of location factors on the attractiveness of product categories and stated that the sales of the whole store were dependent on the intrinsic attractiveness based on category, store and trading area

Investigation of automated planograms using SA based hyper-heuristic

91

characteristics as well as cross elasticities between the categories. However, the model did not consider the difference in visibility or prominence between various locations in the store.

4.2.2

Shelf space allocation models and searching methods

Several space allocation models have been proposed by market researchers. Most formulated the demand rate of an item as a function of the space allocated to the item, of which a classic model appears as a polynomial form proposed by Baker and Urban [I]:

where D(x) is the demand rate of the product, x is the number of facings or the displayed inventory. a is a scale parameter and P is the space elasticity of the product. The advantageous characteristics of this model include the diminishing returns (the increase in the demand rate decreased as the space allocated to this shelf increased), inventory-level elasticity (the shape parameter represents the sensitivity of the demand rate to the changes of the shelf space), intrinsic linearity (the model can be easily transformed to a linear function by a logarithmic transformation and parameters can then be estimated by a simple linear regression) and its richness. Corstjens and Doyle [7] formulated their model as a multiplicative form and incorporated both the space elasticities and cross elasticities. The inventory and handling cost effects were also considered. The model allowed different product profit margins corresponding to different locations and hence captured the location impact on the sales. However, due to the characteristic of the polynomial function, this model tends to scatter the facings of each item into different locations in order to obtain a larger objective function value. Based on this model, some non-space factors were also taken into account by Zufjrden's model [32], such as price, advertisement, promotion, store characteristics, etc. A dynamic programming approach was proposed to solve this model. However, this approach ignored the integer nature of the number of facings of the items and hence only produced suboptimal solutions. Some integrated models were also proposed based on the correlation of retailing decision process [2, 261. Borin et al. [2] developed a different model which tried to maximise the category return on inventory. This model was supposed to help the retailer to decide which products to stock (products assortment) and how much space should be allocated to them. The demand function was formulated into three components: unmodified demand, modified demand and acquired demand. Unmodified demand represented the customers' direct preference of an item and was calculated according to its

92


market share. Modified demand took account of the interdependence and substitution of different merchandise. Acquired demand represented the indirect demand captured from those products which were excluded from the assortment. A heuristic procedure, based on simulated annealing, was employed to optimise the model. The neighbourhood was defined by exchanging one facing of two random items. The result showed that simulated annealing was more efficient and flexible compared with the shelf allocation rule based on the share of sales (a common space allocation rule). The above-mentioned models used the number of facings to foresee the demand quantity of that item. However, the effect of part-stocked items (some facings are missing) was not explicitly reflected. Urban [26] replaced the number of facings with average inventory in his model which integrated existing inventory-control model, product assortment model and shelf-space allocation model. A greedy heuristic and a genetic algorithm (GA) were proposed to solve the problem. A GA chromosome represented a given product assortment vector (i.e. "0":excluded, "1": included). The violations of some constraints were allowed in the initial solutions and then repaired by scaling down the number of facings of each item and their order quantities. However, the GA operations (crossover and mutation) were applied to only produce a good product assortment based on the given objective function. No procedure was carried out to evolve a good space allocation decision. The drawback mainly results from the fact that the model includes many parameters and is difficult to be optimised by current A1 search techniques. In fact, Yang [30] argued that: "$or commercial models, a very important criterionfor selecting a space allocation method is the simplicity and ease of operation of the method". He proposed a simpler linear model based on Zufjrden's work [32], by assuming that total net profit was linear with the number of facings of an item. However, this is unrealistic for the real world retail environment. A greedy algorithm, in conjunction with three simple heuristics, was proposed to optimise the model. However, only several numerical examples were used to justify the algorithm and they are far from the real world shelf space allocation problems which are usually much larger and more complicated. In addition, the three heuristics rejected all "bad moves" (a decrease in the objective value for a maximisation problem). The algorithm, in fact, worked in a random greedy fashion and was easily trapped in local optima.

Meta-heuristics have been intensively investigated and applied to a wide variety of applications in the last twenty years, including scheduling, production planning, resource assignment, supply chain management,

Investigation of automated planograms using SA based hyper-heuristic

93

decision support systems and bio-informatics [18, 241. Most of these applications require a thorough study of the problem and a fixed problem definition. Many of the publications also reported that these algorithms perform very well in solving their specific problems. However, once the problem changes (even slightly), the performance of the already developed meta-heuristic may decrease dramatically for the new problem. Significant parameter tuning may need to be carried out for the purpose of adapting the algorithms to the new problem or the new problem instance. It should also be recognised that real-world problems are subject to changes due to them reflecting changes in the business requirements either by management decisions or other factors, such as trading conditions, research and development, employing new technology etc. The "No Free Lunch Theorem" [29] showed that there is no one algorithm that could beat all other algorithms in all classes of problems. If an algorithm outperforms other algorithms on a specific class of problems, there must exist another class of problems on which this algorithm is worse than the others. Hence, a good way to raise the generality of meta-heuristics is to apply different (meta-)heuristics at different times of the search. In this context, a generalised approach (termed hyper-heuristics) is proposed [3] which "broadly describes the process of using (meta-)heuristics to choose (meta-)heuristics to solve the problem in hand'. This approach differs from the more usual meta-heuristic approach, which operates over the solution space directly. A hyper-heuristic approach operates over the solution space indirectly by searching the heuristic space. In this approach, there is a set of "low-level heuristics" that are designed for the problem to be solved. Another heuristic, a high-level heuristic, operates over the low-level heuristics. From an initial solution, the high-level heuristic leads the search to a good quality solution by making calls to the low-level heuristics. The benefit of this approach is two-fold. Firstly, once the high-level heuristic algorithm has been developed, a new problem can be solved by replacing the set of low-level heuristics and the objective function, which is used to evaluate the quality of the solutions. Secondly, the high-level heuristic can adapt itself in order to tune to the new problem, or even a new problem instance. The application of hyper-heuristic approaches can be traced back to the 1960's although the term "hyper-heuristic" was not used. Fisher and Thompson [17] used an unbiased random process to combine two rules/heuristics to solve a job-shop scheduling problem and the results showed that even this simple combination of rules produced much better results than any of them used separately. Recently, Hart et al. [19] solved a real world chicken factory scheduling problem using a GA based hyperheuristic. The problem involved scheduling the collection and delivery of chicken from farms to its processing factories. The problem was

94


decomposed into two stages and two separate GAS were used to tackle the problem. In the first stage, the orders were split into suitable tasks and these tasks were then assigned to different "catching squads". The second stage dealt with the schedule of the arrival of these squads. The GA chromosome in the first stage represented a sequence of orders, a set of heuristics to split each order into suitable sized tasks and another set of heuristics to assign these tasks to the different "catching squads". The GA was used to evolve a strategy of building a good solution instead of finding the solution directly. The experimental results showed this approach is fast and robust and easy to implement. Another GA based hyper-heuristic framework was also proposed by Cowling et al. [9] in solving a trainer scheduling problem. Here, a GA chromosome represented an ordering of the low-level heuristics that were going to be applied to the current state. A good sequence was evolved during the search corresponding to the given problem instance. The computational results showed that the GA based hyper-heuristic outperformed both a conventional genetic algorithm and a memetic algorithm which directly encoded the problem as a chromosome. Recently, Ross et al. [25] proposed a different type of hyper-heuristic based on a genetic algorithm. The problem is one dimensional bin packing. Instead of working on feasible solutions as the hyper-heuristics mentioned above do, the proposed hyper-heuristic in this paper operates on a partial solution and gradually constructs the solution using different rules (heuristics) until a feasible solution is obtained. The heuristic selection is based on the state of current partial solution. Each state associates a rule or heuristic whose relationship with solution states is evolved by a genetic algorithm. The chromosomes of their GA are defined as a set of blocks and each block contains a set of parameters which is used to define a solution state and its corresponding heuristics. The algorithm is firstly trained on parts of benchmark problems. After the training, the fittest chromosome is then applied to every benchmark problem, 80% of which are solved to optimality. Yet another kind of hyper-heuristic used the ideas of reinforcement learning to guide the choice of the heuristics during the search [8,231. In [8], a sales summit scheduling problem was solved by a "choice function" based hyper-heuristic, in which the choice function dynamically selected suitable heuristics at each decision point. The computational results showed that the choice function based hyper-heuristic performed better than applying the heuristics randomly. Nareyek [23] used a non-stationary reinforcement learning procedure to choose heuristics in solving the Orc Quest problem and the Logistics Domain problem. The author discussed the advantages of the hyper-heuristic approach, especially in solving complex real-world problems in which the computational cost is expensive. Burke et al. [4] applied a tabu search based hyper-heuristic to a nurse rostering problem and a university course timetabling problem, in which the set of


95

heuristics were ranked according to their performances in the search history. A tabu list is also incorporated to prevent the selection of some heuristics at certain points in the search. The remainder of this paper is organised as follows: in the section 4.3, we give a description of the problem and formulate it as a non-linear combinatorial maximisation model. Section 4.4 will focus on the implementation of our simulated annealing hyper-heuristic. Section 4.5 gives the experimental results, together with some analysis. Section 4.6 concludes the paper.

4.3 MODEL FORMULATION

4.3.1

Model formulation

The problem we are solving is the assignment of appropriate shelf space to every stock-keeping unit (SKU) in a given product category, without violating the given constraints, whilst maximising the overall profit. Each stock-keeping unit is defined by a five-tuple ( 1, ,pi ,Pi ,L, ,Ui ) where 1, (respectively, pi , Pi , Li , Ui ) is the length (respectively, profit, space elasticity, lower bounds, upper bounds) of item i. The length of shelf j is denoted by Ti . We assume that: 1) Retailers prevent out-of-stock occurrences. 2) The total profit of item i is proportional to its unit profit p i . 3) We ignore the physical constraints in the other two dimensions (height and depth). We employ Urban's [26] demand function and disregard the cross elasticities not only because they are quite small compared with space elasticities but also because it is quite difficult to obtain a reliable estimation of them. Based on the assumptions we discussed earlier, we have the following space allocation model Maximise P = subject to:

xi"_,

(p,aix,P' )

96


where m is the number of shelves and n is the number of items. The decision variables are x,, representing the number of facings of item i on shelf j and xi = x L , x , is the total number of facings of item i. ai is a scale parameter and ai>O. Constraint (4.3) ensures that the length of a shelf is greater than the total length of the facings assigned to this shelf. Constraint (4.4) ensures that the lower and upper bounds of the number of facings for each item are satisfied. Constraint (4.5) ensures that the number of facings for each item is an integer. The objective is to maximise the overall profit without violating the given constraints. The model is a non-linear, multiconstraints optimisation problem. If Pi+ 1 , the model degenerates into a multi-knapsack problem.

4.3.2

Upper bound of the model

As shelf space allocation cannot be solved to optimality in polynomial time [2], we usually do not know the optimal solution and hence cannot evaluate the quality of a given solution by comparing it with the optimal solution. Yang [30] compared his results with the optimal solution obtained by carrying out a complete enumeration. However, this method is only suitable for very small problem instances. For a shelf space allocation problem with n items (each item has an upper bound of facings U ) and m shelves, it requires Urn""iterations to find the optimal solution using an exhaustive search. Even for a small problem instance: n=6, m=3, U=6, this could take around 40 years, an extremely unrealistic computing time for a practical application. Another common method is to relax the problem to a simpler one and obtain the upper bound of the objective. In this paper, we use a two-stage relaxation to get an upper bound of the model:

0

1 2 3 4

5 6 7 8

9101112

Figure 4.2. Approximate objective with a linear function

Stage 1: we first relax our non-linear model to be a linear model. This is accomplished by applying a linear Taylor expansion at the point 7


97

( L , IF.5 U,)(as illustrated in figure 4.2). The model hence becomes an integer programming (IP) problem: maximise

0 (i.e. solution is infeasible). h2: Select an event at random and move it from its current timeslot to a different timeslot selected at random too. This move is performed only if Hcv = 0 (i.e. solution is already feasible) and the move does not result in Hcv > 0. h3: Swap the timeslots of two events selected at random. This move is performed only if Hcv > 0 (i.e. solution is infeasible). h4: Swap the timeslots of two events selected at random. This move is performed only if Hcv = 0 (i.e. solution is already feasible) and the move does not result in Hcv > 0.

h5: Same as the heuristic [hl] but the timeslot selected for the move is the first one that provokes an improvement on H c v . h6: Same as the heuristic [h2] but the timeslot selected for the move is the first one that provokes an improvement on Scv. h7: Same as the heuristic [h3] but the pair of timeslots selected for the swap is the first one that provokes an improvement on H c v . h8: Same as the heuristic [h4] but the pair of timeslots selected for the swap is the first one that provokes an improvement on Scv. where Scv = LS

6.5.3

+ E i R + SC is the aggregate objective.

Computational Results

Experimental Settings. All algorithms were coded in Microsoft Visual C++ version 6, and all experiments were run on a PC Pentium I11 1000MHz with 128MB RAM running on Microsoft Windows 2000. To test the effectiveness of our hyper-heuristic approaches we considered problem instances taken from (Socha et al. 2002). A set of 20 initial feasible solutions were randomly obtained using the basic tabu search hyper-heuristic of (Burke et al. 2003b). To allow for a fair comparison, all four algorithms described above in this paper ( TSRand Unif, TSRoulWheel, MTSRoulWheel and PureRand) start from the same initial set of solutions. Each of the 20 initial solutions is generated using the same algorithm of (Burke et al. 2003b) with different random seeds. Comparing the Hyper-heuristic Approaches. We show in Fig. 6.4 to 6.6 the off-line non-dominated sets obtained by all four algorithms when applied to three problem instances of medium size (400 events, 10 rooms and 5 features) described in (Socha et al. 2002). The stopping condition is 1000 iterations for each individual solution, i.e. 20000 iterations for the whole population. Of the four algorithms, we note that PureRand performs the poorest. This shows that the benefit obtained by incorporating a learning mechanism into the hyper-heuristic approaches is more evident in this problem than in the space allocation problem above. In the absence of an intelligent mechanism to 'learn' to choose a 'good' heuristic at each decision point, the PureRand algorithm is bound to perform poorly. It can also be said that, overall, TSRoulWeel and MTSRoulWeel seem to produce the best sets of non-dominated solutions. It is striking to note that MTSRoulWeel .does not always get so close to the desired trade-off front. This (relatively) poor performance from MTSRoul Wee1 can be explained by the use of multiple tabu lists.


Figure 6.4. Non-dominated sets obtained with each of the hyper-heuristics for the problem M2.

Indeed, the use of several tabu lists may lead to an overhead in terms of tabu list management. As it was also observed in the application to the space allocation problem, it seems that having just one tabu list is good enough to produce solutions of acceptable quality. Perhaps, more elaborate mechanisms of dealing with multiple tabu lists of neighbourhood search heuristics can help to obtain better results in the MTSRoulWheel. We are currently exploring this possibility.

Comparison with Previous Results. As indicated above, we are tackling the course timetabling problem in a multi-objective fashion. In order to find out if the solutions produced by our approaches are competitive with those obtained with other methods, we compare our results with those reported in (Socha et al. 2002) and in (Burke et al. 2003b). Two tailored algorithms were used in (Socha et al. 2002), a local search approach (LLS) and an ant algorithm (ANT). In (Burke et al. 2003b), the approach presented was a single-objective tabu search hyper-heuristic. In those three algorithms, the problem is tackled as a single objective problem, i.e. using the aggregated value Scv. Here, we tackle the three objectives (LS,EiR, and SC) independently. In addition to the medium size instances M2, M3, and M4 used in the experiments above, we also compare the algorithms in the small size instance S1. To allow a comparison, we computed the aggregated objective value (Scv) for the non-dominated solutions obtained by each hyper-heuristic

Figure.6.5. Non-dominated sets obtained with each of the hyper-heuristics for the problem M3.

Figure 6.6. Non-dominated sets obtained with each of the hyper-heuristics for the problem M4.

152


Table 6.1. Comparison between the multi-objective tabu search hyper-heuristics with the two single-objective local search (LLS) and ant algorithms (ANT) from (Socha et al. 2002) and the single-objective hyper-heuristic (HH) approach from (Burke et al. 2003b). MTSRW is MTSRoulWheel, TSRW is TSRoulWheel, and TSRU is TSRandUnzf. For all the hyper-heuristics the table shows average Scv (if solution is feasible) / best Scv in all runs. In column LLS 77.5% Inf indicates the proportion of infeasible solutions in 40 runs. The best obtained solutions are shown in bold. Sl M2 M3 M4

MTSRW 2.311 198.41168 272.81231 189.21134

TSRW 2.1510 196.51173 276.21224 191.81160

TSRU 1.9510 219.21192 274.21244 190/149

HH 2.211 197.61173 295.41267 1801169

LLS 8 202.5 77.5% Inf 177.5

ANT 1 184 248 164.5

approach. The best and average values for each off-line non-dominated set together with the results obtained in (Socha et al. 2002) and in ( Burke et al. 2003b) are reported in Table 6.1. These results show that the sort of solutions produced by our multi-objective tabu search hyperheuristics are of comparable quality with those reported in (Socha et al. 2002) and in (Burke et al. 2003b). The average solutions obtained by the multi-objective hyper-heuristics of this paper, are competitive with those obtained by the HH, LLS, and ANT approaches. Furthermore, for all instances the best solution is obtained by one of our multi-objective hyperheuristic approaches. It should be noted that our algorithms used substantially fewer evaluations than the algorithms of (Socha et al. 2002). Overall, it can be said that our multi-objective hyper-heuristic approach is effective in tackling the three-objective course timetabling problem considered here.

6.6

THE CONCLUSIONS

The problem of obtaining a uniformly distributed set of non-dominated solutions is of great concern in Pareto optimisation. This work proposes the application of hyper-heuristics for achieving a good coverage of the trade-off surface. The central idea is to develop a strategy that selects the most promising neighbourhood search heuristic in order to guide the search towards the desired areas of the trade-off surface. This technique has the advantage that it can be applied to single-solution and to population based algorithms because no population statistics are required as would be the case in, say, some clustering techniques. Experiments have been carried out on the space allocation problem and the university course timetabling problem. By using a hyper-heuristic approach for multi-objective combinatorial optimisation, the idea is to adapt the

application of neighbourhood search heuristics according to the quality of the current solution in each of the objectives. In a way, this is similar to the strategy of tuning weights to specify search directions. The results obtained show that the hyper-heuristic approaches used here are capable of obtaining non-dominated sets that represent a good coverage of the trade-off surface. The results obtained in our experiments show that among the four approaches implemented here, the TSRoul Wheel algorithm shows the best overall performance. The learning mechanism of the TSRoulWheel approach uses two strategies. One is Roulette-Wheel selection for deciding which objective to be tackled at any one time during the search. The TSRoulWheel algorithm also employs a single tabu list to manage the tabu status of the neighbourhood exploration heuristics during the search. Future work will concentrate on the improvement of the learning mechanism and upon further testing by comparing our approach with other multi-objective optimisers from the literature.

REFERENCES Ayob M., Kendall G. (2004). A Monte Carlo Hyper-Heuristic To Optimise Component Placement Sequencing for Multi Head Placement Machine. Proceedings of the 2003 International Conference on Intelligent Technologies (InTech 2003), pp. 132-141, Chiang Mai Thailand. Burke E.K., Jackson K., Kingston J.H., Weare R. (1997). Automated University Timetabling: the State of the Art. The Computer Journal, Vol. 40, No. 9, pp. 565-571. Burke E.K., Kendall G., Newall J., Hart E., Ross P., Schulemburg S. (2003). Hyper-heuristics: an Emerging Direction in Modern Search Technology. In: Glover F.W., Kochenberger G.A. (eds.), Handbook of Metaheuristics, Kluwer Academic Publishers. Burke E.K., Kendall G., Soubeiga E. (2003b). A Tabu-search Hyperheuristic for Timetabling and Rostering. Journal of Heuristics, Vol. 9, pp. 451-470. Burke E.K., Landa Silva J.D. (2002). Improving the Performance of Multiobjective Optimisers by Using Relaxed Dominance. Proceedings of the 4th Asia-Pacific Conference on Simulated Evolution and Learning (SEAL 2002), Singapore, pp. 203-207. Burke E.K., Landa Silva J.D. (2005). The Influence of the Fitness Evaluation Method on the Performance of Multiobjective Optimisers. To appear in European Journal of Operational Research.

154


Burke E.K., Newall J. (2004). Solving Examination Timetabling Problems Through Adaptation of Heuristic Orderings. Annals of operations Research, Vol. 129, pp. 107-134. Burke E.K., Varley D.B. (1998). Space Allocation: An Analysis of Higher Education Requirements. The Practice and Theory of Automated Timetabling 11: Selected Papers from the 2nd International Conference on the Practice and Theory of Automated Timetabling (PATAT 97), Lecture Notes in Computer Science, Springer, Vol. 1408, pp. 2033. Carter M.W., Laporte G. (1998). Recent Developments in Practical Course Timetabling. The Practice and Theory of Automated Timetabling 11: Selected Papers from the 2nd International Conference on the Practice and Theory of Automated Timetabling (PATAT 97), Lecture Notes in Computer Science, Vol. 1408, Springer, pp. 3-19. Coello Coello C.A., Van Veldhuizen D.A., Lamont G.B. (2002). Evolutionary Algorithms for Solving Multi-Objective Problems, Kluwer Academic Publishers. Cowling P., Kendall G., Han L. (2002). An Investigation of a Hyperheuristic Genetic Algorithm Applied to a Trainer Scheduling Problem. Proceedings of the 2002 Congress on Evolutionary Computation (CEC 2002), pp. 1185-1190. Cowling P., Kendall G., Soubeiga E. (2000). A Hyperheuristic Approach to Scheduling a Sales Summit. The Practice and Theory of Automated Timetabling 111: Selected Papers from the 3rd International Conference on the Practice and Theory of Automated Timetabling PATAT 2000, Lecture Notes in Computer Science, Vol. 2079, Springer, pp. 176-190. Cowling P., Kendall G., Soubeiga E. (2001). Hyperheuristics: A Tool for Rapid Prototyping in Scheduling and Optimisation. Second European Conference on Evolutionary Computing for Combinatorial Optimisation (EvoCop 2002), Lecture Notes in Computer Science, Vol. 2037, Springer, pp. 1-10. Cowling P., Kendall G., Soubeiga E. (2002b). Hyperheuristics: A Robust Optimisation Method Applied to Nurse Scheduling. Proceedings of the VII Parallel Problem Solving From Nature (PPSN VII), Lecture Notes in Computer Science, Vol. 2439, Springer, pp. 7-11. Czyzak P., Jaszkiewicz A. (1998) Pareto Simulated Annealing - A Metaheuristic for Multiple-objective Combinatorial Optimization. Journal of Multicriteria Decision Analysis, Vol. 7, No. 1, pp. 34-47.

Deb K. (2001). Multi-Objective Optimization Using Evolutionary Algorithms, Wiley. Deb K., Manikanth M., Mishra S. (2003). Towards a Quick Computation of Well-Spread Pareto Optimal Solutions. Proceedings of the 2nd International Conference on Evolutionary Multi-Criterion Optimization (EM0 2003), Faro Portugal, Lecture Notes in Computer Science, Vol. 2632, Springer, pp. 222-236. Farina M., Amato P. (2003). Fuzzy Optimality and Evolutionary Multiobjective Optimization. Proceedings of the 2nd International Conference on Evolutionary Multi-Criterion Optimization (EM0 2003), Faro Portugal, Lecture Notes in Computer Science, Vol. 2632, Springer, pp. 58-72. Gaw A., Rattadilok P., Kwan R.S.K. (2004). Distributed Choice Function Hyper-Heuristics for Timetabling and Scheduling. Proceedings of the 2004 International Conference on the Practice and Theory of Automated Timetabling (PATAT 2004), Pittsburgh USA, pp. 495-497. Glover F., Laguna M. (1997). Tabu Search. Kluwer Academic Publishers. Goldberg, D. (1989). Genetic Algorithms in Search, Optimisation and Machine Learning. Addison Wesley. Gunawan S., Farhang A., Azarm 5. (2003). Multi-level Multi-objective Genetic Algorithm Using Entropy to Preserve Diversity. Proceedings of the 2nd International Conference on Evolutionary Multi-Criterion Optimization (EM0 2003), Faro Portugal, Lecture Notes in Computer Science, Vol. 2632, Springer, pp. 148-161. Han L., Kendall G. (2003). Investigation of a Tabu Assisted HyperHeuristic Genetic Algorithm. Proceedings of the 2003 Congress on Evolutionary Computation (CEC2003), Canberra Australia, pp. 22302237, IEEE Press. Hansen P., Mladenovic N. (2001). Variable Neighbourhood Search: Principles and Applications. European Journal of Operational Research, Vol. 130, No. 3, pp. 449-467. Hart E., Ross P. (1998). A Heuristic Combination Method for Solving Job-shop Scheduling Problems, Proceedings of the V Parallel Problem Solving From Nature (PPSN V), Lecture Notes in Computer Science, Vol. 1498, Springer, pp. 845-854. Horn J. (2003). Niche Distributions on the Pareto Optimal Front, Proceedings of the 2nd International Conference on Evolutionary MultiCriterion Optimization (EM0 2003), Faro Portugal, Lecture Notes in Computer Science, Vol. 2632, Springer, pp. 365-375.

156


Ishibuchi H., Yoshida T., Murata T. (2002). Selection of Initial Solutions for Local Search in Multiobjective Genetic Local Search. Proceedings of the 2002 Congress on Evolutionary Computation (CEC 2002), Hawaii USA, pp. 950-955. Ishibuchi H., Shibata Y. (2003). An Empirical Study on the Effect of Mating Restriction on the Search Ability of EM0 Algorithms. Proceedings of the 2nd International Conference on Evolutionary MultiCriterion Optimization (EM0 2003), Faro Portugal, Lecture Notes in Computer Science, Vol. 2632, Springer, pp. 433-447. Jin H., Wong M.L. (2003). Adaptive Diversity Maintenance and Convergence Guarantee in Multiobjective Evolutionary Algorithms. Proceedings of the 2003 Congress on Evolutionary Computation (CEC 2003), Camberra Australia, IEEE Press, pp. 2498-2505. Jones D.F., Mirrazavi S.K., Tamiz M. (2001). Multiobjective Metaheuristics: An Overview of the Current State-of-the-Art. European Journal of Operational Research, Vol. 137, No. 1, pp. 1-9. Kaelbling L.P., Littman M.L., Moore A.W. (1996). Reinforcement Learning: A Survey, Journal of Artificial Intelligence Research, Vol. 4, pp. 237-285. Knowles J., Corne D.C. (2000). Approximating the Nondominated Front Using the Pareto Archived Evolution Strategy, Evolutionary Computation, Vol. 8, No. 2, pp. 149-172. Kokolo I., Hajime K., Shigenobu K., Failure of Pareto-based MOEAS, Does Non-dominated Really Mean Near to Optimal?, Proceedings of the 2001 Congress on Evolutionary Computation (CEC 2001), pp. 957962, 2001. Kumar R., Rockett P. (2002). Improved Sampling of the Pareto-front in Multiobjective Genetic Optimization by Steady-state Evolution: A Pareto Converging Genetic Algorithm, Evolutionary Computation, Vol. 10, No. 3, pp. 283-314. Landa Silva J.D. (2003). Metaheuristic and Multiobjective Approaches for Space Allocation. PhD Thesis, School of Computer Science and Information Technology, University of Nottingham. Laumams M., Thiele L., Deb K., Zitzler E. (2002). Combining Convergence and Diversity in Evolutionary Multiobjective Optimization. Evolutionary Computation, Vol. 10, No. 3, pp. 263-282. Laumanns M., Zitzler E., Thiele L. (2001). On the Effects of Archiving, Elitism, and Density Based Selection in Multi-objective Optimization. Proceedings of the 1st International Conference on Evolutionary

Multi-Criterion Optimization (EM0 2001), Lecture Notes in Computer Science, Vol. 1993, Springer, pp. 181-196. Lu H., Yen G.G. (2002). Rank-density Based Multiobjective Genetic Algorithm. Proceedings of the 2002 Congress on Evolutionary Computation (CEC 2002), Hawaii USA, IEEE Press, PP. 944-949. Martello S., Toth P. (1990). Knapsack Problems - Algorithms and Computer Implementations.Wiley. Mostaghim S., Teich J. (2003). The Role of e-dominance in Multiobjective Particle Swarm Optimization Methods. Proceedings of the 2003 Congress on Evolutionary Computation (CEC 2003), Camberra Australia, IEEE Press, PP. 1764-1771. Murata T., Ishibuchi H., Gen M. (2001). Specification of Genetic Search Directions in Cellular Multi-objective Genetic Algorithms. Proceedings of the 1st International Conference on Evolutionary MultiCriterion Optimization (EM0 2001), Lecture Notes in Computer Science, Vol. 1993, Springer, pp. 82-95. Rosenthal R.E. (1985). Principles of Multiobjective Optimization. Decision Sciences, Vol. 16, pp. 133-152. Ross P., Marin-Blazquez J.G., Schulenburg S., Hart E. (2003). Learning a Procedure that Can Solve Hard Bin-packing Problems: A New GAbased Approach to Hyper-heuristics. Proceedings of the 2003 Genetic and Evolutionary Computation Conference (GECCO 2003), Lecture Notes in Computer Science, Vol. 2724, Springer, pp. 1295-1306. Ross P., Schulenburg S., Marin-Blazquez J.G., Hart E. (2002). Hyperheuristics: Learning to Combine Simplke Heuristics in Bin-packing Problems. Proceedings of the 2002 Genetic and Evolutionary Computation Conference (GECCO 2002), Morgan Kaufmann, pp. 942-948. Rossi-Doria O., Sampels M., Birattari M., Chiarandini M., Dorigo M., Gambardella L.M., Knowles J., Manfrin M., Mastrolilli M., Paechter B., Paquete L., St. zle T. (2003). A Comparion of the Performance of Different Metaheuristics on the Timetabling Problem, The Practice and Theory of Automated Timetabling IV : Selected Papers from the 4th International Conference on the Practice and Theory of Automated Timetabling (PATAT 2002), Lecture Notes in Computer Science, Vol. 2740, Springer, pp. 330-352. Salman F.S., Kalagnaman J.R., Murthy S., Davenport A. n(2002). Cooperative Strategies for Solving Bicriteria Sparse Multiple Knapsack Problem, Journal of Heuristics, Vol. 8, pp. 215-239. Schaerf A. (1999). A Survey of Automated Timetabling. Artificial Intelligence Review, Vol. 13, pp. 87-127.

158


Socha K., Knowles J., Samples M. (2002). A Max-Min Ant System for the University Course Timetabling Problem. Ant Algorithms: Proceedings of the Third International Workshop (ANTS 2002), Lecture Notes in Computer Science, Vol. 2463, Springer, pp. 1-13. Socha K., Kisiel-Dorohinicki M. (2002). Agent-based Evolutionary Multiobjective Optimization. Proceedings of the 2002 Congress on Evolutionary Computation (CEC 2002), Hawaii USA, IEEE Press, PP. 109114. Soubeiga E. (2003). Development and Application of Hyperheuristics to Personnel Scheduling, PhD Thesis, School of Computer Science and Information Technology, University of Nottingham, June 2003. Steuer Ralph E. (1986). Multiple Criteria Optimization: Theory, Computation and Application. Wiley. Sutton R.S., Barto A.G. (1998). Reinforcement Learning, MIT Press. Talbi E.G., Rahoudal M., Mabed M.H., Dhaenens C. (2001). A Hybrid Evolutionary Approach for Multicriteria Optimization Problems: Application to the Flow Shop. Proceedings of the 1st International Conference on Evolutionary Multi-criterion Optimization (EM0 2001), Lecture Notes in Computer Science, Vol. 1993, Zurich Switzerland, Springer, pp. 416-428. Toscano Pulido G., Coello Coello C.A. (2003). The Micro Genetic Algorithm 2: Towards Online Adaptation in Evolutionary Multiobjective Optimization. Proceedings of the 2nd International Conference on Evolutionary Multi-Criterion Optimization (EM0 2003), Lecture Notes in Computer Science, Vol. 2632, Springer, pp. 252-266. Ulungu E.L., Teghem J. Fortemps P.H., Tuyttens D. (1999). MOSA Method: A Tool for Solving Multiobjective Combinatorial Optimization Problems. Journal of Multicriteria Decision Analysis, Vol. 8, pp. 221-236. Zhu Z.Y., Leung K.S. (2002). Asynchronous Self-adjustable Island Genetic Algorithm for Multi-objective Optimization Problems. Proceedings of the 2002 Congress on Evolutionary Computation (CEC 2002), Hawaii USA, IEEE Press, pp. 837-842.

Chapter 7

THEORY AND PRACTICE OF THE MINIMUM SHIFT DESIGN PROBLEM Luca Di G a s p e r o l , Johannes G a r t n e r 2 , Guy Kortsarz3, Andrea Schaerfl and Wolfgang Slany5

N y s r e t Musliu4,

'DIEGM, University of Udine - via delle Scienze 208, 1-33100 Udine, Italy

{ l.digaspero,schaerf) @uniud.it ' ~ i r n e sInc

-

Schwedenplatz 2/26, A - 1010 Wien, Austria

[email protected]

Computer Science Department, Rutgers University - Camden, N J 08102, USA [email protected]

4 ~ n s t .of Inf. Systems, Vienna University of Technology - A-1040 Wien, Austria [email protected]

5 ~ n s tfor . Software Technology, Graz University of Technology - A-8010 Graz, Austria [email protected]

Abstract: The min-SHIFT DESIGNproblem is an important scheduling problem that needs to be solved in many industrial contexts. The issue is to find a minimum number of shifts and the number of employees to be assigned to these shifts in order to minimize the deviation from the workforce requirements. Our research considers both theoretical and practical aspects of the min-SHIFT DESIGN problem. First, we establish a complexity result by means of a reduction to a network flow problem. The result shows that even a logarithmic approximation of the problem is NP-hard. However, the problem becomes polynomial if the issue of minimizing the number of shifts is neglected. On the basis of these results, we propose a hybrid heuristic for the problem which relies on a greedy construction phase, based on the network flow analogy, followed by a local search algorithm that makes use of multiple neighborhood relations. An experimental analysis on structured random instances shows that the hybrid heuristic clearly outperforms an existing commercial implementation and highlights the respective merits of the composing heuristics for different performance parameters.

Keywords: Workforce scheduling, hybrid algorithms, local search, greedy heuristics.

160

7.1


INTRODUCTION

The typical process of planning and scheduling a workforce in an organization is inherently a multi-phase activity [18]. First, the production or the personnel management have to determine the temporal staff requirements, i.e., the number of employees needed for each timeslot of the planning period. Afterwards, it is possible to proceed to determine the shifts and the total number of employees needed to cover each shift. The final phase consists in the assignment of the shifts and days-off to employees. In the literature, there are mainly two approaches to solve the latter two phases. The first approach consists of solving the shift design and the shift assignment phases as a single problem (e.g., [8, 101). A second approach, instead, proceeds in stages by considering the design and the assignment of shifts as separate problems [I, 13,141. However, this approach does not ensure that it will be possible to find a good solution to the assignment problem after the shift design stage. In this work we focus on the problem of designing the shifts. We propose the SHIFT DESIGNformulation where the issue is to find a minimum set of work shifts to use (hence the name) and the number of workers to assign to each shift, in order to meet (or minimize the deviation from) pre-specified staff requirements. The selection of shifts is subject to constraints on the possible start times and the lengths of shifts, and an upper limit for the average number of duties per week per employee. Our work is motivated by practical considerations and differs from other literature dealing with similar problems since we explicitely aim at minimizing the number of shifts. The latter leads to schedules that are easier to read, check, manage and administer. The original formulation of the problem arose in a project at Ximes Inc, a consulting and software development company specializing in shift scheduling. An initial solver for this problem was implemented in a software endproduct called OPA ('Operating hours Assistant') and presented in [15]. The paper is organized as follows. After having formally introduced the problem statement and the relevant related work on the subject (Sect. 7.2), we establish the complexity of the SHIFT DESIGNproblem by means of a reduction to a Network Flow problem, namely the cyclic multi-commodity capacitated fixed-charge min-COST max-FLOWproblem [3, Prob. ND32, page 2141. The precise relation between the two problems is shown in Section 7.3. As we will show, even a logarithmic approximation of the problem is NPhard. However, if the issue of minimizing the number of shifts is neglected, the resulting problem becomes solvable in polynomial time. Then, we introduce a hybrid heuristic for solving the problem that is inspired by the relation between the SHIFT DESIGNand the min-COST max-FLOW problems. The algorithm relies on a greedy solution construction phase, based

Theory andpractice of the minimum shift design problem

161

on the min-COST max-FLOWanalogy, followed by a local search algorithm that makes use of the Multi-Neighborhood Search approach [ 5 ] . The heuristic solver is presented in Section 7.4. In Section 7.5 we compare the performances of the proposed heuristic solver with OPA. The outcome of the comparison shows that our heuristic significantly outperforms the previous approach. Finally, in Section 7.6 we provide some discussion.

7.2

PROBLEM STATEMENT

The minimum shift design problem (MSD) consists in the selection of which work shifts to use and how many people to assign to each such shift in order to meet pre-specified workforce requirements. The requirements are given for d planning days D = ( 1 , . . . ,d ) (the socalledplanning horizon), where a planning day can start at a certain time on a regular calendar day, and ends 24h later, usually on the next calendar day. Each planning day j is split into n equal-size smaller intervals ti = [ri,ri+1), called timeslots, which have the same length h = 1 1 ~ ~ -+ rill ~ E IR expressed in minutes. The time point 7 1 on the first planning day represents the start of the planning horizon, whereas time point rn+l on the last planning day is the end of the planning horizon. In this work we deal with cyclic schedules, thus Tn+l of the last planning day coincides with 7 1 of the first planning day of the next cycle, and the requirements are repeated in each cycle. For each timeslot ti of a day j of a cycle, we are given an optimal number of employees bij, representing the number of persons needed at work in that timeslot. An example of workforce requirements with d = 7 is shown in Table 7.1, where the planning days coincide with calendar days (for the rest of this document we will use the term 'day' when referring to planning days unless stated otherwise). In the table, the days are labeled 'Mon', 'Tue', etc. and, for conciseness, timeslots with the same requirements are grouped together (the example is adapted from a real call-center problem). In this problem we are interested in determining a set of shifts for covering the workforce requirements. Each shift s = [a,,a, A,) is characterized by two values a, and A, that determine the starting time and the length of the shift, respectively. Since we are dealing with discrete time slots, for each shift s, the variables a, can assume only the ri values defined above, and the variables A, are constrained to be a multiple of the timeslot length h. The set of all possible shifts is denoted by S. When designing shifts, not all starting times are feasible, neither are all lengths allowed. For this reason, the problem statement also includes a collection of shift types V = {vl,. . .v,), each of them characterized by the

+

162


Table 7.1. Sample workforce requirements. Start

End

0O:OO 06:OO 08:OO 09:OO 10:OO 11:OO 14:OO 16:OO 17:OO 22:OO

06:OO 08:OO 09:OO 1O:OO 11:OO 1400 16:OO 17:OO 22:OO 24:OO

Mon Tue Wen Thu Fri Sat Sun 5 2 5 7 9 7 10 7 5 5

5 2 5 7 9 7 9 6 4 5

5 2 5 7 9 7 7 4 2 5

5 6 9 13 15 13 9 6 2 5

5 2 5 7 9 7 10 7 5 5

5 0 3 5 7 5 5 2 0 5

5 0 3 5 7 5 5 2 0 5

Table 7.2. An example of shift types Shift type M (morning) D (day) A (afternoon) N (night)

min, 05:OO 09:OO 13:OO 21:OO

ma, OR00 11:OO 15:OO 23:OO

minl 07:OO 07:OO 07:OO 07:OO

ma1

09:OO 09:OO 09:OO 09:OO

earliest and the latest starting times (denoted by mins(vk) and maxs(vk), respectively), and a minimum and maximum length of its shifts (denoted by minl (vk) and maxi (vk)). Each shift s belongs to a unique shift type, therefore its starting time and length are constrained to lie within the intervals defined by its type. We denote the shift type relation with K(s) = vk. A shift s that belongs to the type vk is a feasible shift if mins(vk) 5 a, 5 max,(vk) and mini (vk) 5 As 5 maxl (vk). Table 7.2 shows an example of a set of shift types together with the ranges of allowed starting times and lengths. The times are expressed in the format hour:minute. The shift types together with the time granularity h determine the quantity m = IS1 of possible shifts. For example, assuming a timeslot length of 15 minutes, there are m = 360 different shifts belonging to the types of Table 7.2. The goal of the SHIFT DESIGNproblem is to select a set of q feasible shifts Q = {slys a , . . . s ) and to decide how many people x j (s) E N are ) ? going to work in each shift s E Q for each day j, so that bij people will be present at each timeslot ti of the day. If we denote the collection of shifts that include the timeslot ti with Sti 5 Q, a feasible solution consists of d numbers xj(s) assigned to each shift s, so that 1, = Csss, x ~ ( s )is equal to bG. In other words, we require that the number of workers present at time ti, for all values of i and for all days j, meets the staffing requirements. In practical cases, however, this constraint is relaxed, so that small deviations are allowed. To this aim, each solution of the MSD problem is evaluated

Theory and practice of the minimum shift design problem Table 7.3. A solution to the min-SHIFT DESIGNproblem Start 06:OO 08:OO 09:OO 14:OO 22:OO

Type M M D A N

Length 08:OO 08:OO 08:OO 08:OO 08:OO

Mon 2 3 2 5 5

Tue 2 3 2 4 5

Wed 2 3 2 2 5

Thu 6 3 4 2 5

Fri 2 3 2 5 5

Sat 0 3 3 0 5

Sun 0 3 2 0 5

Sm

Mon

Figure 7.1. A pictorial representation of the solution in Table 7.3

by means of an objective.function to be minimized. The objective function is a weighted s ~ &of thrke main components. The first aid second components are the stajing excess and shortage, namely, the sums FI ( Q ,x ) = ~d J=I En %=Imax{lu - bij,0) and F2(Q,x ) = C jd= , ELl max{bij - l i j , 0). The third component of the objective function is the number of shifts selected F3(Q,x) = IQI. The MSD problem is genuinely a multi objective optimization problem in which the criteria have different relative importance depending on the situation. Therefore, the weights of the three Fi components depend on the instance at hand and can be adjusted interactively by the user. A solution to the problem in Table 7.1 is given in Table 7.3 and is pictorially represented in Figure 7.1. Notice that this solution is not perfect. For example, there is a shortage of workers every day in the timeslot 10:0&11:00, represented by the thin white peaks in the figure. Conversely, on Saturdays there is an excess of one worker in the period O9:O&l7:OO. The values of the objectives Fi are the following. The shortage of employees Fl is 15 person-hours, the excess of workers Fz is 7 person-hours, and the number of shifts used, F3, is 5, as listed in Table 7.3.

164

7.2.1


Related work

Though there is a large literature on shift scheduling problems (see, e.g., [12] for a recent survey), the larger body of work is devoted to the problem of allocation resources to shifts, for which network fbw techniques have, among others, been applied (e.g., [I, 21). Heuristics for a shift selection problem that has some similarity with minSHIFTDESIGNhave been studied by Thompson [17]. In [2], Bartholdi et al. noticed that a problem similar to SHIFT DESIGNcan be translated into a min-COST max-FLOWproblem (which is a polynomial problem, see, e.g., [16]) and thus efficiently solved. The translation can be applied under the hypothesis that the requirement of minimizing the number of selected shifts is neglected and the costs for assignments that do not fulfill the requirements are linear. To the authors knowledge, the only paper that deals explicitly with the formulation of the SHIFT DESIGNproblem considered in this work is a previous paper of M u s h et al. [15], which presents the OPA software. In Section 7.5, we will compare our heuristic solver with the implementation described in [15] by applying it to the set of benchmark instances used in that paper.

7.3

THEORETICAL RESULTS

In this section we prove that a restricted version of SHI SHIFT DESIGNis equivalent to the infinite capacities fbw problem on a Direct Acyclic Graph with unitary edge costs (UDIF), which, in turn, is a variant of min-COSTmaxFLOWproblem [3, Prob. ND32, page 2141. First we present the UDIF problem, which is a network fbw problem with the following features: (1) Every edge not incident to the sink or to the source, calledproper edge, has infinite capacity. Non-proper edges, namely edges incident to the source or to the sink, have arbitrary capacities. (2) The costs of proper edges is 1, whereas the cost of non-proper edges is 0. (3) The underlying fbw network is a Direct Acyclic Graph. (4) The goal is, as in the general problem, to find a maximum fbw f ( e ) over the edges (obeying the capacity and fbw conservation laws) and, among all maximum fbws, to choose the one minimizing the cost of edges carrying non-zero fbw. Hence, in this case, the problem is to minimize the number of proper edges carrying nonzero fbw (namely, minimizing I { e : f ( e ) > 0, e is proper) 1). Thanks to the equivalency between SHI SHIFT DESIGNand UDIF, a hardness of approximation result for UDIF carries over to SHI SHIFT DESIGNand,

Theory and practice of the minimum shift design problem

165

as we are going to see, we could prove a logarithmic lower bound on these problems. To simplify the theoretical analysis of min-SH1F~DESIGN,in this section we restrict ourselves to SHIFT DESIGNinstances where d = 1(i.e., workforce requirements are given for a single day only), and no shifts in the collection of possible shifts span over two days, that is, each shift starts and ends on the same day. We also assume that for the evaluation function, the weights for excess and shortage are equal and are much larger than weights for the number of shifts. This effectively gives priority to the minimization of deviation, thereby only minimizing the number of shifts for all those feasible solutions already having minimum deviation. It is useful to describe the shifts via 0 - 1matrices with the consecutive ones property. A matrix obeys the consecutive ones (el) property if all entries in the matrix are either 0 or 1 and all the 1 in each column appear consecutively. A matrix A for which the c l property holds is called a c l matrix. We now provide a formal description of min-SHIFTDESIGNby means of c l matrices as follows. We are given an n x m matrix A in which each column corresponds to a possible shift. Each entry ai, in the matrix is either 1 if i is a valid timeslot for shift s or 0 otherwise. Since the set of valid timeslots for a given shift type (and thus for a given shift belonging to a shift type) is made up of consecutive timeslots, A is clearly a c l matrix. Furthermore, we are given a vector b of length n of positive integers; each entry bi corresponds to the workforce requirement for the timeslot i. Within these settings, the minSHIFTDESIGNproblem can be stated as a system of inequalities: Ax 2 b with x E Zn,x 2 0, where the vectors x correspond to the shift assignments. The optimization criteria are represented as follows. Let Ai be the ith row in A, and llxlll denote the L1 norm of x. We are looking for a vector x 2 0 with the following properties: (1) The vector x minimizes IIAx - bill (i.e., the deviation from the staffing requirements). (2) Among all vectors minimizing 11 Ax - bill, x has a minimum number of non-zero entries (corresponding to the number of selected shifts). Given this formulation of the restricted variant of min-SHIFTDESIGNit is possible to prove the following result (the detailed proof is contained in [4]).

PROPOSITION 7.1 The restricted one-day noncyclic variant of SHIFT DESIGNwhere a zero deviation solution exists (i.e., h = 1, all shifts start and jinish on the same day, and Ax = b admits a solution), is equivalent to the UDIF problem. The proof proceeds as follows: first a fbw matrix F that preserves the solutions of the problem Ax = b is constructed, by means of a regular transforma-

166


tion of A. Then, after a little post-processing of F,the resulting fbw problem becomes an instance of UDIF. It is possible to show that this result can be exploited also for handling workforce shortage and excess (components Fl and F2 of the objective function), by introducing a set of n slack variables yi and solving the problem (A; -I)(x; y) = b. Moreover, if we neglect the problem of minimizing the number of shifts, the problem (A; -I) (x; y) = b can be transformed into a min-COSTmax-FLOW(MCMF) problem. This allows us to efficiently find the minimum (weighted) deviation from the workforce requirements, and this idea will be employed in the first stage of our heuristic presented in Section 7.4. We next state that, unless P = NP, there is some constant c < 1 such that approximating UDIF within c In n-ratio is NP-hard. Since the case of zero excess SHIFT DESIGNis equivalent to UDIF, similar hardness results follow for SHIFT DESIGNas well.

THEOREM 7.2 There is a constant c < 1 so that approximating the UDIF problem within c In n is NP-hard. The proof employs a reduction from the SET-COVER problem and is omitted for brevity.

7.4

HEURISTIC SOLVER

Our solution heuristic is divided into two stages, namely a greedy construction for the initial solution and a tabu search procedure [7] that iteratively improves it, which are described in the following subsections. In our experiments we evaluate the behavior of each stage and of the resulting hybrid algorithm, in order to analyze the sensitivity of the tabu search procedure to the starting point used.

7.4.1

Greedy constructive heuristic

Based on the equivalence of the (non-cyclic) min-s~IF'TDESIGNproblem to UDIF, and the relationship with the min-COST max-FLOW problem, we propose a new greedy heuristic GreedyMCMFO that uses a polynomial minCOSTmax-FLOWsubroutine (MCMFO). The pseudocode of the algorithm is reported in Figure 7.2. The algorithm is based on the observation that the min-COSTmax-FLOWsubroutine can easily compute the optimal staffing with minimum (weighted) deviation when slack edges have associated costs corresponding, respectively, to the weights of shortage and excess. Note that, however, the algorithm is not able to simultaneously minimize the number of shifts that are used. Since the MCMF() subroutine cannot consider cyclicity, we must first perform a preprocessing step that determines a good split-off time where the cycle

Theory and practice of the minimum shift design problem function GreedyMCMF(S,b): MSD-Solution I* I. Preprocessing step: where to break cyclicity? */ t := FindBestSplitOf%Time(S,b); // Searchfor a split-off on the P day of the cycle /* 2. Greedypart with MCMF subroutine */ f * := MCMF(MSD2Flow(S,b,t)); /I Compute bestflow sofar for MSD instance a := ShiftsAndWorkforceIn(f*); I/ Shifts are edges withflow # 0; worvovce is edgeflow min-cost := MSD_Eval(a); /I Cost of the best MSD solutionfound so far Q := ShiftsInUseIn(a); N Shzjis in the current solution /I Shzjis already tried T := 0; repeat s := UniformlyChooseAShiftFrom(Q \ T); // Consider a shift s that is used but not tried yet f := MCMF(MSD2Flow(Q \ {s},b,t)); N Try to solve the problem without shift s a := ShiftsAndWorkforceIn(f); /I Extract shifts and worvorce from flow solution current-cost := MSD-Eval(a); N Compute the cost of the current solution if current-cost < min-cost then min-cost := current-cost; // Solution with one shift less and lower cost I/ Update the best solutionfound sofar f * := f ; Q := ShiftsInUseIn(o); N Could be less than Q \ {s} endif T := T U {s); /IAdd s to shifts already tried until Q \ T = 0; N Cycle until no shift to try is left /* 3. Postprocessing step to recover cyclicity,peflonn a local search with the ExchangeStaff move */ a := SteepestDescent(ShiftsAndWorkforceIn(f *), Exchangestaff); return o;

Figure 7.2. The Greedy min-COST max-FLOW (MCMF) subroutine computes a solution for the min-SHIFT DESIGN (MSD) problem

of d days should be broken. This is done heuristically by calling MCMF() with different starting times chosen between 5:00 and 8:00 on the first day of the cycle (in practice, we can observe that there is usually a complete exchange of workforce between 5:00 and 8:00 on the mornings of the first day). All possibilities in this interval are tried while eliminating all shifts that span the chosen starting point when translating from MSD to the network fbw instances. The number of possibilities depends on the length of the timeslots of the instance (i.e., the time granularity). The starting point with the smallest cost as determined by MCMF() is used as the split-off time for the rest of the calls to MCMF() in GreedyMCMF. This method has been shown to provide adequate results in practice. In the main loop, the greedy heuristic then removes all shifts that did not contribute to the MSD instance corresponding to the current fbw computed with MCMF(). It randomly chooses one shift (without repetitions) and tests whether removal of this shift still allows the MCMF() to find a solution with the same deviation. If this is the case, that shift is removed and not considered anymore, otherwise it is left in the set of shifts used to build the network fbw instances, but it will not be considered for removal again. Finally, when no shifts can be removed anymore without increasing the deviation, a final postprocessing step is made to restore cyclicity. It consists of

168


a simple repair step performed by a fast steepest descent runner that uses the Exchangestaffneighborhood relation (see below). The runner selects at each iteration the best neighbor, with a random tie-break in case of same cost. It stops as soon as it reaches a local minimum, i.e., when it does not find any improving move. As our MCMF() subroutine, we use CS2 version 3.9 (@ 1995 - 2001 IG Systems, Inc., h t t p ://www .avglab .com/andrew/sof t .html), an efficient implementation of a scaling push-relabel algorithm [9], slightly edited to be callable as a library.

7.4.2

Multi-Neighborhood Search for Shift Design

The second stage of the proposed heuristic is a local search procedure based on multiple neighborhood relations. We first define the search space, then describe the set of neighborhood relations for the exploration of this search space, followed by the search strategies we employ. Search space. We consider as a state for MSD a pair (Q, X ) made up of a set of shifts Q = {sl,s2, . . .) and their staff assignment X = {xl, 22,. . .). The shifts of a state are split into two categories:

Active shifts: at least one employee is assigned to a shift of this type on at least one day. Inactive shifts: no employees are assigned to a shift of this type on any day. These shifts does not contribute to the solution and to the objective function. Their role is explained later. More formally, we say that a shift si E Q is active (resp. inactive) if and only if d xj(si) # 0 (= 0). Neighborhood exploration. In this work we consider three different neighborhood relations that are combined in the spirit of the Multi-Neighborhood search described in [5]. In short, the Multi-Neighborhood Search consists in a set of operators for automatically combining basic neighborhoods and in a set of strategies for combining algorithms (called runners) based on different neighborhoods. The motivation for applying a combination of neighborhoods comes from the observation that for most problems there is more than one natural neighborhood that deserves to be investigated. Furthermore, using different neighborhoods or algorithms in different phases of the search increases diversification, thereby improving the performance of the local search metaheuristics. The way the neighborhoods are employed during the search is explained later. In the following we formally describe each neighborhood relation by means of the attributes needed to identify a move, the preconditions for its

Theory andpractice of the minimum shift design problem

169

applicability, the effects of the move and, possibly, some rules for handling special cases. Given a state ( Q ,X) of the search space the types of moves considered in this study are the following: Changestaff (CS): The staff of a shift si is increased or decreased by one employee, that is either xg (si) := xj (si) 1, or xg (si) := xj (si) - 1.

+

If si is an inactive shift and the move increases its staff, then si becomes active and a new randomly created inactive shift of type K ( s i )is inserted (distinct from the other shifts). Exchangestaff (ES): One employee in a given day is moved from one shift sil to another one of the same type (say si2),i.e., xi(sil) := xj(si1)- 1 and x$(si2):= xj(si2) 1.

+

If si, is an inactive shift, si, becomes active and a new random distinct inactive shift of type K ( s i l ) is inserted (if such a distinct shift exists). If the move makes si, inactive then, in the new state, the shift sil is removed from the set Q. Resizeshift (RS): The length of a shift si is increased or decreased by one time slot, either on the left-hand side or on the right-hand side of the interval. For this kind of move we require that the shift sb, obtained from si by the application of the move must be feasible with respect to the shift type K (si).

We denote with 6 the size modification to be applied to the shift si, that is S = +l when the shift is enlarged by one timeslot and 6 = -1 when the shift is shrunk. If the action should be performed on the left-hand side of si we have that a: := ai - Sh and X i := Xi Sh. Conversely, if the move should take place on the right-hand side ai remains unchanged and := Xi Sh.

+

+

In a previous work, Musliu et al. [15] define many neighborhood relations for this problem including CS, ES, and a variant of RS. In this work, instead, we restrict ourselves to the above three relations for the following two reasons: First, C S and R S represent the most atomic changes, so that all other move types can be built as chains of moves of these two. For example, an ES move can be obtained by a pair of C S moves that delete one employee from the first shift and add one to the other shift. Secondly, even though ES can be seen as a composition of two more basic moves as just explained, we employ it because it turned out to be very effective for the search, especially in combination with the concept of inactive shifts. In fact, the transfer of one employee from a shift to a similar one makes a very

170


small change to the current state, thus allowing for fine grained adjustments that could not effectively be achieved by the other move types. Inactive shifts allow us to insert new shifts and to move staff between shifts in a uniform way. This approach limits the creation of new shifts only to the current inactive ones, rather than considering all possible shifts belonging to the shift types (which are many more). The possibility of creating any legal shift is rescued if we insert as many (distinct) inactive shifts as compatible with the shift type. Experimental results, though, show that there is a trade-off between computational cost and search quality which seems to have its best compromise in having two inactive shifts per type.

Search strategies. For the purpose of analyzing the behavior of the local search heuristic alone, we provide also a mean to generate a random initial solution for the local search algorithm. That is, we create a fixed number of random distinct active and inactive shifts for each shift type. Afterwards, for the active shifts, we assign a random number of employees for each day. In detail, the parameters needed to build a solution are the number of active and inactive shifts for each shift type and the range of the number of employees per day to be assigned to each random active shift. For example, in the experimental session described in Section 7.5, we build a solution with four active and two inactive shifts per type, with one to three employees per day assigned to each active shift. If the possible shifts for a given shift type are less than six, we reduce the generated shifts accordingly, giving precedence to the inactive ones. The proposed local search heuristic is based on tabu search, which turned out to give the best results in a preliminary experimental phase. However, we have developed and experimented also with a set of solvers based on the hill climbing and simulated annealing meta-heuristics. A full description of tabu search is out of the scope of this paper and we refer to [7] for a general introduction. We describe later in this section its specialization to the MSD problem. We employ the three neighborhoods defined above selectively in various phases of the search, rather than exploring all neighborhoods at each iteration. In detail, we combine the neighborhood relations CS, ES, and RS, according to the following scheme made of compositions and interleaving (through the, so-called, token-ring search strategy). That is, our algorithm interleaves three different tabu search runners using the ES move alone, the RS move alone, and the set-union of the two neighborhoods C S and RS, respectively. The token-ring search strategy implemented is the same as that described in 151, i.e., the runners are invoked sequentially and each one starts from the best state obtained from the previous one. The overall process stops when a full round of all of them does not find an improvement. Each single runner


171

stops when it does not improve the current best solution for a given number of iterations. The reason for using only some of the possible neighborhood relations introduced in [15] is not related to the saving of computationaltime, which could be obtained in other ways, for example by a clever ordering of promising moves, as done in the cited paper. The main reason, instead, is the introduction of a suitable degree of diversijcation in the search. In fact, certain move types would be selected very rarely in a full-neighborhood exploration strategy, even though they could help to escape from local minima. For example, we experimentally observe that a runner that uses all the three neighborhood relations combined by means of the union operator would almost never perform a CS move that deteriorates the objective function. The reason for this behavior is that such a runner can always find an ES move that deteriorates the objectives by a smaller amount, even though the CS move could lead to a more promising region of the search space. This intuition is confirmed by the experimental analysis that shows that our results are much better than those in [15]. This composite solver is further improved by making two adjustments to the final state of each runner, the results of which is then handed over as the initial state to the following runner, as follows: Identical shifts are merged into one. When RS moves are used, it is possible that two shifts become identical. This is not checked by the runner after each move as it is a costly operation, and is therefore left to this inter-runner step. Inactive shifts are recreated: the current inactive shifts are deleted, and new distinct ones are created at random in the same quantity. This step, again, is meant to improve the diversification of the search algorithm. Concerning the prohibition mechanism of tabu search, for all three runners, the size of the tabu list is kept dynamic by assigning to each move a number of tabu iterations randomly selected within a given range. The ranges vary for the three runners, and were selected experimentally. The ranges are roughly suggested by the cardinality of the different neighborhoods, in the sense that a larger neighborhood deserves a longer tabu tenure. According to the standard aspiration criterion defined in [7], the tabu status of a move is dropped if it leads to a state better than the current best. As already mentioned, each runner stops when it has performed a fixed number of iterations without any improvement (called idle iterations). For practical reasons, in order to avoid the setting of parameters by an enduser, tabu lengths and idle iterations are selected once for all, and the same values were used for all the instances. The selection turned out to be robust

172


Table 7.4. Tabu search parameter settings Parameter Tabu range

TS(ES)

TS(RS)

TS(CSURS)

10-20

5-10

Idle iterations

300

300

20-40 (CS) 5-10 (RS) 2000

enough for all tested instances. The choice of parameter values is reported in Table 7.4.

7.5

COMPUTATIONAL RESULTS

In this section, we describe the results obtained by our solver on a set of benchmark instances. First, we introduce the instances used in this experimental analysis, then we illustrate the performance parameters that we want to highlight, and finally we present the outcomes of the experiments.

7.5.1

Description of the Sets of Instances

The instances consist of three different sets, each containing thirty randomly generated instances. Instances were generated in a structured way to ensure that they look as similar as possible to real instances while allowing the construction of arbitrarily difficult instances. Set 1 contains the 30 instances that were investigated and described in [15]. They vary in their complexity and we mainly include them to be able to compare the solvers with the results reported in that paper for the OPA implementation. Basically, these instances were generated by constructing feasible solutions with some random elements as they usually appear in real instances, and then taking the resulting staffing numbers as workforce requirements. This implies that a very good solution with zero deviation from workforce requirements is known. Note that our solver could find even better solutions for several of the instances, so these reference solutions may be suboptimal. Nevertheless, we refer in the following to the best solutions we could come up with for these instances as the "best known " solutions. Set 2 contains instances that are similar to those of Set 1. However, in this case the reference solutions of instances 1 to 10 were constructed to feature 12 shifts, those of instances 11 to 20 to feature 16 shifts, and those of instances 21 to 30 to feature 20 shifts. This allows us to study the relation between the number of shifts in the "best known" solutions and the running times of the solver using the different settings. While knowing these "best known" solutions eases the evaluation of the proposed solver in the different settings, it also might form a biased preselection toward instances where zero deviation solutions exist for sure, thereby letting the solver behave in ways that are unusual for instances for which no such so-


173

lution can be constructed. For this reason, the remaining set is composed of instances where with high likelihood solutions without deviations do not exist: Set 3 contains instances without reference solutions. They were constructed with the same random instances generator as the previous sets but allowing the constructed solutions to contain invalid shifts that deviate from normal starting times and lengths by up to 4 timeslots. The number of shifts is similar to those in Set 2, i.e., instances 1 to 10 feature 12 shifts (invalid and valid ones), and so on. This construction ensures that it is unlikely that there exist zero deviation solutions for these instances. It might also be of interest to see whether a significant difference in performance for the solver employing the different settings can be recognized compared to Set 2, which would provide evidence that the way Sets 1 and 2 were constructed constituted a bias for the solver. All sets of instances are available in self-describing text files from h t t p : //www .dbai .tuwien. ac .a t / p r o j /Rota/benchmarks .h t m l . A detailed description of the random instance generator used to construct them can be found in [15].

7.5.2

Experimental setting

In this work we made two types of experiments, aiming at evaluating two different performance parameters: 1) the average time necessary to reach the best known solution; 2) the average cost value obtained within a time bound. Our experiments have been run on different machines. The local search solvers are implemented in C++ using the EASYLOCAL++ framework [6] and they were compiled using the GNU g++ compiler version 3.2.2 on a 1.5 GHz AMD Athlon PC running Linux Kernel 2.4.21. The greedy min-COST maxFLOWalgorithm, instead, was coded in MS Visual Basic and run on a MS Windows NT 4.0 computer. The running times have been normalized according to the DIMACS netfbw benchmark ( f t p ://dimacs. r u t g e r s . e d ~ / ~ u b / n elow/benchmarks/c/) tf to the times of the Linux PC (calibration timings on that machine for above benchmark: t l .wm: user 0.030 sec t 2 .wm: user 0.360 sec). Because of the normalization the reported running times should be taken as indicatory only. We experiment with the following three heuristic solvers: GrMCMF The GreedyMCMFO algorithm is called repeatedly until the stopping criterion is reached. Since the selection of the next shift to be removed in the main loop of GreedyMCMFO is done randomly, we call the basic heuristic repeatedly and use bootstrapping as described in [I 11 to compute expected values for the computational results (counting the

174

Metaheuristics: Progress as Real Problem Solvers preprocessing step only once for each instance since it computes the same split-off time for all runs).

TS The tabu search procedure is repeated several times starting from different random initial solutions. The procedure is stopped either when the time granted has elapsed or when the best solution is reached. Each round of the tabu search procedure is allowed to run at most for 10 seconds. GrMCMF+TS The two solvers are combined in a hybrid heuristic by using the solutions delivered by the GreedyMCMFO procedure as initial states for TS trials. In order to maintain diversification, we exploit the non-determinism of GreedyMCMFO to generate many different solutions, and the initial state of each trial of TS is randomly selected among those states.

7.5.3

Time-to-best results

The first experiment evaluates of the running times needed to reach the "best known" solution. We ran the solvers on data Set 1 for 10 trials until they could reach the "best known" solution, and we recorded the running times for each trial. Table 7.5 shows the average times and their standard deviations (between parentheses) expressed in seconds, needed by our solvers to reach the best known solution. The first two columns show the instance number and the best known cost for that instance. The third column reports the cost of the best solution found by the commercial tool OPA. Bold numbers in the second column indicate that the best known solution for this instance was not found by OPA. Dash symbols denote that the best known solution could not be found in any of the 10 trials for those instances. First, note that all three solvers in general produce better results than the commercial tool. In fact, TS always finds the best solution, GrMCMF in 20 cases and GrMCMF+TS in 29 cases out of 30 instances. OPA, instead, could find the best solution only for 17 instances. However, looking at the time performance on the whole set of instances, it is clear that TS is roughly 30 times slower than GrMCMF and 1.5 times slower than the hybrid heuristic. GrMCMF+TS is significantly outperformed by TS only for some few instances for which GrMCMF could not find the best known solution, thus biasing the local search part of the heuristic away from search space near the best known solution. As a general remark, the TS algorithm proceeds by relatively sudden improvements, especially in the early phases of the search, while the behavior of the GrMCMF+TS is much smoother (we omit graphs showing this for brevity). Thus, it is easier to predict the benefits of letting GrMCMF+TS run for a longer period of time compared to TS alone.


175

Table 7.5. Times to reach the best known solution for Set 1. Data are averages and standard deviations (between parentheses) for 10 trials. Instance 1

Best 480 300

600 450

480 420

OPA ~ 5 1 480 390 600 1,170 480 420

GrMCMF 0.07 0.11 0.20 0.06

(0.00) ((0.01) ((0.16) (0.01)

TS 5.87 16.41 8.96 305.37 5.03 2.62

(4.93) (9.03) (5.44) (397.71) (2.44) (0.99)

GrMCMF+TS 1.06 40.22 1.64 108.29 1.75 0.62

(0.03) (27.93) (0.05) (75.32) (1.43) (0.02)

Starting local search from the solution provided by GrMCMF has also an additional benefit in terms of the increase of robustness, roughly measured by the standard deviations of the running times. In fact, for this set of instances, while the standard deviation for TS is about 50% of the average running time, this value decreases to 35% for GrMCMF+TS. The behavior of the GrMCMF solver is similar to the one of the hybrid heuristic and the standard deviation is about 35% of the average running time.

7.5.4

Time-limited experiments

Moving to the time-limited experiments, we perform two experiments on the different sets of instances. The first experiment with limited running times aims at showing how the solver scales up with respect to the optimum number of shifts. For this purpose we recorded the cost values of 100 runs of our solvers with the different settings on the instances of Sets 1 and 2, for which


Figure 7.3. Aggregated normalized costs for 10s time-limit on data Sets 1 and 2.

the value of a good solution is known. The runs were performed by granting to each trial a time-limit of 10 seconds. The results of the experiment are grouped on the basis of the instance size and are shown in Figure 7.3. The X axis of the figure shows the number of shifts in the best known solution where results on instances with the same number of shifts are clustered together. The Y axis shows normalized costs, obtained by dividing the difference between the average cost and the best cost by the latter value. In other words, each cost y obtained on instance i, for which the best known cost is besti, is transformed by means of the function y - besti f d y ) := The graph presents the data as box-and-whiskers plots, i.e., it shows the range of variation (the interval [fi(min-cosc), fi(max-cos~)]),denoted by the dashed vertical line, and the frequency distribution of the solutions. The latter measure is expressed by means of a boxed area featuring the range between the 1st and the 3rd quartile of the distribution (accounting for 50% of the fiequency). The horizontal line within the box denotes the median of the distribution and the notches around the median indicate the range for which the difference of medians is significant at a probability level of p < 0.05. The figure shows that, for short runs, the hybrid solver is superior to GrMCMF and T S alone, both in terms of solution quality and robustness: the ranges of variation are shorter and the frequency boxes are tinier. Looking at these results from another point of view, it is worth noting that GrMCMF+TS is able to find more low-cost (and even min-cost) solutions that are significantly better than those found by T S and GrMCMF. Furthermore, it is apparent that the hybrid heuristic scales better than its components, since the ",

x-

-

-

-

neory and practice of the minimum shift design problem

177

Table 7.6. Results for Set 3: cost values within 1s time-limit. Data are averages and standard deviations (between parentheses) of 100 trials. The best algorithm on each instance is highlighted in boldface; the symbol t denotes the cases for which the difference between the distribution of solutions was not statistically significant (Ma-Whitney test with p < 0.01). Instance

GrMCMF 2,445.00 (0.00)

TS 9,916.35 (3,216.35)

GrMCMF+TS 2,386.80 (9.60)

deterioration in the solution quality with respect to the number of shifts grows very slowly and always remains under an acceptable level (7% on the worst case, and about 2% for 75% of the runs). The second time-limited experiment aims at investigating the behavior of the solver when provided with a very short running time on "unknown" instances (we use here the term "unknown" by contrast with the sets of instances constructed around a reference solution). We performed this experiment on the third data set and we recorded the cost values found by our solver over 100 trials. Each trial was granted 1 second of running time, in order to simulate a practical situation in which the user needs a fast feedback from the solver. For this problem, speed is of crucial importance to allow for immediate discussion in working groups and refinement of requirements, especially if such a solver is used during a meeting with customers. Hence, without quick answers, understanding requirements and consensus building is much more difficult.

178


In Table 7.6 we report the average and the standard deviation (between parentheses) of the cost values found by each heuristic. In this case the hybrid heuristic performs better than TS on all instances, and it shows a better behavior in terms of algorithm robustness (in fact, the standard deviation of GrMCMF+TS is usually more than an order of magnitude smaller than the one of TS). Moreover, even the GrMCMF achieves better results than the TS heuristic, due to the running time performance of the local search procedure. However, differently from the results of the previous experiment, the hybrid heuristic does not dominate the GrMCMF on all instances. In fact, it is possible to see that GrMCMF+TS finds better results on 15 instances, whereas GrMCMF prevails in 8 cases. On 7 instances there is no clear winner among the two heuristics, and these cases are indicated by the symbol t in the table. The reason of this behavior is related to the amount of running time needed by the local search procedure. Indeed, in another experiment (omitted for brevity) with a higher time-limit, the behavior of the three heuristic tends to be similar to the one observed in the previous experiment, indicating the absence of bias in the construction of sets 1 and 2 of instances.

7.6

CONCLUSIONS

The SHIFT DESIGNproblem is an important shift scheduling problem that arises in many industrial contexts. We provided complexity results for it and designed a hybrid heuristic algorithm composed of a constructive heuristic (suggested by the complexity analysis) and a multi-neighborhood tabu search procedure. This problem appears to be quite difficult in practice, even for small instances, which is also supported by the theoretical results. An important source of hardness is related to the variability in the size of the solution, since dropping this requirement makes the problem solvable in polynomial time. In the experimental part, the hybrid heuristic and its underlying components have been evaluated both in terms of ability to reach good solutions and in quality of solutions reached in fast runs. The outcomes of the comparison show that the hybrid heuristic combines the good features of its components. Indeed, it obtained the best performances in term of solution quality (thanks to the increased thoroughness allowed by tabu search) but with a lower impact on the overall running time. Furthermore, we compare our heuristics with the results obtained with a commercial software as reported [15]. Our hybrid heuristic clearly outperforms this commerical implementation, and thus can be considered as the best general-purpose solver among the other heuristics that were compared to it.


REFERENCES [I] N. Balakrishnan and R.T. Wong. A network model for the rotating workforce scheduling problem. Networks, 20:2542, 1990. [2] J. Bartholdi, J. Orlin, and H.Ratliff. Cyclic scheduling via integer programs with circular ones. Operations Research, 28: 110-1 18, 1980. [3] M. R. Garey and D. S. Johnson. Computers and Intractability--A guide to NP-completeness. W.H. Freeman and Company, San Francisco, 1979. [4] L. Di Gaspero, J. Girtner, G. Kortsarz, N. Musliu, A. Schaerf, and W. Slany. The minimum shift design problem: theory and practice. In Giuseppe Di Battista and Uri Zwick, editors, Proc. of the 11th Annual European Symposium on Algorithms (ESA 2003), number 2832 in Lecture Notes in Computer Science, pages 593-604. Springer-Verlag, BerlinHeidelberg, 2003. ISBN 3-540-20064-9. [5] L. Di Gaspero and A. Schaerf. Multi-neighbourhood local search with application to course timetabling. In E. Burke and P. De Causmaecker, editors, Lecture Notes in Computer Science, number 2740 in Lecture Notes in Computer Science, pages 263-278. Springer-Verlag, BerlinHeidelberg, 2003. ISBN 3-540-40699-9. [6] L. Di Gaspero and A. Schaerf. EASYLOCAL++: An object-oriented framework for fixible design of local search algorithms. Software Practice & Experience, 33(8):733-765, July 2003. [7] F. Glover and M. Laguna. Tabu search. Kluwer Academic Publishers, Boston, July 1997. ISBN 0-7923-9965-X. [8] F. Glover and C. McMillan. The general employee scheduling problem: An integration of MS and AI. Computers & Operations Research, 13(5): 563-573,1986. [9] A.V. Goldberg. An efficient implementation of a scaling minimum-cost fbw algorithm. Journal of Algorithms, 22: 1-29, 1997. [lo] W.K. Jackson, W.S. Havens, and H. Dollard. Staff scheduling: A simple approach that worked. Technical Report CMPT97-23, Intelligent Systems Lab, Centre for Systems Science, Simon Fraser University, 1997. Available at http: //citeseer .nj .nec.com/lOlO34. html. [I 11 D.S. Johnson. A theoretician's guide to the experimental analysis of algorithms. In Proc. 5th and 6th DIMACSImplementation Challenges. American Mathematical Society, 2002. URL ht tp :/ /www .research. att.com/"dsj/papers/experguide.ps. [12] G. Laporte. The art and science of designing rotating schedules. Journal of the Operational Research Society, 50: 1011-1 0 17, 1999.

180


[13] H.C. Lau. On the complexity of manpower scheduling. Computers & Operations Research, 23(1):93-102, 1996. [14] N . Musliu, J . Gartner, and W. Slany. Efficient generation of rotating workforce schedules. Discrete Applied Mathematics, 1 1 8(1-2):85-98,2002. [15] N . Musliu, A. Schaerf, and W. Slany. Local search for shift design. European Journal of Operational Research, l53(1):5144,2004. [16] C.H. Papadirnitriou and K. Steiglitz. Combinatorial Optimization: Algorithms and Complexity. Prentice-Hall, 1982. [17] G. Thompson. A simulated-annealing heuristic for shift scheduling using non-continuously available employees. Computers & Operations Research, 23(3):275-278, 1996. [ I 81 J.M. Tien and A. Kamiyama. On manpower scheduling algorithms. SIAM Review, 24(3):275-287, 1982.

Chapter 8

LOCAL SEARCH ALGORITHMS FOR THE TWO-DIMENSIONAL CUTTING STOCK PROBLEM WITH A GIVEN NUMBER OF DIFFERENT PATTERNS Shinji Imahori,' Mutsunori Yagiura,' Shunji ~ m e t a n iShinya ,~ Adachi2 and Toshihide Ibaraki4 Department of Mathematical Informatics, Graduate School of Information Science and Technology, University of Tokyo, Hongo, Bunkyo-hi, Tokyo 113-8656, Japan

'Department of Applied Mathematics and Physics, Graduate School of Informatics, Kyoto University, Sakyo-ku, Kyoto 606-8501, Japan Cyagiura, shin)@arnp.i.kyoto-u.ac.jp

3 ~ e p a r t m e n tof Advanced Science and Technology, Graduate School of Engineering, Toyota Technological Institute, Tenpalm-ku, Nagoya 468-8511, Japan [email protected]

4 ~ e p a r t m e n tof Informatics, School of Science and Technology, Kwansei G a h i n University, Gakuen, Sanda 669-1337, Japan [email protected]

Abstract: We consider the two-dimensional cutting stock problem that arises in many applications in industries. In recent industrial applications, it is argued that the setup cost for changing patterns becomes more dominant and it is impractical to use many different cutting patterns. Therefore, we consider the pattern restricted two-dimensional cutting stock problem, in which the total number of applications of cutting patterns is minimized while the number of different cutting patterns is given as a parameter n. For this problem, we develop local search algorithms. As the neighborhood size plays a crucial role in determining the efficiency of local search, we propose to use linear programming techniques for the purpose of restricting the number of solutions in the neighborhood. In this process, to generate a cutting pattern, it is required to place all the given products (rectangles) into the stock

182


sheet (two-dimensional area) without mutual overlap. For this purpose, we develop a heuristic algorithm using an existing rectangle packing algorithm with the sequence pair coding scheme. Finally, we generate random test instances of this problem and conduct computational experiments, to evaluate the effectiveness of the proposed algorithms.

Keywords: Two-dimensional cutting stock problem, linear programming, rectangle packing, neighborhood, local search.

8.1

INTRODUCTION

We consider the two-dimensional cutting stock problem, which is one of the representative combinatorial optimization problems, and arises in many industries such as steel, paper, wood, glass and fiber. The problem can be defined as follows: We are given an unlimited number of stock sheets of the same width W and height H, and m types of rectangular products, where each product i has its width wi, height hi and demand di. From stock sheets, we have to cut rectangular products whose numbers are specified as demands. The objective is to minimize the total number of stock sheets required. This problem is NP-hard, since this is a generalization of the two-dimensional bin packing problem and the (one-dimensional) cutting stock problem, which are already known to be NP-hard [5]. A classical approach to the one-dimensional cutting stock problem (1DCSP) is to formulate it as an integer programming problem (IP), and solve it by a heuristic method based on its linear programming (LP) relaxation. As it is impractical to consider all cutting patterns ("a pattern" is a set of rectangles which can be placed in one stock sheet), Gilmore and Gomory [6,7]proposed a column generation technique that generates only the cutting patterns (which correspond to columns in the LP relaxation) necessary to improve the lower bound of IP by solving the associated knapsack problems. The LP relaxation often has the property that the round up of the LP lower bound is equal to the optimal value of IP [14]. Based on these ideas, branch-and-bound, heuristic and metaheuristic algorithms with the column generation technique have been developed with certain computational success [20]. It is however observed that those approaches tend to use many (very close to the number of product types) different cutting patterns. In recent cutting industries, the setup cost for changing patterns is more significant and it is often impractical to use many different cutting patterns. Several researchers (e.g., Foerster and Wascher [4], Haessler [9], Umetani et al. [17]) have proposed algorithms for 1DCSP with consideration on the number of cutting patterns.

Local Search Algorithms for 2DCSPn

183

The two-dimensional cutting stock problem (2DCSP) has also been extensively studied. Gilmore and Gomory [8] extended their previous work, column generation scheme, on 1DCSP [6,7]to the two-dimensional case. Afterwards, various heuristic algorithms based on the column generation technique have been proposed [1,3,19,2l]. Nevertheless, to the authors' knowledge, there is no study on 2DCSP under the constraint on the number of different patterns. In this paper, we consider the two-dimensional cutting stock problem using a given number of different patterns n (we call this problem 2DCSPn). 2DCSPn asks to determine a set of cutting patterns, whose size is n or less, and the numbers of applications of the generated cutting patterns. The objective is to minimize the total number of applications of cutting patterns. The problem of deciding the number of applications for each pattern becomes IP. In Section 8.2, we propose a heuristic algorithm for IP, which is based on its LP relaxation. We incorporate a sensitive analysis technique and the criss-cross method [22], a variant of simplex method, to enhance the effectiveness of our algorithm. In Section 8.3, we propose local search (LS) algorithms to find a good set of cutting patterns. As the size of the neighborhood plays a crucial role in determining the efficiency of LS, we propose to utilize the dual solution of the LP relaxation for the purpose of restricting the neighborhood size. To generate a feasible cutting pattern, we have to place all the given products in the stock sheet (two-dimensional area) without mutual overlap. At this placement stage, we assume that each product can be rotated by 90°, and assume no constraint on products' placement such as "guillotine cut". In Section 8.4, we propose heuristic algorithms to find a feasible placement, which are based on our previous algorithms for the two-dimensional rectangle packing problem [lo,111. In Section 8.5, the outline of our entire local search algorithm, which is comprised of those algorithms proposed in Sections 8.2, 8.3 and 8.4, is described. In Section 8.6, we generate random test instances of 2DCSP and conduct computational experiments to compare two algorithms using basic and enhanced neighborhoods. We also compute the trade-off curve between the number of different cutting patterns n and the solution quality.

8.2

PROBLEM

To define 2DCSP, we are given an unlimited number of stock sheets of the same width W and height H, and m types of rectangular products M = {1,2,. . .,m), where each product i has its width wi, height hi and


184

demand di. A cutting pattern p j is described as pj = (alj, aaj, . . . ,amj), where aij E Z+ (the set of nonnegative integers) is the number of product i cut from a stock sheet by pattern pj. A placement of products in a pattern is defined by a set of their locations in one stock sheet together with their orientations (i.e., the original direction or rotated by 90°), where a placement is feasible if all the products are placed in one stock sheet without mutual overlap. We call a pattern p j feasible if it has a feasible placement. Let S denote the set of all feasible patterns. Note that, the set S is very large and it is not explicitly given; i.e., we must find a feasible placement to confirm that a pattern is feasible. A solution to 2DCSP consists of (1) a set of cutting patterns II = {pl, p2, . . . ,plnl}5 S, (2) a feasible placement of each pattern p j E IT, and (3) the numbers of applications X = (x17x2,. . . ,xlrrl)of all the patterns p j E II, where x j E Z+. A typical cost function is the total number of stock sheets used in a solution. This problem is formally described as follows: 2DCSP:

minimize

x

f (II, X ) =

xj

(8.1)

pjEn

subject to

C a ~ x>j di7 for i E M, pj En

7 II 5 s Xj

E

z+,for pj E n.

In this paper, we consider a variant of 2DCSP with an input parameter n, where n is the number of maximum different cutting patterns Ill\. We call this problem the two-dimensional cutting stock problem with a given number of different patterns n (2DCSPn), which is formally defined as follows: 2DCSPn:

minimize

f (II, X) =

x

xj

(84

pj En

subject to

C aijxj 2 di, for i E M, P~EII

II E 7 s PI 5 n, x j E Z+, for p j E II. Now, we consider lower bounds on the total number of stock sheets used for 2DCSP. A simple lower bound is the so-called continuous lower

Local Search Algorithms for 2DCSPn bound, L1, which is defined as follows:

This bound is easy to compute (it can be computed in O(m) time), and is a good bound when there are many products of small sizes. We also introduce another lower bound L2, which works effectively if there are many large products. This lower bound is obtained by concentrating on large products, and is a little complicated since each product can be rotated by 90'. We note that other lower bounds are known for the two-dimensional bin packing problem without rotation [14]. For each product i, we define wf and hf as follows: wf = hf = min{wi, hi) wf = wi, hf = hi ~f = h i , hf = wi

(if max{wi, hi) 5 min{W, H)), (if wi > H or hi > W), (if wi > W or hi > H).

(8.4)

Given a constant q, with 0 < q 5 H / 2 , we define

No two products i E and j E {My(q) U ~ p ' ( q ) )can be packed into the same stock sheet, and at most [H/qJ products in can be packed into one stock sheet. Therefore, we have the following lower bound:

This bound algorithm.

LY can be computed in O(m log m) time with the following

Algorithm Compute

LY

Step 1: Divide the set of all products M into two sets M W and M\MW. For each product i E MW, if hf 5 H/2, set s(i) := hf; otherwise set s(i) := H - hf E (0 < E 0 do not affect the LP solution, we can not improve the current LP value by this operation. However, if we apply this, we may find a better solution in the subsequent iterations in our local search.

Replacement operation.

If all products in a pattern p j are removed by the redundancy reduction and basic operations, we must reconstruct a new pattern from scratch. This situation always occurs for p j with Gj = 0. To find a new pattern with small trim loss, we keep in memory cn (c is a parameter and we use c = 3) cutting patterns having small trim loss, which were obtained by then, and choose one from them. We call this as the replacement operation.

Enhanced neighborhood.

Now, our new neighborhood is the set of solutions obtained from by applying the operations proposed in this section (i.e., basic, redundancy reduction, filling-up and replacement). We call this neighborhood as the enhanced neighborhood. These two neighborhoods, basic and enhanced, will be computationally compared in Section 8.6.

8.5

FEASIBILITY CHECK FOR A PATTERN

For a given cutting pattern pj, we must check its feasibility (i.e., find a feasible placement of the products in this pattern). This feasibility check is trivial for IDCSP, since we just check the following inequality:

where li is the length of product i and L is the length of the stock roll. On the other hand, the problem is hard for the two-dimensional case; because, in general, we must solve the two-dimensional rectangle packing problem (2DRPP). In this section, we first propose two simple methods to check the feasibility of a given two-dimensional pattern. These methods, however, work well only for some special cases. We then propose a heuristic algorithm to find a feasible placement.


191

We first check a given pattern pj against the continuous lower bound, aijwihi 5 WH. (EM

The pattern is obviously infeasible if this inequality is not satisfied. The second method is used to check a pattern constructed in our neighborhood search. In this case, we remove some products from the current (feasible) pattern and add some products to this pattern. A new pattern has a feasible placement if the products to be added are smaller than the removed products. For example, if we remove two products i and i1 from a pattern, and then add two products, one of them is smaller than i and the other is smaller than it, then the resulting pattern is known to be feasible without solving the rectangle packing problem. In other cases, however, we must tackle 2DRPP which is NP-hard.

Two-Dimensional Rectangle Packing Problem Input: A set of rectangles and one stock sheet, each of the rectangles and the stock sheet having its width and height. Output: The locations (l:, 1;) and orientations of all rectangles k in the stock sheet such that no two rectangles overlap each other. There are many heuristic algorithms in the literature proposed for this problem. Basic ingredients of such algorithms are as follows. 1 Coding scheme: How to represent a solution.

2 Decoding algorithm: How to compute a placement from a coded solution. 3 Search strategy: How to find a good coded solution. In this paper, we use a coding scheme called the sequence pair [15]. A sequence pair is a pair of permutations a = (a+,a_)of given rectangles where a+(a)= k (equivalently a r l ( k ) = a) means that the rectangle k is the a t h rectangle in a+ (a- is similarly defined). Given a sequence pair a = (a+,a-), the binary relations 5; and 5: are defined by

for any pair k and k1 (k # kt) of rectangles. Based on these, we impose the following constraints on relative locations:

192


Figure 8.1. An example of a placement based on sequence pair

where wr,and hr, are the current width and height of rectangle k (depending on its orientation), and the location (I;, 1;) is the x and y coordinates of its lower left corner. That is, if k 5: k' holds, the right side of rectangle k should be placed to the left of the left side of rectangle k'. If k 5: k' holds, on the other hand, the upper hem of rectangle k should be placed to the below of the lower hem of rectangle k'. See figure 8.1 as an example. This coding scheme has the following properties: (1) Constraints (8.17) are a sufficient condition for having no mutual overlap. (2) It is possible to find a feasible placement in polynomial time for a given sequence pair a, if there exists a feasible placement which satisfies constraints (8.17). In [15], Murata et al. proposed a decoding algorithm (i.e., an algorithm to compute locations of all rectangles under constraints (8.17) from a given sequence pair a) which runs in 0(s2)time, where s is the number of rectangles to place. After this, the time complexity has been improved; in [lo], Imahori et al. proposed a decoding algorithm with O(s1ogs) running time, and later it was improved to O(1) amortized computational time per one sequence pair if used in the neighborhood search [ll].Note that, the last algorithm outputs only feasibility; they need O(s log s) more time if a feasible placement for a is required. There are several local search or metaheuristic algorithms proposed to find a good sequence pair [10,11,15]. An iterated local search algorithm proposed by Imahori et al. [ll]is one of the most efficient ones among them. We call this the original algorithm in this paper. As it is too expensive to use the original algorithm in our local search, we modify it in the following manner. In our neighborhood search, we modify a pattern p j E 11 to another pattern pi. Since we already have a good sequence pair u for pattern pj, we construct a sequence pair a' for pi starting from a. As noted before, we remove some products from pattern p j and add some other products


193

to construct a new pattern p[i When a product i is removed, we just remove it from the current sequence pair a. (If p j includes two or more units of product i (i.e., aij 2 2)) we remove one of them at random.) When we add a new product it,we check all insertions of it to all positions of the sequence pair. The number of sequence pairs we check in this process is s2, where s is the number of products in pattern p j (i.e., s = aij). We check all of them in 0(s2)time with the algorithm Evaluate-Shift-Moves proposed in [ll].When there are more than one products to be added, we add them one by one to the sequence pairs generated by then.

zi

8.6

THE ENTIRE ALGORITHM

The outline of our entire local search algorithm is described as follows. (Algorithm NS( (II, , (II*,x*) ,pj, t) in Line 6 will be explained later.)

z)

Algorithm LS-2DCSPn Line 1: Line 2: Line 3: Line 4: Line 5: Line 6: Line 7: Line 8: Line 9: Line 10: Line 11:

Construct an initial set of patterns II and compute its LP solution 51; Set n* := II and compute its integer solution X* heuristically; Start the neighborhood search from the current solution (II,y); f o r t = 0,1,2 do for pj E II do NS((II,X), (II*,x * ) , ~ t~),t o obtain an improved solution; i f an improved solution (II', 5?7) is found then set (II,W):= (II1,fTi)and return t o Line 3; end for end for Output the incumbent solution (II*,x*) and halt;

Note that, the incumbent solution, which is the output of this algorithm, is updated in Line 6. Algorithm NS((II, (II*,x*), pj, t), where NS stands for neighborhood search, is the core routine of our entire algorithm, which is comprised of those algorithms described in Sections 8.2,8.3 and 8.4. Starting from the current set of patterns II, this algorithm checks the family of the sets of patterns generated by modifying the pattern p j E II by the basic, redundancy reduction, filling-up and replacement operations, for a given parameter t (= 0 , l or 2) used in the basic operation. It also computes an integer solution for each set of patterns by the heuristic algorithm of Section 8.2, and updates the incumbent solution (IT*, x*) if a better integer solution is obtained.

x),

194


Algorithm NS((II, X),(II*,x*), pj, t ) Input: The current solution (IT,X), the incumbent solution (II*,x*), a pattern pj E II which is the candidate to be removed from IT, and a parameter t = 0 , l or 2. Output: An improved solution (II', X') or the failure. (If a better integer solution is found in this computation, the incumbent solution (II*,x*) is updated accordingly.) Step 1: If Tj = 0, go to Step 2; otherwise go to Step 3. Step 2: Repeat the following procedure c n times (where c n is the number of good cutting patterns stored in memory, as described in Section 8.3), and then go to Step 5. (replacement operation): Replace pattern p j with a good cutting pattern stored in memory. Compute LP solution (IT', X') and an integer solution (II', XI) for the resulting set of patterns as described in Section 8.2. If (Ill, x') is better than the incumbent solution (IT*, x*), update it. If (II', X') is better than the current solution (IT, fZ;), exit with (IT', X'). Step 3 (redundancy reduction): Remove the redundant products from p j as many as possible, by the procedure in Section 8.3. Denote the resulting pattern as p;. If this pattern does not have more than t products, go to Step 2; otherwise go to Step 4. Step 4: Apply the following procedures to every subset of products M' with IM'I = t and every product i 6M' with ri = 0, as described in Section 8.3. 4-1 (basic operation) : Remove a set of products M' from pi and add one product i. Denote the resulting pattern as pi and check its feasibility by the procedure described in Section 8.4. If a feasible placement is found, then compute the LP solution as described in Section 8.2, and go to 4-2. 4-2 (filling-up operation) : Fill-up the pattern p: by the procedure in Section 8.3. Compute LP solution (11',X') and an integer solution (IT', X I ) for the resulting set of patterns. If (II', XI) is better than the incumbent solution (IT*,x*), update it. If (11', X') is better than the current solution (II, fZ;), exit with (II', X'). Step 5: Exit with failure (no improved LP solution found).


8.7

COMPUTATIONAL EXPERIMENTS

We conducted computational experiments to evaluate the proposed algorithms. They were coded in the C language and run on a handmade PC (Intel Pentium IV 2.8GHz, 1GB memory).

8.7.1

Other existing algorithms

In the literature, several heuristic algorithms have been proposed for 2DCSP [1,2,3,18,19,21]. For the evaluation of our algorithm, it is desirable to compare our algorithm with those algorithms. However, it is not easy for the following reasons. First of all, there are many variations of 2DCSP and those algorithms in the literature were designed for slightly different problems. Cung et al. [2] and Alvarez-ValdBs et al. 1181 considered the following problem, and proposed branch-and-bound and heuristic algorithms: Cut a single rectangular stock sheet into a set of small rectangular products of given sizes and values so as to maximize the total value. If the value of each product is equal to its area, the objective is to minimize the trim loss. Alvarez-ValdBs et al. considered another problem in [19]: A set of stock sheets of different sizes and a set of rectangular products are given. Each product has its width, height, demand and a fixed orientation. From these stock sheets, products are cut by "guillotine cut" in order to satisfy all demands. The objective is to minimize the total area of stock sheets required. Vanderbeck [21] proposed a heuristic algorithm, which is based on a nested decomposition for 2DCSP, with various constraints such as 3-stage pattern and the maximum number of products in one pattern. Chauny and Loulou [I] and Farley [3] considered a similar problem to ours, but the number of different cutting patterns n is not specified. In [I] and [3], heuristic algorithms based on the column generation technique were proposed, together with some computational results. However, their computational results are too limited to compare (i.e., the size of their test instances is too small to evaluate the performance of our local search algorithms). From these observations, we had to give up the comparison with other existing algorithms. Instead, we generated various types of test instances, and conducted detailed experiments with two different types of neighborhoods and by changing the number of patterns n.

8.7.2

Test instances

We generated random test instances of 2DCSP following the generation scheme described in [16,19]. The instances are characterized by the following three parameters.


196 Table 8.1.

Comparison two neighborhoods in solution quality and time basic

enhanced

m

quality

time

quality

time

20 30 40 50

15.17 14.81 11.91 10.94

13.88 41.18 221.61 955.64

10.49 8.71 8.76 8.18

18.42 45.76 144.93 638.86

Number of product types: We have four classes 20, 30, 40 and 50 of the number of product types m (e.g., m = 20 in class 20). Range of demands: Demand di of type S (S stands for small) is randomly taken from interval [1,25], type L (large) is taken from [loo, 2001, and type V (variable) is taken from either interval [I,251 or [loo,2001 with the equal probability for each product i. Size of stock sheet: We have five classes a , p,r, 6 and E of the stock sheets. Class a is the smallest stock sheet which can contain six products on the average, while class E is the largest containing about 50 products.

Hence, there are 60 types of instances and we generated one instance for each type. These instances are named like "20San, "20S/3", . . . , "~OSE", "20LaV,. . . , "~OVE","30SaV,. . . , "50V~".In our computational experiments, we apply our local search algorithms ten times to each instance with different initial solutions, and report the average results of ten trials. All test instances are electronically available from our web site (http://www.simplex.t.u-tokyo.ac.jp/"imahori/packing/).

8.7.3

Comparison of basic and enhanced neighborhoods

First, basic and enhanced neighborhoods were computationally compared. For each instance, we applied our local search algorithms with two types of neighborhoods ten times each, and report the average quality of the obtained solutions and the average computational time, where local search halts only when a locally optimal solution is reached. For simplicity, we set the number of different cutting patterns to the number of product types (i.e., n = m). Results are shown in Table 8.1. Column "m" shows the number of product types. For each m, we have 15 instances with different ranges of demands and different sizes of stock sheet; e.g., we have instances 20Sa, 20S/3, . . . , 2 0 V for ~ m = 20. Column "quality" shows the average percentage deviation from the lower bound computed by (8.8) in Section 8.1. Column "time" shows the average

Local Search Algorithms for 2DCSPn Table 8.2.

Quality and time with various number of different patterns n n=m

quality class 20 class 30 class 40 class 50 class S class L class V class a class p class y class 6 class a average

10.49 8.71 8.76 8.18 12.53 6.19 8.38 10.52 8.05 7.92 7.33 11.35 9.03

time 18.42 45.76 144.93 636.86 149.20 262.20 223.09 46.94 71.71 141.18 311.11 486.53 211.49

n = 0.8m

quality

time

12.25 6.31 9.90 18.53 10.36 45.33 9.94 143.14 14.56 47.34 7.39 57.18 9.89 55.47 12.44 10.00 10.03 15.58 9.66 28.30 8.48 60.77 12.45 151.99 10.61 53.33

n = 0.6m

quality time 14.43 12.18 12.22 11.50 16.38 9.10 12.27 16.32 12.27 11.53 9.40 13.39 12.58

3.75 6.42 15.63 37.29 15.37 16.87 15.09 1.84 3.39 6.26 15.83 51.56 15.78

n = 0.4m

quality time 20.81 1.95 16.76 3.10 16.89 7.09 15.32 12.12 20.77 6.35 12.40 5.37 19.16 6.48 28.20 0.26 19.44 0.78 14.91 1.63 10.80 6.57 13.87 21.09 17.44 6.07

CPU time in seconds of one local search. These notations are also used in Table 8.2. From Table 8.1, we can observe that the enhanced neighborhood gives better solutions than the basic neighborhood in all cases, while using roughly the same computational time. It indicates that the redundancy reduction, filling-up and replacement operations proposed in Section 8.3 make the search more powerful and efficient. Based on this, we will use the enhanced neighborhood in the following experiments.

8.7.4

Effect of the number of patterns n

Next, we conducted computational experiments for different number of patterns n; i.e., n was set to m, 0.8m, 0.6m and 0.4m. Results are given in Table 8.2. The leftmost column shows the instance classes. For example, "class 20" represents 15 instances with m = 20. Each figure in this row is the average of 150 trials (that is, 10 trials with different initial solutions for each instance, and there are 15 instances for class 20). "class S" represents 20 instances whose demand is taken from interval [I, 251, and each figure is the average of 200 trials. Other rows can be similarly interpreted. Now from the rows for classes 20, 30, 40 and 50 in Table 8.2, we can observe that as m becomes larger (i.e., from class 20 to 50), computational time increases and solution quality becomes slightly better. As n becomes smaller, the size of neighborhood becomes smaller and local

198


search algorithm converges to locally optimal solutions rather quickly, making the quality of obtained solution poorer. From the rows for different ranges of demands (i.e., S, L and V), we can observe that the solution quality for class S is the worst. This is due to the influence of rounding and overproduction. Namely, we compute the numbers of applications xj by rounding from the LP solution, and it introduces a little overproduction for several product types. As the total demands is smallest for class S, the effect of one unit of overproduction to the quality is larger. From the rows for different sizes of stock sheet (i.e., class a,@, y,6 and E), we can observe that the solution qualities for classes a and e are worse than others. The reason for class E is similar to the previous one. For many test instances of class E, we could find good solutions if the numbers of applications xj can be fractional. However, these solutions degrade after obtaining integer solutions. On the other hand, as the size of stock sheet becomes smaller, it becomes harder to find a placement of products with small unused area.

8.7.5

Trade-off curve between n and solution quality

Finally, we conducted a more detailed experiment to obtain the tradeoff curve between n and the quality of the obtained solutions. We used two instances 40Va and 40VS. The area of the stock sheet of 40V6 is four times as large as that of 40Va. Results are shown in Figures 8.2 and 8.3. In these figures, horizontal axis is n, and vertical axis shows the solution quality and CPU time in seconds. 40Va-LP (resp., 40VS-LP) shows the average quality of obtained LP solution (i.e., the numbers of applications can be fractional) for 40Va (resp., 40VS), and 40Va-IP (resp., 40VS-IP) shows the average quality of obtained integer solution (as noted in Section 8.2, we solve IP heuristically) for 40Va (resp., 40VS). 40Va-time and 40VS-time show the average CPU times in seconds for ten trials. When n is very small (i.e., n 5 11 for 40Va and n 5 2 for 40VS), we could not find initial feasible solutions. From Figures 8.2 and 8.3, we observe that the computational time tends to increase and the solution quality improves as n increases. For larger n, the improvement in quality becomes tiny instead of the computational time is increasing steadily. Note that, if the numbers of applications can be fractional, an optimal solution for 2DCSP uses at most m different patterns since we solve LP with m constraints to compute the numbers of applications. Nevertheless, our obtained LP solutions for these instances with n = 40 are slightly worse than those with larger n. We

Local Search Algorithms for 2DCSPn 30

--a--40Va-IP

- - - + - -40Va-time

25

20

Z

%

$ 15 C

.8

10

5 +$

:%

0

.~&+.+++#++

0

10

Figure 8.2.

-

,

20

10

.+*+

,

30 40 50 number of dHferent patterns

60

70

0 80

Trade-off between n and solution quality for 40Va

*i ++ +

< rYU++&++++++++*~*, +

10

-

:

20

,

,

30 40 50 number of different patterns

,

,

60

70

Figure 8.3. Trade-off between n and solution quality for 40VS

also observe that the obtained trade-off curves between n and solution quality are not monotonic, which should be non-increasing ideally. From these observations, there is still room for improvement in our neighborhood search. We also observe that the gap between LP and IP solutions for 40V6 are more significant than the gap for 40Va.

200

8.8


CONCLUSION

In this paper, we considered the two-dimensional cutting stock problem using a given number of different patterns n. As this is an intractable combinatorial optimization problem, we proposed a local search algorithm, which is based on linear programming techniques. In this algorithm, we utilized heuristic algorithms to solve three NP-hard subproblems; i.e., the problem to compute the numbers of applications for IT,the two-dimensional bin packing problem and the two-dimensional rectangle packing problem. To see the performance of our local search algorithm, we conducted some computational experiments with randomly generated test instances of 2DCSP. We first confirmed the effectiveness of our enhanced neighborhood, which utilized basic, redundancy reduction, filling-up and replacement operations. We also computed the trade-off curves between n and the quality of the obtained solution. As a future work, we are planning to improve the solution quality by introducing more efficient neighborhood search and by incorporating more sophisticated metaheuristic algorithms.

ACKNOWLEDGEMENT The authors are grateful to anonymous referees for their valuable comments, which were used to improve this paper. This research was partially supported by Scientific Grant-in-Aid, by the Ministry of Education, Culture, Sports, Science and Technology of Japan, and by Informatics Research Center for Development of Knowledge Society Infrastructure (21st century COE program of the Ministry of Education, Culture, Sports, Science and Technology, Japan).

REFERENCES [I] F. Chauny and R. Loulou, "LP-based method for the multi-sheet cutting stock problem," INFOR, Vol. 32, 1994, pp. 253-264. [2] V.D. Cung, M. Hifi and B. Le Cun, "Constrained two-dimensional cutting stock problems a best-first branch-and-bound algorithm," International Transactions in Operational Research, Vol. 7, 2000, pp. 185-210. [3] A.A. Farley, "Practical adaptations of the Gilmore-Gomory approach to cutting stock problems," OR Spectrum, Vol. 10, 1998, pp. 113-123. [4] H. Foerster and G. Wascher, "Pattern reduction in one-dimensional cutting stock problems," International Journal of Production Re-


201

search, Vol. 38, 2000, pp. 1657-1676. [5] M.R. Garey and D.S. Johnson, Computers and Intractability: A Guide to the Theory of NP-Completeness (Freeman, 1979). [6] P.C. Gilmore and R.E. Gomory, "A linear programming approach to the cutting-stock problem," Operations Research, Vol. 9, 1961, pp. 849-859. [7] P.C. Gilmore and R.E. Gomory, "A linear programming approach to the cutting-stock problem-Part 11," Operations Research, Vol. 11, 1963, pp. 863-888. [8] P.C. Gilmore and R.E. Gomory, "Multistage cutting stock problems of two and more dimensions," Operations Research, Vol. 13, 1965, pp. 94-120. [9] R.E. Haessler, "Controlling cutting pattern changes in onedimensional trim problems," Operations Research, Vol. 23, 1975, pp. 483-493. [lo] S. Imahori, M. Yagiura and T. Ibaraki, "Local search algorithms for the rectangle packing problem with general spatial costs," Mathematical Programming, Vol. 97, 2003, pp. 543-569. [ll]S. Imahori, M. Yagiura and T. Ibaraki, "Improved local search algorithms for the rectangle packing problem with general spatial costs," European Journal of Operational Research (to appear). [12] A. Lodi, S. Martello and D. Vigo, "Heuristic and metaheuristic approaches for a class of two-dimensional bin packing problems," INFORMS Journal on Computing, Vol. 11, 1999, pp. 347-357. [13] 0. Marcotte, "The cutting stock problem and integer rounding," Mathematical Programming, Vol. 33, 1985, pp. 82-92. [14] S. Martello and D. Vigo, "Exact solution of the two-dimensional finite bin packing problem," Management Science, Vol. 44, 1998, pp. 388-399. [15] H. Murata, K. F'ujiyoshi, S. Nakatake and Y. Kajitani, "VLSI module placement based on rectangle-packing by the sequence-pair," IEEE Transactions on Computer Aided Design, Vol. 15, 1996, pp. 1518-1524. [16] J. Riehme, G. Scheithauer and J. Terno, "The solution of two-stage guillotine cutting stock problems having extremely varying order demands," European Journal of Operational Research, Vol. 91, 1996, pp. 543-552. [17] S. Umetani, M. Yagiura and T. Ibaraki, "An LP-based local search to the one dimensional cutting stock problem using a given num-

202


ber of cutting patterns," IEICE Transactions on Fundamentals, Vol. E86-A, 2003, pp. 1093-1102. [18] R. Alvarez-Valdhs, A. Paraj6n and J.M. Tamarit, "A tabu search algorithm for large-scale guillotine (un)constrained two-dimensional cutting problems," Computers & Operations Research, Vol. 29, 2002, pp. 925-947. [19] R. Alvarez-Valdhs, A. Paraj6n and J.M. Tamarit , "A computational study of LP-based heuristic algorithms for two-dimensional guillotine cutting stock problems," OR Spectrum, Vol. 24, 2002, pp. 179192. [20] F. Vanderbeck, "Computational study of a column generation algorithm for bin packing and cutting stock problems," Mathematical Programming, Vol. 86, 1999, pp. 565-594. [21] F. Vanderbeck, "A nested decomposition approach to a threestage, two-dimensional cutting-stock problem," Management Science, Vol. 47, 2001, pp. 864-879. [22] S. Zionts, "The criss-cross method for solving linear programming problems," Management Science, Vol. 15, 1969, pp. 426-445.

Chapter 9

A GENERIC OBJECT-ORIENTED TABU SEARCH FRAMEWORK Hoong C. Lau, Xiaomin Jia and Wee C. Wan School of Computing, National University of Singapore 3 Science Drive 2, Singapore 11 7543 {lauhc, jxiaomin, jwan)@comp.nus.edu.sg

Abstract: Presently, most tabu search designers devise their applications without considering the potential of design and code reuse, which consequently prolong the development of subsequent applications. In this paper, we propose a software solution known as Tabu Search Framework (TSF), which is a generic C* software framework for tabu search implementation. The framework excels in code recycling through the use of a welldesigned set of generic abstract classes that clearly define their collaborative roles in the algorithm. Additionally, the framework incorporates a centralized process and control mechanism that enhances the search with intelligence. This results in a generic framework that is capable of solving a wide range of combinatorial optimization problems using various tabu search techniques and adaptive strategies. The applications of TSF are demonstrated on the implementation of two NP-hard problems, the Vehicle Routing Problem with Time Windows (VRPTW) and Quadratic Assignment Problem (QAP). We show that TSF is able to obtain quality solutions within reasonable implementation as well as computation time.

Key words:

9.1

Tabu Search, software framework, reusability, combinatorial optimization.

INTRODUCTION

Recent studies have reported many successful applications of tabu search [Glover and Laguna, 19971 in solving real-world optimization problems. In most cases, tabu search applications are designed specifically for their intended problems, with little or no consideration for design and codes reuse. Consequently, this leads to difficulties in recycling the developed work for subsequent applications. Conceivably, the sokware development cost could

204


be drastically reduced if a well-designed programming framework is available that allows the reuse of both designs and codes. The challenge of developing such a framework lies in the tension between its simplicity of use versus the sophistication involved in supporting user-preferred search strategies. To date, there is a lack of a widely accepted tabu search framework and only few research prototypes have gained limited popularity. Another strong motivation for a tabu search programming framework is the demand for an unbiased platform that could ensure fairness in comparing different tabu search strategies. Typically, it is not unusual for a talented programmer to write better codes than his peers and thus could paint an unrealistic picture of a more efficient algorithm. However, when different algorithms for a given problem are implemented on a common framework, it implies that they have been implemented using common software components (such as using the same tabu search engine) and even underlying data structures, which indirectly enforces fairness when algorithms are compared, especially in terms of run-time performance. In addition, an optimized framework lowers the technical expertise of an algorithm designer by providing him with efficient components. Perhaps an implicit third incentive for a framework can be seen from the software engineering point of view. By enforcing an object-oriented design (OOD), the framework imposes a development discipline on the algorithm designer. Consequently this paves a way for ease of code integration and maintenance, and for future extension. In addition, OOD also provides clarity in design, which allows algorithm designers to quickly grasp the conceptual flow of the framework. This results in more efficient use of the framework as well as less prone to programming errors. In this paper, we propose a generic object-oriented framework that performs the standard routine of the tabu search and yet offers the robustness for algorithms designers and developers to incorporate their desired search strategies. Tabu Search Framework (TSF) is a C++ object-oriented software framework that uses a set of interfaces to epitomize the routine tabu search procedures. It has a centralized control mechanism to adaptively guide the search in accordance to events encountered dynamically. TSF also provides a set of supporting software tools, called the Strategy Software Library, which aids developers in their strategies development. In summary, TSF allows users to focus on designing, testing and comparing algorithms by minimizing efforts in programming. This paper proceeds as follows. Section 9.2 gives a literature review of some existing local search frameworks. Section 9.3 presents the architecture of TSF. Section 9.4 gives 3 illustrations on using TSF to formulate user-defined

A Generic Object-Oriented Tabu Search Framework

205

strategies. Section 9.5 presents experimental results. Section 9.6 presents the conclusion and future works.

9.2

LITERATURE REVIEW

In this section, we present a review of four existing frameworks, OpenTS, Localizer*, EasyLocal++ and HotFrame.

9.2.1

OPENTS

OpenTS [Harder, 20031 is one of the project initialized by Computational Operations Research (COIN-OR) to spur the development of open-source software for the operations research community. It is a javabased tabu search framework that has a well-defined, object-oriented design. The generic aspect of the framework is achieved through inheritance, using well-structured interfaces, which includes Solution, Move, Move Manager, Objective Function, Tabu List and Aspiration Criteria. This unambiguous decomposition defined clearly the collaborative role of each interface in the algorithm. In addition, the author presumes that most TS applications adopt the "tabu-ing the move" strategy and hence provides "helper" classes such as SimpleTabuList, ComplexMove and ComplexTabuList classes to assist the implementation.

Infrastructure for

OpenTS also supports the implementation of adaptive strategies through the use of the EventListener objects. These listeners can be embedded into any of the interface-inherited objects and used later to adjust objects' parameters. However, the listeners only respond to a static set of search events and does not consider user-defined events such as recording the presence (or absence) of certain solution structures. This results in difficulty in implementing strategies that are based on the solution structures (such as recency and frequency based strategies). The absence of a centralized control mechanism also poses a limitation to the framework capability. For example, when two listeners are triggered in the same iteration, their order of execution follows a First-In-First-Out (FIFO) sequence, thus giving no control to the algorithm designer. It is also probable for two conflicting EventListener objects (such as intensification and diversification) to be performed together without designer's intention.

206


The literature presented another framework known as the Localizer++ [Michel and Van Hentenryck, 19991 that incorporates Constraint Local Search (CLS) in C++. The framework is structured into a two-level architecture, which composes of Declarative and Search components. The Declarative components are the core of the architecture and are used to maintain the complex data structure in local search. In addition, it also incorporates a Constraint Library that provides a set of frequently used constraints, such as the AllDiffconstraint which verifies that every element in the data structure has a different value. The Search component on the other hand, operates around the Declarative component and is procedural in nature. Generally, this component implements the general procedure of local search and thus could be used to implement any meta-heuristics that follow to this general behavior (i.e. such as iterative local search and tabu search). Localize*+ requires designers to formulate their problem into its mathematical equivalence form in order for the framework to recognize and subsequently manage the variables (thus achieving the genericty aspect). Algorithm designers are required to implement the routines of the local search such as the local moves and the selection criteria, and together with the Constraint Library, to construct the optimizer. Due to the numerous possible types of constraint, it is improbable for the Constraint Library to provide all forms of constraint and thus Localize*+ copes with this limitation by supporting the extension to the library through the addition of invariants. The framework also supports user-defined search strategies that are triggered at static points of the search (such as at the start or the end of the search) rather than dynamically in response to search events. New search procedures can be extended from Localizer++ through inheritance.

EasyLocal++ [Gaspero and Schaerf, 20011 is another object-oriented framework that can be used as a general tool for the development of local search algorithms in C++. EasyLocal++ relies on programming techniques such as the "Template Method" that specifies and implements the invariant parts of various search algorithms, and the "Strategy Method" for the communication between the main solver and its component classes, in order to achieve the generic aspect. The classes in EasyLocal++ can be classified into four categories, Basic Data, Helpers, Runners and Solvers. The Basic Data is a group of data structure with their managers and is used to maintain the states of the search space, the moves, and the inputloutput data. The


207

Basic Data classes are supplied to the' other classes of the framework by means of template instantiation. The local search problem is embodied in the Helpers classes, which perform actions that are related to some specific aspects of the search, such as maintaining the states or exploring the neighborhood of a solution. The Runners represent the algorithmic core of the framework and are responsible for performing the routine of the metaheuristic. Currently, EasyLocal++ supports several common meta-heuristics such as hill climbing heuristic, simulated annealing and tabu search. EasyLocal++ can be easily deployed by first defining the data classes and the derived helper classes, which encode the specific problem description. These classes are then "linked" with the required Runners and Solvers and the application is ready to run. EasyLocal++ also supports diversification techniques through the Kickers classes. The Kickers objects are incorporated into the Solver and triggered at specific iteration of the search. Hence, this mechanism relies on the knowledge of the algorithm designer to determine the best moment to trigger the diversification. While this may be achievable for most experience designer, it may be demanding for unfamiliar implementer coping with a new problem. In short, the framework provides limited support for adaptive strategies and although it could be possible for such strategies to be incorporated, the authors do not present a clear mechanism to realize them.

9.2.4

HOTFRAME

HotFrame [Fink and VoB, 20021 is a more matured meta-heuristics framework implemented in C++ when compared with Easy Local++. The framework provides numerous adaptable components to incorporate a wide range of meta-heuristics and common problem-specific components. The supported meta-heuristics includes basic and iterated local search, SA and their variations, different variants of tabu search, evolutionary methods, variable depth neighborhood search, candidate list approaches and some hybrid methods. As a means of reducing the programming efforts of designers, HotFrame provides several reusable data structure classes to incorporate common solution spaces such as binary vectors, permutations, combined assignment and sequencing and also some standard neighborhood operations like bit-flip, shift, or swap moves. These classes can be deployed immediately or be used as base classes for subsequent customized derived classes. This design encourages software reuse especially for problems that can be formulated with the components that are already presence in the framework.

208


Meta-heuristics strategies can be implemented in HotFrame through the use of templates. The idea is to incorporate a set of type parameters that can be extended to support both problem-specific and generic strategies. A benefit of this design is that it gives HotFrame a concise and declarative system specification, which would decrease the conceptual gap between program codes and domain concepts. HotFrame also adopts a hierarchical configuration for the formulation of the search techniques in order to separate problem-specific with the generic meta-heuristic concepts. Generic meta-heuristic components are pre-defined in the configuration as a higherlevel control while the problem-specific definitions are incorporated inside these meta-heuristic components to form a two level architecture (i.e. each problem-specific strategy will be embedded to a meta-heuristic scheme). Additionally, inheritance can be applied on these components to overwrite parts of the meta-heuristic routine with user preferred procedure.

9.2.5

Discussion

It can be seen that the focus of the above reviewed frameworks is primarily on relieving the mundane task of meta-heuristic routines from the algorithm designers. TSF has a slightly different objective: TSF is designed with the intention to support adaptive tabu search strategies. As such, in addition to performing the basic routines of tabu search, TSF has a centralized control mechanism to incorporate adaptive strategies. While it is true that most of the reviewed frameworks could also support adaptive strategies, the incorporation of such strategies may not be as straightforward (i.e. no dedicated mechanism is built for it). For example, while HotFrame could incorporate adaptive strategies by extending its procedures, such inheritance often requires the designer to "re-code7' some of the meta-heuristic procedures. This may pose a problem to designers who are unfamiliar with the internal design of the framework, i.e. the framework can no longer be seen as a black box to the designer. TSF works differently fkom such conventional design by incorporating a communication link between the framework engine (which perform the tabu search routines) and the control mechanism. As the search proceeds, the engine will record the current search state and passes this information to the control mechanism. The control mechanism then processes information to determine if actions such as adjusting the search parameters or applying a diversification strategy are necessary. Analogously, the control mechanism can be seen as a feedback mechanism that adapts the framework engine to the search environment. Such feedback control provides a centralized mechanism for designer to collect information on the search spaces as well as to direct future search trajectory.


9.3

DESIGN AND ARCHITECTURE

9.3.1

Frameworks

Framework has a different concept from "Software Library". In a software library, implementers are required to design their program flow and then use the components in the library to develop their applications. The ILOG optimization suite [ILOG, 20031 (such as the CPLEX and Solver engines) is an example of a well-known software library. In ILOG optimization software library, the programmers formulate their problems as a specific constraint/mathematical-programming model, and a predefined engine operates on the formulated model to obtain solutions. A benefit of such software architecture is that it does not require the programmer to specify the algorithms to be performed on the problem. However, this can also be a drawback, as the predefined engine offers little if no capacity for the implementers to control of the search process. On the other hand, in a framework, the reused code is the controller, which provides an overall "frame" for an application. By means of inheritance, the programmer can implement the child classes, which are subordinate to the framework. In an informal sense, frameworks tell the programmer "Don't call us, we'll call you." In summary, while library allows sharing of lowlevel codes, frameworks allow sharing of high-level concepts and control. The essence of our proposed TSF framework revolves around four principal considerations:

(a) Genericity This means that the framework should allow the user to implement any tabu search algorithm. Additionally the framework should not make any assumption on problem type or its solution representation, thus allowing flexibility to the formulation of applications. (b) Reusability The framework should adopt built-in tabu search routines that can be easily recycled across applications. Furthermore, the algorithm procedure should be disintegrated into distinctive interfaces so that the developed components could be recycled easily across different applications. (c) Extensibility The framework should able to extend easily to support not only some predefined tabu search strategies, but also user-defined procedures that

210


are specific to the problem domain. In addition, the possibility of extending the framework to form hybrids should not be ignored. (d) Usage Friendliness The framework should be easy to learn and understand from an algorithm designer and implementer perspective. It should have unambiguous interfaces that give clarity in execution flow. To cater for these design goals, the components of TSF are categorized into 4 components: interfaces, control mechanism, search engine, and strategies softwae library (see Figure 9.1). The interfaces define the basic components used by tabu search in an object-oriented architecture. The control mechanism is for users to define strategies that guide the search adaptively in response to events encountered. TSF eliminates the tedious routine task of programming the search engine repeatedly. The search engine interacts with the interfaces and collects information that is passed dynamically to the control mechanism to influence future search trajectory. Finally, TSF includes an optional Strategy SoNare Library consisting of a set of software components to support various user-defined search strategies.

9.3.2

Interfaces

There are seven key interfaces that must be implemented, described as follows. 1. The solution interface allows the user to encapsulate the data structure(s) that represents the problem's solution. The framework does not impose any restriction on how the user defines the solution or the data structures used since it never manipulates Solution objects directly. 2. The Objective Function interface evaluates the objective value of the solution. 3. The Neighborhood Generator interface is an iterator that generates a collection of neighbors based on the Move and Constraint interfaces. 4. The Move interface defines the move neighborhood, where it constructs possible translations of Solution object. When the engine determines the best move in an iteration, the Solution object is then translated to its new state. 5. The Constraint interface computes the degree of violation for these translations. 6. The Tabu List interface records the tabu-ed solutions or moves. 7. The Aspiration Criteria interface allows specification of aspiration criteria for tabu-ed moves.


211

Com binatorial Problems Interfaces

I

Figure 9.1. TSF Architecture

9.3.3

Control Mechanism

Switch Box Like many machines, a set of switches is required to operate the Search Engine. A Switch Box is used in the framework to control the basic operations of the search engine. The two commonly used switches are the maximizing switch and the first-accept switch. The maximizing switch is used to control the engine to solve a maximizing or a minimizing problem. The First-Accept switch informs the tabu search engine to perform first accept or best accept strategy. The best accept strategy searches through all the feasible solutions in the neighborhood and select the best possible move. When run time is comparatively more crucial than the solution quality, we settle for the first neighbor with a better objective value, i.e. the first-accept strategy. All switches are capable of changing values dynamically set by an application. Event Controller It is often desirable for the search engine to respond to encountered events.

212


For example, a reactive tabu list would need to readjust its tenure in response to the success or failure in obtaining a better solution during the search. Hence we need a means of controlling the tabu search to make dynamic readjustments. TSF uses a centralized control mechanism. It has an Event Controller, which provides interaction between the search engine and its interfaces. When the tabu search engine detects the occurrence of predetermined events, it conveys them to the Event Controller. The Event Controller then responds to these events in accordance to strategies defined by the user. Typically, these strategies will affect one or more of the elements in the interfaces, which in turn, re-adjust the search strategy adopted by the engine. For the reactive tabu list example, the number of non-improving moves encountered can be a "triggering-event", which causes the Event Controller to readjust the tabu tenure based on parameters. Some default events in TSF are as follows: 1.Tabu Search Start is triggered at the start of tabu search. Used to start a timer to record the total time spent in doing the search. 2. Tabu Search Stop is triggered at the end of tabu search. Used to stop the timer or to call an output program to display the results. 3 . N m Best Solution Found is triggered when a new best solution is found. Used for intensification strategies. 4.Non-improving Move Made is triggered when the tabu search engine executes a new non-improving move. Used for diversification strategies. 5.End of Iteration is triggered at the end of the iteration. This is extremely usehl for collection of search information (such as similarity of solutions) or strategies that executed every iteration. 6.No move generated is triggered when the Neighborhood Generator could not generate any moves. 7.No Solution Found event is triggered when the search engine could not find a feasible solution. Used for implementing oscillating strategies. TSF also allows users to define their own events by providing a generic Event interface. Users need to define the triggering event and implement the response to it. For example, suppose we want to apply Random Restart strategy at every n number of completed iterations. To do this, we simply need to implement an Event that is triggered at the every nth iteration. The response to this event is to restart the tabu search with a new starting solution. Figure 9.2 gives a fragment of code segment for such implementation.


213

/ / Base class for the Event interface Class Event{

...... virtual void IterationEvent (TabuSearch* TS){};

}

Class RandomRestart : Event / / user-implemented clas: {

int max-limit = n; // User d e f i n e d n i t e r a t i o n int count~NonImprovingMoves;

I

virtual void IterationEvent (TabuSearch* TS){ if (TS->isBadMove( ) ) int count~NonImprovingMoves++; if (count~NonImprovingMoves> max-limit) ApplyRandomRestart (TS);

Figure 9.2. Code Implementation of a User-DefinedEvent

Some strategies may require history information to be collected during search. In TSF, the Event interface can be used to collect such useful information. For instance, implementing a Frequency and Recency strategy may require the tabu search to record the number of occurrences a substructure/configuration in the solution has appeared during the search. As an example, in the Traveling Salesman Problem, if we discover that the solution that visits customer 4 before customer 3 occurs very frequently in local optima, this may imply that the global optimal may contain the same subroute with the structure X 4 3 - Y , where X and Y refer to some arbitrary customers. In this case, the user may like to implement a soft constraint based on this observation, which in turn will reduce the size of the neighborhood generated. By collecting more information during the search and consequently adaptively modi&ing the search strategy, we can derive a more effective search.

9.3.4

Tabu Search Engine

The Tabu Search Engine component implements the control flow as follows: 1.

Set initial solution as current and best found solution

214

2. 3. 4. 5. 6. 7.

9.3.5

Metaheuristics: Progress as Real Problem Solvers Neighborhood Generator generates a list of feasible moves Objective Function evaluates each move Choose best non-tabu move using Tabu List and Aspiration Criteria Apply Move on the current solution Update Tabu List and trigger related events Go to step 1 until terminating condition(s) is reached

Strategy Software Library (SSL)

Strategy Software Library (SSL) provides optional components for designer to facilitate them in adding generalized strategies. By making assumptions on the solution representation (such as permutation of integers or array of bits), these components can be incorporated to build strategies such as intensijkation among elite solutions, probabilistic diversi~cation,candidate lists, and very large-scale neighborhood (VLSN). Although not as powerful as specific strategies tailored for a single problem type, these generic components provide a quick and easy means for developers to apply them in their search. In the following, we describe some of the components in SSL. Probabilistic Diversification

Probabilistic diversification refers to diversifying the search when it is caught in a local optimum. If the designer adopts a permutation or bits array solution representation, SSL can readily supports this strategy by providing a Random Generator that determines the parts of the solution that will be removed in according to a preset probability distribution (such as uniformly random distribution). These randomly chosen portions are then reconstructed by random swapping (permutation representation) or flipping (bits array) and later recombined. Intensification search on Elite solutions

SSL supports this strategy by storing a list of elite solutions during tabu search in the Elite Recorder. As solution objects inherited Solution interface, different solution representations can be easily stored as their base class. Each of these elite solutions is then used as a new initial solution for future tabu search. The rationale behind this strategy is to search the elite solutions more thoroughly and hence is classified as an intensification strategy. Developers simply need to declare the number of elite solutions to be collected in the preliminary search and TSF would search each of these points more thoroughly.


Very Large-Scale Neighborhood (VLSN)

VLSN [e.g. Ahuja et al., 20021 works on the principle that by generating a larger neighborhood, the hope is to increase the probability of obtaining better solution in a single iteration. Under the assumption that the solution representation is a permutation of integers, this strategy usually requires some permutation function to generate the large neighborhood. SSL provides two functions to support this strategy: PermutationGenerator and NeighborhoodBooster. PermutationGenerator provides the ease of permuting a solution to construct its neighborhood. NeighborhoodBooster, is used to increase the neighborhood size by combining multiple 2-opt moves into k-opt moves. User can also combine this strategy with the candidate list to keep the size of the neighborhood reasonable. Candidate Lists

Candidates are often used to narrow the neighborhood size especially when VLSN is involved. A possible technique is to select neighbors that meet some certain criteria or constraint. SSL provides a Filter function that inherits from the Constraint Interface. It receives a solution, a move and a selection function, and "filters" unfavorable moves that do not meet the constraint.

9.4

ILLUSTRATION

In this section, we illustrate how TSF can deploy some common user-defined search strategies, namely DiversiJication, IntensiJcation and Reactive Tabu Search'. These simplistic examples demonstrate how events can interact and incorporate the necessary actions to execute user-defined strategies.

9.4.1

Diversification

Diversification refers to strategies that transform one solution to a radically different solution. Usually, this transformation involves alternating part or

'

Note that although TSF can support adaptive strategies such as diversification, it is accomplished in a rather rudimentary fashion. Since the publication of the conference version of this work, the authors have developed an enhanced version of TSF known as Metaheuristic Development Framework (MDF), in which TSF is a component of a bigger framework (please see [Lau et al., 20041. In MDF, strategies such as adaptive methods and hybridization can be incorporated in a more elegant approach via the use of event handlers.

216


the whole solution structure. When some forms of probability are involved in the transformation, it is known commonly as probabilistic diversification. The greatest difficulty in executing this strategy is to decide when to apply diversification, for if diversification is applied too often, this may result in accidentally missing out good local optima; otherwise if diversification is performed infrequently, the search may waste too much time exploring potentially useless solutions. The easiest approach to decide when to perform diversification is to execute a fixed number of iteration and then applied the strategy. TSF easily support this strategy by implementing an event that counts the number of iteration performed. This event performs like a hardware counter. When the counter-event reaches zero, it will execute the desired diversifying actions. A code fragment is shown on Figure 9.3. Typically, this simplistic guiding rule is not very effective. An improved strategy is then to apply diversification when the search is caught in local optimal or experiences solution cycling. Unfortunately, both of these situations are extremely diffkult to detect accurately. There exist many heuristics that help to predict their occurrences, and one such heuristic is to observe the number of non-improving moves made since the last local optimum found. This heuristic again can be easily implemented with TSF using the event controller. Here, we implement an adaptive counter that decrements when the search makes a non-improving move and resets itself when a new best solution is found. A code fragment for this adaptive counter is shown in Figure 9.4.

9.4.2

Intensification

Intensification refers to strategies that examine thoroughly on some specific solutions. As oppose to diversification, intensifying strategies improve on the solution quality by searching around the region close to the solution. As such, intensification is usually performed on elite solutions. Hence, intensification often requires two phases - the initial phase is used to identify "good" solutions while the next phase attempts to locate new local optimum around these identified solutions. TSF can implement this strategy using the event controller that track two events for each phase of search respectively. An elite solution recorder is essential to record on the elite solutions and user can use either the provide tool in SSL or to implement their own. In the first phase, the First-Phase event first preset a number of iteration to collect the elite solutions. This is very similar to the counterevent discussed in section 9.4.1. In addition, the First-Phase event also records the solution whenever it encounters a new best-found solution. When the counter reaches zero, the First-Phase event will notify the event controller that it has completed its task and the event controller will proceed to replace the First-Phase event with the Second-Phase


217

event. The Second-Phase event is used to performed intensification on solution collected. One strategy in which intensification can be performed is to use a strategy that is analogous to backtracking. In this strategy, we conduct search on an elite solution for a fix number of iterations. If no better solution can be within these iterations, we would backtrack to our original solution and conduct a new search. To prevent conducting similar search, one approach is to preserve the tabu list. However, this may require a fair amount of memory depending on the number of iteration conducted. We proposed another approach, which is to interchange the tabu list each time we backtrack. The rationale behind this is that tabu list is used to guide the search and hence by using different tabu lists and interchanging them, we expect the search to move in different direction each time we revert to the original elite solution. A pseudo code for the events in both phases is presented in Figure 9.5.

9.4.3

Reactive Tabu Search

Our last illustration is on reactive tabu search, where we explain how two strategies can be incorporated into a single event. Reactive tabu search refers to strategies that adaptively adjusting tabu search parameters according to the search trajectory. Many complex heuristics have been proposed with this strategy, each with its own assumptions on the solution space. In fact a popular analogy is to visualize the solution space as a multi-dimensional terrain. The factors include objective value, similarity in the solution structure and time. Based on these factors, the reactive tabu search attempts to navigate along the terrain toward new local optima. In order to simplify our illustration, we only consider two factors, time and objective value and the parameter adjusted is limited to the tabu tenure. Time simply refers to number of iterations performed. Our simplified strategy works as follows. When we encounter a series of non-improving we lengthen our tabu tenure so as to prevent solution cycling. On the other hand, when we encounter a new best solution, we shorten our tenure in order to perform intensification. Hence we use TSF to implement an event called Reactive-Event to handle the two scenarios. First, when we encounter a series of nonimproving moves, we will increase the tabu tenure by some x amount. On the other hand, when a new best solution is encountered, we will revert the tenure, discarding any move that have been kept for more than n iterations. The pseudo code for this implementation can be found in Figure 9.6.

218


Class CounterEvent : Event / / user-implemented class int startvalue = n; // User d e f i n e d n i t e r a t i o n virtual void IterationEvent (TabuSearch* TS){ startvalue = startvalue - 1; if (startvalue getCurrentSolution()) StartValue = n; / / reset counter

I I I Figure 9.3: Code@agment implementing a counter event. -

-

Class AdaptiveCounterEvent : Event

I int startvalue = n; // User d e f i n e d n moves virtual void NewBestSolutionFound (TabuSearch* TS){ StartValue = n; / / reset counter

I virtual void NonImprovingMoveMade (TabuSearch* TS){ startvalue = startvalue - 1; if (startvalue getCurrentSolution()) StartValue = n; / / reset counter

I I

I Figure 9.4: Code@agment implementing an adaptive counter event.


219

Class FirstPhaseEvent : Event

I int maxIter = n; // Maximum number o f i t e r a t i o n virtual void NewBestSolutionFound (TabuSearch* TS){ EliteRecorder.record(TS->getCurrentSolution());

1 virtual void IterationEvent (TabuSearch* TS){ maxIter = startvalue - 1; if (maxIter getEventController().NextEvent();

I 1 Class SecondPhaseEvent : Event

I int allowedIter = x; virtual void NewBestSolutionFound (TabuSearch* TS){ allowedIter = x;

1 virtual void IterationEvent (TabuSearch* TS){ allowedIter = startvalue - 1; if (allowedIter getTabuList( ) setTabuTenure (t); BadMoveLimit = n; / / reset limit

.

1 virtual void NonImprovingMovesMade (TabuSearch* TS) badMoveLimit = badMoveLimit - 1; if (badMoveLimit getTabuList().getTabuTenure(); TS->getTabuList().setTabuTenure(tenure+x);

1 I Figure 9.6: Codefiagment implementing simpl$ed reactive tabu search.

220

9.5


EXPERIMENTATION

In this section, we report on experimental results on VRPTW and QAP. It is interesting to first observe that a senior undergraduate computer science student proficient at C++ programming took 1 week to learn TSF by studying the documentation and interacting with the TSF developers. He took another 1 week to first implement an application (QAP), and 3 days to implement a second application (VRPTW).

9.5.1

Vehicle Routing with Time Windows (VRPTW)

We benchmark with Solomon's instances [Solomon, 19871. 5 different moves were implemented: Relocate, Exchange, Reverse, Cross and Distribute. Reverse is used to reverse the sequence of customers within a same route and is usehl when the time window is loose. Cross is an extended Exchange where a sub-section of a route is swapped with another. Distribute attempts to reduce a vehicle by distributing the vehicle's customers to other vehicles. The design of these moves exploits the advantage of minimizing the distance without minimizing vehicles. With the exception of Relocate and Distribute, the other moves are designed to minimize the total distance traveled. The tabu list records on the previously accepted moves and a different tenure is set for each type of moves. The values of the tenure are Relocate: 1000, Exchange: 1000, Reverse: 300, Cross: 500 and Distribute: 400 for a problem size of 100 customers. We also adaptively apply intensification or diversification strategies based on the quality of the solutions found. Based on the default events, each solution is classified into two categories: improving solutions and non-improving solutions. An improving solution has an objective value that is better than all previously found solutions. Non-improving solution refers to solutions whose objective value is the same or poorer than the best-found solution. TSF adaptively alternates between intensification and diversification by observing the frequency of non-improving solutions. Diversification will be applied using a greedy heuristic when the frequency of non-improving solution exceeds a certain threshold. Appendix A summarizes our experimental results. TSF Results are results obtained by TSF; Best Results are the best-published results.

9.5.2

Quadratic Assignment Problem (QAP)

In QAP, the Solution can be represented as a permutation on a set of n facilities. A typical move often involves swapping two elements in the solution. [Ahuja et al., 20021 proposed a VLSN strategy for QAP, which implements complex moves involving multiple swaps. Generally, VLSN


22 1

produces better solutions than typically swap move. Following the authors' proposal, we demonstrate that TSF is capable supporting this strategy through the use of two software components: PermutatorGenerator and NeighborhoodBooster. The PermutatorGenerator is used to construct the neighborhood from a solution by generating all the possible permutations. The NeighborhoodBooster then performs two M e r steps to generate a larger neighborhood. First, a selection criterion is used to accept only elite neighbors. These elite neighbors are then further permutated to result in more neighbors. The two steps are repeated for k times (and thus known as k-opt). The tabu list in this case, records the previously visited solution and has a tenure of O.6n, where n is the number of facilities. We conducted our experiments on a set of test cases taken from the QAPLib [Burkard et al., 19911, and the results are summarized in Appendix B. Gap is calculated as Gap = (Best Result - TSF Result)/Best Result *loo%. From the table, we can see that TSF performs well for most of test cases. In Chr test cases, except for Chr20a and Chr25a, the results obtained are optimal; the results for other test cases are within a small gap from optimality.

9.6

CONCLUSION

In this paper, we presented TSF, a C++ object-oriented framework for tabu search. TSF imposes no restriction on the domain representation and yet provides a well-defined programming scheme for customizing the search process. TSF differs from other frameworks in that it offers users the flexibility of incorporating various tabu search strategies through the Event Controller as the centralized control mechanism without compromising too much on the run-time efficiency and solution quality. The Strategies Software Library fbrther supports the development of enhancing solution quality. Through the implementations of TSF on VRPTW and QAP, we illustrate that good results can be obtained with the framework within reasonable implementation time as well as good run-time. TSF is one component within the Meta-Heuristics Development Framework (MDF) [Lau et al., 20041 that is work-in-progress. MDF encompasses other meta-heuristics such as the Simulated Annealing, Genetic Algorithms, and Ants Colony Framework. MDF aims to provide a generic, robust and userfriendly programming framework for promoting the development and integration of meta-heuristics algorithms. It also provides a platform for researchers to equitably compare and contrast meta-heuristics algorithms.

222


ACKNOWLEDGEMENT The authors would like to thank the referees of the 5th Meta-Heuristic International Conference, and the referees of this journal version.


223

Legend: CR2 W. Chiang and R. A. Russell, A Reactive Tabu Search Metaheuristic for Vehicle Routing Problem with Time Windows, INFORMS Journal on Computing, 8:4, 1997 CLM J. F. Cordeau, G. Laporte, and A. Mercier, "A Unified Tabu Search Heuristic for Vehicle Routing Problems with Time Windows," Journal of the Operational Research Society 52,928-936,2001 HG J. Homberger and H. Gehring, "Two Evolutionary Metaheuristics for the Vehicle Routing Problem with Time Windows," INFOR, 37, 297-318, 1999 RT Rochat, Y. and E. Taillard, Probabilistic Diversification and Intensification in Local Search for Vehicle Routing, Journal of Heuristics, 1, 147-167, 1995 RGP L.M. Rousseau, M. Gendreau and G. Pesant, "Using Constraint-Based Operators to Solve the Vehicle Routing Problem with Time Windows," Journal of Heuristics, 8, 43-58, 1999 TBGGP E. Taillard, P. Badeau, M. Gendreau, F. Geurtin, and J.Y. Potvin, "A Tabu Search Heuristic for the Vehicle Routing Problem with Time Windows," Transportation Science, 31, 170-186, 1997

224


APPENDIX B: Experimental results on QAP test cases


225

Legend: Chr: N. Christofides and E. Benavent. An exact algorithm for the quadratic assignment problem. Operations Research, 3:5, 760-768, 1989 Bur: R.E. Burkard and J. Offermann. Entwurf von Schreibmaschinentastaturen mittels quadratischer Zuordnungsprobleme. Zeitschrift Jiir Operations Research, 21, B121-B132, 1977 Nug: C.E. Nugent, T.E. Vollman, and J. Ruml. An experimental comparison of techniques for the assignment of facilities to locations. Operations Research, 16, 150-173, 1968 Sko: J. Skorin-Kapov. Tabu search applied to the quadratic assignment problem. ORSA Journal on Computing, 2: 1, 33-45, 1990

REFERENCES [Ahuja et al., 20021 R. K. Ahuja, J. B. Orlin, 0. Ergun, and A. Punnen A Survey of Very Large-Scale Neighborhood Search for the Quadratic Assignment Problem, Discrete Applied Mathematics 23, 75-102,2002. [Burkard et al., 19911 R. E. Burkard, S.E. Karisch and F. Rendl. QAPLIB A Quadratic Assignment Problem Library, European Journal of Operational Research, 55:99, 115-119, 1991. [Fink and VoB, 20021 A. Fink, S. VoB: HotFrame: A Heuristic Optimization Framework. In: S. VoJ, D.L. WoodrufS (Eds.), Optimization Software Class Libraries, Kluwer, Boston, 81-154,2002. [Glover and Laguna, 19971 F. Glover and M. Laguna, Tabu Search, Reading, Kluwer Academic Publishers, Boston/Dorderecht/London, 1997. [Gaspero and Schaerf, 20011 L. Di Gaspero and A. Schaerf, EasyLocal++: An object-oriented framework for flexible design of local search algorithms, Reading, Kluwer Academic Publishers, 200 1. [Harder, 20031 R. Harder, http://opents.iharder.net, 2003.

IBM

OpenTS

Homepage,

see

[ILOG, 20031 ILOG S.A. www.ilog.com, 2003. [Lau et al., 20041 H. C. Lau, M. K. Lim, W. C. Wan and S. Halim. A Development Framework for Rapid Meta-heuristics Hybridization, Proc.

226


28th Annual International Computer SofhYare and Applications Conference (COMPSAC), 362-367, Hong Kong, 2004. [Michel and Hentenryck, 19991 L. Michel and P. Van Hentenryck. Localizer++: A modeling language for local search. INFORMS Journal of Computing, 11, 1-14, 1999. [Solomon, 19871 M. M Solomon. Algorithms for Vehicle Routing and Scheduling Problem with Time Window Constraints, Operations Research 35, 254 - 265,1987.

Chapter 10 BI-OBJECTIVE SEQUENCING OF CUTTING PATTERNS An applicationfor the paper industry Ana ~ e s ~ i c i and o ' M. EugCnia captivo2 Universidade de Lisboa, Faculdade de Cisncias Centro de Investigap?~Operacional Campo Grande, 1749-016 Lisboa, Portugal

Abstract: Sequencing cutting patterns problems arise in several industries. Given a set of cutting patterns and a given objective, a sequencing problem consists of finding a permutation of patterns that optimises the objective. Single objective problems are NP-hard. Approaches available in the literature have only dealt with single objective problems, and consider heuristics and metaheuristics. Single objective optimisation approaches are myopic regarding other objectives and may loose Pareto optimal solutions. We propose a bi-objective sequencing problem considering the minimisation of the maximum number of open stacks and the minimisation of the average order spread. To approximate the Pareto optimal set we used multi-objective evolutionary algorithms. The bi-objective optimisation approach can provide knowledge about the solution space that would not have been achieved with a pure single objective approach. Key words:

10.1

Cutting-stock, sequencing problems, multi-objective evolutionary algorithms.

INTRODUCTION

Problems of sequencing cutting patterns arise in several industries. Given a set of cutting patterns and a given objective, a sequencing problem consists of finding a permutation of patterns that optimises the objective. Single objective problems are NP-hard. Heuristics and metaheuristics provide suitable solution approaches.

228


Under a cooperation project with Portucel, the major Portuguese paper producer (one of the European leaders in the paper market), we have developed customised interactive tools for decision-making support for production planning and scheduling [9]. Figure 10.1 describes the elaboration of cutting plans. The process consists of four stages, each of which is represented by a box.

I Select orders to cut I

1 t L Widthslnumber of items

Generation of a cutting solution >Minimising cutting waste Column Generation Technique

Cutting solution (widths)

Assignment of items to orders >Minimising number of patterns cutting each order Heuristics

Cutting solution (orders)

Sequencing cutting patterns >Minimising order spread >Minimising open stacks >Which objective? Cutting plan

Figure 10.I. Elaboration of cutting plans

We identified two major sequencing objectives: (1) the minimisation of the maximum number of open stacks and (2) the minimisation of the average order spread. The space around the cutting saw is narrow. As the number of produced items increases, packing mistakes arise. Objective (1) concerns the minimisation of these mistakes, in the worst case. Objective (2) regards the efficiency of the flow of work, on the average case. However the production schedulers were not able to set a preference between these two criteria. They state that "to choose a pattern sequence they need to analyse and compare the best sequences". We propose a bi-objective sequencing problem considering these two objectives. Linhares and Yanasse [6] clearly show that optimising these objectives leads to potentially different solutions. To our knowledge, approaches available in the literature have only dealt with single objective problems. Single objective optimisation approaches are myopic regarding other objectives and may loose Pareto optimal solutions. Approximating the Pareto optimal set allows for a more effective exploration of the solution space. We test a pure multi-objective evolutionary algorithm and propose a new hybrid algorithm, that includes local search procedures. Next section presents the mathematical functions for the objectives and the bi-objective model. Section 10.3 presents a literature summary. Section 10.4 describes the solution approach. Section 10.5 discusses the

Bi-objective sequencing of cutting patterns

229

computational results focusing on different strategies for the algorithm implementation. Section 10.6 presents an interface module to support decision-making. Section 10.7 concludes with a summary of the results achieved.

10.2

PROBLEM STATEMENT

Consider the cutting solution defined by the set of patterns pl,...,pn , where aq is the number of times order i is cut in pattern j , i = l,..., m , j = l,..., n . A permutation of the pattern indexes ll = (q, ...,n,) represents a cutting sequence. The maximum number of simultaneously open stacks in permutation II is given by

where qik(n)=

10,

j=1

j=k

otherwise.

If a stack for order i is open when pattern k is cut then q i k o = l , otherwise, q i k O = 0 , i = 1, ...,m . The spread value of order i in sequence ll , i = I,..., m ,is given by s i o , defined as

The average order spread of permutation II is given by

The bi-objective problem is the minimisation of the functionf that maps each permutation to a pair of objective values: min y = f (x)= (MOS(x),AOR(x)),

230


where x E T ( r is the set of all permutations of cardinality n ) and 0,

'1.

For our bi-objective problem, a single point on the decision space corresponds frequently to multiple alternative decision vectors. The set of all efficient decision vectors constitutes the optimal-Pareto set, and its image on the objective space is the set of all non-dominated solutions or the Paretofiont. Figure 10.2 illustrates these concepts for a bi-objective minimisation problem. Consider the outer solutions of the Pareto-front, z;" = ($,z r d ) and z;' = b;, z r d ) , the points that correspond to the optimums for each objective, respectively. The utopia point, zUt= b;, y;), represents the lower limit for each objective and it corresponds to a feasible solution only if the Paretofront is a singular set. The nadir point, given by z" = ( Z ; Y ~ , Z ?,~ ) represents the upper limits on the objectives. nadir point Y2

0

...............

i 0

utopia point '

0

ioo [ o 0 0 Qo')

0

'

-8-6

j

Non-dominated solution

0 Dominated solution

j

*....0 .........@.....

.

j

-.-

i;j

Figure 10.2. illustration of points on the objective space

Besides computing the approximation of the Pareto set, we also aimed to study the relative amount we could expect to loose in one objective when we optimise the other. Considering the concepts of figure 10.2, these measures are given by: - Maximum relative difference for MOS = ( q d - y;) l y; and - Maximum relative difference for AOR = ( z r d - y;) l y; .

10.3

LITERATURE REVIEW

Approaches in the literature are relevant, but only consider the single objective problems. The corresponding problems are proven to be NP-hard [3, 111. Table 10.1 summarises the literature approaches, the objective(s) considered, and the solution techniques used. There are some slight differences on the way objective values are computed. Some authors

Bi-objective sequencing of cuttingpatterns

23 1

consider the maximum order spread in spite of the average value, and the opposite happens for the maximum number open stacks. Yuen [12, 131 also studied the minimisation of the stacks number. Table 10.1. Summary of the literature for the single objective problems

Dyson and Gregory [l] Haessler and Talbot [S] Madsen [7] Yuen [12, 131 Yuen and Richardson [I41 Foerster and Wascher [4] Yanasse [l 11 Faggioli and Bentivoglio [2] Fink and Voss [3] Respicio et a1 [9] Linhares and Yanasse [6]

10.4

X X

X

X X X

X X

X

X

X X

X X X

X

X X

X

X X

X

X

X

X

X X

X

X

X

SOLUTION APPROACH

10.4.1 Multi-objective evolutionary algorithms We adapted the multi-objective evolutionary optimisation algorithm SPEA2 - an improved version of the Strength Pareto Evolutionary Algorithm (SPEA) - recently proposed [16]. SPEA2 has been compared with other recent multi-objective optimisation techniques, yielding very good results. The main features of the algorithm include elitism, a finegrained fitness assignment scheme and diversity of solutions in each generation. Non-dominated individuals are kept on an archive. We developed new versions of the algorithm, both by considering a special stopping criterion and by introducing local search procedures, as described in section 10.4.2. Encoding of individuals, recombination and mutation operators were adopted from the concepts and techniques for evolutionary algorithms for the TSPIsequencing problems [8, chp. 101. Individuals are encoded using the path representation, which is the most natural form of representing sequences. The recombination operator is the Order Crossover operator OX. The OX builds offspring by selecting a subsequence from one parent and preserving the relative order of elements from the other parent. This operator gives importance to the order of the elements in the sequence, rather

232


than to their positions. The mutation operator is the Reciprocal Exchange operator that exchanges the positioning of two elements.

10.4.2 Versions of the algorithm As stopping criteria, we implemented the usual test on the maximum number of generations and the test on the relative change of the distance between utopia and nadir point approximations, which is the best stopping test for estimating a Pareto-set by evolutionary algorithms [lo]. For this latter test we used a parameter r that rates the number of generations not yet Let tl be the last generation performed for the maximum established (0. when utopia andlor nadir point approximations changed. The algorithm stops at generation t2 if, from generation tl to generation t 2 , the relative change of the distance between utopia and nadir points is near zero and t2 - t, > r(T - t2). At each generation, the satisfaction of the stopping test is verified. The approximation of the Pareto set is given by the set of efficient individuals in the current archive. In the pure version of the algorithm individuals in the initial population are generated randomly. We also developed a hybrid algorithm. For each pattern index, we initialise a sequence with that index and compute the correspondent solution given by the heuristic 3 of Yuen [13], which was claimed to be quasioptimal [14]. Each of these sequences is included in the initial population. The remaining individuals in the initial population are generated randomly. Other feature of this algorithm consists of performing local search aiming to improve the potentially non-dominated individuals found so far. At each set of 50 generations, we test if the approximation of the utopia point has changed and, in that case, we perform a 2-optimal procedure over the nondominated individuals in the current archive. A total of four versions of the algorithm were tested, as summarised in table 10.2. Table 10.2. Versions of the algorithm Type of algorithm pure pure hybrid hybrid

Stopping criterion maximum number of generations distance between utopia-nadir points maximum number of generations distance between utopia-nadir points

Name of the version VP 1 VP2 VH1 VH2


10.5

COMPUTATIONAL TESTS

The algorithms were coded in C. All the tests were performed on a Pentium IV 1600MHz.

10.5.1 Description of the instances We tested over two sets of instances. The first one includes the larger instances randomly generated used by Foerster and Wascher [4] and by Fink and Voss [3]. For m (the total number of different orders), two values were considered m=50 and m=60. The number of patterns, n, is close to m. Four values for v (the relative size of the largest order length to the total raw length) were considered (1-0.25, ~ 0 . 5 ,~ 0 . 7 5 ,1-1). Each pair (m,v) corresponds to a subset of data instances, giving a total of eight instance groups - groups 1 to 4 for m=50 ordered according to decreasing complexity, and groups 5 to 8 for m=60 ordered in the same way. From each of the original groups, we tested over 10 instances (the first 10 of each set), adding up to a total of 80 instances. The second set consists of 22 real instances provided by the manufacturer, where m130 and 0.3950.5.

10.5.2 Description of the experiences For each instance, we made 10 run simulations of each algorithm version using a parameters set. The set of non-dominated solutions is approximated by all non-dominated solutions found during all the runs. VPl and VP2 were tested using the parameters sets PSI and PS2, and VHl and VH2 using PS3 and PS4. The correspondent parameter values for each set are described in table 10.3. Table 10.3. Parameters sets parameter Dimension of the population Dimension of the archive T (number of generations) r (generations remain rate)

PSI 100 100 750 0.2

PS2 150 150 2000 0.4

PS3 225 75 1000 0.1

PS4 300 100 750 0.1

PS5 150 50 750 0.1

We fixed the probability of reproduction to 0.8, the mutation probability to 0.2, and o to 0.5.

234


10.5.3 Evaluation of the algorithm versions To evaluate the algorithm versions, we used three metrics described by Zitzler et al. [15]. Consider a set of efficient decision vectors X', and Y' the correspondent set of non-dominated objective vectors. Let Y denote the optimum Pareto-front. The metric Ml(Y) gives the average distance of Y' to Y. M2(Y) counts the number of niches of neighbourhood o , for a given value o >O. The metric M3(Y) measures the extension of the approximated front on the objective space. To compare the different experiences we compared the approximations of the utopia point and count the relative number of times the best-known solution for each objective was found for each instance.

10.5.4 Experiences over the randomly generated instances All values presented on the following tables of results refer to average values over the simulation runs performed for each experience. Table 10.4 shows the computational results for VP1 and VP2 using the parameters set PSI. The maximum relative difference for the objectives is shown under the title %MRelD$ For each instance, we evaluated the number of times the best-known solution value for each objective (given by the approximated utopia point, over all the sets of experiences) was reached in each experience. Columns under the title %Best display these relative values in percentage. The last row A, displays the average of values in the above cells. Table 10.4. Computational results for VP1 and VP2 using PS 1 Approximated front

VPI

%MRelDif

%Best

M2

M3

MI

M2

M3

MOS AOR UOS AOR

1.5

1.0

0.56

1.48 0.10

0.10

2.69 0.35

90

20

1.4

0.8

0.44

1.72 0.02

0.09

2.16 0.81

50

20

1.5

1.0

0.58

1.22

4.99 3.51

90

30

.4.00 - - - - - -3.40 ----

80

20

#Y'

. 1.2 . . . . . . .0.4 . . . . . . 0.23 . . . . . . .0.71 ............. 1.3

0.6

0.36

2.19

0.24

0.34

1.4

0.8

0.44

2.09

0.12

0.25

1.78 0.61

1.3

0.6

0.37

1.79 0.02

0.08

3.84

1.49

1.2

0.4

0.22

1.12

3.67

1.49

1.4

0.7

0.40

1.54 0.06

3.04

1.55

0.11

1.14 0.73

A single run of VPl or VP2 doesn't approximate properly the final nondominated solutions set - there occur large values of metric MI. Version VP2 stops prematurely. The computing average times are 4.9 minutes for


235

VP1 and 1.4 minutes for VP2 (which corresponds to performing an average of 282 generations). Table 10.5 shows the computational results for VPl and VP2 using the parameters set PS2. For that parameters set, both VP1 and VP2 approximate correctly the Pareto-set. However, the computational effort is excessive even for VP2, which consumes near 7 CPU minutes on average to perform an average of 756 generations (VP1 consumes near 23 CPU minutes). Table 10.5. Computational results for VP1 and VP2 using PS2 Approximated front

VPI

VP2

%MRelDif

%Best

#G

#Y'

M2

M3

MI

M2

M3

MOS AOR MOS AOR

1

1.2

0.8

0.46

1.59 0.28 0.43

1.58 0.20

0.79

2.14

0.33

100

60

2

1.7

1.3

0.71

1.41 0.06 0.15

1.73 0.02 0.32

3.85

1.37

90

60

3

1.1

0.2

0.13

1.42

1.58

0.91

1.03

90

30

1.67 0.46

100

10

M2

M3

MI

.- -4- - - .-1.1 - - - - - -0.2 - - - - - -0.11 - - - . 0.80 0.02 0.04 0.85 5 1.8 1.4 0.76 1.76 0.06 0.19 2.21 0.28

6

1.5

0.9

0.53

2.14 0.08 0.19 2.07 0.05

7

1.6

1.1

0.59

1.65

8

1.0

A

1.4

0.7

0.41

0.54

3.20

1.13

90

70

0.29

2.73

0.95

90

30

6.11

2.74

30

2.57

1.00

83

1.62

0.97 1.47 0.06

0.10

70

1.39 0.13

1.63 0.07

0.25

33

Comparing VH1 and VH2, both versions reached similar values for the evaluation metrics, for the parameters sets PS3 and PS4, as shown in table 10.6 and table 10.7. We compared the components of the utopia point approximations with the best solutions given by the heuristic 3 of Yuen [13]. Columns under the title %MDiJY3 display the values found for the corresponding maximum relative difference (in percentage). Table 10.6. Computational results for VH1 and VH2 using PS3

236


For PS3, the CPU average times were 14.7 minutes for VH1, and 3 minutes for VH2, respectively, and VH2 performed an average of 203 generations. Using PS4, the computing average times were 13.8 minutes for VHl and 2.8 minutes for VH2 (performing an average of 175 generations), respectively. Comparing on the parameters sets, the best results were achieved using PS4, showing that the performance of the algorithm depends more on the number of individuals evaluated on each generation than on the number of generations. Comparing the versions performance for PS4, version VH2 performs well (the evaluation metrics values are similar to those obtainedby VH1). Table 10.7. Computational results for VHl and VH2 using PS4 Approximated front

#G #Y'

VH1

M2

M3

M1

0.11 0.18

M2

VH2 M3

MI

A42

%MRelDiJ %MDtjY3

%Best

M3 MOS AOR MOS AOR UOS AOR

1

1.1

0.20

0.02 0.50 0.05

17

17

50

20

2

1.1

0.40 0.22 0.29 0.20 0.01 0.35 0.04 0.11 1.03 0.35

19

25

30

30

3

1.1

0.20 0.12

30

23

90

70

4

1.0

5

1.2

6

1.0

7

1.2

8

1.0

A

1.1

0.40 0.20

0.02 0.29

0.27

0.54 0.08 0.18 0.71 0.34

0.04

0.06

26- - - - - - - - - - - . . 33 ----100 --- - - - - - -100 --0.86 0.04 0.18 0.88 0.12 0.41 0.82 0.04 21 17 50 30 20

16

30

40

2.22 0.1s 38

32

90

70

40

26

100

100

0.1 1 0.28 0.03 0.03 0.42 0.04 0.12 0.66 0.13 27

23

68

58

0.42 0.02 0.05 0.58 0.08 0.24 0.40

0.21

0.20

0.20

0.36

0.11

0.29

0.02

For the objective MOS, the best average results were achieved by VP1 using PS2, which is explained by the large number of individuals evaluated. This number reaches an average of 480000, that is four times the correspondent number when using PSI, 120000, and twice the number for both PS3 and PS4, 240000. For the objective AOR, the best average results were obtained by VHl and VH2 using PS4 (and not significantly different from the best ones for MOS). The improvements on the hybrid versions explain this superiority. Over all the tested instances, the average cardinality of the nondominated solutions set approximation is near or equal to 1. The maximum cardinality found was 2. The maximum relative variation for the objective AOR is near 3.5%, and the maximum relative variation for MOS is inferior to 7%. The maximum relative differences occur for the "easiest" instance groups (0.751v11), both for m=50 and for m=60 - groups 3,4, 7 and 8. For these groups, the number of orders to cut in each pattern is smaller. For the general case the trade-off is not significant.


10.5.5 Experiences over the real instances For the real instances, we tested VP1 and VP2 using PS 1, and VH1 and VH2 using PS5 (table 10.8). Column SC presents a measure of the sequencing complexity (the average number of different patterns an order as to be cut from). A value of SC =1 corresponds to the easiest sequencing. For all instances, the approximated utopia point is feasible, and all runs reached it for most of the instances. Using PS5, the M2 and M3 values were all zero, except for instance 22, where M2=0.2 and M3=0.6, for VH1; and M2=0.2 and M3=1.0 for VH2, respectively. Using PSI, the CPU average consumption time is 2.3 minutes for VP1, and 22 seconds for VP2 (160 generations). Using PS5, these values are 2.5 minutes for VH1 and 25 seconds for VH2 (175 generations), respectively. However, VH2 using PS5 seems to be the most suitable option, because the metric values show a correct approximation of the Pareto-front and is faster. Table 10.8. Results for the real instances - VPI and VP2 using PSI - VHl and VH2 using

%M MOS -

17 15 11 25

Although heuristic 3 of Yuen [13] was claimed quasi-optimal [14] for minimising the maximum number of open stacks, it found the best-known solutions only for the real instances of small dimension (n I S *[ (where s* is the most complete configuration found so far), which corresponds to the aspiration criterion. Eventually, in the evaluateN function, the condition is not tabu corresponds to (tabu(xi, Di[k]) 5 iter V Is'l > IS*^).

+

+

17.3.5 Diversification The aim of diversification is to enable the search to escape from an attractive zone of the search space. For this purpose, we introduce penalties into the neighbour evaluation. More precisely, each time a configuration s such as 'v's' E N(s), IS'[ 5 IS[ (i.e. Smin > O), we add a penalty to all the pairs (xi, vi) of the allocated variables which have a un-assigned neighbour in the constraint network. Since dmin > 0 means that is not possible to instantiate any variable without violating constraints, the assigned variables belong to a nogood, emphasized by adding penalties, which are considered in the move heuristic during the diversification.

17.3.6

Consistent Neighbourhood in Tabu Search

Combining all the points and implementations described above, leads us to the Tabu Search on a Consistent Neighbourhood algorithm: Algorithm 17.5: CN-Tabu begin s + greedy(S); s* + s repeat 6min, Ccand + evaluateN(s) if 6,in > 0 then Updatenogoodpenalties if Ccand # 0 then iter++; ( x i ,Di[k])+ randSelect(Ccand) propagate-move(xi, vi); f req(xi,vi)++ if IS[ > IS*^ then if Is*l = n then return s* until Ccand = 0 return s* end

The algorithm greedy(S) attempts to assign a free variable while any constraint is violated. If it returns a partial configuration, this last one is processed by CN-Tabu which aims to complete it. CN-Tabu algorithm

376


stops either when a complete solution is reached, or when the tabu list is saturated and no improving configuration is reachable. In some points, CN-Tabu is close to the strategic oscillation [9] which =0 alternates constructive phase (corresponding to the condition in CN-Tabu) and destructive one (&,in > 0), except that, in CNTabu, these two phases constitute only one move and which is completely evaluated.

17.4 REAL-LIFE APPLICATIONS Even though the methodology proposed in this paper could be adapted, we expect it to solve many constrained optimization problems. The following four problems share some important characteristics. First, all the problems can be intuitively implemented by a constraint network. Secondly, they are made up of hard constraints, and finally, the involved constraints have weak arity.

17.4.1

F'requency Assignment Problem with Polarisation

As we shall see below, this first example matches well with our methodology, without any adaptation. All the constraints are binary, and the constraint graph is not multi-edge. A complete description of this problem can be found in [6].

Description. The F A P P is a frequency allocation optimization problem in Hertzian telecommunication networks. A network consists of a set of sites where the located antennae must communicate by hertzian liaisons. A liaison is composed of one or more unidirectional radioelectric bonds, called paths. A frequency allocation problem therefore consists in assigning a resource (frequency, polarisation) for each path where frequency belongs to the authorized waveband and polarisation is a binary attribute which indicates the antenna orientation (vertical or horizontal). All the assignments must satisfy some binary radio-electric compatibility constraints. Among them, the minimal gap constraints (MGC) avoid the interferences in the network. However, many problems are not feasible in practice, so relaxation levels are introduced into those minimal gap constraints to limit the interferences. Modelling. consists of:

Representing the F A P P within the C S P framework

associating a variable xi with each path: X = {xl, ...,x,);

377

Consistent Neighbourhood

associating to Xi a domain Di = Fi x Pi, where Fi is a set of permitted frequencies for the path xi and a polarisation Pi is one of the following set {-I), {I), or {-1,l); adding several imperative constraints (IC) between two paths and xj:

Xi

1 equality or inequality of frequencies across paths: fi = f j or

fi # fj; 2 distance between frequencies: Ifi - f j1 = ~ iorj 1 fi - f j1

# Eij;

3 equality or inequality of polarization across paths: pi = pj or Pi # pj; rn

adding the minimal gap constraints (MGC) where progressive relaxation is authorized:

the index k, growing from 0 to 10, indicates the relaxation level of the MGCs. Every problem is 11-feasible. A good solution has the least relaxed MGCs. We therefore have a hierarchical objective function dependent on k: firstly minimize k, secondly minimize the number of violated MGCs at level k - 1 noted Vk-l, and finally minimize the number of violated MGCs at level less than k - 2: xO

Metaheuristics:: Progress as Real Problem Solvers

Physics Problem Solver (Problem Solvers)

Physics Problem Solver (Problem Solvers)

Statistics Problem Solver (Problem Solvers)

Laplace Transforms (Problem Solvers)

Metaheuristics: Progress in Complex Systems Optimization

Mathematics as problem solving

Mathematics as problem solving

Crime Analysis for Problem Solvers in 60 Small Steps

Essentials of Metaheuristics

Handbook of Metaheuristics

The problem solvers: a history of Arthur D. Little, Inc

A Problem Book in Real Analysis (Problem Books in Mathematics)

Handbook of metaheuristics

Hybrid Metaheuristics Bartz

Systemic text generation as problem solving

Free Will as an Open Scientific Problem

Mathematics as Problem Solving, Second edition

Handbook of Metaheuristics

No Such Thing as the Real World

No Such Thing as the Real

Marriage As a Relationship: Real and Rational

Progress

Progress

Progress

Progress

Progress

Progress

Progress

Progress

Progress

Metaheuristics:: Progress as Real Problem Solvers

Physics Problem Solver (Problem Solvers)

Physics Problem Solver (Problem Solvers)

Statistics Problem Solver (Problem Solvers)

Laplace Transforms (Problem Solvers)

Metaheuristics: Progress in Complex Systems Optimization

Mathematics as problem solving

Mathematics as problem solving

Crime Analysis for Problem Solvers in 60 Small Steps

Essentials of Metaheuristics

Handbook of Metaheuristics

The problem solvers: a history of Arthur D. Little, Inc

A Problem Book in Real Analysis (Problem Books in Mathematics)

Handbook of metaheuristics

Hybrid Metaheuristics Bartz

Systemic text generation as problem solving

Free Will as an Open Scientific Problem

Mathematics as Problem Solving, Second edition

Handbook of Metaheuristics

No Such Thing as the Real World

No Such Thing as the Real

Marriage As a Relationship: Real and Rational

Progress

Progress

Progress

Progress

Progress

Progress

Progress

Progress

Progress

Recommend Documents