DEEP-BO for Hyperparameter Optimization of Deep Networks

05/23/2019 ∙ by Hyunghun Cho, et al. ∙ UNIST Seoul National University 0

The performance of deep neural networks (DNN) is very sensitive to the particular choice of hyper-parameters. To make it worse, the shape of the learning curve can be significantly affected when a technique like batchnorm is used. As a result, hyperparameter optimization of deep networks can be much more challenging than traditional machine learning models. In this work, we start from well known Bayesian Optimization solutions and provide enhancement strategies specifically designed for hyperparameter optimization of deep networks. The resulting algorithm is named as DEEP-BO (Diversified, Early-termination-Enabled, and Parallel Bayesian Optimization). When evaluated over six DNN benchmarks, DEEP-BO easily outperforms or shows comparable performance with some of the well-known solutions including GP-Hedge, Hyperband, BOHB, Median Stopping Rule, and Learning Curve Extrapolation. The code used is made publicly available at



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Hyperparameter optimization(HPO) aims to find the global optima of an unknown black-box function . That is, , where is a hyperparameter space that can be a subset of , contain categorical, or discrete variables. can be evaluated at an arbitrary . Bayesian Optimization(BO) algorithms have been deeply studied and used for HPO in many machine learning(ML) and deep neural network(DNN) problems. Recently, DNN HPO has gained greater importance with increasingly complex tasks that ML techniques cannot fully support.

We have observed that it is difficult to choose an appropriate HPO algorithm because the search space depends on the data characteristics and the DNN structure. As shown in Figure 1, we first evaluated 3 different DNN tasks using various HPO algorithms: random search (Bergstra and Bengio, 2012), Gaussian Process(GP-EI) (Snoek et al., 2012), an adaptive GP algorithm GP-Hedge (Hoffman et al., 2011), two speed-up BOs using Median Stopping Rule(GP-EI-MSR) and Learning Curve Extrapolation(RF-EI-LCE) (Golovin et al., 2017; Domhan et al., 2015), bandit based approach Hyperband (Li et al., 2017) and BOHB (Falkner et al., 2018). No free lunch theorem proves that no algorithm can show superior performance in all cases (Wolpert et al., 1997). Nevertheless, DEEP-BO that this work introduces shows stable performance in most cases.

DEEP-BO (Diversified, Early-termination Enabled, Parallel BO) is an algorithm made more robust by strategically integrating 3 methods - BO diversification, safe early termination, and cost function transformation. We first detail how each method comprising DEEP-BO is developed to enhance its respective precedents and then proceed to observe how their combination outperforms existing strategies for DNN HPO. We discuss the individual strengths of the comprising methods and observe that their combined use in the form of DEEP-BO shows both greater performance and robustness than when used alone in enhancing traditional BO for DNN HPO tasks.

(a) Regression
(b) Language modeling
(c) Classification
Figure 1: HPO performance comparison on 3 different DNN tasks (lower is better): (a) MLP model on kin8nm. (b) LSTM model on PTB, (c) ResNet model on CIFAR-10. Each plot compares min function value of different HPO algorithms as the optimization time increases. DEEP-BO is our method. Note that the shaded areas are 0.25 error.

2 Related Works

2.1 Bayesian Optimization

Bayesian optimization is an iterative process that sequentially chooses the next configuration to evaluate based on previous observations. Three Sequential Model-Based Global Optimization (SMBO) algorithms, Spearmint (Snoek et al., 2012), SMAC (Hutter et al., 2011), and TPE (Bergstra et al., 2011), were introduced and are compared in practical problems (Eggensperger et al., 2013)

. Acquisition functions such as Probability of Improvement (PI), Expected Improvement (EI), and Upper Confidence Bound (UCB) are widely used with these three BO algorithms.

2.2 Diversification strategies

Diversification strategy is introduced to minimize the risk of loss by splitting different categories of methods in various problems. Diversification strategies have been successfully used in many fields such as communication (Zheng and Tse, 2003) and finance (Markowitz, 1952) because of their theoretical and practical advantages. Diversification strategies have also been applied to HPO of ML algorithms in various ways. GP-Hedge (Hoffman et al., 2011) uses multiple acquisition functions together in online multi-armed bandit settings to improve HPO performance. For situations where there is no clear reason to choose a particular acquisition function, using a portfolio of them can be beneficial.

2.3 Early stopping strategies

Speed up practices today attempt to reap the benefits of HPO in the form of resource allocation strategies by considering learning dynamics of DNN. One common prior is that learning curves typically increase and saturate. Li et al. (2017) further articulates this using envelope functions111It is defined as the maximum deviation of the intermediate losses from the terminal validation loss toward which the deviations are suggested to monotonically decrease with resources allocated.

before applying it to the strategy. Even though asymptotic accuracy predictions vary from a heuristic rule 

(Golovin et al., 2017), probabilistic modeling (Domhan et al., 2015), to regression (Baker et al., 2017; Istrate et al., 2018), the termination criterion is set upon such an assumption. Some works develop on these precedents. Klein et al. (2016) uses Bayesian methods to  Domhan et al. (2015). Falkner et al. (2018) applies BO to Li et al. (2017) to capture the density of good configurations evaluated. Most of these works term their strategies as early stopping strategies.

2.4 Parallel BO

BO is a naturally sequential process, but parallelization can also be applied. Some studies address the following issues about parallel BO: scalability (Springenberg et al., 2016), batch configuration (Wu and Frazier, 2016; Nguyen et al., 2016), and exploration-exploitation tradeoffs (Desautels et al., 2014). Snoek et al. (2012)

calculates Monte Carlo estimates of the acquisition function, which can be used in multiprocessor settings where the number of MCMC sampling can control the diversity of a GP model. This dynamic is briefly examined in this work. Many other strategies have been introduced to increase the diversity of parallel BO algorithms: combining UCB and pure exploration 

(Contal et al., 2013), using a penalized acquisition function (González et al., 2016), introducing a randomized strategy to divide and conquer (Wang et al., 2017) and modeling the diversity of a batch (Kathuria et al., 2016).

3 DEEP-BO: An Enhanced Bayesian Algorithm for DNN HPO

We introduce three methods intended to enhance BO performance and robustness. Appendix A details the full algorithm with more explanation.

3.1 Diversification of BO

While a typical BO algorithm uses a single modeling algorithm for all iterations to approximate the true black-box function , sequential diversification uses modeling algorithms () in sequence. This approach rotates over the ordered algorithms in sequence. When parallel processors (workers) are available, the parallel diversification strategy can be used by utilizing modeling algorithms over processors. Assuming that the time required for evaluating is much longer than that required for modeling using history , which is often true for heavy DNN problems, we can adopt a simple strategy where we assign the modeling result to whichever worker that becomes available. Here, would be cycled from 1 to in sequence such that diversification can be enforced.

3.2 Early termination rule

We introduce an early termination rule, which we name as the Compound Rule (CR), developed on the Median Stopping Rule (MSR) (Golovin et al., 2017) suggested to be robust. We define Early Termination Rule (ETR) as a rule that economizes on resources by prematurely terminating unpromising configurations 222Note that we avoided the term early stopping because historically it has been used to refer to a specific process that prevents overfitting from excessive training  (Prechelt, 1998).

. MSR records the mean performance up to some epoch

