Abstract

Bayesian optimization has become a successful tool for hyperparameter optimization of machine learning algorithms, such as support vector machines or deep neural networks.
Despite its success, for large datasets, training and validating a single configuration often takes hours, days, or even weeks, which limits the achievable performance.
To accelerate hyperparameter optimization, we propose a generative model for the validation error as a function of training set size, which is learned during the optimization process and allows exploration of preliminary configurations on small subsets, by extrapolating to the full dataset.
We construct a Bayesian optimization procedure, dubbed Fabolas, which models loss and training time as a function of dataset size and automatically trades off high information gain about the global optimum against computational cost.
Experiments optimizing support vector machines and deep neural networks show that Fabolas often finds high-quality solutions 10 to 100 times faster than other state-of-the-art Bayesian optimization methods or the recently proposed bandit strategy Hyperband.

In the traditional setting of Bayesian hyperparameter optimization, the loss of a machine learning algorithm with hyperparameters x∈X is treated as the “black-box” problem of finding \operatornamewithlimitsargminx∈Xf(x), where the only mode of interaction with the objective f is to evaluate it for inputs x∈X.
If individual evaluations of f on the entire dataset require days or weeks, only very few evaluations are possible, limiting the quality of the best found value.
Human experts instead often study performance on subsets of the data first, to become familiar with its characteristics before gradually increasing the subset size (Bottou, 2012; Montavon et al., 2012).
This approach can still outperform contemporary Bayesian optimization methods.

Motivated by the experts’ strategy, here we leverage dataset size as an additional degree of freedom enriching the representation of the optimization problem.
We treat the size of a randomly subsampled dataset Nsub as an additional input to the blackbox function, and allow the optimizer to actively choose it at each function evaluation.
This allows Bayesian optimization to mimic and improve upon human experts when exploring the hyperparameter space.
In the end, Nsub is not a hyperparameter itself, but the goal remains a good performance on the full dataset, i.e. Nsub=N.

Hyperparameter optimization for large datasets has been explored by other authors before.
Our approach is similar to Multi-Task Bayesian optimization by Swersky et al. (2013), where knowledge is transferred between a finite number of correlated tasks.
If these tasks represent manually-chosen subset-sizes, this method also tries to find the best configuration for the full dataset by evaluating smaller, cheaper subsets.
However, the discrete nature of tasks in that approach requires evaluations on the entire dataset to learn the necessary correlations.
Instead, our approach exploits the regularity of performance across dataset size, enabling generalization to the full dataset without evaluating it directly.

Other approaches for hyperparameter optimization on large datasets include work by Nickson et al. (2014), who estimated a configuration’s performance on a large dataset by evaluating several training runs on small, random subsets of fixed, manually-chosen sizes.
Krueger et al. (2015) showed that, in practical applications, small subsets can suffice to estimate a configuration’s quality, and proposed a cross-validation scheme that sequentially tests a fixed set of configurations on a growing subset of the data, discarding poorly-performing configurations early.

In parallel work1, Li et al. (2017) proposed a multi-arm bandit strategy, called Hyperband, which dynamically allocates more and more resources to randomly sampled configurations based on their performance on subsets of the data.
Hyperband assures that only well-performing configurations are trained on the full dataset while discarding bad ones early.
Despite its simplicity, in their experiments the method was able to outperform well-established Bayesian optimization algorithms.

In §2, we review Bayesian optimization, in particular the Entropy Search algorithm and the related method of Multi-Task Bayesian optimization.
In §3, we introduce our new Bayesian optimization method Fabolas for hyperparameter optimization on large datasets.
In each iteration, Fabolas chooses the configuration x and dataset size Nsub predicted to yield most information about the loss-minimizing configuration on the full dataset per unit time spent.
In §4, a broad range of experiments with support vector machines and various deep neural networks show Fabolas often identifies good hyperparameter settings 10 to 100 times faster than state-of-the-art Bayesian optimization methods acting on the full dataset as well as Hyperband.

