Steven Adriaensen, on the Semi-Automated Design Of
Total Page：16
File Type：pdf, Size：1020Kb
Faculty of Science and Bio-Engineering Sciences Department of Computer Science Artificial Intelligence Laboratory On the Semi-automated Design of Reusable Heuristics with applications to hard combinatorial optimization Dissertation submitted in fulfilment of the requirements for the degree of Doctor of Science: Computer Science Steven Adriaensen Promotor: Prof. Dr. Ann Nowé (Vrije Universiteit Brussel) © 2018 Steven Adriaensen All rights reserved. No parts of this book may be reproduced or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior written permission of the author. Abstract These days, many scientific and engineering disciplines rely on standardization and auto- mated tools. Somewhat ironically, the design of the algorithms underlying these tools is often a highly manual, ad hoc, experience- and intuition-driven process, commonly regarded as an “art” rather than a “science”. The research performed in the scope of this dissertation is geared towards improving the way we design algorithms. Here, we treat algorithm design itself as a computational problem, which we refer to as the Algorithm Design Problem (ADP). In a sense, we study “algorithms for designing algorithms”. The main topic we investigate in this framework is the possibility of solving the ADP automatically. Letting computers, rather than humans, design algorithms has numerous potential benefits. The idea of automating algorithm design is definitely not “new”. At- tempts to do so can be traced back to the origins of computer science, and, ever since, the ADP, in one form or another, has been considered in many different research communities. Therefore, we first present an overview of this vast and highly fragmented field, relating the different approaches, discussing their respective strengths and weaknesses, towards enabling a more unified approach to automated algorithm design. One design approach, which we explore in more depth, solves the ADP by reduction to an Algorithm Configuration Problem (ACP), a practice to which we refer to as Programming by Configuration (PbC). We demonstrate PbC, using it to design a non-exact algorithm (a.k.a. a “heuristic”) for solving hard combinatorial optimization problems. While PbC has previously been applied to the design of heuristics for some specific problem, our approach differs in that we consider the automated design of domain-independent heuristics 3 4 Abstract (a.k.a. “metaheuristics”) which are reusable across a wide class of problems. As a result, we obtain a metaheuristic which we show to be competitive with the state-of-the-art across nine different problem domains. Subsequently, we present a critical reflection on PbC, discuss its limitations, and our own work towards addressing these. In particular, we argue that PbC, in reducing the ADP to an ACP, abstracts information that can be usefully exploited to solve the ADP faster. To this end, we propose a novel performance estimation technique exploiting this information to generalize performance observations across designs. We describe a design procedure implementing our technique and validate experimentally that it improves the data efficiency (up to several orders of magnitude) in three selected scenarios. Finally, we explore an alternative, less disruptive angle. Here, instead of aiming at repla- cing the (manual) process by which algorithms are currently being designed, we investigate the possibility of improving the quality of the resulting design post hoc. In particular, we focus on ’simplicity’, a factor that is often overlooked when designing algorithms, which consequently tend to be overly complicated. To counteract this effect, we advocate Ac- cidental Complexity Analysis (ACA), a research practice targeted at identifying excessive complexity in algorithms. We demonstrate ACA, applying it to an existing state-of-the-art metaheuristic. As an outcome of this analysis, we are able to reduce its logical complexity by a factor of eight, without loss of performance. Samenvatting Vandaag de dag zijn vele wetenschappelijke en technische disciplines afhankelijk van stan- daardisatie en geautomatiseerde tools. Het ontwerp van de algoritmen die deze tools ondersteunen, gebeurt echter nog vaak handmatig, gestuurd door de ervaring en intuitie van de ontwerper, en wordt vaak als een “kunst” eerder dan een “wetenschap” beschouwd. Het onderzoek uitgevoerd in het kader van dit doctoraat is gericht op het verbeteren van dit algoritmeontwerp. Hier behandelen we algoritmeontwerp zelf als een computati- oneel probleem, dat we het “Algorithm Design Problem” (ADP) noemen. In zekere zin bestuderen we “algoritmen voor het ontwerpen van algoritmen”. In dit kader onderzoeken we in het bijzonder de mogelijkheid om computers, in plaats van mensen, algoritmen te laten ontwerpen. Dit biedt tal van mogelijke voordelen. Het idee om algoritmeontwerp te automatiseren is zeker niet “nieuw”. Pogingen daartoe zijn terug te vinden vanaf het onstaan van de computerwetenschap. Sindsdien is dit probleem, in één of andere vorm, beschouwd in vele verschillende onderzoeksgemeenschappen. Daarom presenteren we eerst een overzicht van dit zeer uitgebreide en gefragmenteerde onderzoeks- domein, waarin we de verschillende benaderingen relateren, hun respectievelijke sterke en zwakke punten bespreken, om zo een meer uniforme benadering van geautomatiseerd al- goritmeontwerp mogelijk te maken. Eén specifieke benadering, die we nader onderzocht hebben, ontwerpt algoritmen met behulp van geautomatiseerde tools die bekend staan als “algoritmeconfiguratoren”. Een praktijk waarnaar we verwijzen als “Programming by Configuration” (PbC). We illustreren het gebruik van PbC in het ontwerp van een niet-exact algoritme (ook wel een “heuristiek” genoemd) voor het oplossen van moeilijke combinatorische optimalisatieproblemen. Terwijl 5 6 Samenvatting PbC eerder werd toegepast op het ontwerp van heuristieken voor een specifiek probleem, verschilt onze aanpak in dat we het geautomatiseerde ontwerp van domeinonafhankelijke heuristieken (ook wel “metaheuristieken” genoemd) beschouwen die herbruikbaar zijn voor een groot aantal van verschillende problemen. We tonen aan dat de op deze wijze verkregen metaheuristiek even goed werkt als de best bestaande vergelijkbare technieken voor negen verschillende probleemdomeinen. Vervolgens, presenteren we een kritische reflectie op PbC. We bespreken de beperkin- gen ervan, en ons eigen werk om deze aan te pakken. In het bijzonder stellen we dat PbC nuttige informatie abstraheert die kan worden gebruikt om het ADP sneller op te lossen. Hiertoe stellen we een nieuwe techniek voor die deze informatie gebruikt om algo- ritmeprestaties te schatten aan de hand van minder experimentele data. We beschrijven een ontwerpprocedure die onze techniek implementeert en tonen aan dat deze weldege- lijk de gegevensefficiëntie (tot met meerdere grootteorden) verbetert in drie geselecteerde experimentele scenario’s. Ten slotte verkennen we een alternatieve, minder disruptieve invalshoek. Hier, in plaats van het (handmatige) proces waarmee de algoritmen momenteel worden ontworpen te proberen te vervangen, onderzoeken we de mogelijkheid om achteraf de kwaliteit van het resulterende ontwerp te verbeteren. In het bijzonder richten we ons op ’eenvoud’, een factor die vaak over het hoofd wordt gezien bij het ontwerpen van algoritmen, die bijgevolg de neiging hebben overgecompliceerde te zijn. Om dit effect tegen te gaan, pleiten we voor Accidental Complexity Analysis (ACA), een onderzoekspraktijk gericht op het identificeren van onnodige complexiteit in algoritmen. Als demonstratie, passen we ACA toe op een bestaande metaheuristiek. Deze analyse stelt ons in staat om de complexiteit hiervan met een factor van acht te verminderen, zonder prestatieverlies. Contents Abstract 3 Samenvatting 5 Contents 7 1 Introduction 11 1.1 Our Critical Perspective on Algorithmics . 11 1.2 Research Topic . 14 1.2.1 Scope and Focus . 14 1.2.2 Research Questions . 15 1.3 Structure of this Dissertation . 16 1.3.1 Content Outline . 16 1.3.2 Reader’s Guide . 18 Part 1: Background and Personal Perspectives 19 2 Foundations of Problem-solving 21 2.1 Problems . 21 2.2 Optimization Problems . 23 2.2.1 Examples of Combinatorial Optimization Problems . 24 2.3 Algorithms . 26 2.3.1 Formalization . 29 2.3.2 Computer Programs . 32 2.3.3 Parametrized Algorithms . 33 2.4 Problem Formulation . 34 2.4.1 Reducibility . 34 2.4.2 Problem-solving vs. Problem Formulation . 37 7 8 CONTENTS 2.4.3 Opinion: Importance of Natural Formulations . 38 2.5 Computational Complexity . 39 2.5.1 Analysis of Algorithms . 39 2.5.2 Complexity of Problems . 41 2.6 Beyond Effective Procedures . 43 2.6.1 Randomized Algorithms . 44 2.6.2 Asymptotically Correct Algorithms . 45 2.6.3 Non-exact Algorithms . 47 2.6.4 Contract and Anytime Algorithms . 48 2.7 Search Methods for Combinatorial Optimization . 49 2.7.1 Systematic Search . 50 2.7.2 Heuristic Search . 54 2.8 Summary . 67 3 Algorithm Design 69 3.1 The Algorithm Design Problem . 70 3.2 Algorithm Quality . 71 3.2.1 Performance . 71 3.2.2 Beyond Performance . 73 3.2.3 Conflicting Criteria? . 74 3.3 Who is the Designer? . 80 3.3.1 The Manual Approach . 80 3.3.2 Automated Algorithm Design . 82 3.3.3 Semi-automated Design . 86 3.4 What Information Does the Designer Use? . 93 3.4.1 Analytical . 93 3.4.2 Empirical / Simulation-based . 93 3.4.3 Who Uses What Information? . 94 3.5 When Does Design Take Place? . 94 3.5.1 Offline . 94 3.5.2 Online . 95 3.5.3 Semi-online . 98 3.6 Summary . 99 4 Design by Algorithm Selection 101 4.1 Design by Per-set Algorithm Selection . 102 4.1.1 Formulating the ADP as a set-ASP . 102 4.1.2 Solving the set-ASP . 106 4.2 Design by Per-input Algorithm Selection . 117 CONTENTS 9 4.2.1 The input- and subset-ASP . 117 4.2.2 Formulating the ADP as a subset-ASP . 118 4.2.3 Solving the subset-ASP . 121 4.3 Design by Dynamic Algorithm Selection . 129 4.3.1 The Dynamic ASP . 130 4.3.2 Solving the Dynamic ASP . 139 4.4 A Broader Perspective . 147 4.4.1 Relations between the ASPs .