for each configuration tried and uses its median value to evaluate the pending configuration’s best performance until epoch . Our ETR has 2 design parameters (max epoch and ). is used here with less expected aggressiveness. CR considers curves to be one of three types - highly untrainable, highly desirable, and the rest - and aims to find the first two with checkpoint-1 and checkpoint-2 respectively. Section 5 and Appendix A and B contain further explanation this ETR. Below is a summary of the two checkpoints.

Checkpoint-1 discards highly untrainable configurations. It terminates the training of the current configuration at epoch if its until-then best performance is strictly worse than the percentile value of the running averages for all . The running average performance of up to epoch is calculated as where is performance of at epoch . Poor configurations consistently produce near random-guess performances and more likely arise when necessary priors for hyperparameters are unavailable which greatly limits the optimization potential (Gülçehre and Bengio, 2016). Checkpoint-1 exclusively aims to terminate them with a low ( percentile; MSR uses 50th percentile) threshold.

Checkpoint-2 spares only highly desirable configurations that are likely to outperform the current best. that survives checkpoint-1 is stopped at epoch if its until-then best performance is below the percentile value of the running averages for where for that survived checkpoint-1. Envelope functions suggest more resources be needed to discern configuration quality since envelope overlaps decrease with resources more clearly. We observe this more evidently for highly desirable configurations. We thereby apply the intuition exclusively to discern these good configurations with proportional to threshold height. We also note that the observed range for checkpoint-2 starts from , not the first epoch.

3.3 Parallel BO

As Snoek et al. (2012) points out, the main problem with parallel workers is deciding what to evaluate next while a set of points are still being evaluated. The simplest strategy is to ignore others and include only completely evaluated results into . This can result in duplicate selection where the chosen is already being evaluated by another worker. Snoek et al. (2012) adds randomness through MCMC sampling to reduce duplicate selection. In the case of parallelization, using different algorithms naturally lowers the chance of duplicates because the algorithms tend to make different decisions even for the same . When is much larger than , however, duplicate selection becomes more likely even for diversification. When it occurs, the following can be considered.

  • naïve: evaluate the duplicate anyway

  • random: randomly select a new candidate

  • next candidate: choose the next best candidate that has not been selected before

  • in-progress: temporarily add the premature evaluation results to and find

For DNN, in-progress is attractive because even when the premature result is entirely wrong, it is self-corrected and replaced in when evaluation completes. Experiments conducted with shows that in-progress provides meaningful improvement while the others perform comparably.

Another important topic to consider is cost function transformation. For both improving modeling performance and robustness, we also introduce a hybrid transformation which uses a linear scale when the error rate is above and log transformation when the error rate is below . DNN is often used for classification tasks with the performance as an error rate. When the desired error rate is close to 0, it becomes difficult to accurately model using the original linear scale. For such case, applying log transformation, known to be effective for modeling nonlinear and multimodal functions (Jones et al., 1998), can be advantageous. However, when the error rate is high, this log transformation can be harmful.

4 Empirical Results

HPO Benchmark
Number of hyperparameters
rate scale
Max epoch
Number of
discrete continuous categorical
MNIST-LeNet1 6 3 - log 15 20,000
MNIST-LeNet2 3 3 3 log 15 20,000
PTB-LSTM 3 5 1 linear 15 20,000
CIFAR10-VGG 6 2 2 log 50 20,000
CIFAR10-ResNet 2 4 1 log 100 7,000
CIFAR100-VGG 6 2 2 log 50 20000
Table 1: Benchmark problem settings.

In this study, we thoroughly evaluated DEEP-BO over 6 DNN HPO problems. As summarized in Table 1, we chose the most popular benchmark datasets in the DNN community: MNIST, PTB(Penn Treebank), CIFAR-10, and CIFAR-100. Three HPO tasks of CNN architectures (LeNet, VGG, ResNet) and one of RNN architecture (LSTM) are included. Since practical model implementation almost always limits the number of hyperparameters human experts can adjust, seven to ten hyperparameters are selected for optimization for each benchmark task. Learning rate, often the most critical, is included in all six problems. To repeat the experiments effectively over multiple algorithms, we first created lookup tables for each task by pre-evaluating surrogate configurations sampled by Sobol sequences Sobol’ (1967). The appendix C specifies more details of each benchmark.

We use two different metrics to evaluate HPO algorithms. The first is the success rate, the probability an HPO algorithm achieves a target goal within the given time budget . Assuming the algorithm takes time

, a random variable, to achieve a target accuracy

, the algorithm’s success rate at time can be defined as successfully finding such that before time , or more simply as . The second is expected time to achieve a target accuracy expressed as .

Figure  2 shows the success rate plots of DEEP-BO and other algorithms in 3 of 6 benchmark cases. Unlike other benchmark algorithms, DEEP-BO consistently shows top-level performance for all 3 benchmark cases shown. Appendix D of supplementary materials details plots for all benchmarks.

(a) MNIST-LeNet1 ()
(b) PTB-LSTM ()
(c) CIFAR10-ResNet ()
(d) MNIST-LeNet1 ()
(e) PTB-LSTM ()
(f) CIFAR10-ResNet ()
Figure 2: Success rate to achieve a target error performance using processor(s). All experiments repeated the HPO run 100 times for each algorithm.

Even under the conditions of using a single processor, DEEP-BO is not only robust in all benchmarks, but also has excellent performance. In Figure  1(a)1(c), we evaluated our method using = 1, = 6, = 0.3, = 0.1 and compared it with an adaptive algorithm GP-Hedge, two speed up algorithms (MSR, LCE) and BOHB, a state-of-the-art algorithm by Falkner et al. (2018).

The performance of DEEP-BO under multiprocessing conditions is impressive. Figure 1(d)1(f) plot success rates evaluated in 6 parallel processors( = 6, = 6, = 0.3, = 0.1). DEEP-BO is compared with four different settings of GP-EI algorithms regarding synchronization, MCMC sampling, and early termination. In GP-EI algorithms, MCMC sampling explained in Snoek et al. (2012) was adopted with either 10 or 1 samples used. The GP-EI-MCMC(10) was the baseline algorithm, and GP-EI-MCMC(1) used only one sample to increase randomness. ‘Synch,GP-EI-MCMC(10)’ was a special setting where all the six processors were synchronized for modeling such that there is no difficulty with handling incomplete evaluations. All of six processors started simultaneously and had to wait until the evaluations of all six completed such that the next top 6 candidates can be launched together. It performs poorly as expected, but is provided as a benchmark. Both GP-EI-MCMC(1) and GP-EI-MCMC(10) observably performed comparably and the increased randomness did not a prompt distinct improvement. MSR enabled GP-EI tends to increase the performance but, it is not significantly improved.

Measure Benchmark Single processor () Six processors ()
MNIST-LeNet1 (12h / 2h) 32% 32% 12% 81% 15% 15% 80%
MNIST-LeNet2 (12h / 2h) 39% 48% 1% 82% 39% 41% 95%
PTB-LSTM (12h / 2h) 85% 89% 29% 100% 45% 60% 96%
CIFAR10-VGG (6h / 1h) 53% 48% 0% 80% 32% 50% 75%
CIFAR10-ResNet (90h / 15h) 91% 94% 4% 100% 61% 81% 99%
CIFAR100-VGG (6h / 1h) 92% 85% 4% 100% 30% 43% 99%
Mean 66% 66% 8% 91% 37% 48% 91%
Mean 3.7%
Table 2: Summary of performance achieving top-10 accuracy. For success rate, the numbers in parenthesis of each benchmark indicate the checkpoints when the number of processors is 1 and 6, respectively. We only show the competitors’ performance due to the page limit. See Appendix D for full benchmark results.