Given a black-box function f:X→R, Bayesian optimization2 aims to find an input x⋆∈\operatornamewithlimitsargminx∈Xf(x) that globally minimizes f.
It requires a prior p(f) over the function and an acquisition function ap(f):X→R quantifying the utility of an evaluation at any x.
With these ingredients, the following three steps are iterated (Brochu et al., 2010): (1) find the most promising xn+1∈\operatornamewithlimitsargmaxap(x) by numerical optimization; (2) evaluate the expensive and often noisy function yn+1∼f(xn+1)+N(0,σ2) and add the resulting data point (xn+1,yn+1) to the set of observations Dn=(xj,yj)j=1...n; and (3) update p(f∣Dn+1) and ap(f∣Dn+1).
Typically, evaluations of the acquisition function a are cheap compared to evaluations of f such that the optimization effort is negligible.

2.1 Gaussian Processes

Gaussian processes (GP) are a prominent choice for p(f), thanks to their descriptive power and analytic tractability (e.g. Rasmussen and Williams, 2006).
Formally, a GP is a collection of random variables, such that every finite subset of them follows a multivariate normal distribution.
A GP is identified by a mean function m (often set to m(x)=0∀x∈X), and a positive definite covariance function (kernel) k.
Given observations Dn=(xj,yj)j=1...n=(X,y) with joint Gaussian likelihood p(y∣X,f(X)), the posterior p(f|Dn) follows another GP, with mean and covariance functions of tractable, analytic form.

The covariance function determines how observations influence the prediction.
For the hyperparameters we wish to optimize, we adopt the Matérn \nicefrac52 kernel (Matérn, 1960), in its Automatic Relevance Determination form (MacKay and Neal, 1994).
This stationary, twice-differentiable model constitutes a relatively standard choice in the Bayesian optimization literature.
In contrast to the Gaussian kernel popular elsewhere, it makes less restrictive smoothness assumptions, which can be helpful in the optimization setting (Snoek et al., 2012):

k\nicefrac52(x,x′)=θ(1+√5dλ(x,x′)+\nicefrac53d2λ(x,x′))e−√5dλ(x,x′).

(1)

Here, θ and λ are free parameters—hyperparameters of the GP surrogate model—and dλ(x,x′)=(x−x′)\tiny{\sf{T}}diag(λ)(x−x′) is the Mahalanobis distance.
For the dataset size dependent performance and cost, we construct a custom kernel in 3.1.
An additional hyperparameter of the GP model is a overall noise covariance needed to handle noisy observations.
For clarity: These GP hyperparameters are internal hyperparameters of the Bayesian optimizer, as opposed to those of the target machine learning algorithm to be tuned. Section 3.4 shows how we handle them.

We found EI to perform robustly in most applications, providing a solid baseline;
it is defined as

aEI(x|Dn)

=Ep[max(fmin−f(x),0)].

(2)

where fmin is the best function value known (also called the incumbent).
This expected drop over the best known value is high for points predicted to have small mean and/or large variance.

ES is a more recent acquisition function that selects evaluation points based on the predicted information gain about the optimum, rather than aiming to evaluate near the optimum.
At the heart of ES lies the probability distribution pmin(x∣D):=p(x∈\operatornamewithlimitsargminx′∈Xf(x′)∣D), the belief about the function’s minimum given the prior on f and observations D.
The information gain at x is then measured by the expected Kullback-Leibler divergence (relative entropy) between pmin(⋅∣D∪{(x,y)}) and the uniform distribution u(x), with expectations taken over the measurement y to be obtained at x:

(3)

The primary numerical challenge in this framework is the computation of pmin(⋅∣D∪{(x,y)}) and the integral above.
Due to the intractability, several approximations have to be made.
We refer to Hennig and Schuler (2012) for details, as well as to the supplemental material (Section A), where we also provide pseudocode for our implementation.
Despite the conceptual and computational complexity of ES, it offers a well-defined concept for information gained from function evaluations, which can be meaningfully traded off against other quantities, such as the evaluations’ cost.

PES refers to the same acquisition function, but uses different approximations to compute it.
In Section 3.4 we describe why, for our application, ES was the more direct choice.

