To obtain peak performance of an algorithm, it is often necessary to tune its parameters. The AI community has recently developed automated methods for the resulting algorithm configuration (AC) problem to replace tedious, irreproducible and error-prone manual parameter tuning. Some example applications, for which automated AC procedures led to new state-of-the-art performance, include satisfiability solving (hutter-fmcad07a; hutter-aij17a), maximum satisfiability [Ansótegui, Gabàs, Malitsky, SellmannAnsótegui et al.2016], scheduling [Chiarandini, Fawcett, HoosChiarandini et al.2008], mixed integer programming [Hutter, Hoos, Leyton-BrownHutter et al.2010a, López-Ibáñez StützleLópez-Ibáñez Stützle2014]Bezerra, López-Ibáñez, StützleBezerra et al.2016], answer set solving gebser-lpnmr11a, AI planning [Vallati, Fawcett, Gerevini, Hoos, SaettiVallati et al.2013] and machine learning [Thornton, Hutter, Hoos, Leyton-BrownThornton et al.2013, Feurer, Springenberg, HutterFeurer et al.2015].
Although the usability of AC systems improved over the years [<]e.g., SpySMAC, ¿falkner-sat15a, we still often observe fundamental issues in the design and execution of experiments with algorithm configuration methods by both experts and new users. The goals of this work are therefore to:
highlight the many pitfalls we have encountered in AC experiments (run by ourselves and others);
present best practices to avoid most of these pitfalls; and
propose a unified interface between an AC system and the algorithm it optimizes (the so-called target algorithm) that directly implements best practices related to properly measuring the target algorithm’s performance with different parameter settings.
Providing recommendations and best practices on how to empirically evaluate algorithms and avoid pitfalls is a topic of interest cutting across all of artificial intelligence, including, e.g., evolutionary optimization [Weise, Chiong, TangWeise et al.2012]
, algorithms for NP-complete problems gent-report97a, and reinforcement learning henderson-arxiv13a to mention only a few. Running and comparing implementations of algorithms is the most commonly used approach to understand the behaviour of the underlying method[McGeochMcGeoch1987]. There is a rich literature on how to best conduct such empirical studies [HookerHooker1995, Gent, Grant, MacIntyre, Prosser, Shaw, Smith, WalshGent et al.1997, Howe DahlmanHowe Dahlman2002, McGeochMcGeoch2002, McGeochMcGeoch2012], and for some journals abiding by such guidelines is even mandatory in order to publish research [DorigoDorigo2016, LagunaLaguna2017]. Research in AC depends even more on proper empirical methodology than the rest of artificial intelligence, since AC systems need to automatically evaluate the empirical performance of different algorithm variants in their inner loop in order to find configurations with better performance. Nevertheless, many of the underlying characteristics of empirical evaluations still remain the same as for other domains, and our guidelines thus share many characteristics with existing guidelines and extend them to the setting faced in AC.
The structure of this work is as follows. First, we provide a brief overview of AC, including some guidelines for new users, such as why and when to use AC, and how to set up effective AC experiments (Section 2). Afterwards, we describe common pitfalls in using AC systems and recommendations on how to avoid them. We first discuss pitfalls concerning the interface between AC systems and target algorithms (Section 3), followed by pitfalls regarding over-tuning (Section 4). Throughout, we illustrate pitfalls by AC experiments on propositional satisfiability solvers [Biere, Heule, van Maaren, WalshBiere et al.2009] as a prototypical AC example, but insights directly transfer to other AC problems.111 For these pitfalls, we do not distinguish between decision and optimization problems as the application domain of AC. Although configurators usually take into account whether and how the metric to be optimized relates to runtime, all presented pitfalls can happen in both types of application domain. From our own experiences, we provide further general recommendations for effective configuration in Section 5. We end by presenting a package to provide an interface between AC systems and target algorithms that aims to improve the reliability, reproducibility and robustness of AC experiments (Section 6).
2 Background: Algorithm Configuration
The algorithm configuration problem can be briefly described as follows: given an algorithm to be optimized (the so-called target algorithm) with parameter configuration space , a set of instances , and a cost metric , find a configuration that minimizes the cost metric across the instances in :
A concrete example for this algorithm configuration problem would be to find a parameter setting of a solver for the propositional satisfiability problem (SAT) (¡such as glucose,¿audemard-ijcai09a¡ or lingeling,¿biere-tech13a) on a set of CNF instances (e.g., SAT-encoded hardware or software verification instances) that minimizes ’s average runtime
. Another example would be to find a hyperparameter setting for a machine learning algorithm that minimizes its erroron a given dataset [Snoek, Larochelle, AdamsSnoek et al.2012, Feurer, Springenberg, HutterFeurer et al.2015]; in this latter example, would be validation error, either measured via -fold inner cross-validation (giving rise to instances for algorithm configuration) or a single validation set (in which case there is just a single instance for algorithm configuration).
The general workflow of a sequential algorithm configuration procedure (short: configurator) is shown in Figure 1. In each step, the configurator picks a configuration and an instance , triggers a run of algorithm with configuration on instance with a maximal runtime cutoff (and other resource limitations that apply, such as a memory limit), and measures the resulting cost . As detailed in Section 6, this step is usually mediated by a target-algorithm specific wrapper. The configurator uses this collected data about the target algorithm’s performance to find a well-performing configuration, typically operating as an anytime procedure until its configuration budget is exhausted (e.g., a maximal number of target algorithm calls or a time budget)222Alternatively, the termination criterion could be defined as stopping when no (or only little) further improvement is expected. Although this is a common choice for some other anytime algorithms, such as gradient descent, we often observe that AC trajectories are step functions with long periods of time between finding improving configurations, complicating the prediction of whether improvements will still happen. For these reasons and to enable an efficient use of resources, we chose to treat the budgets as discussed in the text.; when terminated, it returns its current incumbent, i.e., the best found configuration so far.
2.1 Why and When to Consider AC?
Algorithm configuration should always be considered if (i) the empirical performance of an algorithm is relevant and (ii) the algorithm has performance-relevant parameters. This is quite obvious for most empirical studies showing that a new algorithm establishes a new state-of-the-art performance on benchmark problem X. However, in this setting it is also important to tune the parameters of all algorithms to compare against — without this, a comparison would not be fair because one of the algorithms may only perform best because its parameters were tuned with the most effort [HookerHooker1995]. Indeed, as shown several times in the AC literature, optimized configurations often perform much better than default ones; in some cases, the default configuration may even be worse than one drawn uniformly at random (e.g., see Figure 6).
There are several other advantages of AC compared to manual parameter tuning [<]cf. ¿lopez-ibanez-orp16, including:
Automated algorithm configuration is often more reproducible than doing manual parameter tuning. Manual parameter tuning strongly depends on the experience and intuition of an expert for the algorithm at hand and/or for the given instance set. This manual procedure can often not be reproduced by other users. If algorithm developers also make their configuration spaces available (e.g., as the authors of Lingeling [BiereBiere2014] and Clasp [Gebser, Kaufmann, SchaubGebser et al.2012] do), reproducing the performance of an algorithm using AC is feasible.
- Less human-time
Assuming that a reasonable configuration space is known, applying algorithm configuration is often much more efficient than manual parameter tuning. While ceding this tedious task to algorithmic approaches can come at the cost of requiring more computational resources, these tend to be quite cheap compared to paying a human expert and are increasingly widely available.
- More thoroughly tested
Since humans are impatient by nature (e.g., during the development of algorithms), they often focus on a rather small subset of instances to get feedback fast and to evaluate another configuration. Compared to humans, configurators often evaluate (promising) configurations more thoroughly on more instances.
- More configurations evaluated
Because of similar reasons as above, humans tend to evaluate far less configurations than most configurators would do.
However, there are also two major limitations of AC, which must be considered:
- Homogeneous instances
To successfully apply AC, the instances have to be similar enough such that configurations that perform well on subsets of them also tend to perform well on others; we call such instance sets homogeneous. If the instances are not homogeneous, it is harder to find a configuration that performs well on average; it is even possible that a configurator returns a configuration that performs worse than the default one (although may appear to perform better based on the instances the configurator could consider within its limited budget). Unfortunately, so far, none of the existing AC tools implement an automatic check whether the given instances are sufficiently homogeneous. For heterogeneous instance sets, portfolio approaches [Xu, Hutter, Hoos, Leyton-BrownXu et al.2008, Kadioglu, Malitsky, Sabharwal, Samulowitz, SellmannKadioglu et al.2011, Malitsky, Sabharwal, Samulowitz, SellmannMalitsky et al.2012, Lindauer, Hoos, Hutter, SchaubLindauer et al.2015] or instance-specific algorithm configuration [Xu, Hoos, Leyton-BrownXu et al.2010, Kadioglu, Malitsky, Sellmann, TierneyKadioglu et al.2010] provide alternative solutions.
From the restriction to homogeneous instances, the second limitation of AC follows: the optimized configurations (returned by a configurator) are always specialized to the instance set and cost metric at hand. It is hard to obtain a robust configuration on a large variety of heterogeneous instances. (In fact, it is not even guaranteed that a single configuration with strong performance on all instances exists.)
2.2 Setting up AC Experiments
In the following, we describe the typical steps to set up and run AC experiments, and provide pointers to the pitfalls and best practices discussed later.
Implement the interface between your algorithm and the configurator; take Pitfalls 1-4 into consideration (Section 3);
Choose your preferred configurator (e.g., ParamILS, GGA++, irace or SMAC; see Section 2.3)
Define the resource limitations your algorithm (cutoff time and memory limit) and the configurator (configuration budget) should respect (see Section 5.4);
Define your cost metric to be optimized; if the cost metric is runtime, configurators typically optimize PAR10 as the metric of interest, which is the penalized average runtime (in CPU seconds) counting runs exceeding the cutoff time as ; furthermore please consider Pitfalls 2 and 3 (see Section 3.2) and recommendations in Section 5.8 for runtime optimization; if the cost metric is related to the quality of the solution, e.g. the error of a model on a dataset, configurators typically minimize validation error.
Run the AC experiments on the training instances and obtain the final incumbent—consider to use parallel runs (Section 5.5);
Optionally, use further tools to obtain visualizations and gain more insights from the AC experiments, e.g., CAVE [Biedenkapp, Marben, Lindauer, HutterBiedenkapp et al.2018].
As an exemplary application where AC yields dramatic speedups, we ran SMAC to optimize parameters of the configurator Clasp [Gebser, Kaufmann, SchaubGebser et al.2012] to solve N-Rooks [Manthey SteinkeManthey Steinke2014a] instances. We will return to this scenario in more detail in Subsection 4.2. Here, we used a training set of instances and a test set of instances to evaluate the best found configurations over time. We used a cutoff of seconds, within which the default configuration solves of all training instances. Figure 2 reports results from independent SMAC runs, showing that AC using an adequate setup can robustly yield large speedups compared to not tuning the algorithm.
2.3 Approaches for Solving the AC problem
For subproblems of the AC problem that deal neither with instances nor with capped and censored runs, there exist several approaches in the fields of parameter tuning, hyperparameter optimization and expensive black-box optimization. Prominent examples include Bayesian optimization [Mockus, Tiesis, ZilinskasMockus et al.1978, Shahriari, Swersky, Wang, Adams, de FreitasShahriari et al.2016], sequential parameter optimization [Bartz-Beielstein, Lasarczyk, PreussBartz-Beielstein et al.2010], evolution strategies [HansenHansen2006], and combinations of several classical search strategies ansel-pact14a.
For solving the full AC problem, there are several configurators. ParamILS [Hutter, Hoos, Leyton-Brown, StützleHutter et al.2009] uses local search in the configuration space, employing a racing strategy to decide which of two configurations performs better without running both of them on all instances. Recently, caceres-endm17a also proposed to use variable neighborhood search instead of the iterated local search used in ParamILS. irace [López-Ibáñez, Dubois-Lacoste, Caceres, Birattari, StützleLópez-Ibáñez et al.2016] uses iterative races via F-race [Birattari, Stützle, Paquete, VarrentrappBirattari et al.2002] on a set of sampled configurations to determine the best one. SMAC [Hutter, Hoos, Leyton-BrownHutter et al.2011] and its distributed version dSMAC [Hutter, Hoos, Leyton-BrownHutter et al.2012] use probabilistic models of algorithm performance, so-called empirical performance models [Hutter, Xu, Hoos, Leyton-BrownHutter et al.2014b], to guide the search for good configurations by means of an extension of Bayesian Optimization [Brochu, Cora, de FreitasBrochu et al.2010]. GGA [Ansótegui, Sellmann, TierneyAnsótegui et al.2009]
represents parameters as genes and uses a genetic algorithm with a competitive and a non-competitive gender; its newest versionGGA++ [Ansótegui, Malitsky, Sellmann, TierneyAnsótegui et al.2015] also uses an empirical performance model for guidance. For a more detailed description of these algorithms, we refer the interested reader to the original papers or to the report of the Configurable SAT Solver Challenge [Hutter, Lindauer, Balint, Bayless, Hoos, Leyton-BrownHutter et al.2017].
If the cost metric is runtime using PAR10 scores, several configurators use an adaptive capping strategy [Hutter, Hoos, Leyton-Brown, StützleHutter et al.2009] to terminate slow algorithm runs prematurely to save time.333As a side note, we remark that for model-based methods the internal model needs to handle dynamic timeouts arising from adaptive capping and PAR10 scores for guiding the search are based on predictions of that model. Furthermore, evaluations of incumbents for validation purposes are done purely with a fixed timeout , making PAR10 values comparable across configurators. For example, if the maximal cutoff time used at test time is seconds and the best configuration known so far solves each instance in 10 seconds, we can save dramatically by cutting off slow algorithm runs after seconds instead of running all the way to . Since is adapted dynamically, each target algorithm run can be issued with a different one.
2.4 The Role of the Target Algorithm Wrapper
As depicted in Figure 1, configurators execute the target algorithm with configurations on instances and measure the resulting cost . To be generally applicable, configurators specify an interface through which they evaluate the cost of arbitrary algorithms to be optimized. For a new algorithm , users need to implement this interface to actually execute with the desired configuration on the desired instance and measure the desired cost metric (e.g. runtime required to solve a SAT instance or validation error of a machine learning model).
In order to avoid having to change the algorithm to be optimized, this interface is usually implemented by a wrapper.444An alternative to a general wrapper would be a programming language-specific reliable interface for the communication between configurator and target algorithm [HoosHoos2012], which would make it easier for users to apply algorithm configuration to new target algorithms. However, the design of such an interface would also need to consider the pitfalls identified in this paper. In the simplest case, the input to the wrapper is just a parameter configuration , but in general AC it also includes an instance , and it can also include a random seed and computational resource limits, such as a runtime cutoff . Given these inputs, the wrapper executes the target algorithm with configuration on instance , and measures and returns the desired cost metric .
3 Pitfalls and Best Practices Concerning Algorithm Execution
In this and the next section, we describe common pitfalls in algorithm configuration and illustrate their consequences on existing benchmarks from the algorithm configuration library AClib hutter-lion14a555See www.aclib.net. Based on the insights we acquired in thousands of algorithm configuration experiments over the years, we propose best practices to avoid these pitfalls.
Throughout, we will use the state-of-the-art configurator
SMAC [Hutter, Hoos, Leyton-BrownHutter
et al.2011] as an example, typically optimizing PAR10.
Where not specified otherwise, we ran all experiments on the University of Freiburg’s META cluster, each of whose nodes shares 64 GB of RAM among two Intel Xeon E5-2650v2 8-core CPUs with 20 MB L3 cache and runs Ubuntu 14.04 LTS 64 bit.666Data and scripts for the experiments in this paper are available at
3.1 Pitfall 1: Trusting Your Target Algorithm
Many state-of-the-art algorithms have been exhaustively benchmarked and tested with their default parameter configuration. However, since the configuration space of many algorithms is very large, we frequently observed hidden bugs triggered only by rarely-used combinations of parameter values. For example, hutter-cpaior10a reported finding bugs in mixed integer programming solvers and manthey-sat16a bugs in SAT solvers. Due to the size of the associated configuration spaces [<]e.g., 214 parameters and a discretized space of configurations in the state-of-the-art SAT solver Riss,¿riss, exhaustive checks are infeasible in practice.
Over the years, the types of bugs we have experienced even in commercial solvers (that are the result of dozens of person-years of development time) include:
Segmentation faults, Null pointer exceptions, and other unsuccessful algorithm terminations;
Wrong results (e.g., claiming a satisfiable SAT instance to be unsatisfiable);
Not respecting a specified runtime cutoff that is passed as an input;
Not respecting a specified memory limit that is passed as an input;
Rounding down runtime cutoffs to the next integer (even if that integer is zero); and
Returning faulty runtime measurements (even negative ones!)
The various issues above have a multitude of negative effects, from obvious to subtle. If the algorithm run does not respect its resource limits this can lead to congested compute nodes (see Pitfall 3) and to configurator runs that are stuck waiting for an endless algorithm run to finish. Wrongly reported runtimes (e.g., close to negative infinity in one example) can lead to endless configuration runs when trusted. Rounding down cutoff times can let configurators miss the best configuration (e.g., when they use adaptive capping to cap runtimes at the best observed runtime for an instance – if that runtime is below one second then each new configuration will fail on the instance due to using a cutoff of zero seconds).
Algorithm crashes can be fairly benign when they are noticed and counted with the highest possible cost, but they can be catastrophic when not recognized as crashes: e.g., when blindly minimizing an algorithm’s runtime the configurator will typically simply find a configuration that crashes quickly. While this can be exploited to quickly find bugs [Hutter, Hoos, Leyton-BrownHutter et al.2010a, Manthey LindauerManthey Lindauer2016], obtaining faulty configurations is typically the worst possible result of using algorithm configuration in practice. Bugs that lead to wrong results tend to be discovered by configurators when optimizing for runtime, since (at least for -hard problems) we found that such bugs often allow algorithms to find shortcuts and thus shorten runtimes. Therefore, blindly minimizing runtime without solution checking often yields faulty configurations.
In 2012, we used algorithm configuration to minimize the runtime of the state-of-the-art solver glucose [Audemard SimonAudemard Simon2009]. We quickly found a parameter configuration that appeared to yield new state-of-the-art performance on the industrial instances of the SAT Challenge 2012777http://baldur.iti.kit.edu/SAT-Challenge-2012/; however, checking this configuration with the authors of Glucose revealed that it led to a bug which made Glucose falsely report some satisfiable instances as unsatisfiable.888The bug in Glucose version 2.1 was fixed after we reported it to the developers, and we are not aware of any bugs in the newest Glucose version 4.1.
In Figure 3 we reconstruct this behaviour. We ran SMAC on Glucose v2.1 and evaluated configurations found over time when trusting Glucose’s correctness at configuration time: The green curve shows Glucose’s (buggy) outputs on the test instances, whereas the orange curve scored each configuration using solution checking, and returning the worst possible score for configurations that returned a wrong solution. After 300 to 3000 seconds, SMAC found configurations that seemed better when trusting Glucose’s outputs, but that actually sometimes returned wrong solutions, resulting in the true score (orange curve) going up (getting worse) to the worst possible PAR10 score.
Most of the issues above can be avoided by wrapping target algorithm runs with a reliable piece of code that limits their resources and checks whether they yield correct results. Cast differently, the job of this wrapper is to actually measure the cost function of interest, which should intuitively heavily penalize any sort of crashes or bugs that lead to wrong results.
If enough computational time is available, we recommend to first run systems such as SpyBug [Manthey LindauerManthey Lindauer2016] to find bugs in the configuration space, and to either fix them or to exclude the faulty part of the configuration space from consideration. Regardless of whether this is done or not, since it is infeasible to perfectly check the entire configuration space, we always recommend to check the returned solution of the target algorithms during the configuration process. For example, for SAT instances, our example wrapper exploits the standard SAT checker tool routinely used in the SAT competitions to verify the correctness of runs. For solvers that output unsatisfiability proofs, there are also effective tools for checking these proofs [Heule, Hunt, WetzlerHeule et al.2014].
3.2 Pitfall 2: Not Terminating Target Algorithm Runs Properly
Given the undecidability of the halting problem, target algorithm runs need to be limited by some kind of runtime cutoff to prevent poor configurations from running forever. In many AI communities, it is a common practice to set a runtime cutoff as part of the cost metric and measure the number of timeouts with that cutoff (e.g., seconds in the SAT race series). In algorithm configuration, the ability to prematurely cut off unsuccessful runs also enables adaptive capping (see Section 2). Therefore, it is essential that target algorithm runs respect their cutoff. This pitfall is related to Pitfall 1 as the user also needs to trust the target algorithm to work appropriately. While for Pitfall 1 we focus on the returned solution, here we draw attention to the resource limitations.
Consequences of target algorithm runs not respecting their cutoffs can include:
If the target algorithm always uses the maximal cutoff and ignores an adapted cutoff , the configuration process is slowed down since the benefits of adaptive capping are given up;
If the target algorithm completely ignores the cutoff, the configuration process may stall since the configurator waits for a slow target algorithm to terminate (which, in the worst case, may never happen);
If a wrapper is used that fails to terminate the actual algorithm run but nevertheless returns the control flow to the configurator after the cutoff time , then the slow runs executed by the configurator will continue to run in parallel and overload the machine, messing up the cost computation (e.g., wallclock time).
The latter (quite subtle) issue actually happened in a recent publication that compared GGA++ and SMAC, in which a wrapper bug caused SMAC to perform poorly [Ansótegui, Malitsky, Sellmann, TierneyAnsótegui et al.2015]. The authors wrote a wrapper for SMAC that tried to terminate its target algorithm runs (here: Glucose or Lingeling) after the specified cutoff time by sending a KILL signal, but since it ran the target algorithm through a shell (using subprocess.Popen(cmd, shell=True) in Python) the KILL signal only terminated the shell process but not the actual target algorithm (which continued uninterrupted until successful, sometimes for days). When attempting to reproduce the paper’s experiments with the original wrapper kindly provided by the authors, over time more and more target algorithms were spawned without being terminated, causing our 16-core machine to slow down and eventually become unreachable. This issue demonstrates that SMAC heavily relies on a robust wrapper that automatically terminates its target algorithm runs properly.999In contrast to SMAC, GGA++ does not require a wrapper; in the experiments by ansotegui-ijcai15a, GGA++ directly sent its KILL signal to the target algorithm and therefore did not suffer from the same problem SMAC suffered from, which confounded the paper’s comparison between GGA++ and SMAC. Additionally, there was also a simple typo in the authors’ wrapper for SMAC in parsing the target algorithm’s output (here: Glucose) that caused it to count all successful runs on unsatisfiable instances as timeouts. Receiving wrong results for all unsatisfiable instances (about half the instance set) severely affected SMAC’s trajectory; this issue was only present in the wrapper for SMAC (and therefore did not affect GGA++), confounding the comparison between GGA++ and SMAC further.
To illustrate this issue in isolation, we compared SMAC using a working wrapper and a broken version of it that returns the control flow to the configurator when the runtime cutoff is reached, without terminating the target algorithm run process. Figure 4 shows the performance achieved when SMAC is run with either wrapper to configure Cryptominisat [SoosSoos2014] for penalized average runtime (PAR10) to solve Circuit Fuzz instances [Brummayer, Lonsing, BiereBrummayer et al.2012] as used in the CSSC 2014 [Hutter, Lindauer, Balint, Bayless, Hoos, Leyton-BrownHutter et al.2017]. We executed SMAC runs for each wrapper, with independent parallel runs each on five 16-core machines. Both SMAC versions performed equally well until too many target algorithm processes remained on the machines and prevented SMAC from progressing further. Only on one of the five machines that ran SMAC with the broken wrapper, the runs terminated after the specified wallclock-limit of 2 days; after an additional day, three of the remaining machines were still frozen caused by overload and the fourth could not be reached at all.
To avoid this pitfall, we recommend to use some well-tested, external piece of code to reliably control and terminate target algorithm runs.
3.3 Pitfall 3: Slow File System
Related to Pitfall 2, another way to ruin runtime measurements by slowing down a machine is to overload the used file system. Each target algorithm run typically has to read the given problem instance and writes some log files; thus, executing many algorithm configuration runs in parallel can stress the file system.
Slowdowns caused by an overloaded file system can have a severe impact on runtime measurements; in particular this is problematic because most algorithm configurators measure their own configuration budget as wallclock time. Furthermore, these problems are often not immediately recognizable (because everything runs fine when tested at small scale) and sometimes only affect parts of a large set of experiments (as the overload might only happen for a short time).
Over the years, we have experienced file system issues on a variety of clusters with shared file systems when target algorithm runs were allowed to write to the shared network file system. When executing hundreds (or on one cluster, even thousands) of algorithm configuration runs in parallel, this stressed the file system to the point where the system became very slow for all users and we measured 100-fold overheads in individual target algorithm evaluations. Writing target algorithm outputs to the local file system fixed these issues.
Distributing configuration runs across multiple nodes in a compute cluster (e.g., in GGA, irace, or dSMAC) can be error-prone if the configurators communicate via the file system. In particular, we experienced issues with several shared network file systems with asynchronous I/O; e.g., on one compute node a file was written, but that file was not immediately accessible (or still empty) on other compute nodes. Often a second read access resolved the problem, but this solution can be brittle; a change of parallelization strategy may in that case yield more robust results.
Even when writing target algorithm output to the local file system, we once experienced 200-fold overheads in target algorithm runs (invocations of sub-second target algorithm runs hanging for minutes) due to a subtle combination of issues when performing hundreds of algorithm configuration experiments in parallel. On the Orcinus cluster (part of Compute Canada’s Westgrid cluster), which uses a Lustre file system, we had made our algorithm configuration benchmarks read-only to prevent accidental corruption. While that first seemed like a good idea, it disallowed our Python wrapper to create .pyc bytecode files and forced it to recompile at every invocation, which in turn triggered a stats call (similar to ls on the Linux command line) for each run. Stats calls are known to be slow on the Lustre file system, and executing them for each sub-second target algorithm run on hundreds of compute nodes in parallel led to extreme file system slowdowns. After testing many other possible reasons for the slowdowns, removing the read-only condition immediately fixed all issues.
Issues with shared file systems on compute clusters can have subtle reasons and sometimes require close investigation (as in our Example 3). Nevertheless, most issues can be avoided by using the faster local file system (typically /tmp/, or even better, a temporary job-specific subdirectory thereof101010We note that on some modern Linux distributions, /tmp/ can be a RAM disk and therefore may use resources allotted to the algorithm runs; in general, we recommend to make the choice about a fast temporary directory specific to the compute cluster used.) for all temporary files, and by measuring CPU time instead of wallclock time (at least for sequential algorithms).
3.4 Pitfall 4: Handling Target Algorithm Runs Differently
The required functionalities of the target algorithm wrapper differ slightly for different configurators. For example, SMAC and ParamILS trust the wrapper to terminate target algorithms, but GGA sends a KILL signal on its own (see also Pitfall 2). Therefore, sometimes configurators are compared by using different target algorithm calls and measurements. However, if this is not done properly, it can lead to a biased comparison between configurators.
Calling the target algorithm differently for different configurators can lead to different behaviors of the target algorithm and hence, to different returned performance values for the same input. If the configurators receive different performance measurements, they will optimize different objective functions and their runs become incomparable.
During the early development of SMAC (before any publication), we used the same wrappers for ParamILS and SMAC but an absolute path to the problem instance for one and a relative path for the other. Even this tiny difference lead to reproducible differences of runtime measurements of up to 20% when optimizing an algorithm implemented in UBCSAT 1.1.0 [Tompkins HoosTompkins Hoos2005]. The reason was that that version of UBCSAT stored its callstring in its heap space such that the number of characters in the instance name affected data locality and therefore the number of cache misses and the runtime (whereas the number of search steps stayed the same).111111This issue is fixed in later versions of UBCSAT. This subtle issue demonstrates the importance of using the same wrapper for all configurators being compared such that exactly the same target algorithm calls are used.
We recommend to use a single wrapper when comparing configurators against each other, in order to guarantee that all configurators optimize the same objective. For studies comparing configurators, it is also paramount to use tried-and-tested publicly available benchmark scenarios (lowering the risk of typos, etc; see also Footnote 9); our algorithm configuration benchmark library AClib [Hutter, López-Ibánez, Fawcett, Lindauer, Hoos, Leyton-Brown, StützleHutter et al.2014a] provides a very broad collection of such benchmarks.
4 Pitfalls and Best Practices Concerning Over-Tuning
A common issue in applying algorithm configuration is the over-tuning effect [BirattariBirattari2004, Hutter, Hoos, StützleHutter et al.2007b, Birattari KacprzykBirattari Kacprzyk2009, Hutter, Hoos, Leyton-Brown, StützleHutter et al.2009] Over-tuning is very related to the concept of over-fitting in machine learning and denotes the phenomenon of finding parameter configurations that yield strong performance for the training task but do not generalize to test tasks. We emphasize that over-tuning effects are not necessarily only related to the set of training instances used, but can also include the characteristics of the experimental setup such as the resource limitations and bugs in the solver (see Pitfall 1). To safeguard against over-tuning effects, it is crucial to evaluate generalization performance (typically, using a set of benchmark instances disjoint from the benchmarks used for training). In the following, we discuss three pitfalls related to over-tuning.
4.1 Pitfall 5: Over-tuning to Random Seeds
Many algorithms are randomized (e.g., SAT solvers or AI planners). However, in many communities, the random seeds of these algorithms are fixed to simulate a deterministic behavior and to ensure reproducibility of benchmark results.
Ignoring the stochasticity of an algorithm in algorithm configuration by fixing the random seed can lead to over-tuning effects to this seed, i.e., finding a configuration that yields good performance with this fixed random seed (or set of seeds) but poor performance when used with other random seeds. The extreme case is not to only fix the random seed, but to tune the random seed, which can lead to an even stronger over-tuning effect.121212We note that, in principle, one could construct situations where fixing or even optimizing the seed could lead to good performance if that seed is used in all future experiments and a large number of instances is available to obtain generalization to other instances. However, we believe that the potential misuse of tuning seeds outweighs any potential benefits.
To illustrate over-tuning to a random seed in its purest form, independent of a difference between training and test instances, we optimized the parameters of the local-search SAT solver Saps [Hutter, Tompkins, HoosHutter et al.2002] on a single instance, the only difference between training and test being the set of random seeds used. We used different settings of SMAC to handle random seeds: We compared SMAC using a fixed set of 1, 10 or 100 random seeds for each target algorithm run and standard SMAC, which handled the random seed itself (using a larger number of seeds to evaluate the best configurations).
As a cost metric, we minimized the average number of local search steps (the solver’s so-called runlength) since this is perfectly reproducible. For the parameter configurations recommended at each step of each SMAC run, we measured SMAC’s training cost (as the mean across the respective sets of seeds discussed above) as well as its test cost (the mean runlength across 1000 fixed random seeds that were disjoint from the sets of seeds used for configuration) 131313Note that hutter-aaai07a used the median to aggregate across the 1000 seeds, resulting in slightly lower training and test runlengths..
Figure 5 shows median costs across SMAC runs, contrasting training cost (left) and test cost (right). On training, SMAC, using 1 seed per evaluation quickly improved and achieved the best training cost on its one random seed, but its performance does not generalize to the test seeds. SMAC, using 10 or 100 seeds per evaluation were slower but generalized better, and standard SMAC was both fast and generalized best by adaptively handling the number of seeds to run for each configuration.
For randomized algorithms, we recommend to tune parameter configurations across different random seeds—most configurators will take care of the required number of random seeds if the corresponding options are used. If a configuration’s performance does not even generalize well to new random seeds, we expect it to also not generalize well to new instances. Furthermore, the number of available instances is often restricted, but there are infinitely many random seeds which can be easily sampled. Likewise, when there are only few test instances, at validation time we recommend to perform multiple runs with different random seeds for each test instance.
4.2 Pitfall 6: Over-tuning to Training Instances
The most common over-tuning effect is over-tuning to the set of training instances, i.e., finding configurations that perform well on training instances but not on new unseen instances. This can happen if the training instances are not representative for the test instances; in particular this is often an issue if the training instance set is too small or the instances are not homogeneous [Hutter, Hoos, Leyton-BrownHutter et al.2010b, Schneider HoosSchneider Hoos2012], i.e., if there exists no single configuration with strong performance for all instances.
In practice, over-tuned configurations that only perform well on a small finite set of instances are of little value, because users are typically interested in configurations that also perform well on new instances. Phrasing this more generally, research insights should also generalize to experiments with similar characteristics.
To illustrate this problem, we studied training and test performance of various configurations for three exemplary benchmarks (see Figure 6):
- Clasp on N-Rooks
We studied the runtime of the solver Clasp [Gebser, Kaufmann, SchaubGebser et al.2012] on N-Rooks instances [Manthey SteinkeManthey Steinke2014a], a benchmark from the Configurable SAT Solver Challenge (CSSC 2014; hutter-aij17a). In this case, the runtimes on the training and test set were almost perfectly linearly correlated, with a Spearman correlation coefficient of , i.e., the ranking of the configurations on both sets is nearly identical; this is also visualized in Figure 6. This is a very good case for applying algorithm configuration, and, correspondingly, in the CSSC 2014 algorithm configuration yielded large improvements for this benchmark.
- Lingeling on mixed SAT
We reconstructed a benchmark from ansotegui-ijcai15a in which they optimized Lingeling [BiereBiere2014] on a mixed set of industrial SAT instances. Instead of randomly splitting the data into train and test instances, they first created a training set by removing hard instances (i.e., not solved within the cutoff time by reference solvers) and used these remaining hard instances as test instances. Figure 6 shows that SMAC improved the runtime of Lingeling on the training set but that these improvements did not generalize to the test instances. In fact, the training and test scores of the optimized configurations (orange squares) are only weakly correlated (Spearman correlation coefficient of ). The benchmark’s heterogeneity and the mismatch between training and test set make this benchmark poorly suited for algorithm configuration.
- Clasp on LABS
Figure 6 shows another benchmark from the CSSC: configuration of Clasp on SAT-encoded low autocorrelation binary sequence (LABS) benchmarks [Mugrauer BalintMugrauer Balint2013]. This illustrates a rare worst case for algorithm configuration, in which performance even degrades on the training set, which is possible due to SMAC’s (and any other configurator’s) racing approach: the configurator already changes the incumbent before all training instances have been evaluated, and if a subset is not representative of the full set this may lead to performance degradation on the full set.
While we have occasionally observed such strong heterogeneity on instances with very heterogeneous sources, it was very surprising to observe this in a case where all instances stemmed from the same instance family. We therefore analyzed this benchmark further [Hutter, Lindauer, Balint, Bayless, Hoos, Leyton-BrownHutter et al.2017], showing that twice as many SMAC runs with a fivefold larger configuration budget managed to improve training performance slightly. However, that improvement on the training set still did not generalize to the test set due to the benchmark’s heterogeneity. (Although visually not apparent from Figure 6, for this benchmark, the correlation between scores on training and test instances was quite low () for the best-performing randomly sampled configurations). Again, for such heterogeneous benchmarks we recommend the usage of portfolio approaches.
Over-tuning is often not easy to fully rule out by design, since the effect can only be measured by assessing test performance after the configuration process completed (for example by scatter plots, such as in Figure 6). Nevertheless, the following strategies minimize the risk of over-tuning (see also Section 5):
The training instances should be representative of the test instances;
The training set should be relatively large (typically hundreds to thousands of instances) to increase the chance of being representative;
The instance sets should stem from a similar application, use context, etc., increasing the likelihood that they have similar structures which can be exploited with similar solution strategies;
If the instance set is heterogeneous, portfolio approaches [Xu, Hutter, Hoos, Leyton-BrownXu et al.2008, Kadioglu, Malitsky, Sabharwal, Samulowitz, SellmannKadioglu et al.2011, Malitsky, Sabharwal, Samulowitz, SellmannMalitsky et al.2012, Lindauer, Hoos, Hutter, SchaubLindauer et al.2015] or instance-specific algorithm configuration [Xu, Hoos, Leyton-BrownXu et al.2010, Kadioglu, Malitsky, Sellmann, TierneyKadioglu et al.2010] should be used.
4.3 Pitfall 7: Over-tuning to a Particular Machine Type
In the age of cloud computing and large compute clusters, an obvious idea is to use these remotely-accessible compute resources to benchmark algorithms and configure them. However, in the end, these remote machines are not always the production systems the algorithms are used on in the end. geschwender-lion14a indicated in a preliminary study that it is possible in principle to configure algorithms in the cloud, and that the found configurations perform well on another machine. Unfortunately, recent other experiments showed that this does not hold for all kinds of algorithms – for example, the performance of solvers for SAT [Aigner, Biere, Kirsch, Niemetz, PreinerAigner et al.2013] and mixed integer programming (lodi-theory14a; koch-mpc11a) can depend strongly on the used machine type (including hardware, operating system and installed software libraries).
Some algorithms are machine-dependent and obtain different results depending on the hardware they run on. Being unaware of this can ruin both, a successful application and a comparison of configuration methods, in two ways: Firstly, when configuring on one system the best found configuration might perform poorly on another system. Secondly, the ranking of the best found configurations of target algorithms on one system might change when rerunning the experiments on a different system.
An example for such machine-dependent algorithms are SAT solvers that are often highly optimized against cache misses [Aigner, Biere, Kirsch, Niemetz, PreinerAigner et al.2013]. To study the effect of different machines, we optimized three SAT solvers from the configurable SAT solver challenge [Hutter, Lindauer, Balint, Bayless, Hoos, Leyton-BrownHutter et al.2017], namely Minisat-HACK-999ED [OhOh2014], Clasp [Gebser, Kaufmann, SchaubGebser et al.2012] and Lingeling [BiereBiere2014] on Circuit Fuzz instances [Brummayer, Lonsing, BiereBrummayer et al.2012]. As different machine types, we used AWS m4.4xlarge instances with 2.4-GHz Intel Xeon E5-2676 v3 CPUs with 30MB level-3 cache and the META-cluster at the University of Freiburg with 2.6GHz Intel Xeon E5-2650v2 8-core CPUs with 20 MB L3 cache. On both systems, we ran Ubuntu 14.04 64bit and allowed for a memory limit of GB for each solver run. The binaries were statically compiled such that they are not linked against different libraries on the different systems. For each solver we ran independent SMAC runs and validated the cost of the best found configuration for each solver on test instances on the same system.
Table 1 lists the ranking and the PAR10 scores of the solvers on each machine (showing the test cost of the configuration performing best on training); we note that the PAR10 scores are only comparable on the same system. In both environments, Lingeling ended up on rank 3, but the ranks of Clasp and Minisat-HACK-999ED differed between the two environments: if the AWS cloud would be our environment for running AC experiments, we would decide for Minisat-HACK-999ED, but this would not be the best choice on the META-cluster. We note that, since we picked the best of 12 SMAC
runs, due to the high variance of extremal statistics, the exact numbers of this experiments might vary in a rerun. Since we did not have enough compute resources on AWS for carrying out multiple runs, to gain additional confidence in our conclusions, we carried out an additional experiment: we validated the configurations found on AWS on the META-cluster and found that in that setting the configuredMinisat-HACK-999ED performed even worse than Lingeling and Clasp. Therefore, we conclude that the ranking of configured algorithms depends on the hardware.
We note that this pitfall exists only for machine-sensitive algorithms. Therefore, we recommend to investigate whether an algorithm at hand has machine-dependent performance, for example, by validating the performance of various configurations on both the system used for configuration and the production system.
5 Further Recommendations for Effective Configuration
In the following, we describe recommendations for users of algorithm configuration systems to obtain parameter configurations that will perform better in production. Some of these recommendations are rules of thumb, since the involved factors for a successful configuration can be very complex and can change across configuration scenarios. For general empirical algorithmics, mcgeoch-book12a recommends further best practices, including design, reports and analysis of computational experiments.
5.1 Training and Test Sets
As discussed before, following standard practice, we strongly recommend to split the available instances into a training and a test set to obtain an unbiased estimate of generalization performance from the test set [Birattari KacprzykBirattari Kacprzyk2009]. To obtain trivial parallelization of randomized configuration procedures, we recommend to run independent configuration runs and use the training set to select the best of the resulting configurations [Hutter, Hoos, Leyton-BrownHutter et al.2012]. Only that single chosen configuration should be evaluated on the test set; we explicitly note that we cannot select the configuration that performs best on the test set, because that would amount to peeking at our test data and render performance estimates on the test set biased.
5.2 Representative Instances and Runtime Cutoff
Intuitively, instances for which every parameter configuration times out do not help the configurator to make progress. One strategy can be to remove these from the training set. However, this comes with the risk to bias the training set towards easy instances and should be used with caution. Generally, we therefore recommend to use training instances for the configuration process that are representative of the ones to be solved later. Using training instances from a range of hardness can also often help yield configurations that generalize [Hoos, Kaufmann, Schaub, SchneiderHoos et al.2013]. If feasible, we recommend to select instances and runtime cutoffs such that roughly or more of the training instances used during configuration can be solved by the initial parameter configuration within the cutoff. We emphasize that – while the configuration protocol may in principle choose to subsample the training instances in arbitrary ways – the test set should never be touched and not pre-evaluated to ensure an unbiased cost estimate of the optimized configurations in the end (see Pitfall 6). To select a good training instance set, bayless-lion14a proposed a way to quantify whether an instance set is a good proxy for another instance set. Furthermore, styles-gecco13a proposed a splitting strategy of the instances for better scaling to hard instances: They split the instances into a training, validation and test set to use easy instances during configuration for fast progress and select a configuration on the harder validation set such that the configuration will perform well on the hard test set.
5.3 Homogeneous vs Heterogenous Instance Sets
Sometimes configurators are used to obtain well-performing and robust configurations on a heterogeneous instance set. However, we know from algorithm selection [RiceRice1976, KotthoffKotthoff2014] that often no single configuration exists that performs well for all instances in a heterogeneous set, but a portfolio of configurations is required to obtain good performance [Xu, Hutter, Hoos, Leyton-BrownXu et al.2011, Kadioglu, Malitsky, Sellmann, TierneyKadioglu et al.2010]. Furthermore, the task of algorithm configuration becomes a lot harder if all instances can be solved best with very different configurations. Therefore, we recommend to use algorithm configuration mainly on homogeneous instance sets. Furthermore, the size of the used instance set should be adjusted accordingly to the homogeneity of the instance set: on homogeneous instance sets, instances might suffice for good generalization performance to new instances, but on fairly heterogeneous instance sets, we recommend to use at least or, if possible, more than instances to obtain a robust parameter configuration.
5.4 Appropriate Configuration Settings
To use configurators, the user has to set the budget available for the configurator. If the configuration budget is too small, the configurator might make little or no progress within it. In contrast, if the configuration budget is too large, we waste a lot of time and computational resources because the configurator might converge long before the budget is used up. A good rule of thumb in our experience is to use a budget that equals at least the expected runtime of the default configuration on to instances. In practice, an effective configuration budget strongly depends on several factors, including heterogeneity of the instance set (more heterogeneous instance sets require a larger configuration budget) or size of the configuration space (larger configuration spaces require more time to search effectively [Hutter, Lindauer, Balint, Bayless, Hoos, Leyton-BrownHutter et al.2017]). Finally, if the configurator finds better performing configurations quickly, then the estimate of the total runtime based on the runtime of the default configuration might be too conservative.
5.5 Efficient Use of Parallel Resources
Some configurators (such as GGA, irace and dSMAC) can make use of parallel resources, while others (such as ParamILS and SMAC) benefit from executing several independent parallel runs141414In order to perform independent runs with ParamILS or SMAC, one should use a different seed (equivalent to the numRun parameter) for each run. (and using the result from the one with the best training set performance; see, e.g., hutter-lion12a). In the special case of GGA, using more parallel resources can actually improve the adaptive capping mechanism. Given cores, we therefore recommend to execute one GGA run with cores, but independent ParamILS or SMAC runs with one core each. While this protocol was not used in early works151515hutter-lion11a only used a single core per run of GGA, but still followed the protocol by ansotegui-cp09a to race groups of 8 runs in parallel per core; therefore, GGA’s adaptive capping mechanism was the same in that work as in ansotegui-cp09a., it has been used in more recent evaluations [Ansótegui, Malitsky, Sellmann, TierneyAnsótegui et al.2015, Hutter, Lindauer, Balint, Bayless, Hoos, Leyton-BrownHutter et al.2017].
5.6 Reasonable Configuration Space
Another challenge in using algorithm configuration systems is to find the best configuration space. The user has to decide which parameters to optimize and which ranges to allow. The optimal set of parameters to configure is often not clear and in case of doubt, we recommend to add more parameters to the configuration space and to use generous value ranges.
However, we note that unreasonably large configuration spaces are hard to configure and require substantially larger configuration budgets. For example, the state-of-the-art SAT solver Lingeling [BiereBiere2013] has more than parameters and most of them have a value range between and bit maxint, but most of these parameters are either not really relevant for optimizing Lingeling’s runtime or the relevant value ranges are much smaller. Even though Lingeling can already substantially benefit from configuration we expect that with a more carefully designed configuration space even better results could be obtained. Therefore, we recommend to avoid including such parameters and to use smaller value ranges if corresponding expert knowledge is available.
Nevertheless, configurators have already been successfully applied to such large configuration spaces: GGA++ has been used to optimize over parameters of Lingeling [Ansótegui, Malitsky, Sellmann, TierneyAnsótegui et al.2015], irace has been used to optimize over parameters of the mixed integer programming solver SCIP [López-Ibáñez StützleLópez-Ibáñez Stützle2014, AchterbergAchterberg2009] and with SMAC, we have optimized configuration spaces with over parameters [Lindauer, Hoos, Leyton-Brown, SchaubLindauer et al.2017a].
5.7 Which Parameters to Tune
Parameters should never be part of the configuration space if they change the semantics of the problem to be solved; e.g., do not tune the allowed memory or parameters that control whether a run is counted as successful (such as the allowed optimality gap in an optimization setting). Furthermore, to obtain an unbiased estimate of a configuration’s performance across seeds one should not include the seed (or parameters with a similar effect) as a tunable parameter.
5.8 Runtime Metrics
A common cost metric in algorithm configuration is runtime. Obtaining clean runtime measurements is a problem that is by no means limited to algorithm configuration and also appears in general empirical algorithmics [McGeochMcGeoch2012]. However, in algorithm configuration, this problem can be even more tricky, because benchmark machines can be influenced by heavy I/O load on a shared file system created by multiple configuration runs (see Pitfall 3). Furthermore, other running processes on the same machine can influence the measurements. The latter issue can be fixed by using processor affinity to bind processes to a certain CPU. Therefore, we recommend to measure CPU time instead of wallclock time. However, binding processes does not grant exclusive usage of the assigned cores; thus other interfering factors such as operation system load and shared caches remain. Also, CPU time can sometimes be brittle; e.g., its resolution can be insufficient for very short target algorithm runs, such as milliseconds. We note that algorithm configuration can be used to optimize runtime at such very small scales, but extreme care needs to be taken to avoid any pitfalls associated to measuring runtimes. When possible, a better solution for this case is to measure and optimize elementary operations, such as search steps of a local search algorithm or MEMS [<]number of memory accesses,¿knuth-book11a; however, it has to be ensured that such proxy metrics correlate well with runtime. Additionally, expensive one-time operations, such as downloading files or setting up should not be part of the measured runtime and need to be ignored, e.g. via the wrapper. Finally, it remains an open question how robust are different ways to measure runtime and related metrics and how do they influence algorithm configuration.
5.9 Monitoring Experiments
Even a well designed experiment can go wrong because of software and hardware issues. This makes conducting a flawless experiment challenging. However, the risk for falling for a pitfall can be minimized when carefully monitoring ongoing experiments.
Investigating at the first bad sign can save a lot of time and resources. An unexpectedly high load on a machine or swapping memory can be signs of misconfigured scripts. More subtle effects that should also raise one’s attention include the following: (1) the target algorithm uses much more wallclock time than the CPU time reported to the configurator; (2) many configurations crash; or (3) there is a large variation between the performances of independent configuration runs that only differ in their seeds.
We recommend to analyze ongoing experiments with respect to these signs and make use of automated tools, e.g. CAVE [Biedenkapp, Marben, Lindauer, HutterBiedenkapp et al.2018], to analyze and visualize experimental results in a common and unified way independently of the underlying configurator and problem.
5.10 Comparing Configurators on Existing, Open-Source Benchmarks
Although algorithm configuration has been well established for over a decade, nearly every new paper on this topic uses a new set of benchmarks to compare different configurators. This makes it harder to assess progress in the field, and every new benchmark could again suffer from one of the pitfalls described above. Therefore, we recommend to use existing and open-source algorithm configuration benchmarks that are already well tested and can be freely used by the community. The only existing library of such benchmarks we are aware of is the algorithm configuration library AClib [Hutter, López-Ibánez, Fawcett, Lindauer, Hoos, Leyton-Brown, StützleHutter et al.2014a], which comprises benchmarks (in version 1.2) based on open-source scripts and allows users to pick benchmarks from different domains (e.g., mixed integer programming, AI Planning, SAT, and machine learning) and with different characteristics (e.g., small or large configuration spaces).
6 A Generic Wrapper: Towards a Reliable and Unified AC Interface
Learning from the pitfalls above, our conclusion is that most of these pitfalls can be either completely prevented or their risk of occurrence can be substantially reduced by using a generic wrapper which wraps the executions of all target algorithm runs and has the following features:
Parsing the input arguments provided by the configurator in a uniform way such that a user only needs to implement a function to translate them into a call of the target algorithm;
Reliably limiting the run’s computational resources (runtime and memory consumption);
Measuring the cost metric in a standardized way (for which a user only needs to implement a function to parse the output of the target algorithm); and
Returning the output in a standardized way.
We note that some pitfalls cannot be tested easily. E.g., the user is still responsible for domain-dependent solution checking and checking whether the configurator is used as intended. However, if using a wrapper with the features above most pitfalls can be avoided. To demonstrate the usefulness of such a generic wrapper, and to provide a practical proposal for avoiding many of the described pitfalls, we implemented such a wrapper and are already using it in the algorithm configuration library AClib [Hutter, López-Ibánez, Fawcett, Lindauer, Hoos, Leyton-Brown, StützleHutter et al.2014a], to wrap different target algorithms.161616Our package called GenericWrapper4AC is available at https://github.com/automl/GenericWrapper4AC. To address the pitfalls mentioned above, our generic wrapper implements the following best practices:
- Resource Limitation
The tool runsolver [RousselRoussel2011] has been used for several years by the SAT community, in SAT competitions and by many SAT developers, to limit the runtime and memory consumption of an algorithm run.171717The runsolver uses process group IDs to keep track of running processes For example, if the memory or time limit is exceeded, it traverses the process tree bottom-up to terminate all processes that run. However, we note that it is possible to bypass this procedure if a process forks itself or starts a process on a different machine, which can neither be detected nor monitored by the runsolver. We also use this tool in the generic wrapper to reliably limit such resources and to measure algorithm runtimes. This addresses both Pifall 1 (“Trusting Your Target Algorithm”) and Pitfall 2 (“Not Terminating Target Algorithm Runs Properly”).
- Solution Checking for SAT
One of the exemplary instantiations of the generic wrapper we provide for SAT solvers implements solution checking to avoid issues of algorithm correctness (Pitfall 1: “Trusting Your Target Algorithm”).
- Writing to $TMPDIR
On most high-performance clusters these days, the environment variable $TMPDIR specifies a temporary directory on a local file system (not on a shared file system) of a compute node that allows for fast write and read access without affecting the remaining cluster. If this environment variable is set, the generic wrapper writes all temporary files (e.g., log files of the runsolver) to this folder. It only copies these files to a permanent file system in case of a crash of the target algorithm to allow debugging of these crashes. This addresses Pitfall 3 (“Slow File System”).
Furthermore, the use of the generic wrapper has the following advantages compared to implementing the same features directly in an algorithm configurator (which is nevertheless a feasible approach for some use cases):
- Fair Comparisons
As discussed in Pitfall 4 (“Handling Target Algorithm Runs Differently”), to compare different configurators, using a uniform wrapper will ensure that all configurators optimize the same objective function. Even if a wrapper turns out to have a bug, at least all configurators would be affected in the same way.
- Easy Use of Different Configurators
So far, most configurators implement different interfaces to call target algorithms. Therefore, users often implement only one of the interfaces and have not explored which of the available configurator is in fact the best one for their configuration problem. Using a generic wrapper (implementing either a unified interface or several configurator-specific interfaces) will also help users to easily use several configurators for their target algorithms.
- Easier Implementation of New Configurators
The implementation of new configurators is not an easy task, mainly because the handling of target algorithm runs may require many lines of code and is often still brittle. To reduce the burden on configurator developers, the generic wrapper can take over some of the functions required in this setting (e.g., resource limitations). Also, when translating a configurator to a new programming language, one can ensure that functionalities regarding handling that target algorithm remain exactly the same.
- Open Source and Community
Since the generic wrapper is an open-source implementation, we believe that the community will improve the code base and thus improve its quality and robustness over time.
Appendix A provides additional details about our generic wrapper, and an example wrapper for a SAT solver.
Empirically comparing algorithms correctly is hard. This is well known and true for almost every empirical study that involves running third-party code, stochastic algorithms and computationally expensive computations and therefore also applies to algorithm configuration. Subtle mistakes, such as measuring the wrong metric or running parallel experiments without meticulous resource management, can heavily bias the outcome. In this work, we pointed out several pitfalls that can occur in running algorithm configuration experiments and provide concrete examples of how these can impact results. We found that many of these pitfalls result from treating the objective function differently in different configurators, from issues in allocating and monitoring resource consumption, and from various issues concerning over-tuning. To prevent most of these pitfalls we share recommendations and best practices for conducting algorithm configuration experiments, which we hope to be useful for both novices and experts. We also provide an open-source implementation of a generic wrapper that provides a unified interface for the communication between target algorithms and configurators and for limiting resource consumption.
We thank Manuel López-Ibáñez and Kevin Tierney for adapting the interfaces of irace and GGA to work together with GenericWrapper4AC, Yuri Malitsky and Horst Samulowitz for providing the wrappers and benchmarks of ansotegui-ijcai15a, and Kevin Tierney, Manuel López-Ibáñez and Lars Kotthoff for very helpful feedback on the first draft of the paper that led to the inclusion of some further possible issues. Some of the recommendations in Section 5 were inspired by a discussion at a Dagstuhl seminar (see lindauer-dagstuhl17a for more details), and we are thankful for the valuable contributions of the attendees of that discussion: Aymeric Blot, Wanru Gao, Holger Hoos, Laetitia Jourdan, Lars Kotthoff, Manuel López-Ibáñez, Nysret Musliu, Günter Rudolph, Marc Schoenauer, Thomas Stützle and Joaquin Vanschoren. We also thank the anonymous reviewers for their valuable feedback. The authors acknowledge funding by the DFG (German Research Foundation) under Emmy Noether grant HU 1900/2-1. K. Eggensperger additionally acknowledges funding by the State Graduate Funding Program of Baden-Württemberg.
Appendix A Details on GenericWrapper4AC
Listing 1 shows an example for how to extend the GenericWrapper4AC to wrap the well-known SAT Solver MiniSAT [Eén SörenssonEén Sörensson2004]. Since the output format is standardized in the SAT community, we already provide a domain-specific generic wrapper, called SatWrapper, which can parse and verify the SAT solver’s output using standard tools from the annual SAT competitions. Therefore, SAT solver users only need to implement one method, which constructs a command line call string for their SAT solver from the provided input arguments (parameter settings, instance, cutoff time, seed).
In the example shown, the command line call of MiniSAT consists of passing the random seed (Line 4), adding all parameters in the format parameter=value (Lines 5 and 6), and appending the CNF instance name at the end (Line 7). Importantly, it takes care of all aspects of handling cutoff times, measuring runtimes, etc, to avoid the pitfalls discussed in Section 3.
For users of algorithm configuration outside SAT solving, Listing 2 shows an example for how to write a function process_results to parse algorithm outputs. Let us assume that the target algorithm only prints the target cost to be minimized (similar to the format of irace [López-Ibáñez, Dubois-Lacoste, Caceres, Birattari, StützleLópez-Ibáñez et al.2016]). Reading the output of the provided file pointer fp, the function builds and returns a dictionary which includes the cost value and a status, which is either SUCCESS if the target algorithm printed only a single number or CRASHED otherwise. Other states can be TIMEOUT for using more than the cutoff time or ABORT to signal the configurator to abort the AC experiment because of major issues. Furthermore, the exit code of the target algorithm run is also provided (but not used in our example). Another possible functionality that is not shown here is to implement a (domain-specific) method to verify the target algorithm’s returned solution.
Except these two target algorithm-specific functions, the GenericWrapper4AC handles everything else, including
Parsing the input format; native interfaces to ParamILS, ROAR and SMAC are supported right now, and an additional layer to run GGA(++) and irace is available as well. (see AClib2181818https://bitbucket.org/mlindauer/aclib2 for examples).
Calling the target algorithm and limiting its resource limits using the runsolver tool [RousselRoussel2011]
Measuring the CPU time of the target algorithm run (using runsolver)
Returning the cost of the target algorithm run to the configurator
The GenericWrapper4AC is available at GitHub and can be easily installed via python setup.py install (including the runsolver) and runs on UNIX systems.
- [AchterbergAchterberg2009] Achterberg, T. 2009. SCIP: solving constraint integer programs Mathematical Programming Computation, 1, 1–41.
- [Aigner, Biere, Kirsch, Niemetz, PreinerAigner et al.2013] Aigner, M., Biere, A., Kirsch, C., Niemetz, A., Preiner, M. 2013. Analysis of portfolio-style parallel SAT solving on current multi-core architectures In Proceeding of the Fourth International Workshop on Pragmatics of SAT (POS’13).
- [Ansel, Kamil, Veeramachaneni, Ragan-Kelley, Bosboom, O’Reilly, AmarasingheAnsel et al.2014] Ansel, J., Kamil, S., Veeramachaneni, K., Ragan-Kelley, J., Bosboom, J., O’Reilly, U., Amarasinghe, S. 2014. Opentuner: an extensible framework for program autotuning In Amaral, J. Torrellas, J., Proceedings of the International Conference on Parallel Architectures and Compilation (PACT), 303–316. ACM.
- [Ansótegui, Gabàs, Malitsky, SellmannAnsótegui et al.2016] Ansótegui, C., Gabàs, J., Malitsky, Y., Sellmann, M. 2016. Maxsat by improved instance-specific algorithm configuration Artificial Intelligence, 235, 26–39.
- [Ansótegui, Malitsky, Sellmann, TierneyAnsótegui et al.2015] Ansótegui, C., Malitsky, Y., Sellmann, M., Tierney, K. 2015. Model-based genetic algorithms for algorithm configuration In Yang, Q. Wooldridge, M., Proceedings of the 25th International Joint Conference on Artificial Intelligence (IJCAI’15), 733–739.
- [Ansótegui, Sellmann, TierneyAnsótegui et al.2009] Ansótegui, C., Sellmann, M., Tierney, K. 2009. A gender-based genetic algorithm for the automatic configuration of algorithms In Gent, I., Proceedings of the Fifteenth International Conference on Principles and Practice of Constraint Programming (CP’09), 5732 of Lecture Notes in Computer Science, 142–157. Springer-Verlag.
- [Audemard SimonAudemard Simon2009] Audemard, G. Simon, L. 2009. Predicting learnt clauses quality in modern SAT solvers In Boutilier, C., Proceedings of the 22th International Joint Conference on Artificial Intelligence (IJCAI’09), 399–404.
- [Bartz-Beielstein, Lasarczyk, PreussBartz-Beielstein et al.2010] Bartz-Beielstein, T., Lasarczyk, C., Preuss, M. 2010. The sequential parameter optimization toolbox In Bartz-Beielstein, T., Chiarandini, M., Paquete, L., Preus, M., Experimental Methods for the Analysis of Optimization Algorithms, 337–362. Springer-Verlag.
- [Bayless, Tompkins, HoosBayless et al.2014] Bayless, S., Tompkins, D., Hoos, H. 2014. Evaluating instance generators by configuration In Pardalos, P. Resende, M., Proceedings of the Eighth International Conference on Learning and Intelligent Optimization (LION’14), Lecture Notes in Computer Science. Springer-Verlag.
[Bezerra, López-Ibáñez, StützleBezerra et al.2016]
Bezerra, L., López-Ibáñez, M., Stützle, T.
Automatic component-wise design of multiobjective evolutionary
IEEE Trans. Evolutionary Computation, 20(3), 403–417.
- [Biedenkapp, Marben, Lindauer, HutterBiedenkapp et al.2018] Biedenkapp, A., Marben, J., Lindauer, M., Hutter, F. 2018. Cave: Configuration assessment, visualization and evaluation In Proceedings of the Tenth International Conference on Learning and Intelligent Optimization (LION’18), Lecture Notes in Computer Science. Springer-Verlag. To appear.
- [BiereBiere2013] Biere, A. 2013. Lingeling, Plingeling and Treengeling entering the SAT competition 2013 In Balint, A., Belov, A., Heule, M., Järvisalo, M., Proceedings of SAT Competition 2013: Solver and Benchmark Descriptions, B-2013-1 of Department of Computer Science Series of Publications B, 51–52. University of Helsinki.
- [BiereBiere2014] Biere, A. 2014. Yet another local search solver and Lingeling and friends entering the SAT competition 2014 In Belov, A., Diepold, D., Heule, M., Järvisalo, M., Proceedings of SAT Competition 2014: Solver and Benchmark Descriptions, B-2014-2 of Department of Computer Science Series of Publications B, 39–40. University of Helsinki.
- [Biere, Heule, van Maaren, WalshBiere et al.2009] Biere, A., Heule, M., van Maaren, H., Walsh, T.. 2009. Handbook of Satisfiability, 185 of Frontiers in Artificial Intelligence and Applications. IOS Press.
- [Birattari KacprzykBirattari Kacprzyk2009] Birattari, M. Kacprzyk, J. 2009. Tuning metaheuristics: a machine learning perspective, 197. Springer-Verlag.
- [Birattari, Stützle, Paquete, VarrentrappBirattari et al.2002] Birattari, M., Stützle, T., Paquete, L., Varrentrapp, K. 2002. A racing algorithm for configuring metaheuristics In Langdon, W., Cantu-Paz, E., Mathias, K., Roy, R., Davis, D., Poli, R., Balakrishnan, K., Honavar, V., Rudolph, G., Wegener, J., Bull, L., Potter, M., Schultz, A., Miller, J., Burke, E., Jonoska, N., Proceedings of the Genetic and Evolutionary Computation Conference (GECCO’02), 11–18. Morgan Kaufmann Publishers.
- [BirattariBirattari2004] Birattari, M. 2004. The problem of tuning metaheuristics as seen from a machine learning perspective. Ph.D. thesis, Université Libre de Bruxelles.
- [Brochu, Cora, de FreitasBrochu et al.2010] Brochu, E., Cora, V., de Freitas, N. 2010. A tutorial on Bayesian optimization of expensive cost functions, with application to active user modeling and hierarchical reinforcement learning. arXiv:1012.2599.
- [Brummayer, Lonsing, BiereBrummayer et al.2012] Brummayer, R., Lonsing, F., Biere, A. 2012. Automated testing and debugging of SAT and QBF solvers In Cimatti, A. Sebastiani, R., Proceedings of the Fifteenth International Conference on Theory and Applications of Satisfiability Testing (SAT’12), 7317 of Lecture Notes in Computer Science, 44–57. Springer-Verlag.
- [Cáceres StützleCáceres Stützle2017] Cáceres, L. P. Stützle, T. 2017. Exploring variable neighborhood search for automatic algorithm configuration Electronic Notes in Discrete Mathematics, 58, 167–174.
[Chiarandini, Fawcett, HoosChiarandini
Chiarandini, M., Fawcett, C., Hoos, H. 2008.
A modular multiphase heuristic solver for post enrolment course timetablingIn Gendreau, M. Burke, E., Proceedings of the Seventh International Conference on the Practice and Theory of Automated Timetabling.
- [DorigoDorigo2016] Dorigo, M. 2016. Swarm intelligence: A few things you need to know if you want to publish in this journal.
- [Eén SörenssonEén Sörensson2004] Eén, N. Sörensson, N. 2004. An extensible SAT-solver In Giunchiglia, E. Tacchella, A., Proceedings of the conference on Theory and Applications of Satisfiability Testing (SAT), 2919 of Lecture Notes in Computer Science, 502–518. Springer-Verlag.
- [Falkner, Lindauer, HutterFalkner et al.2015] Falkner, S., Lindauer, M., Hutter, F. 2015. SpySMAC: Automated configuration and performance analysis of SAT solvers In Heule, M. Weaver, S., Proceedings of the Eighteenth International Conference on Theory and Applications of Satisfiability Testing (SAT’15), Lecture Notes in Computer Science, 1–8. Springer-Verlag.
- [Feurer, Springenberg, HutterFeurer et al.2015] Feurer, M., Springenberg, T., Hutter, F. 2015. Initializing Bayesian hyperparameter optimization via meta-learning In Bonet, B. Koenig, S., Proceedings of the Twenty-nineth National Conference on Artificial Intelligence (AAAI’15), 1128–1135. AAAI Press.
[Gebser, Kaminski, Kaufmann, Schaub, Schneider, ZillerGebser et al.2011]
Gebser, M., Kaminski, R., Kaufmann, B., Schaub, T., Schneider, M., Ziller, S. 2011.
A portfolio solver for answer set programming: Preliminary
In Delgrande, J. Faber, W., Proceedings of the Eleventh International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR’11), 6645 of Lecture Notes in Computer Science, 352–357. Springer-Verlag.
- [Gebser, Kaufmann, SchaubGebser et al.2012] Gebser, M., Kaufmann, B., Schaub, T. 2012. Conflict-driven answer set solving: From theory to practice Artificial Intelligence, 187-188, 52–89.
- [Gent, Grant, MacIntyre, Prosser, Shaw, Smith, WalshGent et al.1997] Gent, I., Grant, S., MacIntyre, E., Prosser, P., Shaw, P., Smith, B., Walsh, T. 1997. How not to do it 97.92, University of Leeds.
- [Geschwender, Hutter, Kotthoff, Malitsky, Hoos, Leyton-BrownGeschwender et al.2014] Geschwender, D., Hutter, F., Kotthoff, L., Malitsky, Y., Hoos, H., Leyton-Brown, K. 2014. Algorithm configuration in the cloud: A feasibility study In Pardalos, P. Resende, M., Proceedings of the Eighth International Conference on Learning and Intelligent Optimization (LION’14), Lecture Notes in Computer Science, 41–46. Springer-Verlag.
- [HansenHansen2006] Hansen, N. 2006. The CMA evolution strategy: a comparing review In Lozano, J., Larranaga, P., Inza, I., Bengoetxea, E., Towards a new evolutionary computation. Advances on estimation of distribution algorithms, 75–102. Springer.
- [Henderson, Islam, Bachman, Pineau, Precup, MegerHenderson et al.2018] Henderson, P., Islam, R., Bachman, P., Pineau, J., Precup, D., Meger, D. 2018. Deep reinforcement learning that matters. arXiv:1709.06560.
- [Heule, Hunt, WetzlerHeule et al.2014] Heule, M., Hunt, W., Wetzler, N. 2014. Bridging the gap between easy generation and efficient verification of unsatisfiability proofs Software Testing Verification and Reliability, 24(8), 593–607.
- [HookerHooker1995] Hooker, J. 1995. Testing heuristics: We have it all wrong Journal of Heuristics, 1, 33–42.
- [HoosHoos2012] Hoos, H. 2012. Programming by optimization Communications of the ACM, 55(2), 70–80.
- [Hoos, Kaufmann, Schaub, SchneiderHoos et al.2013] Hoos, H., Kaufmann, B., Schaub, T., Schneider, M. 2013. Robust benchmark set selection for boolean constraint solvers In Pardalos, P. Nicosia, G., Proceedings of the Seventh International Conference on Learning and Intelligent Optimization (LION’13), 7997 of Lecture Notes in Computer Science, 138–152. Springer-Verlag.
- [Howe DahlmanHowe Dahlman2002] Howe, A. Dahlman, E. 2002. A critical assessment of benchmark comparison in planning Journal of Artificial Intelligence Research, 17, 1–33.
- [Hutter, Babić, Hoos, HuHutter et al.2007a] Hutter, F., Babić, D., Hoos, H., Hu, A. 2007a. Boosting verification by automatic tuning of decision procedures In O’Conner, L., Formal Methods in Computer Aided Design (FMCAD’07), 27–34. IEEE Computer Society Press.
- [Hutter, Hoos, Leyton-BrownHutter et al.2010a] Hutter, F., Hoos, H., Leyton-Brown, K. 2010a. Automated configuration of mixed integer programming solvers In Lodi, A., Milano, M., Toth, P., Proceedings of the Seventh International Conference on Integration of AI and OR Techniques in Constraint Programming (CPAIOR’10), 6140 of Lecture Notes in Computer Science, 186–202. Springer-Verlag.
- [Hutter, Hoos, Leyton-BrownHutter et al.2010b] Hutter, F., Hoos, H., Leyton-Brown, K. 2010b. Tradeoffs in the empirical evaluation of competing algorithm designs Annals of Mathematics and Artificial Intelligenc (AMAI), Special Issue on Learning and Intelligent Optimization, 60(1), 65–89.
- [Hutter, Hoos, Leyton-BrownHutter et al.2011] Hutter, F., Hoos, H., Leyton-Brown, K. 2011. Sequential model-based optimization for general algorithm configuration In Coello, C., Proceedings of the Fifth International Conference on Learning and Intelligent Optimization (LION’11), 6683 of Lecture Notes in Computer Science, 507–523. Springer-Verlag.
- [Hutter, Hoos, Leyton-BrownHutter et al.2012] Hutter, F., Hoos, H., Leyton-Brown, K. 2012. Parallel algorithm configuration In Hamadi, Y. Schoenauer, M., Proceedings of the Sixth International Conference on Learning and Intelligent Optimization (LION’12), 7219 of Lecture Notes in Computer Science, 55–70. Springer-Verlag.
- [Hutter, Hoos, Leyton-Brown, StützleHutter et al.2009] Hutter, F., Hoos, H., Leyton-Brown, K., Stützle, T. 2009. ParamILS: An automatic algorithm configuration framework Journal of Artificial Intelligence Research, 36, 267–306.
- [Hutter, Hoos, StützleHutter et al.2007b] Hutter, F., Hoos, H., Stützle, T. 2007b. Automatic algorithm configuration based on local search In Holte, R. Howe, A., Proceedings of the Twenty-second National Conference on Artificial Intelligence (AAAI’07), 1152–1157. AAAI Press.
- [Hutter, Lindauer, Balint, Bayless, Hoos, Leyton-BrownHutter et al.2017] Hutter, F., Lindauer, M., Balint, A., Bayless, S., Hoos, H., Leyton-Brown, K. 2017. The configurable SAT solver challenge (CSSC) Artificial Intelligence, 243, 1–25.
- [Hutter, López-Ibánez, Fawcett, Lindauer, Hoos, Leyton-Brown, StützleHutter et al.2014a] Hutter, F., López-Ibánez, M., Fawcett, C., Lindauer, M., Hoos, H., Leyton-Brown, K., Stützle, T. 2014a. AClib: a benchmark library for algorithm configuration In Pardalos, P. Resende, M., Proceedings of the Eighth International Conference on Learning and Intelligent Optimization (LION’14), Lecture Notes in Computer Science. Springer-Verlag.
- [Hutter, Tompkins, HoosHutter et al.2002] Hutter, F., Tompkins, D., Hoos, H. 2002. Scaling and probabilistic smoothing: Efficient dynamic local search for SAT In Hentenryck, P. V., Proceedings of the international conference on Principles and Practice of Constraint Programming, 2470 of Lecture Notes in Computer Science, 233–248. Springer-Verlag.
- [Hutter, Xu, Hoos, Leyton-BrownHutter et al.2014b] Hutter, F., Xu, L., Hoos, H., Leyton-Brown, K. 2014b. Algorithm runtime prediction: Methods and evaluation Artificial Intelligence, 206, 79–111.
- [Kadioglu, Malitsky, Sabharwal, Samulowitz, SellmannKadioglu et al.2011] Kadioglu, S., Malitsky, Y., Sabharwal, A., Samulowitz, H., Sellmann, M. 2011. Algorithm selection and scheduling In Lee, J., Proceedings of the Seventeenth International Conference on Principles and Practice of Constraint Programming (CP’11), 6876 of Lecture Notes in Computer Science, 454–469. Springer-Verlag.
- [Kadioglu, Malitsky, Sellmann, TierneyKadioglu et al.2010] Kadioglu, S., Malitsky, Y., Sellmann, M., Tierney, K. 2010. ISAC - instance-specific algorithm configuration In Coelho, H., Studer, R., Wooldridge, M., Proceedings of the Nineteenth European Conference on Artificial Intelligence (ECAI’10), 751–756. IOS Press.
- [KnuthKnuth2011] Knuth, D. 2011. The Art of Computer Programming, Volume IV. Addison-Wesley.
- [Koch, Achterberg, Andersen, Bastert, Berthold, Bixby, Danna, Gamrath, Gleixner, Heinz, Lodi, Mittelmann, Ralphs, Salvagnin, Steffy, WolterKoch et al.2011] Koch, T., Achterberg, T., Andersen, E., Bastert, O., Berthold, T., Bixby, R., Danna, E., Gamrath, G., Gleixner, A., Heinz, S., Lodi, A., Mittelmann, H., Ralphs, T., Salvagnin, D., Steffy, D., Wolter, K. 2011. MIPLIB 2010 Mathematical Programming Computation, 3, 103–163.
- [KotthoffKotthoff2014] Kotthoff, L. 2014. Algorithm selection for combinatorial search problems: A survey AI Magazine, 35(3), 48–60.
- [LagunaLaguna2017] Laguna, M. 2017. Journal of heuristic policies on heuristic search research.
- [Lindauer, Hoos, Hutter, SchaubLindauer et al.2015] Lindauer, M., Hoos, H., Hutter, F., Schaub, T. 2015. Autofolio: An automatically configured algorithm selector Journal of Artificial Intelligence Research, 53, 745–778.
- [Lindauer, Hoos, Leyton-Brown, SchaubLindauer et al.2017a] Lindauer, M., Hoos, H., Leyton-Brown, K., Schaub, T. 2017a. Automatic construction of parallel portfolios via algorithm configuration Artificial Intelligence, 244, 272–290.
- [Lindauer HutterLindauer Hutter2017b] Lindauer, M. Hutter, F. 2017b. Pitfalls and best practices for algorithm configuration (breakout session report) Dagstuhl Reports, 6, 70–72.
- [Lodi TramontaniLodi Tramontani2014] Lodi, A. Tramontani, A. 2014. Performance variability in mixed-integer programming In Topaloglu, H., Smith, J., Greenberg, H., Theory Driven by Influential Applications, 1, 1–12. INFORMS.
- [López-Ibáñez, Dubois-Lacoste, Caceres, Birattari, StützleLópez-Ibáñez et al.2016] López-Ibáñez, M., Dubois-Lacoste, J., Caceres, L. P., Birattari, M., Stützle, T. 2016. The irace package: Iterated racing for automatic algorithm configuration Operations Research Perspectives, 3, 43–58.
- [López-Ibáñez StützleLópez-Ibáñez Stützle2014] López-Ibáñez, M. Stützle, T. 2014. Automatically improving the anytime behaviour of optimisation algorithms European Journal of Operational Research, 235, 569–582.
- [Malitsky, Sabharwal, Samulowitz, SellmannMalitsky et al.2012] Malitsky, Y., Sabharwal, A., Samulowitz, H., Sellmann, M. 2012. Parallel SAT solver selection and scheduling In Milano, M., Proceedings of the Eighteenth International Conference on Principles and Practice of Constraint Programming (CP’12), 7514 of Lecture Notes in Computer Science, 512–526. Springer-Verlag.
- [MantheyManthey2014b] Manthey, N. 2014b. Riss 4.27 In Belov, A., Diepold, D., Heule, M., Järvisalo, M., Proceedings of SAT Competition 2014: Solver and Benchmark Descriptions, B-2014-2 of Department of Computer Science Series of Publications B, 65–67. University of Helsinki.
- [Manthey LindauerManthey Lindauer2016] Manthey, N. Lindauer, M. 2016. Spybug: Automated bug detection in the configuration space of sat solvers In Creignou, N. Berre, D. L., Proceedings of the Nineteenth International Conference on Theory and Applications of Satisfiability Testing (SAT’16), Lecture Notes in Computer Science, 554–561. Springer-Verlag.
- [Manthey SteinkeManthey Steinke2014a] Manthey, N. Steinke, P. 2014a. Too many rooks In Belov, A., Diepold, D., Heule, M., Järvisalo, M., Proceedings of SAT Competition 2014: Solver and Benchmark Descriptions, B-2014-2 of Department of Computer Science Series of Publications B, 97–98. University of Helsinki.
- [McGeochMcGeoch1987] McGeoch, C. 1987. Experimental Analysis of Algorithms. Ph.D. thesis, Carnegie-Mellon University, Computer Science.
- [McGeochMcGeoch2002] McGeoch, C. 2002. Experimental analysis of algorithms In Pardalos, P. Romeijn, E., Handbook of Global Optimization, 489–513. Springer-Verlag.
- [McGeochMcGeoch2012] McGeoch, C. C. 2012. A Guide to Experimental Algorithmics. Cambridge University Press.
- [Mockus, Tiesis, ZilinskasMockus et al.1978] Mockus, J., Tiesis, V., Zilinskas, A. 1978. The application of Bayesian methods for seeking the extremum Towards Global Optimization, 2(117-129).
- [Mugrauer BalintMugrauer Balint2013] Mugrauer, F. Balint, A. 2013. SAT encoded low autocorrelation binary sequence (LABS) benchmark description In Balint, A., Belov, A., Heule, M., Järvisalo, M., Proceedings of SAT Competition 2013: Solver and Benchmark Descriptions, B-2013-1 of Department of Computer Science Series of Publications B. University of Helsinki.
- [OhOh2014] Oh, C. 2014. MiniSat HACK 999ED, MiniSat HACK 1430ED and SWDiA5BY In Belov, A., Diepold, D., Heule, M., Järvisalo, M., Proceedings of SAT Competition 2014: Solver and Benchmark Descriptions, B-2014-2 of Department of Computer Science Series of Publications B, 46. University of Helsinki.
- [RiceRice1976] Rice, J. 1976. The algorithm selection problem Advances in Computers, 15, 65–118.
- [RousselRoussel2011] Roussel, O. 2011. Controlling a solver execution with the runsolver tool Journal on Satisfiability, Boolean Modeling and Computation, 7(4), 139–144.
- [Schneider HoosSchneider Hoos2012] Schneider, M. Hoos, H. 2012. Quantifying homogeneity of instance sets for algorithm configuration In Hamadi, Y. Schoenauer, M., Proceedings of the Sixth International Conference on Learning and Intelligent Optimization (LION’12), 7219 of Lecture Notes in Computer Science, 190–204. Springer-Verlag.
- [Shahriari, Swersky, Wang, Adams, de FreitasShahriari et al.2016] Shahriari, B., Swersky, K., Wang, Z., Adams, R., de Freitas, N. 2016. Taking the human out of the loop: A review of Bayesian optimization Proceedings of the IEEE, 104(1), 148–175.
- [Snoek, Larochelle, AdamsSnoek et al.2012] Snoek, J., Larochelle, H., Adams, R. P. 2012. Practical Bayesian optimization of machine learning algorithms In Bartlett, P., Pereira, F., Burges, C., Bottou, L., Weinberger, K., Proceedings of the 26th International Conference on Advances in Neural Information Processing Systems (NIPS’12), 2960–2968.
- [SoosSoos2014] Soos, M. 2014. CryptoMiniSat v4 In Belov, A., Diepold, D., Heule, M., Järvisalo, M., Proceedings of SAT Competition 2014: Solver and Benchmark Descriptions, B-2014-2 of Department of Computer Science Series of Publications B, 23. University of Helsinki.
- [Styles HoosStyles Hoos2015] Styles, J. Hoos, H. 2015. Ordered racing protocols for automatically configuring algorithms for scaling performance In Blum, C. Alba, E., Proceedings of the Genetic and Evolutionary Computation Conference (GECCO’13), 551–558. ACM.
- [Thornton, Hutter, Hoos, Leyton-BrownThornton et al.2013] Thornton, C., Hutter, F., Hoos, H., Leyton-Brown, K. 2013. Auto-WEKA: combined selection and hyperparameter optimization of classification algorithms In Dhillon, I., Koren, Y., Ghani, R., Senator, T., Bradley, P., Parekh, R., He, J., Grossman, R., Uthurusamy, R., The 19th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD’13), 847–855. ACM Press.
- [Tompkins HoosTompkins Hoos2005] Tompkins, D. Hoos, H. 2005. UBCSAT: An implementation and experimentation environment for SLS algorithms for SAT and MAX-SAT In Proceedings of the Seventh International Conference on Theory and Applications of Satisfiability Testing (SAT 2004), Lecture Notes in Computer Science, 306–320. Springer-Verlag.
- [Vallati, Fawcett, Gerevini, Hoos, SaettiVallati et al.2013] Vallati, M., Fawcett, C., Gerevini, A., Hoos, H., Saetti, A. 2013. Automatic generation of efficient domain-optimized planners from generic parametrized planners In Helmert, M. Röger, G., Proceedings of the Sixth Annual Symposium on Combinatorial Search (SOCS’14). AAAI Press.
- [Weise, Chiong, TangWeise et al.2012] Weise, T., Chiong, R., Tang, K. 2012. Evolutionary optimization: Pitfalls and booby traps Journal of Computer Science and Technology, 27, 907–936.
- [Xu, Hoos, Leyton-BrownXu et al.2010] Xu, L., Hoos, H., Leyton-Brown, K. 2010. Hydra: Automatically configuring algorithms for portfolio-based selection In Fox, M. Poole, D., Proceedings of the Twenty-fourth National Conference on Artificial Intelligence (AAAI’10), 210–216. AAAI Press.
- [Xu, Hutter, Hoos, Leyton-BrownXu et al.2008] Xu, L., Hutter, F., Hoos, H., Leyton-Brown, K. 2008. SATzilla: Portfolio-based algorithm selection for SAT Journal of Artificial Intelligence Research, 32, 565–606.
- [Xu, Hutter, Hoos, Leyton-BrownXu et al.2011] Xu, L., Hutter, F., Hoos, H., Leyton-Brown, K. 2011. Hydra-MIP: Automated algorithm configuration and selection for mixed integer programming In Proc. of RCRA workshop at IJCAI.