DEEP-BO notably enhances performance with a single processor. DEEP-BO with 6 processors can enhance more through parallelization. As shown in Figure 2, DEEP-BO outperforms in all benchmarks and seems robust than competitors. In terms of expected time, DEEP-BO performance using 1 processor is 10.7 hours, but that with 6 processors is only 2 hours (5.35 times faster). The state of the art algorithm, BOHB, did not perform well in these benchmarks even though we had tried to set its hyperparameters properly. We discuss why in the section 5.

Expected time (hour)
on on on
on on off
on off on
on off off
off on on
off on off
off off on
off off off
Table 3: Ablation test results with DEEP-BO using 6 processors. Bold refers to the best performance and Italic refers to comparable results.

The ablation study in Table 3 shows that, under all conditions, components applied to DEEP-BO do not always perform well but are generally stable. Table 3 shows (on, on, on) produces the most successful performances for 3 of 6 tasks and second best performances at worst. Using this with some components turned off can be a little harmful, but it is shown that all the best cases were where at least 2 of the 3 switches were on. Overall, (on, on, on) is a beneficial strategy for all benchmarks.

5 Discussion

A few of the core design principles of DEEP-BO are explained and discussed in this section.

5.1 Diversity gain and cooperation effect

Figure 3: Diversity gain
(a) Expected time (b) Performance w.r.t. linear gain
Figure 4: Parallelization loss.

For an HPO algorithm, we can define its failure rate as where is a random variable representing the algorithm’s time to achieve the target accuracy . If the algorithm is run over parallel workers without sharing their histories among the workers, the chance that all attempts fail is simply because forms an i.i.d. process. Therefore, we can see that order diversity gain (increase in the exponent of the failure rate) is achieved at the cost of times increase in resources. In Figure 4, success rate curves are shown for a benchmark problem. RF-EI(=1) is the baseline with success rate equal to , and Theoretical(=6) is a synthetic curve calculated from . Clearly, success rate of Theoretical(=6) ramps up much faster than DEEP-BO(=1) and demonstrates the power of order six diversity. The exciting part is the performance of DEEP-BO(=6) that is shown together. DEEP-BO(=6) overwhelmingly outperforms Theoretical(=6), indicating that it can achieve much more than order six diversity ().

A large portion of the substantial extra improvement is due to the mix of individual models with different modeling characteristics, and the effect comes in two-fold. The first is the different (ideally independent) characteristics of the models where at least one might work well. This is another type of diversity that is different from the effect, and basically says at least one of will likely be small over the individual models for any given task. The second is the cooperative nature of the diversified algorithm thanks to the sharing of . When an individual model A is not capable of selecting good target points for exploration and is stuck in a bad region, some of the other models might make better selections that serve well as exploratory points to the model A. Then the poorly performing model A can escape from the bad cycle and start to perform well. In our empirical experiments, we extensively tried multi-armed-bandit-like approaches to provide more turns to the better performing individual models, but the strategy actually turned out to hurt the overall performance. It turns out that it is better to give a fair chance to even the worst performing model such that its different modeling characteristic can be utilized. Of course, this is assuming that even the worst performing model is generally a plausible and useful model for DNN HPO.

5.2 Parallelization loss

When the expected time is considered, it would be ideal if the time is reduced by by using processors. We examined if such a linear gain in performance can be retained as becomes large. In Figure 3(a)

, distributions of the expected time are shown for 3, 6, 12, and 18 processors. Expected time and variance can be seen to decrease as the number of processor increases. As for GP-EI, we have found that MCMC(1) performs better probably because the increased randomness is helpful when multiple processors are used. In Figure 

3(b), the expected time performance with respect to is shown after normalization. The dotted gray line shows the performance. All the algorithms show the decrease in the normalized performance as is increased. But the values do not drop very fast after reaches 45 processors. For parallel diversification, interestingly the performance even went above linear gain when is between 2 and 4. This is due to the diversification and cooperation.

5.3 Robust termination criterion

Evaluating configurations very early can much save resources, but is possibly hazardous for BO. CR, our ETR, intentionally does not locate in early epochs considering cases illustrated in Figure 5 for configurations with "batchnorm" whose termination can prompt false alarms that harm BO. Checkpoint-1() here was set as rounded to lessen this possibility. Similar reasoning goes for checkpoint-2 whose observation start point for the scope of epochs observed is set as epoch , not the first epoch. With all other conditions fixed for former-half epochs, the inter-dataset and of survivor rank regret is strictly counter-proportional to the observation start point for checkpoint-2 of our ETR (see Appendix B for details). These correlations strongly indicate that a delayed observation start point may encompass more reliable information (smaller ) and allow greater robustness (smaller ).

(a) Initial performance
(b) Later performance
(c) Top-10 performing curves
Figure 5: These are based on the pre-evaluated CIFAR10-VGG surrogate configurations which included one of the three: batchnorm, dropout, or none. 4(a) and 4(b) show the performance distribution these 3 groups for top-200 curves. Configurations with batchnorm initially (epoch ) performs worst but later (epoch ) performs much better, signifying that early epoch information may be misleading. This relates to conjectures from Choi et al. (2018). In fact, all top-10 curves (4(c)) were from configurations that had batchnorm whose group initially performs worst.

Notable observations with our ETR are DEEP-BO’s results compared to MSR and BOHB in Figure 2 and the comparison of ablation results about "Early Termination" in Table 3. That DEEP-BO outperforms MSR in our benchmarks is not too surprising as our rule was developed on MSR. The more interesting part is that from the perspective of success rates, DEEP-BO outperforms BOHB even though both methods conceptually refer to similar parts of the envelope function (Li et al., 2017).

DEEP-BO abstains from evaluating too early and specifies envelope functions to be more evidently applicable to well-trainable configurations. BOHB evaluates from early epochs which can be dangerous for cases like Figure 5 particularly when all observed best configurations have poor initial performances. Terminating very early does help BO’s explorability and allows the algorithm to reach easy goal performances very rapidly. However, this could increase false alarms, hindering the algorithm from performing beyond such easy targets. Success rate is the average of Boolean results where the iteration is matched with 0 if it does not exceed goal performance. The goal for our study is set high and thereby BOHB could have failed drastically.

(a) Envelope Function Concept
(b) CIFAR10-VGG’s Envelopes
(c) CIFAR100-VGG’s Envelopes
Figure 6: Envelope function expectations (Li et al., 2017) and their actual observations in CIFAR10/100-VGG for top-100 curves in total. Asymptotes (terminal performances) are approximated by the mean of the latter half performances and aligned at 0.5 for comparison.

Envelope function overlappings should be minimal to be applicable. Though this is more evidently observed with high performing configurations, sporadic fluctuations that can bother evaluation still exist as Figure 6 illustrates. Thereby, it would be crucial for the ETR to be less fluctuation-prone. This can be aided by referring to a range of epochs rather than just a single epoch. Our rule and MSR are designed in such a way and therefore are in advantage in regards of robustness.