2.3 Multi-Task Bayesian optimization

The Multi-Task Bayesian optimization (MTBO) method of Swersky et al. (2013) refers to a general framework for optimizing in the presents of different, but correlated tasks.
Given a set of such tasks T={1,…,T}, the objective function f:X×T→R corresponds to evaluating a given x∈X on one of the tasks t∈T.
The relation between points in X×T is modeled via a GP using a product kernel:

kMT((x,t),(x′,t′))=kT(t,t′)⋅k\nicefrac52(x,x′).

(4)

The kernel kT is represented implicitly by the Cholesky decomposition of k(T,T) whose entries are sampled via MCMC together with the other hyperparameters of the GP.
By considering the distribution over the optimum on the target task t∗∈T, pt∗min(x∣D):=p(x∈\operatornamewithlimitsargminx′∈Xf(x′,t=t∗)∣D), and computing any information w.r.t. it, Swersky et al. (2013) use the information gain per unit cost as their acquisition function3:

aMT(x,t):

=1c(x,t)Ep(y∣x,t,D)[∫pt∗min(x′∣D′)

⋅logpt∗min(x′∣D′)u(x′)dx′],

(5)

where D′=D∪{(x,t,y)}.
The expectation represents the information gain on the target task averaged over the possible outcomes of f(x,t) based on the current model.
If the cost c(x,t) of a configuration x on task t is not known a priori it can be modelled the same way as the objective function.

This model supports machine learning hyperparameter optimization for large datasets by using discrete dataset sizes as tasks. Swersky et al. (2013) indeed studied this approach for the special case of T={0,1}, representing a small and a large dataset; this will be a baseline in our experiments.

Here, we introduce our new approach for FAst Bayesian Optimization on LArge data Sets (Fabolas).
While traditional Bayesian hyperparameter optimizers model the loss of machine learning algorithms on a given dataset as a blackbox function f to be minimized,
Fabolas models loss and computational cost across dataset size and uses these models to carry out Bayesian optimization with an extra degree of freedom.
The blackbox function f:X×R→R now takes another input representing the data subset size; we will use relative sizes s=Nsub/N∈[0,1], with s=1 representing the entire dataset.
While the eventual goal is to minimize the loss f(x,s=1) for the entire dataset, evaluating f for smaller s is usually cheaper, and the function values obtained correlate across s.
Unfortunately, this correlation structure is initially unknown, so the challenge is to design a strategy that trades off the cost of function evaluations against the benefit of learning about the scaling behavior of f and, ultimately, about which configurations work best on the full dataset.
Following the nomenclature of Williams et al. (2000), we call s∈[0,1] an environmental variable that can be changed freely during optimization, but that is set to s=1 (i.e., the entire dataset size), at evaluation time.

We propose a principled rule for the automatic selection of the next (x,s) pair to evaluate.
In a nutshell, where standard Bayesian optimization would always run configurations on the full dataset, we use ES to reason about, how much can be learned about performance on the full dataset from an evaluation at any s.
In doing so, Fabolas automatically determines the amount of data necessary to (usefully) extrapolate to the full dataset.

(a)s=\nicefrac1128

(b)s=\nicefrac116

(c)s=\nicefrac14

(d)s=1

Figure 1: Validation error of a grid of 400 SVM configurations (20 settings of each of the regularization parameter C and kernel parameter γ, both on a log-scale in [−10,10]) for subsets of the MNIST dataset (LeCun et al., 2001) of various sizes Nsub.
Small subsets are quite representative: The validation error of bad configuration (yellow) remains constant at around 0.9, whereas the region of good configurations (blue) does not change drastically with s.

