PC-DARTS: P ARTIAL C HANNEL C ONNECTIONS FOR M EMORY -E FFICIENT A RCHITECTURE S EARCH
Anonymous authors
Paper under double-blind review
A BSTRACT
Differentiable architecture search (
DARTS) provided a fast solution in ﬁnding effective network architectures but suffered from large memory and computing overheads in jointly training a super-net and searching for an optimal architecture
In this paper
, we present a novel approach, namely
Partially-Connected
DARTS
, by sampling a small part of super-net to reduce the redundancy in ex ploring the network space thereby performing a more efﬁcient search without comprising the performance
In particular
, we perform operation search in a sub
- set of channels while bypassing the held out part in a shortcut
This strategy may suffer from an undesired inconsistency on selecting the edges of super-net caused by sampling different channels
We solve it by introducing edge normalization which adds a new set of edge-level hyper-parameters to reduce uncertainty in search.
Thanks to the reduced memory cost
PC-DARTS can be trained with a larger batch size and consequently enjoy both faster speed and higher train ing stability
Experiment results demonstrate the effectiveness of the proposed method
Speciﬁcally
, we achieve an error rate of on CIFAR within merely
1 GPU- days for architecture search and a state- of
-the-art top- error rate of on
ImageNet (under the mobile setting) within
8 GPU-days for search.
Our code has been made available at https://www.dropbox.com/ sh/on9lg3rpx1r6dkf/AABG5mt0sMHjnEJyoRnLEYW4a?dl=0 .
I NTRODUCTION
Neural architecture search (NAS) emerges as an important branch of automatic machine learning (AutoML), and has been attracting increasing attentions from both academia and industry.
The key methodology of NAS is to build a large space of network architectures, develop an efﬁcient algorithm to explore the space, and discover the optimal structure under a combination of training data and constraints ( e.g. , network size and latency).
Different from early approaches that often incur large computation overheads (Zoph & Le, 2017;
Zoph et al., 2018; Real et al., 2019), recent oneshot approaches (Pham et al., 2018; Liu et al., 2019) have reduced the search costs by orders of magnitudes, which advances its applications to many real-world problems.
In particular, DARTS (Liu et al., 2019) converts the operation selection into weighting a ﬁxed set of operations.
This makes the entire framework differentiable to architecture hyper-parameters and thus the network search can be efﬁciently accomplished in an end-to-end fashion.
Despite its sophisticated design, DARTS is still subject to a large yet redundant space of network architectures and thus suffers from heavy memory and computation overheads.
This prevents the search process from using larger batch sizes for either speedup or higher stability.
Prior work (Chen et al., 2019) proposed to reduce the search space, which leads to an approximation that may sacriﬁce the optimality of the discovered architecture.
In this paper, we present a simple yet effective approach named Partially-Connected DARTS (PCDARTS) to reduce the burdens of memory and computation.
The core idea is intuitive: instead of sending all channels into the block of operation selection, we randomly sample a subset of them in each step, while bypassing the rest directly in a shortcut.
We assume the computation on this subset is a surrogate approximating that on all the channels.
Besides the tremendous reduction in memory and computation costs, channel sampling brings another beneﬁt – operation search is regularized and less likely to fall into local optima.
However, PC-DARTS incurs a side effect, where the selection of channel connectivity would become unstable as different subsets of channels are sampled across iterations.
Thus, we introduce edge normalization to stabilize the search for network connectivity by explicitly learning an extra set of edge-selection hyper-parameters.
By sharing these hyper-parameters throughout the training process, the sought network architecture is insensitive to the sampled channels across iterations and thus is more stable.
Beneﬁting from the partial connection strategy, we are able to greatly increase the batch size.
Specifically, as only 1 /K of channels are randomly sampled for an operation selection, it reduces the memory burden by almost K times.
This allows us to use a K times larger batch size during search, which not only accelerates the network search but also stabilizes the process particularly for largescale datasets.
Experiments on benchmark datasets demonstrate the effectiveness of PC-DARTS.
Speciﬁcally, we achieve an error rate of 2 .
57% in less than 0 .
1 GPU-days (around 1 . 5 hours) on a single GPU, surpassing the result of 2 .
76% reported by DARTS that required an entire GPU-day.
Furthermore, PC-DARTS allows a direct search on ImageNet (while DARTS failed due to low stability), and sets the state-of-the-art record with a top-1 error of 24 .
2% (under the mobile setting) in only 3 .
8 GPU-days ( 11 . 5 hours) on eight GPUs.
The remainder of this paper is organized as follows.
Section 2 reviews related works, and Sectionpresents our approach.
Experiments are demonstrated in Section 4, and we conclude in Section 5.
R ELATED W ORK
Thanks to the rapid development of deep learning, signiﬁcant gain in performance has been brought to a wide range of computer vision problems, most of which owed to manually desgined network architectures (Krizhevsky et al., 2012; Simonyan & Zisserman, 2015; He et al., 2016; Huang et al., 2017).
Recently, a new research ﬁeld named neural architecture search (NAS) has been attracting increasing attentions.
The goal is to ﬁnd automatic ways of designing neural architectures to replace conventional handcrafted ones.
According to the heuristics to explore the large architecture space, existing NAS approaches can be roughly divided into three categories, namely, evolution-based approaches, reinforcement-learning-based approaches and one-shot approaches.
The ﬁrst type of architecture search methods (Liu et al., 2018b; Xie & Yuille, 2017; Real et al., 2017;
Elsken et al., 2019; Real et al., 2019; Miikkulainen et al., 2019) adopted evolutionary algorithms, which assumed the possibility of applying genetic operations to force a single architecture or a family evolve towards better performance.
Among them, Liu et al.
(Liu et al., 2018b) introduced a hierarchical representation for describing a network architecture, and Xie et al.
(Xie & Yuille, 2017) decomposed each architecture into a representation of ‘genes’.
Real et al.
(Real et al., 2019) proposed aging evolution which improved upon standard tournament selection, and surpassed the best manually designed architecture since then.
Another line of heuristics turns to reinforcement learning (RL) (Zoph & Le, 2017; Baker et al., 2017; Zoph et al., 2018; Zhong et al., 2018;
Liu et al., 2018a), which trained a meta-controller to guide the search process in the huge architecture space.
Zoph et al.
(Zoph & Le, 2017)
ﬁrst proposed using a controller-based recurrent neural network to generate hyper-parameters of neural networks.
To reduce the computation cost, researchers started to search for blocks or cells (Zhong et al., 2018; Zoph et al., 2018) instead of the entire network, and consequently, (Zoph et al., 2018) managed to reduce the overall computational costs by a factor of 7 .
Other kinds of approximation, such as greedy search (Liu et al., 2018a), were also applied to further accelerate search.
Nevertheless, the computation costs of these approaches, based on either evolution or RL, are still beyond acceptance.
In order to accomplish architecture search within a short period of time, researchers considered to reduce the costs of evaluating each searched candidate.
Early efforts include sharing weights between searched and newly generated networks (Cai et al., 2018), and later these methods were generalized into a more elegant framework named one-shot architecture search (Brock et al., 2018;
Cai et al., 2019; Liu et al., 2019; Pham et al., 2018; Xie et al., 2019).
In these approaches, an overparameterized network or super network covering all candidate operations was trained only once, and the ﬁnal architecture is obtained from sampling from this super network.
Among them, Brock et al.
(Brock et al., 2018) trained the over-parameterized network by a HyperNet (Ha et al., 2017), and
Pham et al.
(Pham et al., 2018) proposed to share parameters among child models to avoid retraining each candidate from scratch.
This paper is based on DARTS (Liu et al., 2018b), which introduced a differentiable framework for architecture search, and thus combine the search and evaluation stages into one.
A super-network is
3x3 sep 5x5sep
Identity … …
+ + +
Concat Sample
[Figure]
+ 𝑞 1,
[Figure]
Partial Channel Connection
Edge Normalization 𝑝 𝑜𝐱𝐱𝐱𝑓 0,3PC (𝐱 0 ;𝐒 0,3 ) 𝑓 1,3PC (𝐱 1 ;𝐒 1,3 ) 𝑓 2,3PC (𝐱 2 ;𝐒 2,3 ) 𝐱 3PC 𝐱𝐒 0, 𝑓 0,3PC (𝐱 0 ;𝐒 0,3 )
𝑝 𝑜 = exp{𝛼 𝑖,𝑗𝑜 } σ 𝑜 ′ ∈𝒪 exp{𝛼 𝑖,𝑗𝑜 ′ } 𝑞
𝑖,𝑗 =
exp{𝛽 𝑖,𝑗 } σ 𝑖 ′ <
𝑗 exp{𝛽 𝑖 ′ ,𝑗 } 𝑝 𝑜𝑝 𝑜    optimized during the search stage, after which the strongest sub-network is preserved and then retrained.
Despite its simplicity, researchers detected some of its drawbacks, such as instability (Li & Talwalkar, 2019; Sciuto et al., 2019), which led to a few improved approaches beyond DARTS (Cai et al., 2019; Xie et al., 2019; Chen et al., 2019).
In particular, ProxylessNAS (Cai et al., 2019) was the ﬁrst method that searched directly on ImageNet, and P-DARTS
(Chen et al., 2019) designed a progressive search stage to bridge the depth gap between the super-network and the sub-network.
T HE P ROPOSED A PPROACH 3. P RELIMINARIES : D IFFERENTIABLE A RCHITECTURE S EARCH (DARTS)
We ﬁrst review the baseline DARTS (Liu et al., 2019), and deﬁne the notations for the discussion later.
Mathematically, DARTS decomposes the searched network into a number ( L ) of cells.
Each cell is represented as a directed acyclic graph (DAG) with N nodes, where each node deﬁnes a network layer.
There is a pre-deﬁned space of operations denoted by O , in which each element, o ( · ) , is a ﬁxed operation ( e.g. , identity connection, and 3 × 3 convolution) performed at a network layer.
Within a cell, the goal is to choose one operation from O to connect each pair of nodes.
Let a pair of nodes be ( i, j ) , where 0 (cid:54)
i < j (cid:54) N − 1 , the core idea of DARTS is to formulate the information propagated from i to j as a weighted sum over |O| operations, namely, f i,j ( x i ) =
(cid:80) o [Equation]
[Equation]
i,j } · o ( x i ) , where x i is the output of the i -th node, and α oi,j is a hyper-parameter for weighting operation o ( x i ) .
The output of a node is the sum of all input ﬂows, i.e. , x j = (cid:80) i<
j f i,j ( x i ) , and the output of the entire cell is formed by concatenating the output of nodes x 2 – x N − 1 , i.e. , concat( x 2 , x 3 , . . .
x N − 1 ) .
Note that the ﬁrst two nodes, x 0 and x 1 , are input nodes to a cell, which are ﬁxed during architecture search.
This design makes the entire framework differentiable to both layer weights and hyper-parameters α oi,j , so that it is possible to perform architecture search in an end-to-end fashion.
After the search process is ﬁnished, on each edge ( i, j ) , the operation o with the largest α oi,j value is preserved, and each node j is connected to two precedents i < j with the largest α o i,j preserved.
3. P ARTIAL C HANNEL C ONNECTIONS
A drawback of DARTS lies in its memory inefﬁciency.
To accommodate |O| operations, in the main part of the searched architecture, |O| copies of operations and their outputs need to be stored at each node ( i.e. , each network layer), leading to |O|× memory to use.
To ﬁt into a GPU, one must reduce the batch size during search, which inevitably slows down search speed, and may deteriorate search stability and accuracy.
An alternative solution to memory efﬁciency is the partial channel connection as depicted in Figure 1.
Take the connection from x i to x j for example.
This involves deﬁning a channel sampling mask S i,j , which assigns 1 to selected channels and 0 to masked ones.
The selected channels are sent into mixed computation of |O| operations, while the masked ones bypass these operations, i.e. , they are directly copied to the output,
[Equation]
where, S i,j ∗ x i and (1 − S i,j ) ∗ x
i denote the selected and masked channels, respectively.
In practice, we set the proportion of selected channels to 1 /K by regarding K as a hyper-parameter.
By varying K , we could trade off between architecture search accuracy (smaller K ) and efﬁciency (larger K ) to strike a balance (See Section 4.4.1 for more details).
A direct beneﬁt brought by the partial channel connection is that the memory overhead of computing f PC i,j ( x i ; S i,j ) is reduced by K times.
This allows us to use a larger batch size for architecture search.
There are twofold beneﬁts.
First, the computing cost could be reduced by K times during the architecture search.
Moreover, the larger batch size implies the possibility of sampling more training data during each iteration.
This is particularly important for the stability of architecture search.
In most cases, the advantage of one operation over another is not signiﬁcant, unless more training data are involved in a mini-batch to reduce the uncertainty in updating the parameters of network weights and architectures.
3. E DGE N ORMALIZATION
Let us look into the impact of sampling channels on neural architecture search.
There are both positive and negative effects.
On the upside , by feeding a small subset of channels for operation mixture while bypassing the remainder, we make it less biased in selecting operations.
In other words, for edge ( i, j ) , given an input x i , the difference from using two sets of hyper-parameters (cid:8) α
oi,j (cid:9) and (cid:8) α (cid:48)
oi,j (cid:9) is largely reduced, because only a small part ( 1 /K ) of input channels would go through the operation mixture while the remaining channels are left intact.
This regularizes the preference of a weight-free operation ( e.g. , skip-connect , max-pooling , etc. ) over a weight-equipped one ( e.g. , various kinds of convolution ) in O .
In the early stage, the search algorithm often prefers weight-free operations, because they do not have weights to train and thus produce more consistent outputs, i.e. , o ( x i ) .
In contrast, the weight-equipped ones, before their weights are well optimized, would propagate inconsistent information across iterations.
Consequently, weight-free operations often accumulate larger weights (namely α oi,j ) at the beginning, and this makes it difﬁcult for the weightequipped operations to beat them even after they have been well trained thereafter.
This phenomenon is especially signiﬁcant when the proxy dataset (on which architecture search is performed) is difﬁcult, and this could prevent DARTS from performing satisfactory architecture search on ImageNet.
In experiments, we will show that PC-DARTS, with partial channel connections, produces more stable and superior performance on ImageNet.
On the downside , in a cell, each output node x j needs to pick up two input nodes from its precedents { x 0 , x 1 , . . .
, x j − 1 } , which are weighted by max o α o 0 ,j , max o α o 1 ,j , . . .
, max
[Equation]
α
[Equation]
− 1 ,j , respectively, following the original DARTS.
However, these architecture parameters are optimized by randomly sampled channels across iterations, and thus the optimal connectivity determined by them could be unstable as the sampled channels change over time.
This could cause undesired ﬂuctuation in the resultant network architecture.
To mitigate this problem, we introduce edge normalization that weighs on each edge ( i, j ) explicitly, denoted by β i,j , so that the computation of x j becomes:
[Equation]
Speciﬁcally, after the architecture search is done, the connectivity of edge ( i, j ) is determined by both (cid:8)
α oi,j (cid:9) and β i,j , for which we multiply the normalized coefﬁcients together, i.e. , multiplying exp { β i,j } (cid:80) i (cid:48) <
j exp { β i (cid:48) ,j } with exp { α oi,j } (cid:80) o
(cid:48)∈O exp { α o (cid:48)
i,j } .
Then the edges are selected by ﬁnding the large edge weights as in DARTS.
Since β i,j are shared through the training process, the learned network architecture is insensitive to the sampled channels across iterations, making the architecture search more stable.
In Section 4.4.2, we will show that edge normalization is also effective over the original DARTS.
Finally, the extra computation overhead required for edge normalization is negligible.
3. D ISCUSSIONS AND R ELATIONSHIP TO P RIOR W ORK
First of all, we hope to deliver the insights behind our approach, which are not trivial.
There are two major contributions, namely, channel sampling and edge normalization.
Channel sampling, as the key technique in this work, has not been studied in NAS for reducing computational overhead (other regularization methods like Dropout (Srivastava et al., 2014) and DropPath (Larsson et al., 2017) cannot achieve the same efﬁciency, in both time and memory, as channel sampling).
It accelerates and regularizes search and, with the help of edge normalization, improves search stability.
Note that both search speed and stability are very important for a search algorithm.
Combining channel sampling and edge normalization, we obtain the best accuracy on ImageNet (based on the DARTS search space), and the direct search cost on ImageNet ( 4 GPU-days) is the lowest known.
Moreover, these two components are easily transplanted to other search algorithms to improve search accuracy and speed, e.g. , edge normalization boosts the accuracy and speed of the original DARTS methods signiﬁcantly (Table 3).
Other researchers also tried to alleviate the large memory consumption of DARTS.
Among prior efforts, ProxylessNAS (Cai et al., 2019) binarized the multinomial distribution α oi,j and samples two paths at each time, which signiﬁcantly reduced memory cost and enabled direct search on ImageNet.
PARSEC (Casale et al., 2019) also proposed a sampling-based optimization method to learn a probability distribution.
Our solution, by preserving all operations for architecture search, achieves a higher accuracy in particular on challenging datasets like ImageNet ( +0 . 7% over ProxylessNAS and +1 .
8% over PARSEC).
Another practical method towards memory efﬁciency is ProgressiveDARTS (Chen et al., 2019), which eliminated a subset of operators in order to provide sufﬁcient memory for deeper architecture search.
In comparison, our approach preserves all operators and instead performs sub-sampling on the channel dimension.
This strategy works better in particular on large-scale datasets like ImageNet.
E XPERIMENTS 4. D ATASETS AND I MPLEMENTATION D ETAILS
We perform experiments on CIFAR10 and ImageNet, two most popular datasets for evaluating neural architecture search.
CIFAR10 (Krizhevsky & Hinton, 2009) consists of 60K images, all of which are of a spatial resolution of 32 × 32 .
These images are equally distributed over 10 classes, with 50K training and 10K testing images.
ImageNet (Deng et al., 2009) contains 1 , 000 object categories, and
3M training images and 50K validation images, all of which are high-resolution and roughly equally distributed over all classes.
Following the conventions (Zoph et al., 2018; Liu et al., 2019), we apply the mobile setting where the input image size is ﬁxed to be 224 × 224 and the number of multi-add operations does not exceed 600M in the testing stage.
Following DARTS (Liu et al., 2019) as well as conventional architecture search approaches, we use an individual stage for architecture search, and after the optimal architecture is obtained, we conduct another training process from scratch.
In the search stage, the goal is to determine the best sets of hyper-parameters, namely (cid:8)
α o
i,j (cid:9) and { β i,j } for each edge ( i, j ) .
To this end, the trainnig set is partitioned into two parts, with the ﬁrst part used for optimizing network parameters, e.g. , convolutional weights, and the second part used for optimizing hyper-parameters.
The entire search stage is accomplished in an end-to-end manner.
For fair comparison, the operation space O remains the same as the convention, which contains 8 choices, i.e. , 3 × 3 and 5 × 5 separable convolution , 3 × 3 and 5 × 5 dilated separable convolution , 3 × 3 max-pooling , 3 × 3 average-pooling , skip-connect ( identity ), and zero ( none ).
[Table]
We propose an alternative and more efﬁcient implementation for partial channel connections.
For edge ( i, j ) , we do not perform channel sampling at each time of computing o ( x i ) , but instead choose the ﬁrst 1 /K channels of x i for operation mixture directly.
To compensate, after x j is obtained, we shufﬂe its channels before using it for further computations.
This is the same implementation used in ShufﬂeNet (Zhang et al., 2018), which is more GPU-friendly and thus runs faster.
4. R ESULTS ON CIFAR
In the search scenario, the over-parameterized network is constructed by stacking 8 cells ( 6 normal cells and 2 reduction cells), and each cell consists of N = 6 nodes.
We train the network forepochs, with the initial number of channels being 16 .
The 50K training set of CIFAR10 is split into two subsets with equal size, with one subset used for training network weights and the other used for architecture hyper-parameters.
We set K = 4 for CIFAR10, i.e. , only 1 / 4 features are sampled on each edge, so that the batch size during search is increased to 256 .
Besides, following (Chen et al., 2019), we freeze network hyper-parameters and only allow network parameters to be tuned in the ﬁrst 15 epochs.
This is to provide a warm-up for network parameters and thus alleviates the drawback of parameterized operations.
The total memory cost is less than 12GB so that we can train it on most modern GPUs.
The network weights are optimized by momentum SGD, with an initial learning rate of 0 .
1 (annealed down to zero following a cosine schedule without restart), a momentum of 0.9, and a weight decay of 3 × 10 − 4 .
We use the Adam optimizer (Kingma & Ba, 2015) for hyper-parameters (cid:8)
α oi,j (cid:9) and { β i,j } , with a ﬁxed learning rate of 6 × 10 − 4 , a momentum of (0 . 5 , 0 . 999) and a weight decay of 10 − 3 .
Owing to the increased batch size, the entire search process only requires 3 hours on a single
NVIDIA GTX 1080Ti GPU, or 1 .
5 hours on a single Tesla V100 GPU, which is almost 4 × faster than the original ﬁrst-order DARTS.
The evaluation stage simply follows that of DARTS.
The network is composed of 20 cells ( 18 normal cells and 2 reduction cells), and each type of cells share the same architecture.
The initial number of channels is 36 .
The entire 50K training set is used, and the network is trained from scratch for 600 epochs using a batch size of 128 .
We use the SGD optimizer with an initial learning rate of 0 .
025 (annealed down to zero following a cosine schedule without restart), a momentum of 0 .
9 , a weight decay of 3 × 10 − 4 and a norm gradient clipping at 5 .
Drop-path with a rate of 0 .
3 as well as cutout (DeVries & Taylor, 2017) is also used for regularization.
We visualize the searched normal and reduction cells in the left-hand side of Figure 2.
[Figure]
and comparison summarized in
57% , with both search time and accuracy surpassing the baseline, DARTS, signiﬁcantly.
To the best of our knowledge, our approach is the fastest one that achieves an error rate of less than 3% .
Our number ranks among the top of recent architecture search results.
ProxylessNAS used a different protocol to achieve an error rate of 2 .
08% , and also reported a much longer time for architecture search.
P-DARTS
(Chen et al., 2019) slightly outperforms our approach by searching over a deeper architecture, which we can integrate our approach into
P-DARTS to accelerate it as well as improve its performance (consistent accuracy gain is obtained).
4. R ESULTS ON I MAGE N ET
We slightly modify the network architecture used on CIFAR10 to ﬁt ImageNet.
The overparameterized network starts with three convolution layers of stride 2 to reduce the input image resolution from 224 × 224 to 28 × 28 .
8 cells ( 6 normal cells and 2 reduction cells) are stacked beyond this point, and each cell consists of N = 6 nodes.
To reduce search time, we randomly sample two subsets from the 1 .
3M training set of ImageNet, with 10% and 2 .
5% images, respectively.
The former one is used for training network weights and the latter for updating hyper-parameters.
ImageNet is much more difﬁcult than CIFAR10.
To preserve more information, we use a subsampling rate of 1 / 2 , which doubles that used in CIFAR10.
Still, a total of 50 epochs are trained and architecture hyper-parameters are frozen during the ﬁrst 35 epochs.
For network weights, we use a momentum SGD with an initial learning rate of 0 .
5 (annealed down to zero following a cosine schedule without restart), a momentum of 0 . 9 , and a weight decay of 3 × 10 − 5 .
For hyper-parameters, we use the Adam optimizer (Kingma & Ba, 2015) with a ﬁxed learning rate of 6 × 10 − 3 , a momentum (0 . 5 , 0 . 999) and a weight decay of 10 − 3 .
We use eight Tesla V100 GPUs for search, and the total batch size is 1 , 024 .
The entire search process takes around 11 .
5 hours.
We visualize the searched normal and reduction cells in the right-hand side of Figure 2.
The evaluation stage follows that of DARTS, which also starts with three convolution layers of stride 2 that reduce the input image resolution from 224 × 224 to 28 × 28 .
14 cells ( 12 normal cells andreduction cells) are stacked beyond this point, with the initial channel number being 48 .
The network is trained from scratch for 250 epochs using a batch size of 1 , 024 .
We use the SGD optimizer with a momentum of 0 .
9 , an initial learning rate of 0 .
5 (decayed down to zero linearly), and a weight decay of 3 × 10 − 5 .
Additional enhancements are adopted including label smoothing and an auxiliary loss tower during training.
Learning rate warm-up is applied for the ﬁrst 5 epochs.
Results are summarized in Table 2.
Note that the architectures searched on CIFAR10 and ImageNet itself are both evaluated.
For the former, it reports a top-1/5 error of 25 . 1% / 7 . 8% , which signiﬁcantly
[Table]
gradient-based SNAS (mild) (Xie et al., 2019) 27.
gradient-based
ProxylessNAS (GPU) ‡
(Cai et al., 2019) 24.
gradient-based P-DARTS (CIFAR10) (Chen et al., 2019) 24. gradient-based P-DARTS (CIFAR100) (Chen et al., 2019) 24.
gradient-based BayesNAS (Zhou et al., 2019) 26.
gradient-based
PC-DARTS (CIFAR10) 25.
gradient-based
PC-DARTS (ImageNet) ‡ 24.
gradient-based outperforms 26 .
7% reported by DARTS.
This is impressive given that our search time is much shorter.
For the latter, we achieve a top-1/5 accuracy of 24 .
2% / 7 . 3% , which is the best known performance to date.
In comparison, ProxylessNAS (Cai et al., 2019), another approach that directly searched on ImageNet, used almost doubled time to produce 24 . 9% / 7 . 5% , which veriﬁes that our strategy of reducing memory consumption is more efﬁcient yet effective.
[Figure] [Figure]
parison between our approach with different sampling rates, namely, 1 / 1 , 1 / 2 , 1 / 4 and 1 / 8 , among which 1 / 4 makes a nice tradeoff between accuracy and efﬁciency.
[Table]
4. A BLATION S TUDY 4.4. E FFECTIVENESS OF C HANNEL P ROPORTION 1 /K
We ﬁrst evaluate K , the hyper-parameter that controls the sampling rate of channels.
Note that a tradeoff exists: increasing the sampling rate ( i
[Table]
e. , using a smaller K ) allows more accurate information to be propagated, while sampling a smaller portion of channels casts heavier regularization and may alleviate over-ﬁtting.
To study its impacts, we evaluate the performance produced by four
[Table]
sampling rates, namely 1 / 1 , 1 / 2 , 1 / 4 and 1 / 8 , on CIFAR
[Table]
and plot the results into a diagram of search time and accuracy in Figure 3.
One can observe that a sampling rate of 1 / 4 yields superior performance over 1 / 2 and 1 / 1 in terms of both time and accruacy.
Using 1 / 8 , while being able to further reduce search time, causes a dramatic accuracy drop.
These experiments not only justify the tradeoff between accuracy and efﬁciency of architecture search, but also reveal the redundancy of super-network optimization in the context of NAS.
More essentially, this reﬂects the gap between search and evaluation,
i
[Table]
e. , a better optimized super-network does not guarantee a better searched architecture – in other words, differentiable NAS approaches are easily to over-ﬁt on the super-network.
From this viewpoint, channel sampling plays the role of regularization, which shrinks the gap between search and evaluation.
4.4. C ONTRIBUTIONS OF D IFFERENT C OMPONENTS OF PC-DARTS
Next, we evaluate the contributions made by two components of PC-DARTS, namely, partial channel connections and edge normalization.
The results are summarized in Table 3.
It is clear that edge normalization brings the effect of regularization even when the channels are fully-connected.
Being a component with very few extra costs, it can be freely applied to a wide range of approaches involving edge selection.
In addition, edge normalization cooperates well with partial channel connections to provide further improvement.
Without edge normalization, our approach can suffer low stability in both the number of network parameters and accuracy.
On CIFAR10, we run search without edge normalization for several times, and the testing error ranges from 2 .
54% to 3 .
On the other hand, with edge normalization, the maximal difference among ﬁve runs does not exceed 0 .
Therefore, we justify our motivation in designing edge normalization (see Section 3.3, i.e. , it can be a standalone method for stabilizing architecture search, yet it works particularly well under partial channel connection, since the latter introduces randomness and stabilization indeed helps.
4.4. S TABILITY OF O UR A PPROACH
In this part, we demonstrate the stability of our approach from three different perspectives.
Results are summarized in Table 4, with detailed analysis below.
• First, we evaluate the stability of different approaches by conducting 5 independent search runs.
We re-implement DARTS-v1 and DARTS-v2 with the proposed code, as well as that of our approach, and perform ﬁve individual search processes with the same hyperparameters but different random seeds (0, 1, 2, 3, 4).
The architectures found by DARTS in different runs, either v1 or v2, suffer much higher standard deviations than that of our approach (DARTS-v1: ± 0 .
15% , DARTS-v2: ± 0 .
21% , PC-DARTS: ± 0 .
• Next, we study how the search algorithm is robust to hyper-parameters, e.g. , the length of the search stage.
We try different numbers of epochs, from 50 to 125 , and observe how it impacts the performance of searched architectures.
Again, we ﬁnd that both DARTS-v and DARTS-v2 are less robust to this change.
Third, we go one step further by enlarging the search space, allowing a larger number of nodes to appear in each cell – the original DARTS-based space has 6 nodes, and here we allow 5 , 6 and 7 nodes.
From 5 to 6 nodes, the performance of all three algorithms goes up, while from 6 to 7 nodes, DARTS-v2 suffers a signiﬁcant accuracy drop, while PC-DARTS mostly preserves it performance.
As a side note, all these algorithms fail to gain accuracy
[Table]
in enlarged search spaces
[Table]
because CIFAR10 is relatively simple and the performance of searched architectures seems to saturate.
With all the above experiments
[Table]
we can conclude that PC-DARTS is indeed more robust than DARTS in different scenarios of evaluation.
This largely owes to the regularization mechanism introduced by
PC-DARTS, which (i) forces it to adjust to dynamic architectures, and (ii) avoids the large pruning gap after search, brought by the none operator.
4. T RANSFERRING TO O BJECT D ETECTION
To further validate the performance of the architecture found by PC-DARTS, we use it as the backbone for object detection.
We plug the architecture found on ImageNet, as shown in Figure 2, into a popular object detection framework named Single-Shot Detectors (SSD) (Liu et al., 2016).
We train the entire model on the MS-COCO (Lin et al., 2014) trainval dataset, which is obtained by a standard pipeline that excludes 5k images from the val set, merges the rest data into the 80k train set and evaluates it on the test-dev 2015 set.
Results are summarized in Table 5.
Results for SSD, YOLO and MobileNets are from (Tan et al., 2019).
With the backbone searched by PC-DARTS, we need only 1 .
2B FLOPs to achieve an AP of 28 .
9% , which is 5 .
7% higher than SSD
(but with 29 × fewer FLOPs), or 2 .
1% higher than
SSD512 (but with 83 × fewer FLOPs).
Compared to the ‘Lite’ versions of SSD, our result enjoys signiﬁcant advantages in AP, surpassing the most powerful one (SSDLiteV3) by an AP of 6 . 9% .
All these results suggest that the advantages obtained by PC-DARTS on image classiﬁcation can transfer well to object detection, a more challenging task, and we believe these architectures would beneﬁt even more application scenarios.
C ONCLUSIONS
In this paper, we proposed a simple and effective approach named partially-connected differentiable architecture search (PC-DARTS).
The core idea is to randomly sample a proportion of channels for operation search, so that the framework is more memory efﬁcient and, consequently, a larger batch size can be used for higher stability.
Additional contribution to search stability is made by edge normalization, a light-weighted module that requires merely no extra computation.
Our approach can accomplish a complete search within 0 .
1 GPU-days on CIFAR10, or 3 .
8 GPU-days on ImageNet, and report state-of-the-art classiﬁcation accuracy in particular on ImageNet.
This research delivers two important messages that are important for future research.
First, differentiable architecture search seems to suffer even more signiﬁcant instability compared to conventional neural network training, and so it can largely beneﬁt from both (i) regularization and (ii) a larger batch size.
This work shows an efﬁcient way to incorporate these two factors in a single pipeline, yet we believe there exist other (possibly more essential) solutions for this purpose.
Second, going one step further, our work reveals the redundancy of super-network optimization in NAS, and experiments reveal a gap between improving super-network optimization and ﬁnding a better architecture, and regularization plays an efﬁcient role in shrinking the gap.
We believe these insights can inspire future research in this ﬁeld, and we will also follow this path towards designing stabilized yet efﬁcient differentiable architecture search methods.