Table 3 shows both the strength of DEEP-BO’s ETR and the general limit of ETRs. The fact that DEEP-BO with CR was best for 5 out of 6 cases heuristically supports its robustness. However, one case revealed that there might be no always good ETR. CR was designed to be more robust than its precedents but still has its limits when used alone. Observations recommend ETRs be used along with other methods that help BO’s robustness as this work attempts.

6 Conclusion

In this work, we proposed three different strategies to enhance Bayesian Optimization for DNN HPO with a pursuit of improved average performance and enhanced robustness. We first adopted the concept of diversification. Individual BO models tend to focus on different parts of search space due to the different modeling characteristics. With diversification, each algorithm ends up serving as an excellent exploration guide to the other individual algorithms while being a greedy exploiter for its own selection. Then, we proposed an early termination strategy that works well by being conservative. Learning curves of DNN can show distinct patterns depending on what options (e.g. batchnorm) are turned on, and it is very important to avoid being too aggressive. For parallel processing, we suggested the in-progress method that uses premature evaluation results of pending DNN evaluations. Even when a premature evaluation is inaccurate and harmful, the problem is self-corrected after completing the evaluation. Additionally, we introduced a cost function transformation technique that can be helpful. Overall, the resulting DEEP-BO works very well and outperformed the existing state-of-the-art algorithms for the six benchmark DNN HPO tasks that we have investigated.


  • Baker et al. [2017] B. Baker, O. Gupta, R. Raskar, and N. Naik. Accelerating neural architecture search using performance prediction. arXiv preprint arXiv:1705.10823, 2017.
  • Bergstra and Bengio [2012] J. Bergstra and Y. Bengio. Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13(Feb):281–305, 2012.
  • Bergstra et al. [2011] J. S. Bergstra, R. Bardenet, Y. Bengio, and B. Kégl. Algorithms for hyper-parameter optimization. In Advances in neural information processing systems, pages 2546–2554, 2011.
  • Choi et al. [2018] D. Choi, H. Cho, and W. Rhee. On the difficulty of dnn hyperparameter optimization using learning curve prediction. In TENCON 2018-2018 IEEE Region 10 Conference, pages 0651–0656. IEEE, 2018.
  • Contal et al. [2013] E. Contal, D. Buffoni, A. Robicquet, and N. Vayatis. Parallel gaussian process optimization with upper confidence bound and pure exploration. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 225–240. Springer, 2013.
  • Desautels et al. [2014] T. Desautels, A. Krause, and J. W. Burdick. Parallelizing exploration-exploitation tradeoffs in gaussian process bandit optimization. The Journal of Machine Learning Research, 15(1):3873–3923, 2014.
  • Domhan et al. [2015] T. Domhan, J. T. Springenberg, and F. Hutter. Speeding up automatic hyperparameter optimization of deep neural networks by extrapolation of learning curves. In

    Proceedings of the 24th International Joint Conference on Artificial Intelligence (IJCAI)

    , 2015.
  • Eggensperger et al. [2013] K. Eggensperger, M. Feurer, F. Hutter, J. Bergstra, J. Snoek, H. Hoos, and K. Leyton-Brown. Towards an empirical foundation for assessing bayesian optimization of hyperparameters. In NIPS workshop on Bayesian Optimization in Theory and Practice, pages 1–5, 2013.
  • Eggensperger et al. [2015] K. Eggensperger, F. Hutter, H. H. Hoos, and K. Leyton-Brown. Efficient benchmarking of hyperparameter optimizers via surrogates. In AAAI, pages 1114–1120, 2015.
  • Falkner et al. [2018] S. Falkner, A. Klein, and F. Hutter. Bohb: Robust and efficient hyperparameter optimization at scale. arXiv preprint arXiv:1807.01774, 2018.
  • Golovin et al. [2017] D. Golovin, B. Solnik, S. Moitra, G. Kochanski, J. Karro, and D. Sculley. Google vizier: A service for black-box optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pages 1487–1495. ACM, 2017.
  • González et al. [2016] J. González, Z. Dai, P. Hennig, and N. Lawrence. Batch bayesian optimization via local penalization. In Artificial Intelligence and Statistics, pages 648–657, 2016.
  • Gülçehre and Bengio [2016] Ç. Gülçehre and Y. Bengio. Knowledge matters: Importance of prior information for optimization. The Journal of Machine Learning Research, 17(1):226–257, 2016.
  • Hoffman et al. [2011] M. D. Hoffman, E. Brochu, and N. de Freitas. Portfolio allocation for bayesian optimization. In UAI, pages 327–336, 2011.
  • Hutter et al. [2011] F. Hutter, H. H. Hoos, and K. Leyton-Brown. Sequential model-based optimization for general algorithm configuration. In International Conference on Learning and Intelligent Optimization, pages 507–523. Springer, 2011.
  • Istrate et al. [2018] R. Istrate, F. Scheidegger, G. Mariani, D. Nikolopoulos, C. Bekas, and A. C. I. Malossi. Tapas: Train-less accuracy predictor for architecture search. arXiv preprint arXiv:1806.00250, 2018.
  • Jones et al. [1998] D. R. Jones, M. Schonlau, and W. J. Welch. Efficient global optimization of expensive black-box functions. Journal of Global optimization, 13(4):455–492, 1998.
  • Kathuria et al. [2016] T. Kathuria, A. Deshpande, and P. Kohli. Batched gaussian process bandit optimization via determinantal point processes. In Advances in Neural Information Processing Systems, pages 4206–4214, 2016.
  • Klein et al. [2016] A. Klein, S. Falkner, J. T. Springenberg, and F. Hutter. Learning curve prediction with bayesian neural networks. 2016.
  • Kushner [1964] H. J. Kushner. A new method of locating the maximum point of an arbitrary multipeak curve in the presence of noise. Journal of Basic Engineering, 86(1):97–106, 1964.
  • Li et al. [2017] L. Li, K. Jamieson, G. DeSalvo, A. Rostamizadeh, and A. Talwalkar. Hyperband: A novel bandit-based approach to hyperparameter optimization. The Journal of Machine Learning Research, 18(1):6765–6816, 2017.
  • Markowitz [1952] H. Markowitz. Portfolio selection. The journal of finance, 7(1):77–91, 1952.
  • Mockus et al. [1978] J. Mockus, V. Tiesis, and A. Zilinskas. chapter bayesian methods for seeking the extremum. Toward global optimization, volume 2, 1978.
  • Nguyen et al. [2016] V. Nguyen, S. Rana, S. K. Gupta, C. Li, and S. Venkatesh. Budgeted batch bayesian optimization. In Data Mining (ICDM), 2016 IEEE 16th International Conference on, pages 1107–1112. IEEE, 2016.
  • Prechelt [1998] L. Prechelt. Automatic early stopping using cross validation: quantifying the criteria. Neural Networks, 11(4):761–767, 1998.
  • Shah and Ghahramani [2015] A. Shah and Z. Ghahramani. Parallel predictive entropy search for batch global optimization of expensive objective functions. In Advances in Neural Information Processing Systems, pages 3330–3338, 2015.
  • Snoek et al. [2012] J. Snoek, H. Larochelle, and R. P. Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pages 2951–2959, 2012.
  • Sobol’ [1967] I. M. Sobol’. On the distribution of points in a cube and the approximate evaluation of integrals. Zhurnal Vychislitel’noi Matematiki i Matematicheskoi Fiziki, 7(4):784–802, 1967.
  • Springenberg et al. [2016] J. T. Springenberg, A. Klein, S. Falkner, and F. Hutter. Bayesian optimization with robust bayesian neural networks. In Advances in Neural Information Processing Systems, pages 4134–4142, 2016.
  • Srinivas et al. [2009] N. Srinivas, A. Krause, S. M. Kakade, and M. Seeger. Gaussian process optimization in the bandit setting: No regret and experimental design. arXiv preprint arXiv:0912.3995, 2009.
  • Wang et al. [2017] Z. Wang, C. Gehring, P. Kohli, and S. Jegelka. Batched large-scale bayesian optimization in high-dimensional spaces. arXiv preprint arXiv:1706.01445, 2017.
  • Wolpert et al. [1997] D. H. Wolpert, W. G. Macready, et al. No free lunch theorems for optimization.

    IEEE transactions on evolutionary computation

    , 1(1):67–82, 1997.
  • Wu and Frazier [2016] J. Wu and P. Frazier. The parallel knowledge gradient method for batch bayesian optimization. In Advances in Neural Information Processing Systems, pages 3126–3134, 2016.
  • Zheng and Tse [2003] L. Zheng and D. N. C. Tse. Diversity and multiplexing: A fundamental tradeoff in multiple-antenna channels. IEEE Transactions on information theory, 49(5):1073–1096, 2003.