For an initial intuition on how performance changes with dataset size, we evaluated a grid of 400 configurations of a support vector machine (SVM) on subsets of the MNIST dataset (LeCun et al., 2001) ; MNIST has N=50000 data points and we evaluated relative subset sizes s∈{\nicefrac1512,\nicefrac1256,\nicefrac1128,…,\nicefrac14,\nicefrac12,1}.
Figure 1 visualizes the validation error of these configurations on s=\nicefrac1128, \nicefrac116, \nicefrac14, and 1.
Evidently, just \nicefrac1128 of the dataset is quite representative and sufficient to locate a reasonable configuration.
Additionally, there are no deceiving local optima on smaller subsets.
Based on these observations, we expect that relatively small fractions of the dataset yield representative performances and therefore vary our relative size parameter s on a logarithmic scale.

3.1 Kernels for loss and computational cost

To transfer the insights from this illustrative example into a formal model for the loss and cost across subset sizes, we extend the GP model by an additional input dimension, namely s∈[0,1].
This allows the surrogate to extrapolate to the full data set at s=1 without necessarily evaluating there.
We chose a factorized kernel, consisting of the standard stationary kernel over hyperparameters, multiplied with a finite-rank (“degenerate”) covariance function in s:

k((x,s),(x′,s′))=k\nicefrac52(x,x′)⋅(ϕT(s)⋅Σϕ⋅ϕ(s′)).

(6)

Since any choice of the basis function ϕ yields a positive semi-definite covariance function, this provides a flexible language for prior knowledge relating to s.
We use the same form of kernel to model the loss f and cost c, respectively, but with different basis functions ϕf and ϕc.

The loss of a machine learning algorithms usually decreases with more training data. We incorporate this behavior by choosing ϕf(s)=(1,(1−s)2)T to enforce monotonic predictions with an extremum at s=1. This kernel choice is equivalent to Bayesian linear regression with these basis functions and Gaussian priors on the weights.

To model computational cost c, we note that the complexity usually grows with relative dataset size s. To fit polynomial complexity O(sα) for arbitrary α and simultaneously enforce positive predictions, we model the log-cost and use ϕc(s)=(1,s)T.
As above, this amounts to Bayesian linear regression with shown basis functions.

In the supplemental material (Section B), we visualize scaling of loss and cost with s for the SVM example above and show that our kernels indeed fit them well. We also evaluate the possibility of modelling the heteroscedastic noise introduced by subsampling the data (supplementary material, Section C).

3.2 Formal algorithm description

Fabolas starts with an initial design, described in more detail in Section 3.3.
Afterwards, at the beginning of each iteration it fits GPs for loss and computational cost across dataset sizes s using the kernel from Eq. 6. Then, capturing the distribution of the optimum for s=1 using , it selects the maximizer of the following acquisition function to trade off information gain versus cost:

6: Choose incumbent ^xt based on the predicted loss at s=1 of all {x1,x2,…,xt}.

7:endfor

Algorithm 1 Fast BO for Large Datasets (Fabolas)

Our proposed acquisition function resembles the one used by MTBO (Eq. 2.3), with two differences: First, MTBO’s discrete tasks t are replaced by a continuous dataset size s (allowing to learn correlations without evaluations at s=1, and to choose the appropriate subset size automatically).
Second, the prediction of computational cost is augmented by the overhead of the Bayesian optimization method.
This inclusion of the reasoning overhead is important to appropriately reflect the information gain per unit time spent: it does not matter whether the time is spent with a function evaluation or with reasoning about which evaluation to perform.
In practice, due to cubic scaling in the number of data points of GPs and the computational complexity of approximating ps=1min, the additional overhead of Fabolas is within the order of minutes, such that differences in computational cost in the order of seconds become negligible in comparison.4

Being an anytime algorithm, Fabolas keeps track of its incumbent at each time step.
To select a configuration that performs well on the full dataset, it predicts the loss of all evaluated configurations at s=1 using the GP model and picks the minimizer.
We found this to work more robustly than globally minimizing the posterior mean, or similar approaches.

3.3 Initial design

