M ULTI - OBJECTIVE N EURAL A RCHITECTURE S EARCH VIA P REDICTIVE N ETWORK P ERFORMANCE O PTIMIZATION
Anonymous authors
Paper under double-blind review
A BSTRACT
Neural Architecture Search (NAS) has shown great potentials in ﬁnding a better neural network design than human design.
Sample-based NAS is the most fundamental method aiming at exploring the search space and evaluating the most promising architecture.
However, few works have focused on improving the sampling efﬁciency for a multi-objective NAS.
Inspired by the nature of the graph structure of a neural network, we propose BOGCN-NAS, a NAS algorithm using Bayesian Optimization with Graph Convolutional Network (GCN) predictor.
Speciﬁcally, we apply GCN as a surrogate model to adaptively discover and incorporate nodes structure to approximate the performance of the architecture.
For
NAS-oriented tasks
, we also design a weighted loss focusing on architectures with high performance.
Our method further considers an efﬁcient multi-objective search which can be ﬂexibly injected into any sample-based NAS pipelines to efﬁciently ﬁnd the best speed/accuracy trade-off.
Extensive experiments are conducted to verify the effectiveness of our method over many competing methods, e.g. 128 .
4 × more efﬁcient than Random Search and 7 . 8 × more efﬁcient than previous SOTA LaNAS for ﬁnding the best architecture on the largest NAS dataset
NASBench-101.
I NTRODUCTION
Recently Neural Architecture Search (NAS) has aroused a surge of interest by its potentials of freeing the researchers from tedious and time-consuming architecture tuning for each new task and dataset.
Speciﬁcally, NAS has already shown some competitive results comparing with hand-crafted architectures in computer vision: classiﬁcation (Real et al., 2019b), detection, segmentation (Ghiasi et al., 2019;
Chen et al., 2019; Liu et al., 2019a) and super-resolution (Chu et al., 2019).
Meanwhile,
NAS has also achieved remarkable results in natural language processing tasks (Luong et al., 2018;
So et al., 2019).
A variety of search strategies have been proposed, which may be categorized into two groups: oneshot NAS algorithms (Liu et al., 2019b; Pham et al., 2018; Luo et al., 2018), and sample-based algorithms (Zoph & Le, 2017; Liu et al., 2018a;
Real et al., 2019b).
One-shot NAS algorithms embed the architecture searching process into the training stage by using weight sharing, continuous relaxation or network morphisms.
However, those methods cannot guarantee the optimal performance of the ﬁnal model due to those approximation tricks and is usually sensitive to the initial seeds (Sciuto et al., 2019).
On the other hand, sample-based algorithms are relatively slower but reliable.
They explore and exploit the search space using some general search algorithms by providing potential candidates with higher accuracy.
However, it requires fully training of huge amounts of candidate models.
Typically, the focus of most existing NAS methods has been on the accuracy of the ﬁnal searched model alone, ignoring the cost spent in the search phase.
Thus, the comparison between existing search algorithms for NAS is very difﬁcult.
(Wang et al., 2019b) gives us an example of evaluating the NAS algorithms from this view.
They compare the number of training architectures sampled until ﬁnding the global optimal architecture with the top accuracy in the NAS datasets.
Besides accuracy, in real applications, there are many other objectives we should concern, such as speed/accuracy trade-off.
Hence, in this paper, we aim at designing an efﬁcient multi-objective NAS algorithm to adaptively explore the search space and capture the structural information of architectures related to the performance.
The common issue faced by this problem is that optimizing objective functions is computationally expensive and the search space always contains billions of architectures.
To tackle this problem, we present BOGCN-NAS, a NAS algorithm that utilizes Bayesian Optimization (BO) together with
Graph Convolutional Network (GCN).
BO is an efﬁcient algorithm for ﬁnding the global optimum of costly black-box function (Mockus et al., 1978).
In our method, we replace the popular Gaussian Processes model with a proposed GCN model as the surrogate function for BO (Jones, 2001).
We have found that GCN can generalize fairly well with just a few architecture-accuracy pairs as its training set.
As BO balances exploration and exploitation during searching and GCN extracts embeddings that can well represent model architectures, BOGCN-NAS is able to obtain the optimal model architecture with only a few samples from the search space.
Thus, our method is more resource-efﬁcient than the previous ones.
Graph neural network has been proposed in previous work for predicting the parameters of the architecture using a graph hypernetwork (Zhang et al., 2019).
However, it’s still a one-shot NAS method and thus cannot ensure the performance of the ﬁnal found model.
In contrast, we use graph embedding to predict the performance directly and can guarantee performance as well.
The proposed BOGCN-NAS outperforms current state-of-the-art searching methods, including Evolution (Real et al., 2019b), MCTS (Wang et al., 2019b), LaNAS (Wang et al., 2019a).
We observe consistent gains on multiple search space for CV and NLP tasks, i.e., NASBench-101 (denoted NASBench)
(Ying et al., 2019) and LSTM-12K (toy dataset).
In particular, our method BOGCN-NAS is 128 .
4 × more efﬁcient than Random Search and 7 . 8 × more efﬁcient than previous SOTA LaNAS on
NASBench (Wang et al., 2019a).
We apply our method to multi-objective NAS further, considering adding more search objectives including accuracy and number of parameters.
Our method can ﬁnd more superior Pareto front on NASBench.
Our algorithm is applied on open domain search with NASNet search space and ResNet Style search space, which ﬁnds competitive models in both scenarios.
The results of experiment demonstrate our proposed algorithm can ﬁnd a more competitive Pareto front compared with other sample-based methods.
R ELATED W ORK 2. B AYESIAN O PTIMIZATION
Bayesian Optimization aims to ﬁnd the global optimal over a compact subset X
(here we consider maximization problem):
[Equation]
Bayesian Optimization considers prior belief about objective function and updates posterior probability with online sampling.
Gaussian Processes (GPs) is widely used as a surrogate model to approximate the objective function (Jones, 2001).
And Expected Improvement acquisition function is often adopted (Mockus et al., 1978).
For the hyperparameters of the surrogate model Θ , we deﬁne
[Equation]
where µ ( x ; D , Θ) is the predictive mean, σ 2 ( x ; D , Θ) is the predictive variance and f ( x best ) is the maximal value observed.
The Expected Improvement (EI) criterion is deﬁned as follows.
[Equation]
where N ( · ; 0 , 1) is the probability density function of a standard normal and Φ( · ; 0 , 1) is its cumulative distribution.
2. M ULTI - OBJECTIVE O PTIMIZATION
Without loss of generality about max or min , given a search space X and m ≥ 1 objectives f 1 :
X → R , . . .
, f m : X → R , variable X 1 ∈ X dominates variable X 2 ∈ X (denoted X 1 (cid:31) X 2 ) if (i)
f i ( X 1 ) ≥ f
i
X 2 ) , ∀ i ∈ { 1 , . .
, m } ; and (ii)
f j ( X 1 ) >
f j ( X 2 ) for at least one j ∈ { 1 , . . .
, m } .
X ∗ is Pareto optimal if there is no X ∈ X that domaines X ∗ .
The set of all Pareto optimal architectures consitutes the Pareto front P f .
A multi-objective optimization problem (MOP) aims at ﬁnding such input X ∈ X that X cannot be dominated by any variable in X (Marler & Arora, 2004).
2. G RAPH C ONVOLUTIONAL N ETWORK
Let the graph be G =
( V, E ) , where V is a set of N nodes and E is the set of edges.
Let its adjacency matrix be A and feature matrix be X .
The graph convolutional network (GCN) is a learning model for graph-structure data (Kipf & Welling, 2016).
For a L -layer GCN the layer-wise propagation rule is given by:
[Equation]
where (cid:101)
A =
A + I , I is the identity matrix, (cid:101) D is a diagonal matrix with (cid:101) D ii =
(cid:80) Nj =
1 A ij , H ( l ) and W ( l ) are the feature map and weight at the l -th layer respectively, and ReLU ( · ) is the ReLU activation function.
H (0) is the original feature matrix X , and H ( L ) is the graph embedding matrix.
BOGCN-NAS
To search for the optimal architecture more efﬁciently, we proposed BOGCN-NAS by using predictive network performance Optimization with the GCN (Section 3.2) while utilizing the Bayesian
Optimization.
Figure 1 shows the overview of the proposed algorithm.
3. M ULTI - OBJECTIVE NAS
We formulate NAS problem as a multi-objective optimization problem over the architecture search space A where objective functions can be accuracy, latency, number of parameters, etc.
We aim to ﬁnd architectures on the Pareto front of A .
Speciﬁcally, when m = 1 , it reduces to single-objective (usually accuracy) NAS and the corresponding Pareto front reduces to one optimal architecture.
3. GCN P REDICTOR
GCN predictor predicts the performance (like accuracy) of an architecture.
Compared with MLP and
LSTM predictors proposed before (Wang et al., 2019b), GCN can preserve the context of graph data better.
Another important characteristic of GCN is its ability to handle variable number of nodes, while an MLP cannot take a larger architecture as the input.
Even though the LSTM can handle variable-length sequences, its performance is not competitive because of the ﬂat string encoding.
A neural network can be viewed as a directed attributed graph, in which each node represents an operation (such as convolution operation) and each edge represents a data ﬂow.
As a concrete illustration, we use the architectures in the NASBench dataset (Ying et al., 2019) as an example.
The idea can be easily extended to other architectures.
In NASBench, each architecture is constituted by stacking multiple repeated cells.
Thus, we will focus on searching the cell architecture.
An example cell in NASBench is illustrated on the left side of Figure 1, where “input” represents the input of the cell, “output” represents the output of the cell, “ 1 × 1 Conv, 3 × 3 Conv, Max Pooling” are three different operations (5 operations totally).
We propose to encode the cell into an adjacency matrix A (asymmetric) and a feature matrix X , as the input of our GCN predictor.
Note that the vanilla GCN only extracts the node embeddings, while we want to obtain graph embedding.
Following (Scarselli et al., 2008), we add a global node to the original graph of the cell and let every node point at the global node.
The adjacency matrix can be obtained directly from the graph structure.
For the feature matrix, we use the one-hot coding scheme for each operation.
Besides the original 5 different operations deﬁned in NASBench, we add another operation (global node) into coding scheme.
We feed A and X to a multi-layer GCN model to obtain the embedding of every node H ( L ) by (Eq.
For high-level prediction, we leave original nodes out and take the embedding of global node solely because it already has the overall context of the architecture.
Followed by one fully-connected layer with sigmoid activation function, we can get the predicted accuracy.
In training phase, we use
MSE loss for regression optimization.
3. I NCORPORATING BO INTO GCN
Bayesian Optimization is an efﬁcient model for search and optimization problems, which considers balancing both exploitation and exploration balanced.
It depends on updating the posterior distribution with the samples drawn from the search space based on one cheap surrogate model.
GPs is one of the most popular choices because Gaussian distribution is self-conjugate such that a posterior distribution is also the same form as the prior.
(Kandasamy et al., 2018) and (Jin et al., 2019)
both deﬁne the heuristic distance between neural architectures and use GPs with deﬁned distence for searching.
However, since the computation increases cubically with the number of samples (Snoek et al., 2015), GPs is so costly for NAS problem, whose search space is always huge.
Another drawback for GPs is that it cannot handle graph-data directly without a special encoding scheme.
In this work, we replace the popular surrogate model with our GCN predictor and take the uncertainty into consideration.
Inspired by previous work (Snoek et al., 2015), we train the GCN predictor ﬁrst with the trained architecture set D containing architectures { ( A i , X i ) } ni =1 with their actual performances { t i } ni =1 , , then during searching, we replace the last fully connected layer with Bayesian Linear Regressor (BLR) for Bayesian estimation and retain GCN related layers for point estimation.
We only consider the uncertainty of the weights on the last fully-connected layer.
We denote the embedding function of global node by φ ( · , · ) =
[ φ 1 ( · , · ) , φ 2 ( · , · ) , ..., φ d ( · , · )] T .
We can get the embedding of every architecture φ ( A i , X i ) from the trained architecture set D and treat them as the basis functions for
BO.
For clarifying, we deﬁne Φ to be the design matrix where Φ ij = φ j
( A i , X i ) .
Different from typical Bayesian Linear Regression (BLR) (Bishop, 2006), the ﬁnal layer of our GCN predictor contains non-linear activation function.
Here we use the inverse function trick to avoid the non-trivial variant.
Without ﬁtting the true accuracy t , we prefer to estimate the value before the activation function logit ( t ) such that we can convert non-linear regression to linear regression problem.
The key of BO is the order of the acquisition function over all sampled architectures rather than true values.
Due to the monotonicity of sigmoid function, the order property still holds.
The predicted mean and variance given by our model without the last activation function are shown below.
[Equation]
where
[Equation]
Here, α, β are precisions of the prior, which are hyperparameters of the Bayesian Optimization model.
We can estimate them by maximizing the log marginal likelihood as following (Snoek et al., 2012).
[Equation]
3. S EARCH WITH A LTERNATE L EARNING
NAS is a process of online learning during which we can utilize new fully-trained architectures sampled from the search space.
Therefore, the GCN model and BLR in BOGCN-NAS should be updated with the increasing number of samples for better generalization.
In this work, for the reason that GCN retraining is more expensive than BLR updating, we update BLR more frequently than
GCN predictor.
The algorithm of our proposed BOGCN-NAS is illustrated in Algorithm 1.
Given the search space
A , we initialize trained architecture sets U containing architectures ( A i , X i ) with their performance t i = { f 1 i , . . .
, f mi } .
We train GCN predictor ﬁrstly with U and replace the last fully-connected layer with BLR described in Section 3.3.
Then we randomly sample a subspace R as following candidate pool if A is such huge that we cannot cover every architecture.
After obtaining the candidate pool, we can calculate every candidate model’s Expected Improvement as their estimated objective values ˆ t j = { ˆ f 1 j , . . .
, ˆ f mj } .
Based on ˆ t j and multi-objective formulation (Section 3.1), we can generate a estimated Pareto Front and sample estimated Pareto optimal models as set S and fullytrain them to obtain the true objective values t j .
The trained architecture sets is then updated by
U =
U ∪ S .
Accumulating a certain amount of new data, we update GCN and BLR alternately for next periodic sampling until satisfying the stop criteria.
3. E XPONENTIAL W EIGHTED L OSS
For GCN predictor alone, MSE loss can achieve competitive performance for ﬁtting all data.
However, when it comes to the surrogate function for ﬁnding the top-performance model, we should pay more attention to architectures with high performance compared to others.
In the search phase of BO, we select samples with top values of acquisition function.
Speciﬁcally, we expect to predict architectures with high performance as accurately as possible, while distinguishing low-performance architecture is sufﬁcient for our purpose.
For adapting NAS task, we propose Exponential Weighted Loss for the surrogate GCN model and replace common MSE loss with weighted loss completely in Algorithm 1.
[Equation]
here y i is the predicted accuracy, (cid:101)
y i is the ground truth and e − 1 is normalization factor ( e is the base of the natural logarithm).
Thus, our predictor will focus on predicting for those models with higher accuracy.
E XPERIMENT
Dataset and Search Space
In this section, we validate the performance of the proposed BOGCNNAS on NASBench (Ying et al., 2019).
This is the largest benchmark NAS dataset for computer vision task currently, with 420 K architectures.
To show the generalization of our method, we collect 12 K LSTM models trained on PTB dataset (MARCUS et al., 1993) aiming at NLP task.
We also compare our method in open domains with NASNet search space (Zoph et al., 2018) and ResNet style search space (Li et al., 2019).
We will provide the detail of the search space and collection method in Appendices Section.
Speciﬁcally, we prove the performance of single proposed GCN Predictor ﬁrstly and then validate the whole framework on single-objective/multi-objective search problems compared with other baselines (with default settings).
The results of the experiment illustrate the efﬁciency of BOGCNNAS.
4. C OMPARISON OF INDIVIDUAL PREDICTORS
We use a four-layer GCN, with 64 hidden units in each layer, as the surrogate model for BO.
During training, we use the Adam optimizer (Kingma & Ba, 2014), with a learning rate of 0.001 and a minibatch size of 128 .
The proposed GCN predictor is compared with an MLP predictor and LSTM predictor (Liu et al., 2018a;
Wang et al., 2019b).
Here we apply MSE loss because we compare the stand-alone predictors, while we replace with Exponential Weighted Loss for subsequent NAS problems.
For the evaluation metric, we follow (Wang et al., 2019b) and use the correlation between the predicted accuracy and true accuracy.
One difference between our evaluation method and (Wang et al., 2019b) is that we compare predictor’s performance training on fewer architectures rather than whole search space, because NAS start with little training data and we cannot train such a large number of architectures in practice.
We used 1000 architectures in NASBench for training,architectures for validation, and 10000 architectures for testing.
Table 1 shows the correlation result of various predictors and the number of predictors’ parameters.
The prediction result of three predictors is also illustrated in Figure 2 and the value means the [Figure]
It can be found that our GCN predictor has better correlation performance than the competing predictors.
Gaussian kernel-density estimation.
As can be seen, the GCN predictor can predict the performance of architectures more accurately than the other two predictors.
In addition, the GCN predictor has fewer parameters compared with them.
[Table]
[Table]
4. S INGLE - OBJECTIVE S EARCH
Single-objective (accuracy) search is a special case of multi-objective search.
For the proposed
BOGCN-NAS, we randomly sample 50 architectures to fully train and use them as the initial trained architecture sets, which is counted into the total sample numbers. Since the whole NASBench and
LSTM datasets can be inferred easily (less than 0.01s), we set R =
A in the experiment, which means we take total search space as the candidate pool. During the search phase, we use GCN to obtain embeddings and use the Bayesian regressor to compute EI scores for all architectures in the search domain, rank them based on the score and select the top ten models to fully train, obtain the accuracies and add them to trained architecture sets, update the best accuracy observed.
The process is repeated for k = 10 times.
The GCN predictor is then retrained with our updated trained architecture sets.
This is repeated until the target model is found over 50 rounds.
Note that GCN model is trained using Exponential Weighted Loss instead in NAS procedure.
BOGCN-NAS is compared with the following state-of-the-art sample-based NAS baselines: (i) Random Search, which explores the search space without performing exploitation; (ii) Regularized
Evolution (Real et al., 2019b), which uses heuristic evolution process for exploitation but is still constrained by the available human prior knowledge; (iii) Monte Carlo tree search (MCTS) (Wang et al., 2019b); and (iv) LaNAS (Wang et al., 2019a).
Both MCTS and LaNAS only estimate the performance of models in a coarse subspace, and then select models randomly in that subspace.
In contrast, Bayesian optimization conducts a more ﬁne-grained search and predicts the expected improvement of candidate pool.
Figure 3 and Table 2 show the number of samples until ﬁnding the global optimal architecture using different methods.
The proposed algorithm outperforms the other baselines consistently on the two different datasets.
On NASBench, BOGCN-NAS is 128 . 4 × , 59 .
6 × , 50 .
5 × , 7 . 8 × more sample-efﬁcient than Random Search, Regularized Evolution, MCTS and LaNAS respectively.
On the smaller NLP dataset, BOGCN-NAS can still search and ﬁnd the optimal architecture with fewer samples. [Figure]
We predict all architectures ( 420 K 12 K ) together on NASBench and LSTM dataset because the cost of inference all once is negligible. For larger search space, we can use sampling methods as mentioned in Section 3.4 instead. In every iteration, we randomly sample a subset architectures R as candidate pool from the search space A for performance prediction and select top models among this pool.
The performance of BOGCN versus the pool sampling ratio ( |R| / |A| ) is shown in Table 3.
As can be seen, the overall performance of our BOGCN can still ﬁnd the optimal model with less samples compared with other baselines.
Even though random sampling is good enough, an alternative sampling method can be Evolutionary Algorithm.
[Table]
In this section, we focus on multi-objective (accuracy and number of parameters) search.
As the same settings of BOGCN-NAS with Section 4.2, the only difference is the criteria for updating the best architecture observed.
Here we extend baselines in Section 4.2 to multi-objective form for comparison.
In detail, we sample 2 , 000 architectures in total and compare the found Pareto front (cid:102) P f with the optimal Pareto front P f on NASBench dataset.
As shown in Figure 4a, the grey dots are the overall architectures of NASBench, the red dots are samples selected by BOGCN and the blue dots are architectures undominated by our selected samples.
Based on them, we can make sure the respective Pareto fronts - the green dashed line is the optimal Pareto front and the red dashed line is the estimated Pareto front.
Figure 4b shows the Pareto fronts estimated by different algorithms, which demonstrates the superiority of BOGCN mothod.
Compared with other baselines, the models sampled by our method are gathered near the optimal
Pareto front, and the found Pareto front is also closer to the optimal Pareto front.
This validates the efﬁciency of our algorithm on this multi-objective search task.
4. O PEN DOMAIN S EARCH
In this section, we validate the propose method on the open domains - NASNet search space and ResNet style search space (described in Appendices Section). Since the size of open domain is [Figure]
enormous, we set the size of R equals to 1 M every iteration for both search spaces.
And the found architectures by BOGCN-NAS can be found in Appendices Section. 4.4. NASN ET SEARCH SPACE For NASNet search space, we consider single-objective (accuracy) search on Cifar-10. For efﬁciency, we train the sampled architectures by early stopping at 100 epochs rather than fully training.
It’s remarkable that we stop the algorithm after a certain number of samples | S | rather than until ﬁnding the optimal architecture beacuse we don’t know the optimal architecture and the open domain contains billions of architectures.
And other experiment settings are the same with Section 4.
as well.
We pick two best performing architectures V1 and V2 within 200 and 400 samples respectively and fully train them.
Table 2 compares our results with other baselines on CIFAR-10.
As can be seen, even though one-shot NAS methods don’t need any architecture evaluated directly, the performance of the ﬁnal found models is not as good as sample-based methods averagely.
Compared with other sample-based NAS method, BOGCN outperforms all methods except for AmoebaNet-B, which costs 67 .
5 × more evaluating samples.
[Table]
DARTS
[Table]
cutout (Liu et al., 2019b)
[Table]
BayesNAS+cutout (Zhou et al., 2019)
[Table]
ASNG-NAS+cutout (Akimoto et al., 2019)
[Table]
BOGCN
[Table]
[Table]
4.4. R ES N ET STYLE SEARCH SPACE
For ResNet style search space, we validate the proposed method for multi-objective search on ImageNet (Deng et al., 2009).
Here we consider classiﬁcation accuracy and the number of parameters of the model at the same time.
Due to the large volume of the dataset, we train the sampled architectures by early stopping at 40 epochs rather than fully training. And other experiment settings are the same with Section 4.3 as well. [Figure] Compared with Random Sampling, BOGCN-NAS achieves a more competitive Pareto front.
The accuracy and number of parameters of the sampled model are illustrated in Figure 5.
Compared to random sampling, BOGCN-NAS achieves a more competitive Pareto front.
We fully train every model on the estimated Pareto front and pick three models (M1, M2, M3), which can dominate
ResNets. The comparison of our found models and famous ResNet family models are shown in Figure 5b.
It shows that ResNets can be dominated by our found models seriously.
4. S EARCH S PCAE E XTENSION T RANSFER
In this section, we discover the ability of our proposed algorithm on search spcae extension transfer.
Most NAS algorithms only focus on static search space.
In contrast, how to adapt the methods for extension of search space is still an open problem.
For instance, after searching in one small search space A 1 , how to transfer the obtained knowledge to a larger search space A 2 .
For validation, we split NASBench into two sub-datasets: architectures with 6 nodes ( 62 K ) and architectures withnodes ( 359 K ).
Using the same settings with Section 4.2, we pretrained our GCN model on architectures withnodes and then transfer the GCN predictor to searching on the architecture domain with 7 nodes.
For comparison, we run the same algorithm without pretraining.
The search method with pretrained
GCN predictor ﬁnds optimal model after 511.9 samples while the method without pretraining needs 1386.4 samples.
As can be seen, pretraining can reach the optimal model 2 .
7 × more efﬁciently than unpretrained, validating the transfer ability of GCN predictor.
Thus, BOGCN-NAS can handle different-scale architectures as long as their operation choices are the same.
C ONCLUSION
In this work, we propose BOGCN-NAS, a multi-objective NAS method using Bayesian Optimization with Graph Convolutional Network predictor.
We formulate the problem as a multi-objective optimization problem and utilize the efﬁciency of BO to search top-performance architectures.
Instead of using popular Gaussian Processes surrogate model, we replace it with proposed GCN predictor such that graph-based structure can be preserved better.
For NAS-speciﬁc tasks, we also propose weighted loss focusing on top-performance models.
Experimental results show that the proposed algorithm outperforms the SOTA LaNAS on single-objective NAS and validate its efﬁciency on multi-objective NAS as well
Appendices A A BLATION S TUDY A. T HE ADVANTAGE OF GCN P REDICTOR AND B AYESIAN O PTIMIZATION
To verify that GCN is a superior choice of predictor against others (e.g. MLP, RNN), we replaced GCN in the search algorithm with MLP predictor.
And for demonstrating that Bayesian Optimization indeed improves the performance of our search algorithm, we also remove BLR and use point estimation only.
In other words, we select candidate models based only on GCN’s predictive accuracies of architectures.
Therefore, there are four different models correspondingly: (1) MLP; (2) BOMLP; (3) GCN; (4) BOGCN, where MLP, GCN use predictor only for model selection and BOMLP, BOGCN apply Bayesian Optimization on the strength of respective predictor.
With other settings same with with Section 4.2, we perform single-objective NAS algorithms over 50 rounds and the results of experiments on NASBench and LSTM datasets are shown in Figure 6. As can be seen, GCN is able to discover the optimal architecture with fewer samples than MLP, which proves the superiority of GCN predictor and our algorithm is more efﬁcient with Bayesian Optimization.
[Figure]
The comparison shows that the efﬁciency of the search can be boosted by adding Bayesian optimization and Graph Convolutional Network modules respectively.
A. T HE IMPROVEMENT OF E XPONENTIAL W EIGHTED L OSS
To prove the improvement of our proposed weighted loss empirically, we compare it with MSE loss.
We also design other two weighted losses as following to show the inﬂuence of the second-order derivative of added weight.
We apply the same settings with Section 4.2 for algorithm performing and the experiment result of single-objective (accuracy) on NASBench is shown in Figure 7.
As can be seen, exponential weighted loss outperforms other three losses, which is consistent with our intuition.
[Equation]
[Figure]
B S UPPLEMENTAL E XPERIMENTS B. T IME COURSE PERFORMANCE COMPARISON
Following (Wang et al., 2019b;a), besides comparing the number of training architectures sampled until ﬁnding the global optimal architecture, we also evaluate the current best models during the searching process.
As shown in Figure 8, our proposed BOGCN-NAS outperform other search algorithms except for the very beginning on LSTM model searching.
[Figure]
B. P REDICTOR TRAINING ON WHOLE SEARCH SPACE
For comparison with previous work (Wang et al., 2019b), we also train our GCN predictor on whole
NASBench dataset ( 420 K models)
(Ying et al., 2019).
We use 85% NASBench for training, 10% for validation and remaining 5% for testing.
As shown in Figure 9 (the value also means the density of architectures around), GCN outperforms others consistently with experiment training on fewer data (Section 4.1).
Even though the correlations of the GCN and MLP are comparable here, the performance is less important than cases training on fewer data. [Figure]
[Figure]
C. LSTM-12K DATASET
To create LSTM model dataset, we follow the same setting proposed by ENAS (Pham et al., 2018), we use adjacency matrix and a list of operators to represent an LSTM cell, and randomly sampled 12K cell structures from that domain, because the cells have natural graph structures, it is easy to feed them directly into GCN and conduct training.
Due to the limitation on computational resources, we only sample architectures with number of nodes less than or equal to 8, and trained each cell for 10 epochs on PTB dataset (MARCUS et al., 1993).
We use perplexity as a performance measure for the cells.
C. NASN ET SEARCH SPACE
We follow the search space setting of DARTS (Liu et al., 2019b), in which the architecture is stacked by the learned cell.
The cell consists of 4 blocks, two inputs (the output of previous cell and the previous previous cell) and one output.
There are 8 types operations allowed: 3 × 3 and 5 ×separable convolutions, 3 × 3 and 5 × 5 dilated separable convolutions, 3 × 3 max pooling, 3 ×average pooling, identity, and zero.
Similar to previous work (Liu et al., 2018a), we apply the same cell architecture for both “normal” and “reduction” layer.
For adapting to proposed GCN predictor, we regard the operation as the node and regard the data ﬂow as the edge.
The encoding examples are illustrated in Appendices E.
C. R ES N ET STYLE SEARCH SPACE
We follow the setting of Li et al.
(2019) to prepare the ResNet style search space.
This search space aims to ﬁnd when to perform down-sampling and when to double the channels.
The ResNet style backbone consists of 5 stages with different resolutions from input images.
The spatial size of Stage 1 to 5 is gradually down-sampled by the factor of 2 .
As suggested in Li et al.
(2019), we ﬁxed one 3 × 3 convolution layer ( stride = 2 ) in Stage-1 and the beginning of Stage-2.
We use the block setting as bottleneck residual block in ResNet.
Then, the backbone architecture encoding string looks like “ 1211 − 211 − 1111 − 12111 ”, where “ − ” separates each stage with different resolution, “ 1 ” means regular block with no change of channels and “ 2 ” indicated the number of base channels is doubled in this block.
The base channel size is 64 .
In Section 4.4, we just take “ − , 1 , 2 ” as three different operations and encode architectures as a series of strings.
We train the model generated from this search space for 40 epochs with a fast convergence learning rate schedule.
Each architecture can be evaluated in 4 hours on one server with 8 V100 GPU machines.
D NAS R ELATED W ORK
NAS aims at automatically ﬁnding a neural network architecture for a certain task such as CV and
NPL (Chen et al., 2018; Liu et al., 2019a; Chen et al., 2019) and different datasets without human’s labor of designing networks.
Particularly, in real applications, the objective of NAS is more preferred to be obtaining a decent accuracy under a limited computational budget.
Thus a multi-objective NAS is a more practical setting than only focusing on accuracy.
There are several approaches in NAS area: 1) Reinforcement learning-based algorithm.
Baker et al.
; Zoph & Le (2017);
Cai et al.
(2018) train an RNN policy controller to generate a sequence of actions to design cell structure for a specify CNN architecture; 2) Evolution-based algorithm.
Real et al.
; Liu et al.
(2018b); Real et al.
(2019a) try to evolve architectures or Network Morphism by mutating the current best architectures and explore new potential models; 3) Gradient-based algorithm Liu et al.
(2019b);
Cai et al.
; Xie et al.
(2019) deﬁne an architecture parameter for continuous relaxation of the discrete search space, thus allowing differentiable optimization of the architecture.
4) Bayesian
Optimization-based algorithm.
(Kandasamy et al., 2018) and (Jin et al., 2019) deﬁne the heuristic distances between architectures and apply BO with Gaussian Processes.
Among those algorithms, most existing methods focus on a single objective (accuracy), others adding computation constraints as a regularization loss in the gradient-based method or as a reward in the RL-based algorithm.
In contrast, our method reformulates the multi-objective NAS as a non-dominate sorting problem and further enables an efﬁcient search over ﬂexible customized search space.
E B EST F OUND M ODELS E. NASN ET SEARCH SPACE
Figure 11a and 11c show the found architectures from the open domain search on NASNet search space by our method.
E. R ES N ET STYLE SEARCH SPACE
Figure 12, 13 and 14 show the found architectures from the open domain search on ResNet style search space by our method.
[Figure]