Appendix A. Algorithm Description

Inputs: DNN , modeling algorithm , , , processor , , , hyperparameter space , target accuracy , cost function transformation , early termination functions and , hybrid transformation parameter , early termination parameter , max epoch .
                                                                                                               # global shared history
for  do
     Update with on                                                     # preset to when
     Select on
     for  do                                                                            # execute asynchronously
          on where is accuracy for th epoch
                           # in-progress history update after loss transformation
         if  then
              if  then
                  break                                                                                         # early termination
              end if
         end if
     end for
     if  then
         break                                                                   # finish when desired accuracy achieved
     end if
end for
Algorithm A1. DEEP-BO

Hybrid log transformation


Note that ( - ) is added to make a continuous function. In our work, we use . When is not an accuracy, its range can be scaled to come within [0,1].

Compound termination rule

Figure A1. An illustration of our Compound Rule with 3 sample curves. Epoch and are checkpoints that determine whether a given should be terminated, and is target accuracy. Here, they are . is terminated at epoch if its performance at epoch is below which is computed referring to all . The second checkpoint, epoch , applies to those that survived the first checkpoint for which the same logic applies but with whose computation refers only the history of those that survived the checkpoint-1.

We designed an early termination rule and named as the Compound Rule (CR). We first introduce two formulaic tools required for computing function and which constitute our CR. Function

refers to the cumulative distribution function (CDF) for the distribution of a given random variable

. The rule’s design constrains the range of to .


Next, we show which returns the two checkpoints’ epoch locations (epoch and ) and define , that holds the history for configurations that survived the checkpoint computed by function .


Using the above, we show which returns one of two thresholds. If , returns the threshold for epoch (checkpoint-1), and otherwise returns the threshold for epoch (checkpoint-2).


Under a hypothetical environment where mapping early terminated configurations with intermediate performances does not penalize BO’s modeling and per-epoch training time is fixed at , larger is observed to increase the number of configurations a BO process expectedly encounters per unit time. This is expressed as below:


initially increases almost linearly with but starts to wane away from this linear trajectory from about . Though this conditioned observation suggests choosing , such condition would not hold for practical BO processes, making deterministic assumptions difficult. may be tuned based on practical user constraints.

Appendix B.  Early Termination Rule (ETR)

Structural components for ETR

ETRs rely on parameters that control several smaller knobs composing such structures. Traditionally, works in ETRs explore the theoretical and empirical robustness of the ETR as a single compound but not these knobs that comprise that compound. Comprehension of these knobs and their inner-workings is likely to further our understanding of early termination and potentially provide intuitions for ETR designs. In this part of our study, we attempt to observe and objectify some common knobs that many ETRs may share.

We can annotate that an ETR evaluates works on a learning curve model where defines with preset features for . Each refers to the ’s features which include, but are not excluded to, the maximum budget for training a configuration, whether is a regression model, refers to configuration history for adaptation, or uses extrapolated fantasy values for modeling.

takes 2 vector inputs: the selected hyperparameter configuration

and a design parameter vector to decide whether to terminate . If where 0 means termination and 1 means no termination,


whose domain is a Cartesian product. would be forced to be an ordered vector space if some dictates to refer to the configuration history.

Number of elements in vary according to the proposed ETRs but are common in that they control several inner knobs at once. We observe and objectify 4 inner knobs and with them build on this equation.

  • Observation Start Point : This refers to a point from which the learning curve is meaningfully observed to compute the threshold. is usually defined as a position relative to the maximum trainable epochs or resources allocated to . Its value is observed to be proportional to the maximum epochs and is usually expressed as its percentile value.

  • Observation End Point : This refers to a point until which the learning curve is meaningfully observed to compute the threshold. is also observed to be defined proportional to the maximum epochs and together with point determines the scope of learning curve information that the ETR employs for evaluating . by definition cannot exceed . Cases where is when the ETR uses the performance at that epoch alone to evaluate .

  • Observation Checkpoint : This refers to a point where the learning curve is ultimately evaluated for termination. is also observed to be defined proportional to the maximum epochs. by definition cannot exceed . Many cases set so that the evaluation of is made right after the end of observation. For our study, we fix to .

  • Termination Threshold : This refers to a knob that controls the threshold aggressiveness at the point with which the configuration is terminated or not. where essentially equals to no ETR applied and indiscriminately terminates all configurations at point . Given , with a vector input of performances defined by and determines how the should evaluate at point .

An ETR that has a single checkpoint to evaluate requires one value for each knob. An ETR that has checkpoints would require ordered vectors for each knob at length so that checkpoint- corresponds to , , , and .

Survivor Rank Regret

Survivor rank regret is calculated as the mean value of rank regrets for configurations that are not terminated by the ETR. We first explain rank regrets and then survivor rank regret.

Rank regret is an adaption of the ‘immediate regret’ [Shah and Ghahramani, 2015] whose original definition is , where is the known optimizer of and is the recommendation of an algorithm after batch evaluations. Rank regret uses ranks as the basic unit of measurement instead of where the ranks are derived by using the pre-evaluated configuration tables generated with the Sobol sequences. Rank regret is used for our experiment instead because our work attempts to compare between datasets to check for the algorithm’s robustness. ‘Immediate regret’ is not suitable for such inter-dataset analysis because each dataset has different characteristics and different distributions of achievable performance and therefore the scale of values about BO vary greatly about datasets. Amount of change observed in for before and after applying some ETR to BO is thereby useless for inter-dataset comparison and analysis.

Rank regret, and thereby survivor rank regret, on the other hand is able to deliver information on relative performance improvement. Rank regret first lines up the configurations according to their best performances and ranks the best among those configurations as the first. If we define the rank of in the table as , we normalize its difference with which by definition is 1 so we get Rank regret where refer to the number of configurations in the table. Our pre-evaluated configurations for each observed dataset contained 20,000 configurations, so for this work would simply equal 20,000.