It is common in Bayesian optimization to start with an initial design of points chosen at random or from a Latin hypercube design to allow for reasonable GP models as starting points.
To fully leverage the speedups we can obtain from evaluating small datasets, we bias this selection towards points with small (cheap) datasets in order to improve the prediction for dependencies on s:
We draw k random points in X (k=10 in our experiments) and evaluate them on different subsets of the data (for instance on the support vector machine experiments we used s∈{\nicefrac164,\nicefrac132,\nicefrac116,\nicefrac18}).
This provides information on scaling behavior, and, assuming that costs increase linearly or superlinearly with s, these k function evaluations cost less than k8 function evaluations on the full dataset. This is important as the cost of the initial design, of course, counts towards Fabolas’ runtime.

3.4 Implementation details

The presentation of Fabolas above omits some details that impact the performance of our method.
As it has become standard in Bayesian optimization (Snoek et al., 2012), we use Markov-Chain Monte Carlo (MCMC) integration to marginalize over the GPs hyperparameters (we use the emcee package (Foreman-Mackey et al., 2013)).
To accelerate the optimization, we use hyper-priors to emphasize meaningful values for the parameters,
chiefly adopting the choices of the spearmint toolbox (Snoek et al., 2012):
a uniform prior between [−10,2] for all length scales λ in log space, a lognormal prior (μa=0, σ2a=1) for the covariance amplitude θ, and a horseshoe prior with length scale of 0.1 for the noise variance σ2.

We used the original formulation of ES by Hennig and Schuler (2012) rather than the recent reformulation of PES by Hernández-Lobato et al. (2014).
The main reason for this is that the latter prohibits non-stationary kernels due to its use of Bochner’s theorem for a spectral approximation.
PES could in principle be extended to work for our particular choice of kernels (using an Eigen-expansion, from which we could sample features); since this would complicate making modifications to our kernel, we leave it as an avenue for future work, but note that in any case it may only further improve our method.
To maximize the acquisition function we used the blackbox optimizer DIRECT (Jones, 2001) and CMAES (Hansen, 2006).

Figure 2: Evaluation on SVM grid on MNIST. (Left) Baseline comparison of test performance of the methods’ selected incumbents over time.
(Middle) Test performance over time for variants of MTBO with different dataset sizes for the auxiliary task.
(Right) Dataset size Fabolas and MTBO pick in each iteration to trade off small cost and high information gain; unlike elsewhere in the paper, this right plot shows mean ±\nicefrac14 stddev of 30 runs (medians would only take two values for MTBO).

For our empirical evaluation of Fabolas, we compared it to standard Bayesian optimization (using EI and ES as acquisition functions), MTBO, and Hyperband.
For each method, we tracked wall clock time (counting both optimization overhead and the cost of function evaluations, including the initial design), storing the incumbent returned after every iteration.
In an offline validation step, we then trained models with all incumbents on the full dataset and measured their test error. We plot these test errors throughout.5
To obtain error bars, we performed 10 independent runs of each method with different seeds (except on the grid experiment, where we could afford 30 runs per method) and plot medians, along with 25th and 75th percentiles for all experiments.
Details on the hyperparameter ranges used in every experiment are given in the supplemental material (Section D).

We implemented Hyperband following Li et al. (2017) using the recommended setting for the parameter η=3 that controls the intermediate subset sizes.
For each experiment, we adjusted the budget allocated to each Hyperband iteration to allow the same minimum dataset size as for Fabolas: 10 times the number of classes for the support vector machine benchmarks and the maximum batch size for the neural network benchmarks.
We also followed the prescribed incumbent estimation after each iteration as the configuration with the best performance on the full dataset size.

4.1 Support vector machine grid on MNIST

First, we considered a benchmark allowing the comparison of the various Bayesian optimization methods on ground truth: our SVM grid on MNIST (described in Section 3), for which we had performed all function evaluations beforehand, measuring loss and cost 10 times for each configuration x and subset size s to account for performance variations.
(In this case, we computed each method’s wall clock time in each iteration as its summed optimization overheads so far, plus the summed costs for the function values it queried so far.)

