I NTERPRETABLE N EURAL A RCHITECTURE S
EARCH
VIA
B AYESIAN
O PTIMISATION
WITH
W EISFEILERL EHMAN K ERNELS
Anonymous authors
Paper under double-blind review
A
BSTRACT
Current neural architecture search (NAS) strategies focus only on ﬁnding a single, good, architecture.
They offer little insight into why a speciﬁc network is performing well, or how we should modify the architecture if we want further improvements.
We propose a Bayesian optimisation (BO) approach for NAS that combines the Weisfeiler-Lehman graph kernel with a Gaussian process surrogate.
Our method optimises the architecture in a highly data-efﬁcient manner: it is capable of capturing the topological structures of the architectures and is scalable to large graphs, thus making the high-dimensional and graph-like search spaces amenable to BO.
More importantly, our method affords interpretability by discovering useful network features and their corresponding impact on the network performance.
Indeed, we demonstrate empirically that our surrogate model is capable of identifying useful motifs which can guide the generation of new architectures.
We ﬁnally show that our method outperforms existing NAS approaches to achieve the state of the art on both closed- and open-domain search spaces.
I NTRODUCTION
Neural architecture search (NAS) aims to automate the design of good neural network architectures for a given task and dataset.
Although different NAS strategies have led to state-of-the-art neural architectures, outperforming human experts’ design on a variety of tasks (Real et al., 2017; Zoph and
Le, 2017; Cai et al., 2018; Liu et al., 2018a;b; Luo et al., 2018; Pham et al., 2018; Real et al., 2018;
Zoph et al., 2018a; Xie et al., 2018), these strategies behave in a black-box fashion, which returns little design insight except for the ﬁnal architecture for deployment.
In this paper, we introduce the idea of interpretable NAS, extending the learning scope from simply the optimal architecture to interpretable features.
These features can help explain the performance of networks searched and guide future architecture design.
We make the ﬁrst attempt at interpretable NAS by proposing a new NAS method, NAS-BOWL; our method combines a Gaussian process (GP) surrogate with the Weisfeiler-Lehman (WL) subtree graph kernel (we term this surrogate GPWL) and applies it within the Bayesian Optimisation (BO) framework to efﬁciently query the search space.
During search, we harness the interpretable architecture features extracted by the WL kernel and learn their corresponding effects on the network performance based on the surrogate gradient information.
Besides offering a new perspective on interpratability, our method also improves over the existing
BO-based NAS approaches.
To accommodate the popular cell-based search spaces, which are noncontinuous and graph-like (Zoph et al., 2018a;
Ying et al., 2019; Dong and Yang, 2020), current approaches either rely on encoding schemes (Ying et al., 2019; White et al., 2019) or manually designed similarity metrics (Kandasamy et al., 2018), both of which are not scalable to large architectures and ignore the important topological structure of architectures.
Another line of work employs graph neural networks (GNNs) to construct the BO surrogate (Ma et al., 2019; Zhang et al., 2019; Shi et al., 2019); however, the GNN design introduces additional hyperparameter tuning, and the training of the GNN also requires a large amount of architecture data, which is particularly expensive to obtain in NAS.
Our method, instead, uses the WL graph kernel to naturally handle the graph-like search spaces and capture the topological structure of architectures.
Meanwhile, our surrogate preserves the merits of GPs in data-efﬁciency, uncertainty computation and automated hyperparameter treatment.
In summary, our main contributions are as follows:
• We introduce a GP-based BO strategy for NAS, NAS-BOWL, which is highly query-efﬁcient and amenable to the graph-like NAS search spaces.
Our proposed surrogate model combines a GP with the WL graph kernel (GPWL) to exploit the implicit topological structure of architectures.
It is scalable to large architecture cells (e
g. 32 nodes) and can achieve better prediction performance than competing methods.
• We propose the idea of interpretable NAS based on the graph features extracted by the WL kernel and their corresponding surrogate derivatives.
We show that interpretability helps in explaining the performance of the searched neural architectures, and demonstrate a simple yet effective motif-based transfer learning baseline on warm-starting related yet unseen tasks in NAS.
• We empirically demonstrate that our surrogate model achieves superior performance with much fewer observations in NAS search spaces of different sizes.
We ﬁnally show that our strategy both achieves the state-of-the-art performance on NAS-Bench datasets and performs extremely competitively on open-domain experiments while being much more efﬁcient than comparable methods.
P RELIMINARIES
Graph Representation of Neural Networks Architectures in popular NAS search spaces can be represented as an acyclic directed graph (Elsken et al., 2018;
Zoph et al., 2018b; Ying et al., 2019;
Dong and Yang, 2020; Xie et al., 2019), where each graph node represents an operation unit or layer (e.g. a conv3 × 3-bn-relu in Ying et al. (2019)) and each edge deﬁnes the information ﬂow from one layer to another.
With this representation, NAS can be formulated as an optimisation problem to ﬁnd the directed graph and its corresponding node operations (i.e. the directed attributed graph G ) that give the best architecture validation performance y ( G ) : G ∗ = arg max G y ( G ) .
Bayesian Optimisation and Gaussian Processes To solve the above optimisation, we adopt
BO, which is a query-efﬁcient technique for optimising a black-box, expensive-to-evaluate objective (Brochu et al., 2010).
BO uses a statistical surrogate to model the objective and builds an acquisition function based on the surrogate.
The next query location is recommended by optimising the acquisition function which balances the exploitation and exploration.
We use a
GP as the surrogate model in this work, as it can achieve competitive modelling performance with small amount of query data (Williams and Rasmussen, 2006) and give analytic predictive posterior mean µ ( G t |D t − 1 ) and variance k ( G t , G (cid:48) t |D t − 1 ) on the heretofore unseen graph G t given t − 1 observations: µ ( G t |D t − 1 ) =
k ( G t , G 1: t − 1 ) K − 1 1: t − 1 y 1: t − 1 and k ( G t , G (cid:48) t |D t − 1 )
=
k ( G t , G (cid:48) t )
− k ( G t , G 1: t − 1 ) K − 1 1: t − 1 k ( G 1: t − 1 , G (cid:48) t ) where G 1: t − 1 = { G 1 , . . .
, G t − 1 } and y 1: t − 1 =
[ y 1 , . . .
, y t − 1 ] T are the t − 1 observed graphs and objective function values, respectively, and
D t − 1 = { G 1: t − 1 , y 1: t − 1 } .
[ K 1: t − 1 ] i,j = k ( G i , G j ) is the ( i, j ) -th element of Gram matrix induced on the ( i, j ) -th training samples by k ( · , · ) , the graph kernel function.
We use Expected Improvement (Mockus et al., 1978) as the acquisition function in this work though our approach is compatible with alternative choices.
Graph Kernels Graph kernels are kernel functions deﬁned over graphs to compute their level of similarity.
A generic graph kernel may be represented by the function k ( · , · ) over a pair of graphs G and G (cid:48)
(Kriege et al., 2020):
[Equation]
) (cid:105) H (2.1) where φ ( · ) is some feature representation of the graph extracted by the graph kernel and (cid:104)· , ·(cid:105) H denotes inner product in the associated reproducing kernel Hilbert space (RKHS) (Nikolentzos et al., 2019; Kriege et al., 2020).
For more detailed reviews on graph kernels, the readers are referred to
Nikolentzos et al.
(2019), Ghosh et al.
and Kriege et al.
P ROPOSED M ETHOD
We begin by presenting our proposed algorithm, NAS-BOWL in Algorithm 1, where there are the three key design features, namely the design of the GP surrogate suitable for architecture search (we term the surrogate GPWL), (optionally) transfer learning based on interpretable motifs, and the method to generate candidate architectures at each BO iteration.
We will discuss the ﬁrst two in
Section 3.1 and 3.2, respectively.
For architecture generation, we either generate the new candidates via random sampling the adjacency matrices, or use a mutation algorithm similar to those used in a number of previous works (Kandasamy et al., 2018; Ma et al., 2019; White et al., 2019; Shi et al., 2019): at each iteration, we generate the architectures by mutating a number of queried architectures that perform the best.
Generating candidate architectures in this way enables us to exploit the prior information on the best architectures observed so far to explore the large search space more efﬁciently.
We report NAS-BOWL with both strategies in our experiments.
3. S URROGATE AND G RAPH K ERNEL D ESIGN
To enable the GP to work effectively on the graph-like architecture search space, selecting a suitable kernel function is arguably the most important design decision.
We propose to use the WeisfeilerLehman (WL) graph kernel (Shervashidze et al., 2011) to enable the direct deﬁnition of a GP surrogate on the graph-like search space.
The WL kernel compares two directed graphs based on both local and global structures.
It starts by comparing the node labels of both graphs via a base kernel k base (cid:0) φ 0 ( G ) , φ 0 ( G (cid:48) ) (cid:1) where φ 0 ( G ) denotes the histogram of features at level h =
(i.e. node features) in the graph, where h is both the index of WL iterations and the depth of the subtree features extracted.
For the WL kernel with h > 0 , it then proceeds to collect features at h = 1 by aggregating neighbourhood labels, and compare the two graphs with k base (cid:0) φ 1 ( G ) , φ 1 ( G (cid:48) ) (cid:1) based on the subtree structures of depth 1 (Shervashidze et al., 2011; Höppner and Jahnke, 2020).
The procedure then repeats until the highest iteration level h
=
H speciﬁed and the resulting WL kernel is given by:
[Equation]
In the above equation, k base is a base kernel (such as dot product) over the vector feature embedding.
As h increases, the WL kernel captures higher-order features which correspond to increasingly larger neighbourhoods and features at each h are concatenated to form the the ﬁnal feature vector ( φ ( G ) =
[ φ 0 ( G ) , ..., φ H ( G )] ).
The readers are referred to App.
A for more detailed schematic and algorithmic descriptions of the WL kernel.
We argue that WL is desirable for three reasons.
First, in contrast to many ad hoc approaches, WL is established with proven successes on labelled and directed graphs, by which networks are represented.
Second, the WL representation of graphs is expressive, topology-preserving yet interpretable: Morris et al.
(2019) show that WL is as powerful as standard GNNs in terms of discrimination power.
However, GNNs requires relatively large amount of training data and thus is more data-inefﬁcient
(we validate this in Sec. 5).
Also, the features extracted by GNNs are harder to interpret compared to those by WL.
Note that the WL kernel by itself only measures the similarity between graphs and does not aim to select useful substructures explicitly.
It is our novel deployment of the WL procedure (App.
A) for the NAS application that leads to the extraction of interpretable features while comparing different architectures.
We further make smart use of these network features to help explain the architecture performance in Sec 3.2.
Finally, WL is efﬁcient and scalable: denoting { n, m } as the number of nodes and edges respectively, computing the Gram matrix on N training graphs may scale
O ( NHm + N 2 Hn ) (Shervashidze et al., 2011).
As we show in App.
E.3, in typical cell-based spaces H ≤ 3 sufﬁces, suggesting that the kernel computation cost is likely eclipsed by the O ( N 3 ) scaling of GP we incur nonetheless.
This is to be contrasted to approaches such as path encoding in White et al.
(2019), which scales exponentially with n without truncation, and the edit distance kernel in Jin et al.
(2019), whose exact solution is NP-complete (Zeng et al., 2009).
With the above-mentioned merits, the incorporation of the WL kernel permits the usage of GP-based
BO on various NAS search spaces.
This enables the practitioners to harness the rich literature of
GP-based BO methods on hyperparameter optimisation and redeploy them on NAS problems.
Most prominently, the use of GP surrogate frees us from hand-picking the WL hyperparameter H as we can automatically learn the optimal values by maximising the Bayesian marginal likelihood.
As we will justify in Sec. 5 and App.
E.3, this process is extremely effective.
This renders a further major advantage of our method as it has no inherent hyperparameters that require manual tuning .
This reafﬁrms with our belief that a practical NAS method itself should require minimum tuning, as it is almost impossible to run traditional hyperparameter search given the vast resources required.
Other enhancements, such as improving the expressiveness of the surrogate by combining multiple types of kernels, are brieﬂy investigated in App.
C.
We ﬁnd the amount of performance gain depends on the
NAS search space and a WL kernel alone sufﬁces for common cell-based spaces.
3. I NTERPRETABLE NAS
The unique advantage of the WL kernel is that it extracts interpretable features, i.e. network motifs from the original graphs.
This in combination with our GP surrogate enables us to predict the effect of the extracted features on the architecture performance directly by examining the derivatives of the
GP predictive mean w.r.t.
the features.
Derivatives as tools to interpret ML models have been used previously (Engelbrecht et al., 1995;
Koh and Liang, 2017; Ribeiro et al., 2016) but, given the GP, we can compute these derivatives analytically .
Following the notations in Sec. 2, the derivative with respect to φ j ( G t ) , the j -th element of φ ( G t ) (the feature vector of a graph G t ) is Gaussian with an expected value:
[Equation]
where Φ 1: t − 1 =
[ φ ( G 1 ) , . . .
, φ ( G t − 1 )] T is the feature matrix stacked from the feature vectors of the previous observations.
Intuitively, since each φ j ( G t ) denotes the count of a WL feature in G t , its derivative naturally encodes the direction and sensitivity of the objective (in this case the predicted validation accuracy) about that feature.
Computationally, since the costly term, K − 1 1: t − 1 y 1: t − 1 , is already computed in the posterior mean, the derivatives can be obtained at minimal additional cost.
By evaluating the aforementioned derivative at some graph G , we obtain the local sensitivities of the objective function around φ ( G ) .
To achieve global attribution of network performance w.r.t interpretable features which we are ultimately interested in, we take inspirations from the principled averaging approach featured in many gradient-based attribution methods (Sundararajan et al., 2017;
Ancona et al., 2017), by computing and integrating over the aforementioned derivatives at all training samples to obtain the averaged gradient (AG).
AG of the j -th feature φ j is given by:
[Equation]
Fortunately, in WL kernel, φ j ( · ) ∈ Z ≥ 0 ∀ j and thus p ( φ j ( · )) is discrete, the expectation integral reduces to a weighted summation over the “prior” distribution p ( φ j ( · )) ∀ j .
To approximate p ( φ j ( · )) , we count the number of occurrences of each feature φ j ( G n ) in all the training graphs { G 1 , ..., G t − 1 } where φ j ( · ) is present and assign weights according to its frequency of occurrence.
Formally, denoting
G as the subset of the training graphs where for each of its element φ j > 0 , we have
[Equation]
where w n ( φ j ) = 1 |G| |G| (cid:88) n (cid:48) =
δ ( φ
[Equation]
G
[Equation]
φ
[Equation]
( G n (cid:48)
[Equation]
3.4) where δ ( · , · ) is the Kronecker delta function and | · | the cardinality of a set.
Finally, we additionally incorporate the uncertainty of the derivative estimation by also normalising AG with the square root of the empirical variance ( EV ) to penalise high-variance (hence less trustworthy as a whole) gradient estimates closer to 0 .
EV may be straightforwardly computed:
[Equation]
The resultant derivatives w.r.t.
interpretable features AG( φ j ) / (cid:112) EV( φ j ) allow us to directly identify the most inﬂuential motifs on network performance.
By considering the presence or absence of such motifs, we may explain the competitiveness of an architecture or the lack of it, provided the surrogate is accurate which we show is the case in Sec.
More importantly, beyond passive explaining , we can also actively use these features as building blocks to facilitate manual construction of promising networks, or as priors to prune the massive NAS search space, which we believe would be of interest to both human designers and NAS practitioners.
To validate this, we train our GPWL on architectures drawn from various search spaces, rank all the features based on their computed derivatives and show the motifs with most positive and negative derivatives (hence the most and least desirable features) 1 .
We present the extracted network motifs on the CIFAR-10 task of NAS-Bench-201 (N201) (Dong and Yang, 2020) and DARTS search space in Fig. 1(a).
The motifs extracted on other N201 image tasks (CIFAR-100/ImageNet16) and on NAS-Bench-101 (N101) (Ying et al., 2019) are shown in App.
D.2.
The results reveal some interesting insights on network performance: for example, almost every good motif in N201 contains conv_3 × 3 and all-but-one good motifs in the DARTS results contain at least one separable conv_3 × 3 .
In fact, this preference over (separable) convolutions is almost universally observed in many popular NAS methods (Liu et al., 2018a; Shi et al., 2019; Wang et al., 2019; Pham et al., 2018) and ours: besides skip links, the operations in their best cells are dominated by separable convolutions (Fig. 2).
Moving from node operation label to higher-order topological features, in both search spaces, our GPWL consistently ﬁnds a series of high-performing motifs that entail the parallel connection from input to multiple conv s often of different ﬁlter sizes – this corresponds to the grouped convolution unit critical to the success of, e.g. ResNeXt (Xie et al., 2017).
A speciﬁc example is the boxed motif in Fig. 1(a), which combines parallel conv s with a skip link.
This motif or other highly similar ones are consistently present in the optimal cells found by many
NAS methods including ours (as shown in Fig. 2) despite the disparity in their search strategies.
This suggests a correlation between these motifs and good architecture performance.
Another observation is that a majority of the important motifs for both search spaces in Fig.
1(a) involve the input.
From this and our previous remarks on the consensus amongst NAS methods in favouring certain operations and connections, we hypothesise that at least for a cell-based search space, the network performance might be determined more by the connections in the vicinity to the inputs (on which the optimal cells produced by different NAS methods are surprisingly consistent) than other parts of the network (on which they differ).
This phenomenon is partly observed in Shu et al.
(2019), where the authors found that NAS algorithms tend to favour architecture cells with most intermediate nodes having direct connection with the input nodes.
The veriﬁcation of this hypothesis is beyond the scope of this paper, but this shows the potential of our GPWL in discovering novel yet interpretable network features, with potential implications for both NAS and manual network design.
Going beyond the qualitative arguments above, we now quantitatively validate the informativeness of the motifs discovered.
After identifying the motifs, in N201, we randomly draw another 1, validation architectures unseen by the surrogate.
Given the motifs identiﬁed in Fig. 1(a), an architecture is labelled either “good” ( ≥ 1 good motif), “bad” ( ≥ 1 bad motif) or neither.
Note if an architecture contains both good and bad motifs, it is both “good” and “bad”.
As demonstrated in
Fig. 1(b), we indeed ﬁnd that the presence of important motifs is predictive of network performance.
A similar conclusion holds for DARTS space.
However, due to the extreme cost in sampling the open-domain space, we make two modiﬁcations to our strategy.
Firstly, the training samples are taken from a BO run, instead of randomly sampled.
Secondly, we reuse the training samples for
Fig. 1(b) instead of sampling and evaluating the hold-out sets.
The key takeaway here is that motifs are effective in identifying promising and unpromising candidates, and thus can be used to aid NAS agents to partition the vast combinatorial search space, which is often considered a key challenge of NAS, and to focus on the most promising sub-regions.
More importantly, the motifs are also transferable : while the patterns in Fig.
1(a) are solely trained on the CIFAR-10, they generalise well to CIFAR-100/ImageNet16 tasks – this is unsurprising, as one of the key motivations of using cell-based search space is exactly to improve transferability of the learnt structure across related tasks (Zoph et al., 2018a).
Given that motifs are the building blocks of the cells, we expect them to transfer well, too.
With this, we propose a simple transfer learning baseline as a concrete usecase of interpretability, though we believe there will be many more in this exciting direction of interpretable NAS.
Speciﬁcally, we can exploit the motifs identiﬁed on one task to warm-start the search on a related new task.
With reference to the highlighted part in Algorithm 1, under the transfer learning setup, we use a GPWL surrogate trained on the query data of a past related task S past as well as the surrogate on the new target task S to compute the AG of motifs present in queried architectures (equation 3.4) and identify the most positively inﬂuential motifs similar to Fig. 1(a)
( Line 3 ).
We then use these motifs to generate a set of candidate architectures G t for optimising the acquisition function at every BO iteration on the new task; Speciﬁcally, we only accept a candidate, which could be produced via random sampling or mutation, if it contains at least one of the top 25% good motifs (i.e. pruning rule ).
Finally, with more query data obtained on the target task, we will dynamically update the
[Figure]
surrogate S and the motif scores to mitigate the risk of discarding motifs purely based
By using the aforementioned procedure, we now force the BO agent to select from a smaller subset of architectures deemed more promising from a previous task, thereby “warm starting” the search on a new task.
We brieﬂy validate this proposal in the N201 experiments of Sec. 5.
R ELATED WORK
In terms of NAS strategies, there have been several recent attempts in using BO (Kandasamy et al., 2018;
Ying et al., 2019; Ma et al., 2019; Shi et al., 2019; White et al., 2019).
To overcome the limitations of conventional BO for discrete and graph-like NAS search spaces, Kandasamy et al.
(2018) uses optimal transport to design a similarity measure among neural architectures while Ying et al.
and White et al.
(2019) suggest encoding schemes to characterise neural architectures with discrete and categorical variables.
Yet, these methods are either computationally inefﬁcient or not scalable to large architectures/cells (Shi et al., 2019; White et al., 2019).
Alternatively, several works use graph neural networks (GNNs) as the surrogate model (Ma et al., 2019; Zhang et al., 2019;
Shi et al., 2019) to capture the graph structure of neural networks.
However, the design of the GNN introduces many additional hyperparameters to be tuned and GNN requires a relatively large number of training data to achieve decent prediction performance as shown in Sec. 5.
Another related work (Ramachandram et al., 2018) applies GP-based BO with diffusion kernels to design multimodal fusion networks; however, it assigns each possible architecture as a node in an undirected super-graph and the need for construction of and computation on such super-graphs limits the method to relatively small search spaces.
In terms of interpretability, Shu et al.
(2019) study the connection pattern of network cells found by popular NAS methods and ﬁnd a shared tendency for choosing wide and shallow cells which enjoy faster convergence.
You et al.
(2020), by representing neural networks as relational graphs, observe that the network performance depends on the clustering coefﬁcient and average path length of its graph representation.
Radosavovic et al.
(2020) propose a series of manual design principles derived from extensive empirical comparison to reﬁne a ResNet-based search space.
Nevertheless, all these works do not offer a NAS strategy, and purely rely on human experts to derive insights on NAS architectures from extensive empirical studies.
In contrast, our method learns the interpretable feature information without human inputs while searching for the optimal architecture.
E XPERIMENTS
Surrogate Regression Performance We examine the regression performance of GPWL on several
NAS datasets: NAS-Bench-101 (N101) on CIFAR-10 (Ying et al., 2019), and N201 on CIFAR-10,
CIFAR-100 and ImageNet16.
As both datasets only contain CIFAR-sized images and relatively small architecture cells 2 , to further demonstrate the scalability of our proposed methods to much larger architectures, we also construct a dataset with 547 architectures sampled from the randomly wired graph generator described in Xie et al.
; each architecture cell has 32 operation nodes and all the architectures are trained on the Flowers102 dataset (Nilsback and Zisserman, 2008)
Similar to
Ying et al.
; Dong and Yang (2020); Shi et al.
(2019), we use Spearman’s rank correlation between predicted validation accuracy and the true validation accuracy as the performance metric, as what matters for comparing architectures is their relative performance ranking.
[Figure]
We compare the regression performance against various competitive baselines, including NASBOT (Kandasamy et al., 2018), GPs with path encodings (PathEncode)
(White et al., 2019), GNN (Shi et al., 2019) which uses a combination of graph convolutional network and a ﬁnal Bayesian linear regression layer as the surrogate, and COMBO (Oh et al., 2019) 3 , which use a GP with a diffusion kernel on a graph representation of the combinatorial search spaces.
We report the results in Fig.
It is evident that our GPWL surrogate clearly outperforms all competing methods on all the NAS datasets with much less training data, especially on datasets with larger search spaces.
Speciﬁcally,
GPWL requires at least 3 times less data than GNN and PathEncode and 10 times less than COMBO on N201 datasets.
It is also able to achieve high rank correlation on datasets with larger search spaces such as N101 and Flowers102 while requiring 20 times less data than GNN on Flowers and 30 times less data on N101.
Moreover, in BO, uncertainty estimates are as important as the prediction accuracy; we show that GPWL produces sound uncertainty estimates in App.
E.1.
Finally, in addition to these surrogates previously used in NAS, we also demonstrate that our surrogate compares favourably against other popular graph kernels, as discussed in App.
E.2.
Architecture Search on NAS-Bench Datasets We benchmark our proposed method, NAS-BOWL, against a range of existing methods, including random search, TPE (Bergstra et al., 2011), Reinforcement Learning ( rl ) (Zoph and Le, 2016), BO with SMAC ( smacbo ) (Hutter et al., 2011), regularised evolution (Real et al., 2019) and BO with GNN surrogate ( gcnbo ) (Shi et al., 2019).
On N101, we also include BANANAS (White et al., 2019) which claims the state-of-the-art performance.
In both NAS-Bench datasets, validation errors of different random seeds are provided, thereby creating noisy objective functions.
We perform experiments using the deterministic setup described in White et al.
(2019), where the validation errors over multiple seeds are averaged to eliminate stochasticity, and also report results with noisy objective functions.
We show the test results in both setups in
Fig.
4 and the validation results in App.
F.3.
In these ﬁgures, we use NASBOWLm and NASBOWLr to denote NAS-BOWL with architectures generated from mutating good observed candidates and from random sampling, respectively.
Similarly, BANANASm / BANANASr represent the BANANAS with mutation/random sampling
(White et al., 2019).
On CIFAR-100/ImageNet tasks of N201, we also include NASBOWLm(TL) which is NASBOWLm with additional knowledge on motifs transferred from a previous run on the CIFAR-10 task of N201 to prune the candidate architectures as described in Sec. 3.2.
The readers are referred to App.
F.2 for detailed setups.
[Table]
It is evident that NAS-BOWL outperforms all baselines on all NAS-Bench tasks in achieving both lowest validation and test errors.
The experiments with noisy observations further show that even in a more realistic setup with noisy objective function observations, NAS-BOWL still performs very well as it inherits the robustness against noise from the GP.
The preliminary experiments on transfer learning also show that motifs contain extremely useful prior knowledge that may be transferred to warm-start a related task: notice that even the architectures at the very start without any search already perform well – this is particularly appealing, as in a realistic setting, searching directly on large-scale datasets like ImageNet from scratch is extremely expensive.
This simple knowledge transfer scheme from a smaller dataset potentially allows us to drastically reduce the number of samples needed to be drawn for costly tasks.
Finally, we perform ablation studies in App.
F.3.
Open-domain Search We ﬁnally test NAS-BOWL on the open-domain search space from DARTS (Liu et al., 2018a).
We allow a maximum budget of 150 queries, and we follow the DARTS setup (See App.
G for details): during the search phase, instead of training the ﬁnal 20-cell architectures, we train a small 8-cell architectures for 50 epochs.
Whereas this results in signiﬁcant computational savings, it also leads to the degraded rank correlation of performance during search and evaluation stages.
This leads to a more challenging setup than most other sample-based methods which train for longer epochs and/or search on the ﬁnal 20-cell architectures directly.
Beyond this, we also search a single cell structure and use it for the two cell types (normal and reduction) deﬁned in DARTS search space.
We also use a default maximum number of 4 operation blocks to ﬁt the training on a single
GPU; this is contrasted to, e.g. ENAS and LaNet that allow for up to 5 and 7 blocks, respectively.
We compare NAS-BOWL with other methods in Table 1, and the best cell found by NAS-BOWL is already shown in Fig.
2 in Sec. 3.2.
To ensure fairness of comparison, we only include previous methods with comparable search spaces and training techniques, and exclude methods that train much longer and/or use additional tricks (Liang et al., 2019;
Cai et al., 2019).
It is evident that NASBOWL ﬁnds very promising architectures despite operating in a more restricted setup.
Consuming
GPU-days, NAS-BOWL is of comparable computing cost to the one-shot methods but performs on par with or better than methods that consume orders of magnitude more resources, such as LaNet which is 50 × more costly.
Furthermore, it is worth noting that, if desired, NAS-BOWL may beneﬁt from any higher computing budgets by relaxing the aforementioned restrictions (e.g. train longer on larger architectures during search).
Finally, while we use a single GPU, NAS-BOWL can be easily deployed to run on parallel computing resources to further reduce wall-clock time.
C ONCLUSION
In this paper, we propose a novel BO-based NAS strategy, NAS-BOWL, which uses a GP surrogate with the WL graph kernel.
We show that our method performs competitively on both closed- and open-domain experiments with high sample efﬁciency.
More importantly, our method represents a ﬁrst step towards interpretable NAS , where we propose to learn interpretable network features to help explain the architectures found as well as guide the search on new tasks.
Future directions include extending such afforded interpretability in architecture search and discovering more use-cases such as on multi-objective settings and broader search spaces.
A A LGORITHMS
Description of the WL kernel WL kernel starts by comparing the node labels of both graphs ( h = 0 features 0 to 4 in Fig. 5) via a base kernel k base (cid:0) φ 0 ( G ) , φ 0 ( G (cid:48) ) (cid:1) where φ 0 ( G ) denotes the histogram of h = 0 features in the graph, and h is the index of WL iterations and also the depth of the subtree features extracted.
For the WL kernel with h > 0 , it then proceeds to collect h = 1 features following steps 1 to 3 in Fig.
5 and compare the two graphs with k base (cid:0) φ 1 ( G ) , φ 1 ( G (cid:48) ) (cid:1) based on the subtree structures of depth 1 (Shervashidze et al., 2011; Höppner and Jahnke, 2020).
The procedure repeats until the highest iteration level h
= H and the resultant WL kernel is:
[Equation]
where k base is a base kernel speciﬁed by the user and a simple example is the dot product of the feature embeddings (cid:104) φ ( G ) , φ ( G (cid:48) )
(cid:105) and w h contains the weights associated with each WL iteration h (in this work, all w is set to 1 , so equation A.1 reduces to equation 3.1 in the main text).
.Note
as a result of the WL label reassignment, the node labels in Arch A at initialisation ( h = 0 ) are different from those in Arch A in Step 3 ( h = 1 ); h = 0 features represent subtrees of depth 0 while h =features are subtrees of depth 1.
In this way, as h increases, the WL kernel captures higher-order features which correspond to increasingly larger neighbourhoods.
The readers are ﬁnally referred to a formal, algorithmic description of the WL procedure in Algorithm 2.
B D ETAILED REASONS FOR USING THE WL KERNEL
We argue that WL kernel is a desirable choice for the NAS application for the following reasons.
WL kernel is able to compare labeled and directed graphs of different sizes.
As discussed in Section 2, architectures in almost all popular NAS search spaces (Ying et al., 2019; Dong and Yang, 2020; Zoph et al., 2018b; Xie et al., 2019) can be represented as directed graphs with node/edge attributes.
Thus, WL kernel can be directly applied on them.
On the other hand, many graph kernels
Assign a multiset-label M h ( v ) to each node v in G consisting of the multiset { l h − 1 | u ∈ N ( v ) , where l h − 1 ( v ) is the node label of node v of the h − 1 -th WL iteration; N ( v are the neighbour
Sort in ascending order and concatenate them into
Concatenate the φ ( G φ ( with the respective counts of the new labels 11:
Compute either do not handle node labels (Shervashidze et al., 2009), or are incompatible with directed graphs (Kondor and Pan, 2016; de Lara and Pineau, 2018).
Converting architectures into undirected graphs can result in loss of valuable information such as the direction of data ﬂow in the architecture (we show this in Section 5).
WL
kernel is expressive yet highly interpretable.
WL kernel is able to capture substructures that go from local to global scale with increasing h values.
Such multi-scale comparison is similar to that enabled by a Multiscale Laplacian Kernel (Kondor and Pan, 2016) and is desirable for architecture comparison.
This is in contrast to graph kernels such as Kashima et al.
; Shervashidze et al.
(2009), which only focus on local substructures, or those based on graph spectra de Lara and Pineau (2018), which only look at global connectivities.
Furthermore, the WL kernel is derived directly from the Weisfeiler-Lehman graph isomorphism test (Weisfeiler and Lehman, 1968), which is shown to be as powerful as a GNN in distinguishing non-isomorphic graphs (Morris et al., 2019;
Xu et al., 2018).
However, the higher-order graph features extracted by GNNs are hard to interpret by humans.
On the other hand, the subtree features learnt by WL kernel (e.g. the h =
and h = 1 features in Figure 5) are easily interpretable.
WL
kernel is relatively efﬁcient and scalable.
Other expressive graph kernels are often prohibitive to compute: for example, deﬁning { n, m } to be the number of nodes and edges in a graph, random walk (Gärtner et al., 2003), shortest path (Borgwardt and Kriegel, 2005) and graphlet kernels (Shervashidze et al., 2009) incur a complexity of O ( n 3 ) , O ( n 4 ) and O ( n k ) respectively where k is the maximum graphlet size.
Another approach based on computing the architecture edit-distance (Jin et al., 2019) is also expensive: its exact solution is NP-complete (Zeng et al., 2009) and is provably difﬁcult to approximate (Lin, 1994).
On the other hand, the WL kernel only entails a complexity 4 of
O ( Hm ) white2019bananas, which without truncation scales exponentially with n .
C C OMBINING D IFFERENT K
[Equation]
In general, the sum or product of valid kernels gives another valid kernel, as such, combining different kernels to yield a better-performing kernel is commonly used in GP and Multiple Kernel Learning (MKL) literature (Rasmussen, 2003; Gönen and Alpaydin, 2011).
In this section, we conduct a preliminary discussion on its usefulness to GPWL.
As a singular example, we consider the additive kernel that is a linear combination of the WL kernel and the MLP kernel:
[Equation]
where α, β are the kernel weights.
We choose WL and MLP because we expect them to extract diverse information: whereas WL processes the graph node information directly, MLP consider the spectrum of the graph Laplacian matrix, which often reﬂect the global properties such as the topology and the graph connectivity.
We expect the more diverse features captured by the constituent kernels will lead to a more effective additive kernel.
While it is possible to determine the weights in a more principled way such as jointly optimising them in the GP log-marginal likelihood, in this example we simply set α = 0 .
7 and β = 0 .
We then perform regression on NAS-Bench-101 and Flower datasets following the setup as in Sec. 5.
We repeat each experiment 20 times and report the mean and standard deviation in Table 2, and we show the uncertainty estimate of additive kernel in Fig.
In both search spaces the additive kernel outperforms the constituent kernels but the gain over the WL kernel is marginal.
Interestingly, while MLP performs poorly on its own, it can be seen that the complementary spectral information extracted by it can be helpful when used alongside our WL kernel.
Generally, we hypothesise that as the search space increases in complexity (e.g., larger graphs, more edge connections permitted, etc), we expect that the beneﬁts from combining different kernels to increase and we defer a more comprehensive discussion on this to a future work.
As a starting point, one concrete proposal would be applying a MKL method such as ALIGNF (Cortes et al., 2012) in our context directly.
[Table]
† : Taken directly from Table 3.
[Figure]
D F URTHER D ETAILS ON I NTERPRETABILITY D. S ELECTION P ROCEDURE FOR M OTIF D ISCOVERY
NAS-Bench datasets In the closed-domain NAS-Bench datasets (including both NAS-
benchand NAS-Bench-201), we randomly sample 300 architectures from their respective search space, ﬁt the GPWL surrogate, and compute the derivatives of all the features that appeared in the training set.
As a regularity constraint, we then ﬁlter the motifs to only retain those that appear for more than 10 times to ensure the estimates of the derivatives by the GPWL surrogate are accurate enough and are not swayed by noises/outliers.
We ﬁnally rank the features by the numerical values of the derivatives, and present the top and bottom quantiles of the features as “best motifs” and “worst motifs” respectively in Fig.
1 in the main text and Fig.
7 in Sec.
D.2.
DARTS Search Space
In the open-domain search space, it is impossible to sample efﬁciently since each sample drawn requires us to evaluate the architecture in full, which is computationally prohibitive.
Instead, we simply reuse the GPWL surrogate trained in one run of NAS-BOWL on the open-domain experiments described in Sec. 5, which contains 120 architecture 5 -validation accuracy pair evaluated over 3 GPU days.
Due to the smaller number of available samples, here we only require each feature to appear at least twice as a prerequisite, and we select the top and bottom 15% of the features to be presented in the graphs.
All other treatments are identical to the descriptions above.
D. M OTIF D ISCOVERY ON N101 AND O THER T ASKS OF N
Supplementary to Fig.
1 in main text, here we outline the motifs discovered by GPWL also on the
N101 search space and on the other tasks (CIFAR-100, ImageNet16) of N201 in Fig.
We follow the identical setup as described in both the main text and Sec.
D.1.
In all cases, the motifs are highly effective in separating the architecture pool and it is also noteworthy that the motifs found in the other N201 tasks are highly consistent with those shown in Fig.
1 in the main text with only minor differences, further supporting our claim that the GPWL is capable of identifying transferable features without unduly overﬁtting to a particular task.
To give further concrete evidence on the working and advantage of the proposed method in N201, in Fig 14 we show the top-4 motifs in terms of the derivatives computed from one experiment on
CIFAR-10 only , according to Sec 3.2, and the ground-truth best architectures in each of the three tasks included.
In this case, while the optimal cells for the different tasks are similar (but not identical) and reﬂective of a high-level transferability of the cells, transferring the optimal cell in one task directly to
[Figure]
another will be sub-optimal.
However, using our method as described in Algorithm 1 by transferring the motifs in Fig 14(a) on CIFAR-100 and ImageNet tasks, we reduce the search space and resultantly search time drastically (as any cell to be evaluated now needs to contain one of the motifs in Fig.
14(a))
yet we do not preemptively rule out the optimal cell (as all optimal cells contain ≥ 1 "good" motifs).
As such, our method strikes a balance between performance and efﬁciency.
E F URTHER R EGRESSION R ESULTS E. P REDICTIVE M EAN ± 1 S TANDARD D EVIATION OF GPWL S URROGATE ON NAS D ATASETS
In this section, we show the GPWL predictions on the various NAS datasets when trained withsamples each.
It can be shown that not only a satisfactory predictive mean is produced by GPWL in terms of the rank correlation and the agreement with the ground truth, there is also sound uncertainty estimates, as we can see that in most cases the ground truths are within the error bar representing one standard deviation of the GP predictive distributions.
For the training of GPWL, we always transform the validation errors (the targets of the regression) into log-scale, normalise the data and transform it back at prediction, as empirically we ﬁnd this leads to better uncertainty estimates.
E. C OMPARISON WITH O THER G RAPH K ERNELS
We further compare the performance of WL kernel against other popular graph kernels such as (fast)
Random Walk (RW)
(Kashima et al., 2003; Gärtner et al., 2003), Shortest-Path (SP) (Borgwardt and Kriegel, 2005), Multiscale Laplacian (MLP) (Kondor and Pan, 2016) kernels when combined with GPs.
These competing graph kernels are chosen because they represent distinct graph kernel classes and are suitable for NAS search space with small or no modiﬁcations.
In each NAS dataset, we randomly sample 50 architecture data to train the GP surrogate and use another 400 architectures as the validation set to evaluate the rank correlation between the predicted and the ground-truth validation accuracy.
We repeat each trial 20 times, and report the mean and standard error of all the kernel choices on all NAS datasets in Table 3.
We also include the worst-case complexity of the kernel computation between a pair of graphs in the table.
The results in this section justify our reasoning in App.
B; combined with the interpretability beneﬁts we discussed, WL consistently outperforms other kernels across search spaces while retaining modest computational costs.
RW often comes a close competitor, but its computational complexity is worse and does not always converge.
MLP, which requires us to convert directed graphs to undirected graphs, performs poorly, thereby validating that directional information is highly important.
[Table] [Table]
[Figure]
E. V ALUE OF H ( MAXIMUM NUMBER OF WL ITERATIONS )
As discussed, the Weisfeiler-Lehman kernel is singly parameterised by H , the maximum number of
WL iterations.
The expressive power of the kernel generally increases with H , as the kernel is capable of covering increasingly global features, but at the same time we might overﬁt into the training set, posing a classical problem of variance-bias trade-off.
In this work, by combining WL with GP, we optimise H against the negative log-marginal likelihood of the GP.
In this section, on different data-sets we show that this approach satisfactorily balances data-ﬁtting with model complexity.
To verify, on both N101 and Flowers102 data-sets we described, we train GPWL surrogates onrandom training samples.
On N101, we draw another 400 testing samples and on Flowers102, we use the rest of the data-set as the validation set.
We use the Spearman correlation between prediction and the ground truths of the validation set as the performance metric.
We summarise our result in Fig.
9: in both data-sets, we observe a large jump in performance from H = 0 to 1 (measured by the improvements in both validation and training Spearman correlation), and a slight dip in validation correlation from H = 2 to 3 , suggesting an increasing amount of overﬁtting if we increase H further.
In both cases, the automatic selection described above succeeded in ﬁnding the “sweet spot” of
H = 1 or 2 , demonstrating the effectiveness of the approach.
F C LOSED -D OMAIN E XPERIMENTAL D ETAILS
All experiments were conducted on a 36-core 2.3GHz Intel Xeon processor with 512 GB RAM
. F. D ATASETS
We experiment on the following datasets:
• NAS-Bench-101 (Ying et al., 2019):
The search space is an acyclic directed graph withnodes and a maximum of 9 edges.
Besides the input node and output node, the remaining 5 operation nodes can choose one of the three possible operations: conv3 × 3-bn-relu , conv1 × 1-bn-relu and maxpool3 × 3 .
The dataset contains all 423,624 unique neural architectures in the search space.
Each architecture is trained for 108 epochs and evaluated on CIFAR10 image data.
The evaluation is repeated over 3 random initialisation seeds.
We can access the ﬁnal training/validation/test accuracy, the number of parameters as well as training time of each architecture from the dataset.
The dataset and its API can be downloaded from https://github.com/google-research/nasbench/ .
• NAS-Bench-
(Dong and Yang, 2020):
The search space is an acyclic directed graph withnodes and 6 edges.
Each edge corresponds to an operation selected from the set of 5 possible options: conv1 × 1 , conv3 × 3 , avgpool3 × 3 , skip-connect and zeroize .
This search space is applicable to almost all up-to-date NAS algorithms.
Note although the search space of NAS-Bench-201 is more general, it’s smaller than that of NAS-Bench-101.
The dataset contains all 15,625 unique neural architectures in the search space.
Each architecture is trained for 200 epochs and evaluated on 3 image datasets: CIFAR10, CIFAR100, ImageNet16-120.
The evaluation is repeated over 3 random initialisation seeds.
We can access the training accuracy/loss, validation accuracy/loss after every training epoch, the ﬁnal test accuracy/loss, number of parameters as well as FLOPs from the dataset.
The dataset and its API can be downloaded from https://github.com/D-X-Y/NAS-Bench-201 .
• Flowers102 : We generate this dataset based on the random graph generators proposed in Xie et al.
The search space is an acyclic directed graph with 32 nodes and a varying number of edges.
All the nodes can take one of the three possible options: input , output , relu-conv3 × 3-bn .
Thus, the graph can have multiple inputs and outputs.
This search space is very different from those of NAS-Bench-101 and NAS-Bench-201 and is used to test the scalability of our surrogate model for a large-scale search space (i.t.o number of numbers in the graph).
The edges/wiring/connection in the graph is created by one of the three classic random graph models: Erdos-Renyi (ER), Barabasi-Albert (BA) and Watt-Strogatz (WS).
Different random graph models result in graphs of different topological structures and connectivity patterns and are deﬁned by one or two hyperparameters.
We investigate a total of 69 different sets of hyperparameters: 8 values for the hyperparameter of ER model, 6 values for the hyperparameter of BA model and 55 different value combinations for the two hyperparameters of WS model.
For each hyperparameter set, we generate 8 different architectures using the random graph model and train each architecture for 250 epochs before evaluating on Flowers102 dataset.
The training set-ups follow Liu et al.
This results in our dataset of 552 randomly wired neural architectures.
F. E XPERIMENTAL S ETUP
NAS-BOWL We use a batch size B = 5 (i.e., at each BO iteration, architectures yielding top 5 acquisition function values are selected to be evaluated in parallel).
When mutation algorithm described in Sec. 3.2 is used, we use a pool size of P = 200 , and half of which is generated from mutating the top-10 best performing architectures already queried and the other half is generated from random sampling to encourage more explorations in NAS-Bench-101.
In NAS-Bench-201, accounting for the much smaller search space and consequently the lesser need to exploration, we simply generate all architectures from mutation.
For experiments with random acquisition, we also use
P = 200 throughout, and we also study the effect of varying P later in this section.
We use WL with optimal assignment (OA) (Kriege et al., 2016) for all datasets apart from NAS-Bench-201.
Denoting the feature vectors of two graphs G 1 and G 2 as φ ( G 1 ) and φ ( G 2 ) respectively, the OA inner product in the WL case is given by the histogram intersection (cid:104) φ ( G 1 ) , φ ( G 2 ) (cid:105) =
(cid:80) j min( φ j ( G 1 ) , φ j ( G 2 ) , where φ j ( · ) is the j -th element of the vector.
On NAS-Bench-201 which features a much smaller search space which we ﬁnd a simple dot product of the feature vectors φ ( G 1 ) T φ ( G 2 ) to perform empirically better.
We always use 10 random samples to initialise NAS-BOWL.
On NAS-Bench-101 dataset, we always apply pruning (which is available in the NAS-BenchAPI) to remove the invalid nodes and edges from the graphs.
On NAS-Bench-201 dataset, since the architectures are deﬁned over a DARTS-like, edge-labelled search space, we ﬁrst convert the edgelabelled graphs to node-labelled graphs as a pre-processing step.
It is worth noting that it is possible to use WL kernel deﬁned over edge-labelled graphs directly (e.g the WL-edge kernel proposed by
Shervashidze et al.
(2011)), although in this paper we ﬁnd the WL kernels over node-labelled graphs to perform empirically better.
On the transfer learning setup of N201, we ﬁrst run a standard optimisation task on the CIFAR-10 task (we term this the base task ) but we allow for up to an expanded budget of 250 architecture evaluations to build up the conﬁdence of GPWL derivative estimates.
We then extract the “good motifs” identiﬁed by GPWL (i.e. those features with derivatives in the top quantile).
For the subsequent CIFAR100/ImageNet16 optimisations (we term this the transferred tasks ).
On the transferred tasks, with everything else unmodiﬁed from standard runs (e.g. budget, pool size, batch size, acquisition function choice, etc), we additionally enforce the pruning rule such that only candidates in the pool with at least 1 match to the previously identiﬁed “good motifs” are allowed for evaluations and the rest are removed.
The key difference is that under standard runs, the pool of size B is generated once per
BO iteration via random sampling/mutation algorithm since all candidates are accepted; here, this procedure is executed for many times as required until we have a pool of B architectures where each meets the pruning criteria.
BANANAS We use the code made public by the authors (White et al., 2019)
( https://github. com/naszilla/bananas ), and use the default settings contained in the code with the exception of the number of architectures queried at each BO iteration (i.e. BO batch size): the default is 10 , but to conform to our test settings we use 5 instead.
While we do not change the default pool size of P = 200 at each BO iteration, instead of ﬁlling the pool entirely from mutation of the best architectures, we only mutate 100 architectures from top-10 best architectures and generate the other 100 randomly to enable a fair comparison with our method.
It is worth noting that neither changes led to a signiﬁcant deterioration in the performance of BANANAS: under the deterministic validation error setup, the results we report are largely consistent with the results reported in White et al.
(2019); under the stochastic validation error setup, our BANANAS results actually slightly outperform results in the original paper.
It is ﬁnally worth noting that the public implementation of BANANAS on
NAS-Bench-201 was not released by the authors.
GCNBO for NAS We implemented the GNN surrogate in Sec.
5.1 by ourselves following the description in the most recent work (Shi et al., 2019), which uses a graph convolution neural network in combination with a Bayesian linear regression layer to predict architecture performance in its BO-based NAS 6 .
To ensure fair comparison with our NAS-BOWL, we then deﬁne a normal
Expected Improvement (EI) acquisition function based on the predictive distribution by the GNN surrogate to obtain another BO-based NAS baseline in Sec.
5.2, GCNBO.
Similar to all the other baselines including our NASBOWLr and BANANASr , we use random sampling to generate candidate architectures for acquisition function optimisation.
However, different from NAS-BOWL and
BANANAS, GCNBO uses a batch size B = 1 , i.e. at each BO iteration, NAS-BOWL and BANANAS select 5 new architectures to evaluate next but GCNBO select 1 new architecture to evaluate next.
This setup should favour GCNBO if we measure the optimisation performance against the number of architecture evaluations which is the metric used in Figs. 4 and 4 because at each BO iteration,
GCNBO selects the next architecture G t based on the most up-to-date information α t ( G |D t − 1 ) whereas NAS-BOWL and BANANAS only select one architecture G t, 1 in such fully informed way but select the other four architectures { G t,i } 5 i =2 with outdated information.
Speciﬁcally, in the sequential case ( B = 1 ), G t, 2 is selected only after we have evaluated G t, 1 , G t, 2 is selected by maximising α t ( G |{D t − 1 , ( G t, 1 , y t, 1 ) } ) ; the same procedure applies for G t, 3 , G t, 4 and G t, 5 .
However, in the batch case ( B = 5 ) where G t,i for 2 ≤ i ≤ 5 need to be selected before G t,i − 1 is evaluated, { G t,i } 5 i =2 are all decided based on α t ( G |D t − 1 ) like G t, 1 .
For a more detailed discussion on sequential ( B = 1 ) and batch ( B > 1 ) BO, the readers are referred to Alvi et al.
Other Baselines For all the other baselines: random search (Bergstra and Bengio, 2012), TPE (Bergstra et al., 2011), Reinforcement Learning (Zoph and Le, 2016), BO with SMAC (Hutter et al., 2011), regularised evolution (Real et al., 2019), we follow the implementation available at https://github.com/automl/nas_benchmarks for NAS-Bench-101 (Ying et al., 2019).
We modify them to be applicable on NAS-Bench-201 (Dong and Yang, 2020).
Note that like GCNBO, all these methods are sequential B = 1 , and thus should enjoy the same advantage mentioned above when measured against the number of architectures evaluated.
F. A DDITIONAL NAS-B ENCH R ESULTS
Validation Errors Against Number of Evaluations We show the validation errors against number of evaluations using both stochastic and deterministic validation errors of NAS-Bench datasets in Fig.
It is worth noting that regardless of whether the validation errors are stochastic or not, the test errors are always averaged to deterministic values for fair comparison.
It is obvious that NAS-BOWL still outperforms the other methods under this metric in achieving lower test error or enjoying faster convergence, or having both under most circumstances.
This corresponds well with the results on the test error in Fig.
4 and double-conﬁrms the superior performance of our proposed NAS-BOWL in searching optimal architectures.
Effect of Varying Pool Size As discussed in the main text, NAS-BOWL introduces no inherent hyperparameters that require manual tuning as it relies on a non-parametric surrogate.
Nonetheless, besides the surrogate, the choice on how to generate the candidate architectures requires us to specify [Figure] a number of parameters such as the pool size ( P , the number of candidate architectures to generate at each BO iteration) and batch size B .
In our main experiments, we have set P = 200 and B =throughout; in this section, we consider the effect of varying P to investigate whether the performance of NAS-BOWL is sensitive to this parameter.
We keep B = 5 but adjust P ∈ { 50 , 100 , 200 , 400 } , and keep all other settings to be consistent with the other experiments using the deterministic validation errors on NAS-Bench-101 (N101) (i.e. averaging the validation error seeds to remove stochasticity), and we report our results in Fig.where the median result is computed from 20 experiment repeats.
It can be shown that while the convergence speed varies slightly between the different P choices, for all choices of P apart fromwhich performs slightly worse, NAS-BOWL converges to similar validation and test errors at the end of 150 architecture evaluations – this suggests that the performance of NAS-BOWL is rather robust to the value of P and that our recommendation of P = 200 does perform well both in terms of both the ﬁnal solution returned and the convergence speed. [Figure]
Ablation Studies
In this section we perform ablation studies on the NAS-BOWL performance on both N101 and N201 (with deterministic validation errors).
We repeat each experiment 20 times, and we present the median and standard error in terms of both validation and test performances in Fig.(N101 in (a)(b) and N201 in (c)(d)).
We now explain each legend as follow:
1. mutate : Full NAS-BOWL with the mutation described in Sec.
3.2 (identical to NASBOWLm in Figs.
10 and 4);
rand : NAS-BOWL with random candidate generation.
This is identical to NASBOWLr in Figs.
10 and 4; 3.
UCB : NAS-BOWL with random candidate generation, but with the acquisition function changed from Expected Improvement (EI) to Upper Conﬁdence Bound (UCB) Srinivas et al.
α acq = µ + β n σ , where µ, σ are the predictive mean and standard deviation of the GPWL surrogate, respectively and β n is a coefﬁcient that changes as a function of n , the number of BO iterations.
We select β at initialisation ( β 0 ) to 3 , but decay it according to β n = β 0 (cid:113) 12 log(2( n + 1)) as suggested by Srinivas et al.
(2009), where n is the number of BO iterations.
VH : NAS-BOWL with random candidate generation, but instead of leaving the value of h (number of WL iterations) to be automatically determined by the optimisation of the GP log marginal likelihood, we set h = 0 ,
i
e. no WL iteration takes place and the only features we use are the counts of each type of original node operation features (e
g. conv3 × 3-bn-relu ).
This essentially reduces the WL kernel to a Vertex Histogram (VH) kernel.
[Figure]
We ﬁnd that topological information and using an appropriate h are highly crucial: in both N101 and
N201, VH signiﬁcantly underperforms the other variants, although the extent of underperformance is smaller in N201 likely due to its smaller search space.
This suggests that how the nodes are connected, which are extracted as higher-order WL features, are very important, and the multi-scale feature extraction in the WL kernel is crucial to the success of NAS-BOWL.
On the other hand, the choice of the acquisition function seems not to matter as much, as there is little difference between UCB and WL runs in both N101 and N201.
Finally, using mutation algorithm leads to a signiﬁcant improvement in the performance of NAS-BOWL, as we have already seen in the main text.
G O PEN - DOMAIN E XPERIMENTAL D ETAILS
All experiments were conducted on a machine with an Intel Xeon-W processor with 64 GB RAM and a single NVIDIA GeForce RTX 2080 Ti GPU with 11 GB VRAM.
G. S EARCH S PACE
Our search space is identical to that of DARTS (Liu et al., 2018a): it is in the popular NASNet search space, and we limit the maximum number of operation nodes to be 4 (in addition to 2 input nodes and 1 input node in each cell), and the possible node operations are 3 × 3 and 5 × 5 separable convolutions ( sep-conv-3 × 3 and
sep-conv-5 × 5 ), 3 × 3 and 5 × 5 dilated convolutions ( dil-conv-3 × 3 and dil-conv-5 × 5 ), 3 × 3 max pooling and average pooling ( max-pool-3 × 3 and avg-pool-3 × 3 ), identity skip connection ( skip-connect ) and zeroise ( none ).To
enable the application of the GPWL surrogate without modiﬁcation, we use the ENASstyle node-attributed DAG representation of the cells (this representation can be easily converted to the
DARTS-style edge-attributed DAG without any loss of information).
We show the best cell identiﬁed by NAS-BOWL in the DARTS search space in both edge- and node-attributed DAG representations in Fig, 13 as an example.
[Figure]
G. E XPERIMENTAL S ETUP
We mostly follow the setup and the code base ( https://github.com/quark0/darts ) from
DARTS (Liu et al., 2018a), and we detail the setup in full below:
Architecture Search
During the architecture search, we use half of the CIFAR-10 training data and leave the other half as the validation set.
We use stack the search cell 8 times to produced a small network, and use batch size of 64 and initial number of channels of 16.
As discussed, we only search one cell, and use this for both normal and reduction cells (in DARTS the two cells are searched separately).
We use SGD optimiser with momentum of 0.9, weight decay of 3 × 10 − 4 and an initial learning rate of 0.025 which is cosine annealed to zero over 50 epochs.
As known by previous works (Liu et al., 2018a), the validation performance on CIFAR-10 is very volatile, and to ameliorate this we feed the average of the validation accuracy of the ﬁnal 5 epochs as the observed accuracy to the
GPWL surrogate.
We use the identical setup for GPWL surrogate as the NAS-Bench experiments and we use the standard mutation algorithm described to generate the candidates every BO iteration.
Architecture Evaluation After the search budget (set to 150 architectures) is exhausted, we evaluate the neural network stacked from the best architecture found, based on the validation accuracy during the search stage .
During evaluation, we construct a larger network of 20 cells and is trained for 600 epochs with batch size 96 and initial number of channels of 36.
Additional enhancements that are almost universally used in previous works, such as path dropout of probability 0.2, cutout, and auxiliary towers with weight 0.4 are also applied in this stage (these techniques are all identical to those used in Liu et al.
(2018a)).
Any other enhancements not used in DARTS such as mixup, AutoAugment and test-time data augmentation are not applied.
The optimiser setting is identical to that during architecture search, with the exception that the cosine annealing is over the full 600 epochs instead of 50 during search.
During this stage, we use the entire CIFAR-10 training set for training, and report best accuracy encountered during evaluation on the validation set in Table 1.
We ﬁnally train the ﬁnal architecture for 4 random repeats on CIFAR-10 dataset.
[Figure]