Survivor rank regret here is simply the mean value of rank regret values for a subset of observed configurations that were not terminated at any checkpoint of the ETR and was fully trained to the maximum allocated budget for the configuration. This metric is intended to evaluate whether the configurations that the ETR decided to be worth fully training were, on average, better than those chosen without the ETR. Smaller survivor rank regret values would indicate that the surviving pool of configurations are those with high performances and therefore more likely reach some given goal accuracy. If they are not as good as the baseline average rank regret of an BO with no ETR, then that ETR would be of no help, or even harming, the BO. As this metric is intended for inter-dataset comparison, small inter-dataset variance values for respective survivor rank regret values would signify that the ETR of concern is more likely robust in regards of ETR’s contribution to BO.

A Delayed Observation Start Point for CR’s Checkpoint-2

50% 70% 90% 50% 70% 90%
0% % % % % % %
10% % % % % % %
20% % % % % % %
30% % % % % % %
40% % % % % % %
Table B1. Each cell shows of the respective median survivor rank regret values for 3 pre-evaluated surrogate configurations(MNIST-LeNet2, PTB-LSTM, and CIFAR10-VGG benchmark) for 50 trials with our ETR on the cell’s setting(row:, column:). As DEEP-BO uses , this table sets the threshold at the 90th percentile value for comparison.

This part of the work incorporates the structural framework introduced in this appendix to observe experiment results summarized in Table B1 and suggest the motivations for choosing a delayed observation start point () for checkpoint-2. We note that the results in this experiment is a full version of CR but closer to MSR particularly intended for CR’s checkpoint-2. This experiment limits the focus to observing the effects of the change in on the survivor rank regret which acted as one motivation for the design choice of CR’s checkpoint-2.

As shown in Table B1, and (those corresponding to checkpoint-1 is and ) together form the scope of epochs observed in producing the 90th percentile threshold at for checkpoint-2 (subscript 2 indicates that and are those corresponding to checkpoint-2). Among these 2 knobs, we wish to focus on in particular where for the given column, the inter-dataset and values for survivor rank regret strictly decrease as increases. This work considers this dynamic to be an important marker for using a delayed for checkpoint-2 in regards of enhancing both performance and robustness. Observation of decreasing indicates that this algorithm (with a delayed ) improves BO’s potential performance for datasets overall and the observation with decreasing indicates greater robustness among datasets. Though the dynamic between and does contribute to the reasoning for our choice of for checkpoint-2, our work puts more emphasis on the dynamic between and .

Smaller among datasets is an indicator that the effects of an algorithm on BO, whether good or bad (here is the former considering the observations with values), is stable and therefore more likely to act in such steady manner even for unseen datasets. This observation with decreasing can also be intuitively inferred, as exemplified in Figure 4, considering the fact that the overall maximum deviations in performance are smaller (though that amount varies according to the type of curves) for latter epochs. As stated in the paper, occasional disasterous failures are intolerable and thereby the quality of some algorithm to perform well and steadily is crucial for practical DNN HPO. Therefore, the early termination rule for our DEEP-BO algorithm chooses to have a more delayed observation start point. As checkpoint-2 considers only the configurations that survived checkpoint-1 at epoch , the observation start point for checkpoint-2 here is set at for convenience.

ETR performance comparison

Evaluating the ETR performance only, we compare our ETR, which here we name as Compound rule(CR), to existing ETRs such as Median Stopping Rule(MSR) [Golovin et al., 2017], Learning Curve Extrapolation(LCE) [Domhan et al., 2015]. We select GP-EI as a default BO algorithm which will be accelerated. We evaluated BOHB instead of HB. BOHB is an extended version of HB, which works like an ETR by dynamic resource allocation manner, and also this algorithm already utilizes the other BO. Baker et al. [2017] is excluded in this study because this requires a long warm-up time to train the regression model, which is impractical to our benchmark problem.

(a) MNIST-LeNet1
(b) CIFAR10-ResNet
Figure B1. Success rate of ETRs achieving Top-10 accuracy. ETRs are used on GP-EI. MSR stands for Median Stopping Rule by Golovin et al. [2017]. CR stands for our compound termination rule. LCE stands for Learning Curve Extrapolation by Domhan et al. [2015].

As shown in Figure B1, our CR performs better in MNIST-LeNet1 or similar in CIFAR10-ResNet than MSR. However, LCE and BOHB which performs similarly with CR in MNIST-LeNet1 perform worst in CIFAR10-ResNet. Especially, the ETRs which performs worse than random means that they failed severely. We tried best to optimize their termination criteria but, we could not make them robust in this benchmark. These model-based algorithms assume that the asymptotic performance of a given configuration observing with just partial points in a learning curve can be highly predictable. This may cause their prediction failures and also modeling failure of BO. However, model-free algorithms such as MSR seem to perform robustly in any benchmark.

Appendix C. Experiment Design

Benchmark algorithms

For the modeling algorithms, we adopted two of the most popular modeling algorithms of BO - GP and RF. Specifically, we have closely followed the implementations of Spearmint for GP and SMAC for RF. For GP, we used the automatic relevance determination(ARD) Matérn 5/2 kernel and a Monte Carlo estimation of the integrated acquisition as suggested in Snoek et al. [2012]

. For RF, we used the hyperparameter setting where the number of trees and the number of minimum items in a split are set to 50, 2, respectively. We also one-hot encoded for categorical hyperparameter values to avoid unexpected distortion of modeling.

For the acquisition function, we utilized the three basic approaches - EI, PI, and UCB. By considering all possible combinations between the modeling algorithms and the acquisition functions, we ended up with six different algorithms. For DEEP-BO, we have adopted the six combinations as individual algorithms and implemented the diversification strategies. The algorithms that are evaluated are summarized below.

  • The random algorithm [Bergstra and Bengio, 2012]

  • Six individual BO algorithms. Cartesian product by two modeling algorithms [Snoek et al., 2012, Hutter et al., 2011] and three acquisition functions(Probability of Improvement, Expected Improvement, and Upper Confidence Bound) [Kushner, 1964, Mockus et al., 1978, Srinivas et al., 2009]: GP-EI, GP-PI, GP-UCB, RF-EI, RF-PI, and RF-UCB

  • GP-Hedge introduced by Hoffman et al. [2011], where GP-EI, GP-PI, GP-UCB are used as the three arms of multi-armed bandit

  • RF-EI using Learning Curve Extrapolation (LCE) [Domhan et al., 2015].

  • GP-EI using Median Stopping Rule (MSR) [Golovin et al., 2017]

  • Hyperband (HB) Li et al. [2017]

  • BOHB which allocates resources as an infinite bandit-based approach but, it samples better than random using TPE [Falkner et al., 2018].

  • Our method DEEP-BO.

Random algorithm was included because it is frequently used to replace grid-search, but typically its performance is much worse than the others for DNN tasks. This will become obvious in the result plots.

Hyperparameter configuration space

Architecture Name Type Range
LeNet1 LeNet2
LeNet-5 20cmnumber of first convolution
kernels discrete [1, 350] [1, 350]
10cmfirst pooling size discrete [2, 3] -
10cmnumber of second convolution
kernels discrete [1, 350] [1, 350]
10cmsecond pooling size discrete [2, 3] -

10cmnumber of neurons in fully