MTBO requires choosing the number of data points in its auxiliary task.
Figure 2 (middle) evaluates MTBO variants with a single auxiliary task with a relative size of \nicefrac14, \nicefrac132, and \nicefrac1512, respectively.
With auxiliary tasks at either s=\nicefrac1512 or \nicefrac132, MTBO improved quickly, but converged more slowly to the optimum; we believe small correlations between the tasks cause this.
Figure 2 (right) shows the dataset sizes chosen by the different algorithms during the optimization; all methods slowly increased the average subset size used over time.
An auxiliary task with s=\nicefrac14 worked best and we used this for MTBO in the remaining experiments.

At first glance, one might expect many tasks (e.g., with a task for each s∈{\nicefrac1512,\nicefrac1256,…,\nicefrac12,1}) to work best, but quite the opposite is true.
In preliminary experiments, we evaluated MTBO with up to 3 auxiliary tasks (s=\nicefrac14, \nicefrac132, and \nicefrac1512), but found performance to strongly degrade with a growing number of tasks.
We suspect that the (|T|2) kernel parameters that have to be learned for the discrete task kernel for |T| tasks are the main reason.
If the MCMC sampling is too short, the correlations are not appropriately reflected, especially in early iterations, and an adjusted sampling creates a large computational overhead that dominates wall-clock time.
We therefore obtained best performance with only one auxiliary task.

Figure 2 (left) shows results using EI, ES, random search, MTBO and fabolas on this SVM benchmark.
EI and ES perform equally well and find the best configuration (which yields an error of 0.014, or 1.4%) after around 105 seconds, roughly five times faster than random search.
MTBO achieves good performance faster, requiring only around 2×104 seconds to find the global optimum.
Fabolas is roughly another order of magnitude faster than MTBO in finding good configurations, and finds the global optimum at the same time.

Figure 3: SVM hyperparameter optimization on the datasets covertype (left), vehicle (middle) and MNIST(right). At each time, the plots show test performance of the methods’ respective incumbents. Fabolas finds a good configuration between 10 and 1000 times faster than the other methods.

4.2 Support vector machines on various datasets

For a more realistic scenario, we optimized the same SVM hyperparameters without a grid constraint on MNIST and two other prominent UCI datasets (gathered from OpenML (Vanschoren et al., 2014)), vehicle registration (Siebert, 1987) and forest cover types (Blackard and Dean, 1999) with more than 50000 data points, now also comparing to Hyperband. Training SVMs on these datasets can take several hours, and Figure 3 shows that Fabolas found good configurations for them between 10 and 1000 times faster than the other methods.

Hyperband required a relatively long time until it recommended its first hyperparameter setting, but this first recommendation was already very good, making Hyperband substantially faster to find good settings than standard Bayesian optimization running on the full dataset. However, Fabolas typically returned configurations with the same quality another order of magnitude faster.

4.3 Convolutional neural networks on CIFAR-10 and SVHN

Convolutional neural networks (CNNs) have shown superior performance on a variety of computer vision and speech recognition benchmarks, but finding good hyperparameter settings remains challenging, and almost no theoretical guarantees exist.
Tuning CNNs for modern, large datasets is often infeasible via standard Bayesian optimization; in fact, this motivated the development of Fabolas.

We experimented with hyperparameter optimization for CNNs on two well-established object recognition datasets, namely CIFAR10 (Krizhevsky, 2009) and SVHN (Netzer et al., 2011).
We used the same setup for both datasets (a CNN with three convolutional layers, with batch normalization (Ioffe and Szegedy, 2015) in each layer, optimized using Adam (Kingma and Ba, 2014)).
We considered a total of five hyperparameters: the initial learning rate, the batch size and the number of units in each layer.
For CIFAR10, we used 40000 images for training, 10000 to estimate validation error, and the standard 10000 hold-out images to estimate the final test performance of incumbents.
For SVHN, we used 6000 of the 73257 training images to estimate validation error, the rest for training, and the standard 26032 images for testing.

The results in Figure 4 show that—compared to the SVM tasks—Fabolas’ speedup was smaller because CNNs scale linearly in the number of datapoints. Nevertheless, it found good configurations about 10 times faster than vanilla Bayesian optimization. For the same reason of linear scaling, Hyperband was substantially slower than vanilla Bayesian optimization to make a recommendation, but it did find good hyperparameter settings when given enough time.

4.4 Residual neural network on CIFAR-10

Figure 5: Validation performance of a residual network on CIFAR10.

In the final experiment, we evaluated the performance of our method further on a more expensive benchmark, optimizing the validation performance of a deep residual network on the CIFAR10 dataset, using the original architecture from He et al. (2015).
As hyperparameters we exposed the learning rate, L2 regularization, momentum and the factor by which the learning rate is multiplied after 41 and 61 epochs.

Figure 5 shows that Fabolas found configurations with reasonable performance roughly 10 times faster than ES and MTBO.
Note that due to limited computational capacities, we were unable to run Hyperband on this benchmark: a single iteration took longer than a day, making it prohibitively expensive. (Also note that by that time all other methods had already found good hyperparameter settings.)
We want to emphasize that the runtime could be improved by adapting Hyperband’s parameters to the benchmark, but we decided to keep all methods’ parameters fixed throughout the experiments to also show their robustness.

We presented Fabolas, a new Bayesian optimization method based on entropy search that mimics human experts in evaluating algorithms on subsets of the data to quickly gather information about good hyperparameter settings.
Fabolas extends the standard way of modelling the objective function by treating the dataset size as an additional continuous input variable. This allows the incorporation of strong prior information.
It models the time it takes to evaluate a configuration and aims to evaluate points that yield—per time spent—the most information about the globally best hyperparameters for the full dataset.
In various hyperparameter optimization experiments using support vector machines and deep neural networks, Fabolas often found good configurations 10 to 100 times faster than the related approach of Multi-Task Bayesian optimization, Hyperband and standard Bayesian optimization. Our open-source code is available at https://github.com/automl/RoBO, along with scripts for reproducing our experiments.

In future work, we plan to expand our algorithm to model other environmental variables, such as the resolution size of images, the number of classes, and the number of epochs, and we expect this to yield additional speedups.
Since our method reduces the cost of individual function evaluations but requires more of these cheaper evaluations, we expect the cubic complexity of Gaussian processes to become the limiting factor in many practical applications. We therefore plan to extend this work to other model classes, such as Bayesian neural networks (Neal, 1996; Hernández-Lobato and Adams, 2015; Blundell et al., 2015; Springenberg et al., 2016; Klein et al., 2017), which may lower the computational overhead while having similar predictive quality.

Footnotes

Hyperband was first described in a 2016 arXiv paper (Li et al., 2016), and Fabolas was first described in a 2015 NIPS workshop paper (Klein et al., )

In fact, Swersky et al. (2013) deviated slightly from this formula (which follows the ES approach of Hennig and Schuler (2012)) by considering the difference in information gains in pt∗min(x∣D) and pt∗min(x∣D∪{(x,y)}). They stated this to work better in practice, but we did not find evidence for this in our experiments and thus, for consistency, use the variant presented here throughout.

The same is true for standard ES and MTBO, but was never exploited as no emphasis was put on the total wall clock time spent for the hyperparameter optimization.
We want to emphasize that we express budgets in terms of wall clock time (not function evaluations) since this is natural in most practical applications.

The residual network in Section 4.4 is an exception: here, we trained networks with the incumbents on the full training set (50000 data points, augmented to 100000 as in the original code) and then measured and plotted performance on the validation set.

In fact, Swersky et al. (2013) deviated slightly from this formula (which follows the ES approach of Hennig and Schuler (2012)) by considering the difference in information gains in pt∗min(x∣D) and pt∗min(x∣D∪{(x,y)}). They stated this to work better in practice, but we did not find evidence for this in our experiments and thus, for consistency, use the variant presented here throughout.

The same is true for standard ES and MTBO, but was never exploited as no emphasis was put on the total wall clock time spent for the hyperparameter optimization.
We want to emphasize that we express budgets in terms of wall clock time (not function evaluations) since this is natural in most practical applications.

The residual network in Section 4.4 is an exception: here, we trained networks with the incumbents on the full training set (50000 data points, augmented to 100000 as in the original code) and then measured and plotted performance on the validation set.