connected layer discrete [1, 1024] [1, 1024]
10cmsquare length of the convolution
kernel discrete [2, 10] -
learning rate continuous 10cm[0.0001, 0.4]
(log scale) 10cm[0.0001, 0.4]
(log scale)
L2 regularization factor continuous [0.0, 1.0] [0.0, 1.0]
drop out rate continuous [0.0, 0.9] [0.0, 1.0]
activation function type categorical - 10cmReLU, tanh,sigmoid,

eLU, leaky ReLU

optimizer type categorical - 10cmAdaDelta, AdaGrad, Adam,

GD, Momentum, RMSProp

batch normalization categorical - 10cmEnable, Disable
Table C1: The hyperparameter spaces of LeNet on MNIST dataset.
Architecture Name Type Range
VGG 10cmnumber of first convolution kernels discrete [8, 32]
10cmnumber of second convolution kernels discrete [32, 64]
10cmnumber of third convolution kernels discrete [64, 128]
10cmnumber of forth convolution kernels discrete [64, 128]
10cmnumber of neurons in fully connected layer discrete [10, 1000]
10cmsquare length of convolution kernel discrete [2, 3]
learning rate continuous 10cm[0.0001, 0.4]
(log scale)
L2 regularization factor continuous [0.0, 1.0]
activation function type categorical 10cmReLU, tanh, eLU
regularization method categorical 10cmNone, Dropout, BatchNorm
ResNet 10cmnumber of layers discrete 38, 44, 50, 56, 62, 70, 78
10cmtraining data batch size discrete 45, 90, 180, 360, 450
10cmdata augmentation categorical True, False
learning rate continuous 10cm[0.0001, 0.1]
(log scale)
10cmmomentum for MomentumOptimizer continuous [0.1, 0.9]
10cmweight decay continuous 10cm[0.00001, 0.001]
(log scale)
10cmbatch normalization decay continuous 10cm[0.9, 0.999]
Table C2: The hyperparameter spaces of VGGNet and ResNet on CIFAR10.
Architecture Name Type Range
LSTM 10cmnumber of neurons in hidden layer discrete [10, 200]
10cmnumber of hidden layers discrete [1, 2]
10cmnumber of training steps discrete [10, 20]
10cminitial value of uniform random scale continuous [0.01, 0.1]
drop out rate continuous [0.0, 0.9]
learning rate continuous 10cm[0.1, 1.0]
learning rate decay continuous [0.5, 1.0]
10cmgradient clipping by global normalization continuous [5.0, 10.0]
RNN training module categorical 10cmBasic, Block, cuDNN
Table C3: The hyperparameter space of LSTM on PTB dataset.
Architecture Name Type Range
VGG 10cmnumber of first convolution kernels discrete [8, 32]
10cmnumber of second convolution kernels discrete [32, 64]
10cmnumber of third convolution kernels discrete [64, 128]
10cmnumber of forth convolution kernels discrete [64, 128]
10cmnumber of neurons in fully connected layer discrete [10, 1000]
10cmsquare length of convolution kernel discrete [2, 3]
learning rate continuous 10cm[0.0001, 0.4]
(log scale)
L2 regularization factor continuous [0.0, 1.0]
activation function type categorical 10cmReLU, tanh,sigmoid, eLU
regularization method categorical 10cmNone, Dropout, BatchNorm
Table C4: The hyperparameter space of VGGNet on CIFAR100 dataset.

Surrogate configurations

The performance of an HPO algorithm for a specific task is not deterministic. For example, GP-EI would output a different result for each trial of hyperparameter optimization. Therefore, repeated experiments are necessary to estimate the ‘success rate’ and ‘expected time’ to success in a credible way. However, each trial of a single HPO run requires a considerable number of DNN trainings (typically a few hundreds of DNN trainings), and thus it would be extremely time-consuming to repeat the experiments over multiple algorithms. In this regard, Eggensperger, Hutter, Hoos, and Leyton-Brown [2015] suggest that surrogate benchmarks are cheaper to evaluate and closely follow real-world benchmarks.

Architecture LeNet1 LeNet2 LSTM VGG ResNet VGG
Total evaluation time (day) 88.1 55.5 87.3 75.2 385 82.1
Mean evaluation time (min) 6.3 4 6.3 5.4 79 5.9
Global optimum (top accuracy) 0.9939 0.9941 0.9008 0.8052 0.9368 0.5067
Target performance (top-10 accuracy) 0.9933 0.9922 0.8993 0.7836 0.9333 0.4596
Table C5: Statistics of pre-evaluated configurations.

To utilize surrogate benchmarks, we pre-selected a representative set of model configurations, pre-evaluated all the selected configurations, and saved their DNN training results (including the evaluated test performance and the consumed time) into a database. This process takes some time to complete because we need to complete DNN trainings of all the configurations. In our case, we had 20,000 configurations for five benchmarks and 7,000 for the other, and thus a total of 107,000 configurations worth of DNN training had to be completed for the six benchmarks. However, once completed, we were able to repeatedly perform HPO experiments using the database without requiring to resort to actual DNN evaluations every time they were necessary. With the pre-generated database, proper book-keeping can be performed to expedite the experiments. Using this methodology, we were able to evaluate each HPO algorithm 100 times for each benchmark task.

In order to select ‘a representative set of configurations’, we used Sobol sequencing method to choose the configurations. Sobol is a quasi-random low-discrepancy sequence in a unit hypercube, and its samples are known to be more evenly distributed in a given space than those from uniform random sampling. We set an appropriate range for each hyperparameter. Here, each range can be a real interval or a bounded set of discrete/categorical values. Then, if we were to say that we are concern with of hyperparameters, we cast this truncated hyperparameter space into a -dimensional unit hypercube and generate a Sobol sequence within the hypercube. Finally, we train DNN for all configurations sampled by Sobol grids and save the necessary information such as respective training time and prediction accuracy. We collected these training results for six benchmarks on machines with NVIDIA 1080 TI GPU.

Hyperparameter configuration of BOHB

Hyperparameter configurations for the MNIST-LeNet1 benchmark were applied with a minimum budget 1 and maximum budget 81. Other hyperparameters used for BOHB in our experiments are as follows; the scaling parameter is 3, the number of samples used to optimize the acquisition function is 64, the fraction of purely random configuration is 0.33, the minimum budget is 1, the maximum budget is 15.

Hyperparameters, except the minimum and maximum budgets, followed the parameters used for the MNIST dataset in Falkner et al. [2018]. We were able to observe comparable results with those produced in the parameter settings provided by Falkner et al. [2018] when we experimented with the algorithm in our environmental settings by changing its hyperparameters for the given minimum and maximum budgets.

For the PTB-LSTM benchmark, we also used the hyperparameter configuration with minimum budget 1, maximum budget 15 and the scaling parameter as 3. For the CIFAR10-ResNet benchmark, the hyperparameters were applied with a maximum budget of 100 and the scaling parameter as 3. Other hyperpaprameters are the same as above.

Appendix D. Benchmark Performance

Using single processor

Table B3 summarizes the performances of six individual algorithms and the diversification algorithms for the six benchmarks.

Two types of performance metrics, success rate and expected time, were evaluated and those that performed best were shown in bold. For both metrics, the target performance was set as the lower bound of top-10 best performances found among the pre-evaluated results. All algorithms run until the best performance currently outperform the top-10.

As for the success rate using a single processor, we list the success rate after 12 hours for MNIST-LeNet, and PTB-LSTM, because most algorithms’ average time for success is less than 12 hours. For a similar reason, the success rate after 6 hours is considered for CIFAR10-VGG and CIFAR100-VGG. In the case of CIFAR10-ResNet, we list the success rate after 90 hours. Note that the success rate listed in Table D1 are cross-sectional snapshots of Figure 2 that show the time series of success rates. On the mean performance of all benchmarks, the success rate of DEEP-BO was 12% superior to RF-PI, which was the best among the other algorithms. DEEP-BO achieved 31% of average improvements over the early-termination-disabled individual algorithms. DEEP-BO is also 25% better than GP-EI-MSR or GP-Hedge when compared to the other advanced algorithms. Compared to random, the baseline algorithm, it’s improved by 85%.

Regarding expected time, DEEP-BO achieved 60% of time reductions over the early-termination-disabled individual algorithms. DEEP-BO decreased 6.5 hours compared to the second fastest GP-EI-MSR.

MNIST-LeNet1 (12h) 34% 34% 29% 48% 61% 41%
MNIST-LeNet2 (12h) 49% 29% 48% 63% 57% 65%
PTB-LSTM (12h) 89% 83% 86% 68% 92% 89%
CIFAR10-VGG (6h) 50% 43% 46% 77% 77% 75%
CIFAR10-ResNet (90h) 91% 86% 92% 69% 89% 86%
CIFAR100-VGG (6h) 87% 81% 79% 96% 98% 97%
Mean 67% 59% 63% 70% 79% 76%
Measure Benckmark Random GP-Hedge GP-EI-MSR RF-EI-LCE BOHB DEEP-BO
MNIST-LeNet1 (12h) 7% 32% 32% 36% 12% 81%
MNIST-LeNet2 (12h) 12% 39% 48% 54% 1% 82%
PTB-LSTM (12h) 3% 85% 89% 41% 29% 100%
CIFAR10-VGG (6h) 5% 53% 48% 78% 0% 80%
CIFAR10-ResNet (90h) 7% 91% 94% 0% 4% 100%
CIFAR100-VGG (6h) 2% 92% 85% -% 4% 100%
Mean 6% 66% 66% 42% 8% 91%
Table D1. Summary of single processor performance achieving top-10 accuracy.
(c) MNIST-LeNet1
(d) MNIST-LeNet2
(e) PTB
(g) CIFAR10-ResNet
(h) CIFAR100-VGG
Figure D1. Success rate to achieve over the top-10 error performance using a single processor(higher is better).
(i) ~1h
(j) 1~12h
Figure D2-1. HPO performance comparison of MNIST-LeNet1 benchmark(lower is better). Note that the shaded areas are 0.25 error bars.
(k) ~1h
(l) 1~9h
Figure D2-2. HPO performance of MNIST-LeNet2 benchmark.
(m) ~1h
(n) 1~12h
Figure D2-3. HPO performance of PTB-LSTM benchmark.
(o) ~1h
(p) 1~12h
Figure D2-4. HPO performance of CIFAR10-VGG benchmark.
(q) ~12h
(r) 12~78h
Figure D2-5. HPO performance of CIFAR10-ResNet benchmark.
(s) ~1h
(t) 1~12h
Figure D2-6. HPO performance of CIFAR100-VGG benchmark.

Using 6 parallel processors

MNIST-LeNet1 (2h) 15% 9% 13% 32% 58% 30% 15% 80%
MNIST-LeNet2 (2h) 39% 17% 38% 44% 56% 46% 41% 95%
PTB-LSTM (2h) 45% 68% 52% 24% 63% 35% 60% 95%
CIFAR10-VGG (1h) 32% 43% 39% 40% 48% 32% 50% 75%
CIFAR10-ResNet (15h) 61% 59% 70% 37% 58% 55% 81% 99%
CIFAR100-VGG (1h) 30% 25% 37% 51% 59% 47% 43% 99%
Mean 37% 37% 42% 38% 57% 41% 48% 91%
Mean 5.5 6.5 5.0 5.2 4.1 4.4 3.7 2.0
Table D3. Summary of the 6 processors performance achieving top-10 accuracy.

As shown in Table D3, our algorithm can complete the tasks in merely 2 hours on average using 6 processors. On the mean performance of all benchmarks, the success rate of DEEP-BO was 34% superior compared to RF-PI and the expected time decreased by 2.1 hours. Regarding success rate, DEEP-BO achieved 117%, 88% of average improvements over the individual BO algorithms and ETR-applied algorithm, respectively. Regarding expected time, DEEP-BO achieved 60%, 44% of time reductions over the individual algorithms or the ETR-applied algorithm, respectively.

(u) MNIST-LeNet1
(v) MNIST-LeNet2
(y) CIFAR10-ResNet
(z) CIFAR100-VGG
Figure D3. Success rate to achieve over the top-10 error performance when using six processors.

Extra comparisons

For fair comparison with HB, we have run the regression sample provided by a HB implementation. See

Figure D4. HPO of Regression model on kin8nm dataset.

For fair comparison with BOHB, we have run the sample code provided by BOHB’s author. This example aims to demonstrate how to use the BOHB to tune the hyperparameter of the classification model learned with MNIST data. Its hyperparameter space has 9-dimensional space which consists of 5 discrete, 3 continuous, and 1 categorical variable respectively. See for details.

(aa) Easy target (5% error)
(ab) Hard target (1% error)
(ac) Best error performance
Figure D5. Performance comparison on a benchmark problem provided by BOHB.

As shown in Figure D5, our DEEP-BO outperforms BOHB and TPE. However, BOHB could not achieve any better result compared with TPE. This experiment was repeated 30 times to get a statistically significant result(F-statistics is 13.18, p-value is 1e-05). We will discuss later why BOHB failed catastrophically in DNN problem.

Performance on the number of hyperparameters

Eggensperger et al. [2013] summarize the performance characteristics of 3 HPO algorithms(Spearmint, SMAC, TPE) which are used widely. Spearmint which models using GP tends to be better in the low-dimensional continuous problem. Instead, SMAC and TPE tend to be better in the high-dimensional problem. Afterall, Figure C6 shows that our diversification strategy always performs well at any dimensional problem.

(ad) 4 continuous parameters
(ae) 17 discrete, continuous, categorical parameters
Figure D6. Performance comparisons when optimizing the different dimensional problem. We created this problem to evaluate BO algorithms only for the dimension size issue by decreasing or increasing the number of hyperparameters of CIFAR10-VGG benchmark problem.

Performance by max epochs setting

Figure D7. Performance comparisons when the number of max epochs is increased. We evaluated our algorithm on the sample code provided by BOHB’s author. Our DEEP-BO always perform better than BOHB. In the case of this problem, the asymptotic performance tends to achieved when 6 hours later. Too small or too much max epoch tends to be ineffective to achieve the target goal in a given budget.

In DNN HPO problems, setting proper max epochs of training is very important to find their optimal performance. Because of no way of predicting the optimal number of epochs before evaluated, this remains an art of human experts. If we have a lack of prior knowledge about the problem to optimize, too few or too much of max epochs tends to bring unexpected results even after spending much expense. Therefore, escalating the target performance is required by considering the budget.