1 Introduction
Deep neural networks (DNNs) (lecun1989backpropagation, ) have been producing stateoftheart results in many challenging tasks including image classification guo2018double ; krizhevsky2012imagenet ; srivastava2015training ; zheng2014topic ; zheng2015deep ; Jiang:2017:VDE:3172077.3172161 ; guo2016shallow ; zhang2019whole
(schroff2015facenet, ; sun2015deeply, ; zheng2015neural, ), brain signal processing nam2018brain ; pan2016eeg , video analysis (wang2016temporal, ; zeng2019graph, ; zeng2019breaking, ) and many other areas zheng2016neural ; zheng2016implicit ; lauly2017document ; cao2018adversarial ; guo2019auto ; guo2018dual ; cao2019multi . One of the key factors behind the success lies in the innovation of neural architectures, such as VGG simonyan2014very and ResNethe2016deep . However, designing effective neural architectures is often laborintensive and relies heavily on substantial human expertise. Moreover, the humandesigned process cannot fully explore the whole architecture space and thus the designed architectures may not be optimal. Hence, there is a growing interest to replace the manual process of architecture design with Neural Architecture Search (NAS).Recently, substantial studies liu2018darts ; pham2018efficient ; zoph2016neural have shown that the automatically discovered architectures are able to achieve highly competitive performance compared to existing handcrafted architectures. However, there are some limitations in NAS based architecture design methods. In fact, since there is an extremely large search space pham2018efficient ; zoph2016neural (e.g., billions of candidate architectures), these methods often produce suboptimal architectures, leading to limited representation performance or substantial computation cost. Thus, even for a welldesigned model, it is necessary yet important to optimize its architecture (e.g., removing the redundant operations) to achieve better performance and/or reduce the computation cost.
To optimize the architectures, Luo et al. recently proposed a neural architecture optimization (NAO) method luo2018neural . Specifically, NAO first encodes an architecture into an embedding in continuous space and then conducts gradient descent to obtain a better embedding. After that, it uses a decoder to map the embedding back to obtain an optimized architecture. However, NAO comes with its own set of limitations. First, NAO often produces a totally different architecture from the input one and may introduce extra parameters or additional computation cost. Second, similar to the NAS based methods, NAO has a huge search space, which, however, may not be necessary for the task of architecture optimization and may make the optimization problem very expensive to solve. An illustrative comparison between our method and NAO can be found in Figure 1.
Unlike existing methods that design neural architectures, we seek to design an architecture optimization method, called Neural Architecture Transformer (NAT), to optimize neural architectures. Since the optimization problem is nontrivial to solve, we cast it into a Markov decision process (MDP). Thus, the architecture optimization process is reduced to a series of decision making problems. Based on MDP, we seek to replace the expensive operations or redundant modules in the architecture with more computationally efficient ones. Specifically, NAT shall remove the redundant modules or replace these modules with skip connections. In this way, the search space can be significantly reduced. Thus, the training complexity to learn an architecture optimizer is smaller than those NAS based methods, e.g., NAO. Last, it is worth mentioning that our NAT model can be used as a general architecture optimizer which takes any architecture as the input and output an optimized one. In experiments, we apply NAT to both handcrafted and NAS based architectures and demonstrate the performance on two benchmark datasets, namely CIFAR10 (krizhevsky2009learning, ) and ImageNet (deng2009imagenet, ).
The main contributions of this paper are summarized as follows.

[leftmargin=*]

We propose a novel architecture optimization method, called Neural Architecture Transformer (NAT), to optimize arbitrary architectures in order to achieve better performance and/or reduce computation cost. To this end, NAT either removes the redundant paths or replaces the original operation with skip connection to improve the architecture design.

We cast the architecture optimization problem into a Markov decision process (MDP), in which we seek to solve a series of decision making problems to optimize the operations. We then solve the MDP problem with policy gradient. To better exploit the adjacency information of operations in an architecture, we propose to exploit graph convolution network (GCN) to build the architecture optimization model.

Extensive experiments demonstrate the effectiveness of our NAT on both handcrafted and NAS based architectures. Specifically, for handcrafted models (e.g., VGG), our NAT automatically introduces additional skip connections into the plain network and results in 2.75% improvement in terms of Top1 accuracy on ImageNet. For NAS based models (e.g., DARTS liu2018darts ), NAT reduces 30% parameters and achieves 1.31% improvement in terms of Top1 accuracy on ImageNet.
2 Related Work
Handcrafted architecture design. Many studies focus on architecture design and propose a series of deep neural architectures, such as Networkinnetwork lin2013network , VGG simonyan2014very , GoogLeNet szegedy2015going and so on. Unlike these plain networks that only contain a stack of convolutions, He et al. propose the residual network (ResNet) he2016deep by introducing residual shortcuts between different layers. However, the humandesigned process often requires substantial human effort and cannot fully explore the whole architecture space, making the handcrafted architectures often not optimal.
Neural architecture search. Recently, neural architecture search (NAS) methods have been proposed to automate the process of architecture design zoph2016neural ; zoph2018learning ; pham2018efficient ; baker2016designing ; zhong2018practical ; liu2018darts ; cai2018proxylessnas ; vaswani2017attention ; so2019evolved . Some researchers conduct architecture search by modeling the architecture as a graph zhang2018graph ; jin2018learning . Unlike these methods, DSONAS zhang2018single finds the optimal architectures by starting from a fully connected block and then imposing sparse regularization huang2018data ; tan2014towards to prune useless connections. Besides, Jin et al. propose a Bayesian optimization approach jin2018efficient to morph the deep architectures by inserting additional layers, adding more filters or introducing additional skip connections. More recently, Luo et al. propose the neural architecture optimization (NAO) luo2018neural method to perform the architecture search on continuous space by exploiting the encodingdecoding technique. However, NAO is essentially designed for architecture search and often obtains very different architectures from the input architectures and may introduce extra parameters. Unlike these methods, our method is able to optimize architectures without introducing extra computation cost (See the detailed comparison in Figure 1).
Architecture adaptation and model compression. Several methods yang2018netadapt ; lemaire2019structured ; dai2019chamnet ; chen2015net2net
have been proposed to obtain compact architectures by learning the optimal settings of each convolution, including kernel size, stride and the number of filters. To obtain compact models, model compression methods
li2016pruning ; he2017channel ; luo2017thinet ; zhuang2018discrimination detect and remove the redundant channels from the original models. However, these methods only change the settings of convolution but ignore the fact that adjusting the connections in the architecture could be more critical. Recently, Cao et al. propose an automatic architecture compression method cao2019learnable . However, this method has to learn a compressed model for each given pretrained model and thus has limited generalization ability to different architectures. Unlike these methods, we seek to learn a general optimizer for any arbitrary architecture.3 Neural Architecture Transformer
3.1 Problem Definition
Given an architecture space , we can represent an architecture as a directed acyclic graph (DAG), i.e., , where is a set of nodes that denote the feature maps in DNNs and is an edge set zoph2016neural ; pham2018efficient ; liu2018darts , as shown in Figure 2. Here, the directed edge denotes some operation (e.g.,
convolution or max pooling) that transforms the feature map from node
to . For convenience, we divide the edges in into three categories, namely, , , , as shown in Figure 2. Here, denotes the skip connection, denotes the null connection (i.e., no edge between two nodes), and denotes the operations other than skip connection or null connection (e.g., convolution or max pooling). Note that different operations have different costs. Specifically, let be a function to evaluate the computation cost. Obviously, we have .In this paper, we seek to design an architecture optimization method, called Neural Architecture Transformer (NAT), to optimize any given architecture into a better one with the improved performance and/or less computation cost. To achieve this, an intuitive way is to make the original operation with less computation cost, e.g., using the skip connection to replace convolution or using the null connection to replace skip connection. Although the skip connection has slightly higher cost than the null connection, it often can significantly improve the performance he2016deep ; he2016identity . Thus, we enable the transition from null connection to skip connection to increase the representation ability of deep networks. In summary, we constrain the possible transitions among , , and in Figure 2 in order to reduce the computation cost.
Note that the architecture optimization on an entire network is still very computationally expensive. Moreover, we hope to learn a general architecture optimizer. Given these two concerns, we consider learning a computational cell as the building block of the final architecture. To build a cell, we follow the same settings as that in ENAS pham2018efficient . Specifically, each cell has two input nodes, i.e., and , which denote the outputs of the second nearest and the nearest cell in front of the current one, respectively. Each intermediate node (marked as the blue box in Figure 1) also takes two previous nodes in this cell as inputs. Last, based on the learned cell, we are able to form any final network.
3.2 Markov Decision Process for Architecture Optimization
In this paper, we seek to learn a general architecture optimizer , which transforms any into an optimized and is parameterized by . Here, we assume follows some distribution , e.g., multivariate uniformly discrete distribution. Let and be the welllearned model parameters of architectures and , respectively. We measure the performance of and by some metric and , e.g., the accuracy on validation data. For convenience, we define the performance improvement between and by .
To learn a good transformer to optimize arbitrary , we can maximize the expectation of performance improvement over the distribution of under a constraint of computation cost , where measures the cost of and is an upper bound of the cost. Then, the optimization problem can be written as
(1) 
Unfortunately, it is nontrivial to directly obtain the optimal given different . Nevertheless, following zoph2016neural ; pham2018efficient , given any architecture , we instead sample from some well learned policy, denoted by , namely . In other words, NAT first learns the policy and then conducts sampling from it to obtain the optimized architecture. In this sense, the parameters to be learned only exist in . To learn the policy, we solve the following optimization problem:
(2) 
where and denote the expectation operation over and , respectively.
This problem, however, is still very challenging to solve. First, the computation cost of deep networks can be evaluated by many metrics, such as the number of multiplyadds (MAdds), latency, and energy consumption, making it hard to find a comprehensive measure to accurately evaluate the cost. Second, the upper bound of computation cost in Eqn. (1) may vary for different cases and thereby is hard to determine. Even if there already exists a specific upper bound, dealing with the constrained optimization problem is still a typical NPhard problem. Third, how to compute remains a question.
To address the above challenges, we cast the optimization problem into an architecture transformation problem and reformulate it as a Markov decision process (MDP). Specifically, we optimize architectures by making a series of decisions to alternate the types of different operations. Following the transition graph in Figure 2, as , we can naturally obtain more compact architectures than the given ones. In this sense, we can achieve the goal to optimize arbitrary architecture without introducing extra cost into the architecture. Thus, for the first two challenges, we do not have to evaluate the cost or determine the upper bound
. For the third challenge, we estimate the expectation value by sampling architectures from
and (See details in Section 3.4).MDP formulation details. A typical MDP schulman2015trust is defined by a tuple , where is a finite set of states, is a finite set of actions, is the state transition distribution, is the reward function, is the distribution of initial state, and is a discount factor. Here, we define an architecture as a state, a transformation mapping as an action. Here, we use the accuracy improvement on the validation set as the reward. Since the problem is a onestep MDP, we can omit the discount factor . Based on the problem definition, we transform any into an optimized architecture with the policy . Then, the main challenge becomes how to learn an optimal policy . Here, we exploit reinforcement learning williams1992simple to solve the problem and propose an efficient policy learning algorithm.
Search space of over a cell structure. For a cell structure with nodes and three states for each edge, there are edges and the size of the search space is . Thus, NAT has a much smaller search space than NAS methods pham2018efficient ; zoph2016neural , i.e., , where denotes the number of candidate operations (e.g., in ENAS pham2018efficient and in DARTS liu2018darts ).
3.3 Policy Learning by Graph Convolutional Neural Networks
To learn the optimal policy w.r.t. an arbitrary architecture , we propose an effective learning method to optimize the operations inside the architecture. Specifically, we take an arbitrary architecture graph as the input and output the optimization policy w.r.t . Such a policy is used to optimize the operations of the given architecture. Since the choice of operation on an edge depends on the adjacent nodes and edges, we have to consider the attributes of both the current edge and its neighbors. For this reason, we employ a graph convolution networks (GCN) kipf2016semi to exploit the adjacency information of the operations in the architecture. Here, an architecture graph can be represented by a data pair , where denotes the adjacency matrix of the graph and denotes the attributes of the nodes together with their two input edges^{1}^{1}1Due to the page limit, we put the detailed representation methods in the supplementary.. We consider a twolayer GCN and formulate the model as:
(3) 
where and denote the weights of two graph convolution layers, denotes the weight of the fullyconnected layer,
is a nonlinear activation function (
e.g., the Rectified Linear Unit (ReLU)
nair2010rectified ), andrefers to the probability distribution of different candidate operations on the edges,
i.e., the learned policy . For convenience, we denote as the parameters of the architecture transformer. To cover all possible architectures, we randomly sample architectures from the whole architecture space and use them to train our model.Differences with LSTM.
The architecture graph can also be processed by the long shortterm memory (LSTM)
hochreiter1997long , which is a common practice in NAS methods luo2018neural ; zoph2016neural ; pham2018efficient . In these methods, LSTM first treats the graph as a sequence of tokens and then learns the information from the sequence. However, turning a graph into a sequence of tokens may lose some connectivity information of the graph, leading to limited performance. On the contrary, our GCN model can better exploit the information from the graph and yield superior performance (See results in Section 4.4).3.4 Training and Inference of NAT
We apply the policy gradient williams1992simple to train our model. The overall scheme is shown in Algorithm 1, which employs an alternating manner.
Specifically, in each training epoch,
we first train the model parameters with fixed transformer parameters . Then, we train the transformer parameters by fixing the model parameters .Training the model parameters . Given any , we need to update the model parameters based on the training data. Here, to accelerate the training process, we adopt the parameter sharing technique pham2018efficient , i.e., we construct a large computational graph, where each subgraph represents a neural network architecture, hence forcing all architectures to share the parameters. Thus, we can use the shared parameters to represent the parameters for different architectures. For any architecture , let
be the loss function on the training data,
e.g., the crossentropy loss. Then, given any sampled architectures, the updating rule for with parameter sharing can be given by , where is the learning rate.Training the transformer parameters . We train the transformer model with policy gradient williams1992simple . To encourage exploration, we introduce an entropy regularization term into the objective to prevent the transformer from converging to a local optimum too quickly zoph2018learning , e.g., selecting the “original” option for all the operations. Given the shared parameters , the objective can be formulated as
(4)  
where is the probability to sample some architecture from the distribution , is the probability to sample some architecture from the distribution , evaluates the entropy of the policy, and controls the strength of the entropy regularization term. For each input architecture, we sample optimized architectures from the distribution in each iteration. Thus, the gradient of Eqn. (4) w.r.t. becomes^{2}^{2}2We put the derivations of Eqn. (5) in the supplementary.
(5) 
The regularization term encourages the distribution to have high entropy, i.e., high diversity in the decisions on the edges. Thus, the decisions for some operations would be encouraged to choose the “identity” or “null” operations during training. As a result, NAT is able to sufficiently explore the whole search space to find the optimal architecture.
Inference the optimized architecture. We do not explicitly obtain the optimized architecture via . Instead, we conduct sampling according to the learned probability distribution. Specifically, we first sample several candidate optimized architectures from the learned policy and then select the architecture with the highest validation accuracy. Note that we can also obtain the optimized architecture by selecting the operation with the maximum probability, which, however, tends to reach a local optimum and yields worse results than the sampling based method (See comparisons in Section 4.4).
4 Experiments
In this section, we apply NAT on both handcrafted and NAS based architectures, and conduct experiments on two image classification benchmark datasets, i.e., CIFAR10 (krizhevsky2009learning, ) and ImageNet (deng2009imagenet, )
. All implementations are based on PyTorch.
^{3}^{3}3The source code of NAT is available at https://github.com/guoyongcs/NAT.4.1 Implementation Details
We consider two kinds of cells in a deep network, including the normal cell and the reduction cell. The normal cell preserves the same spatial size as inputs while the reduction cell reduces the spatial size by . Both the normal and reduction cells contain 2 input nodes and a number of intermediate nodes. During training, we build the deep network by stacking 8 basic cells and train the transformer for 100 epochs. We set , , and in the training. We split CIFAR10 training set into and slices to train the model parameters and the transformer parameters , respectively. As for the evaluation of the networks with different architectures, we replace the original cell with the optimized one and train the model from scratch. Please see more details in the supplementary. For all the considered architectures, we follow the same settings of the original papers. In the experiments, we only apply cutout to the NAS based architectures on CIFAR10.
CIFAR10  ImageNet  
Model  Method  #Params (M)  #MAdds (M)  Acc. (%)  Model  Method  #Params (M)  #MAdds (M)  Acc. (%)  
Top1  Top5  
VGG16  /  15.2  313  93.56  VGG16  /  138.4  15620  71.6  90.4 
NAOluo2018neural  19.5  548  95.72  NAO luo2018neural  147.7  18896  72.9  91.3  
NAT  15.2  315  96.04  NAT  138.4  15693  74.3  92.0  
ResNet20  /  0.3  41  91.37  ResNet18  /  11.7  1580  69.8  89.1 
NAO luo2018neural  0.4  61  92.44  NAO luo2018neural  17.9  2246  70.8  89.7  
NAT  0.3  42  92.95  NAT  11.7  1588  71.1  90.0  
ResNet56  /  0.9  127  93.21  ResNet50  /  25.6  3530  76.2  92.9 
NAO luo2018neural  1.3  199  95.27  NAO luo2018neural  34.8  4505  77.4  93.2  
NAT  0.9  129  95.40  NAT  25.6  3547  77.7  93.5  
MobileNetV2  /  2.3  91  94.47  MobileNetV2  /  3.4  300  72.0  90.3 
NAO luo2018neural  2.9  131  94.75  NAO luo2018neural  4.5  513  72.2  90.6  
NAT  2.3  92  95.17  NAT  3.4  302  72.5  91.0 
CIFAR10  ImageNet  
Model  Method  #Params (M)  #MAdds (M)  Acc. (%)  Model  Method  #Params (M)  #MAdds (M)  Acc. (%)  
Top1  Top5  
AmoebaNet real2018regularized  /  3.2    96.73  AmoebaNet real2018regularized  /  5.1  555  74.5  92.0 
PNAS liu2018progressive  3.2    96.67  PNAS liu2018progressive  5.1  588  74.2  91.9  
SNAS xie2018snas  2.9    97.08  SNAS xie2018snas  4.3  522  72.7  90.8  
GHN zhang2018graph  5.7    97.22  GHN zhang2018graph  6.1  569  73.0  91.3  
ENAS pham2018efficient  /  4.6  804  97.11  ENAS pham2018efficient  /  5.6  679  73.8  91.7 
NAO luo2018neural  4.5  763  97.05  NAO luo2018neural  5.5  656  73.7  91.7  
NAT  4.6  804  97.24  NAT  5.6  679  73.9  91.8  
DARTS liu2018darts  /  3.3  533  97.06  DARTS liu2018darts  /  5.9  595  73.1  91.0 
NAO luo2018neural  3.5  577  97.09  NAO luo2018neural  6.1  627  73.3  91.1  
NAT  3.0  483  97.28  NAT  3.9  515  74.4  92.2  
NAONet luo2018neural  /  128  66016  97.89  NAONet luo2018neural  /  11.35  1360  74.3  91.8 
NAO luo2018neural  143  73705  97.91  NAO luo2018neural  11.83  1417  74.5  92.0  
NAT  113  58326  98.01  NAT  8.36  1025  74.8  92.3 
4.2 Results on Handcrafted Architectures
In this experiment, we apply NAT on three popular handcrafted models, i.e., VGG simonyan2014very , ResNet he2016deep , and MobileNet sandler2018mobilenetv2 . To make all architectures share the same graph representation method defined in Section 3.2, we add null connections into the handcrafted architectures to ensure that each node has two input nodes (See examples in Figure 3). For a fair comparison, we build deep networks using the original and optimized architectures while keeping the same depth and number of channels as the original models. We compare NAT with a strong baseline method Neural Architecture Optimization (NAO) luo2018neural . We show the results in Table 1 and the corresponding architectures in Figure 3. From Table 1, although the models with NAO yield better performance than the original ones, they often have more parameters and higher computation cost. By contrast, our NAT based models consistently outperform the original models by a large margin with approximately the same computation cost.
4.3 Results on NAS Based Architectures
For the automatically searched architectures, we evaluate the proposed NAT on three stateoftheart NAS based architectures, i.e., DARTS liu2018darts , NAONet luo2018neural , and ENAS pham2018efficient . Moreover, we also compare our optimized architectures with other NAS based architectures, including AmoebaNet real2018regularized , PNAS liu2018progressive , SNAS xie2018snas and GHN zhang2018graph . From Table 2, all the NAT based architectures yield higher accuracy than their baseline models and the models optimized by NAO on CIFAR10 and ImageNet. Compared with other NAS based architectures, our NATDARTS performs the best on CIFAR10 and achieves the competitive performance compared to the best architecture (i.e., AmoebaNet) on ImageNet with less computation cost and fewer number of parameters. We also visualize the architectures of the original and optimized cell in Figure 4. As for DARTS and NAONet, NAT replaces several redundant operations with the skip connections or directly removes the connection, leading to fewer number of parameters. While optimizing ENAS, NAT removes the average pooling operation and improves the performance without introducing extra computations.
4.4 Comparisons of Different Policy Learners
In this experiment, we compare the performance of different policy learners, including Random Search, LSTM, and the GCN method. For the Random Search method, we perform random transitions among , , and on the input architectures. For the GCN method, we consider two variants which infer the optimized architecture by sampling from the learned policy (denoted by SamplingGCN) or by selecting the operation with the maximum probability (denoted by MaximumGCN). From Table 3, our SamplingGCN method outperforms all the considered policies on different architectures. These results demonstrate the superiority of the proposed GCN method as the policy learner.
4.5 Effect of Different Graph Representations on Handcrafted Architectures
In this experiment, we investigate the effect of different graph representations on handcrafted architectures. Note that an architecture may correspond to many different topological graphs, especially for the handcrafted architectures, e.g., VGG and ResNet, where the number of nodes is smaller than that of our basic cell. For convenience, we study three different graphs for VGG and ResNet20, respectively. The average accuracy of NATVGG is 95.83% and outperforms the baseline VGG with the accuracy of 93.56%. Similarly, our NATResNet20 yields the average accuracy of 92.48%, which is also better than the original model. We put the architecture and the performance of each possible representation in the supplementary. In practice, the graph representation may influence the result of NAT and how to alleviate its effect still remains an open question.
Method  VGG16  ResNet20  MobileNetV2  ENAS  DARTS  NAONet 
/  93.56  91.37  94.47  97.11  97.06  97.89 
Random Search  93.17  91.56  94.38  96.58  95.17  96.31 
LSTM  94.45  92.19  95.01  97.05  97.05  97.93 
MaximumGCN  94.37  92.57  94.87  96.92  97.00  97.90 
SamplingGCN (Ours)  95.93  92.97  95.13  97.21  97.26  97.99 
5 Conclusion
In this paper, we have proposed a novel Neural Architecture Transformer (NAT) for the task of architecture optimization. To solve this problem, we cast it into a Markov decision process (MDP) by making a series of decisions to optimize existing operations with more computationally efficient operations, including skip connection and null operation. To show the effectiveness of NAT, we apply it to both handcrafted architectures and Neural Architecture Search (NAS) based architectures. Extensive experiments on CIFAR10 and ImageNet datasets demonstrate the effectiveness of the proposed method in improving the accuracy and the compactness of neural architectures.
Acknowledgments
This work was partially supported by Guangdong Provincial Scientific and Technological Funds under Grants 2018B010107001, National Natural Science Foundation of China (NSFC) (No. 61602185), key project of NSFC (No. 61836003), Fundamental Research Funds for the Central Universities (No. D2191240), Program for Guangdong Introducing Innovative and Enterpreneurial Teams 2017ZT07X183, Tencent AI Lab RhinoBird Focused Research Program (No. JR201902), Guangdong Special Branch Plans Young Talent with Scientific and Technological Innovation (No. 2016TQ03X445), Guangzhou Science and Technology Planning Project (No. 201904010197), and Microsoft Research Asia (MSRA Collaborative Research Program). We last thank Tencent AI Lab.
References
 [1] B. Baker, O. Gupta, N. Naik, and R. Raskar. Designing neural network architectures using reinforcement learning. In International Conference on Learning Representations, 2017.
 [2] H. Cai, L. Zhu, and S. Han. ProxylessNAS: Direct neural architecture search on target task and hardware. In International Conference on Learning Representations, 2019.

[3]
J. Cao, Y. Guo, Q. Wu, C. Shen, J. Huang, and M. Tan.
Adversarial learning with local coordinate coding.
In
International Conference on Machine Learning
, pages 706–714, 2018.  [4] J. Cao, L. Mo, Y. Zhang, K. Jia, C. Shen, and M. Tan. Multimarginal wasserstein gan. In Advances in Neural Information Processing Systems, 2019.
 [5] S. Cao, X. Wang, and K. M. Kitani. Learnable embedding space for efficient neural architecture compression. In International Conference on Learning Representations, 2019.
 [6] T. Chen, I. Goodfellow, and J. Shlens. Net2net: Accelerating learning via knowledge transfer. In International Conference on Learning Representations, 2016.

[7]
X. Dai, P. Zhang, B. Wu, H. Yin, F. Sun, Y. Wang, M. Dukhan, Y. Hu, Y. Wu,
Y. Jia, et al.
Chamnet: Towards efficient network design through platformaware
model adaptation.
In
The IEEE Conference on Computer Vision and Pattern Recognition
, pages 11398–11407, 2019.  [8] J. Deng, W. Dong, R. Socher, L.J. Li, K. Li, and L. FeiFei. Imagenet: A largescale hierarchical image database. In The IEEE Conference on Computer Vision and Pattern Recognition, pages 248–255, 2009.
 [9] Y. Guo, Q. Chen, J. Chen, J. Huang, Y. Xu, J. Cao, P. Zhao, and M. Tan. Dual reconstruction nets for image superresolution with gradient sensitive loss. arXiv preprint arXiv:1809.07099, 2018.
 [10] Y. Guo, Q. Chen, J. Chen, Q. Wu, Q. Shi, and M. Tan. Autoembedding generative adversarial networks for high resolution image synthesis. IEEE Transactions on Multimedia, 2019.
 [11] Y. Guo, M. Tan, Q. Wu, J. Chen, A. V. D. Hengel, and Q. Shi. The shallow end: Empowering shallower deepconvolutional networks through auxiliary outputs. arXiv preprint arXiv:1611.01773, 2016.

[12]
Y. Guo, Q. Wu, C. Deng, J. Chen, and M. Tan.
Double forward propagation for memorized batch normalization.
InAAAI Conference on Artificial Intelligence
, pages 3134–3141, 2018.  [13] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In The IEEE Conference on Computer Vision and Pattern Recognition, pages 770–778, 2016.
 [14] K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. In The European Conference on Computer Vision, pages 630–645, 2016.
 [15] Y. He, X. Zhang, and J. Sun. Channel pruning for accelerating very deep neural networks. In The IEEE International Conference on Computer Vision, pages 1398–1406, 2017.
 [16] S. Hochreiter and J. Schmidhuber. Long shortterm memory. Neural Computation, 9(8):1735–1780, 1997.
 [17] Z. Huang and N. Wang. Datadriven sparse structure selection for deep neural networks. In Proceedings of the European Conference on Computer Vision (ECCV), pages 304–320, 2018.
 [18] Z. Jiang, Y. Zheng, H. Tan, B. Tang, and H. Zhou. Variational deep embedding: An unsupervised and generative approach to clustering. In International Joint Conference on Artificial Intelligence, pages 1965–1972, 2017.
 [19] H. Jin, Q. Song, and X. Hu. Autokeras: Efficient neural architecture search with network morphism. arXiv preprint arXiv:1806.10282, 2018.
 [20] W. Jin, K. Yang, R. Barzilay, and T. Jaakkola. Learning multimodal graphtograph translation for molecular optimization. In International Conference on Learning Representations, 2019.
 [21] T. N. Kipf and M. Welling. Semisupervised classification with graph convolutional networks. In International Conference on Learning Representations, 2016.
 [22] A. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.

[23]
A. Krizhevsky, I. Sutskever, and G. E. Hinton.
Imagenet classification with deep convolutional neural networks.
In Advances in Neural Information Processing Systems, pages 1097–1105, 2012.  [24] S. Lauly, Y. Zheng, A. Allauzen, and H. Larochelle. Document neural autoregressive distribution estimation. The Journal of Machine Learning Research, 18(1):4046–4069, 2017.
 [25] Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. Backpropagation Applied to Handwritten zip Code Recognition. Neural Computation, 1(4):541–551, 1989.
 [26] C. Lemaire, A. Achkar, and P.M. Jodoin. Structured pruning of neural networks with budgetaware regularization. In The IEEE Conference on Computer Vision and Pattern Recognition, pages 9108–9116, 2019.
 [27] H. Li, A. Kadav, I. Durdanovic, H. Samet, and H. P. Graf. Pruning filters for efficient convnets. In International Conference on Learning Representations, 2017.
 [28] M. Lin, Q. Chen, and S. Yan. Network in network. In International Conference on Learning Representations, 2014.
 [29] C. Liu, B. Zoph, M. Neumann, J. Shlens, W. Hua, L.J. Li, L. FeiFei, A. Yuille, J. Huang, and K. Murphy. Progressive neural architecture search. In The European Conference on Computer Vision, pages 19–34, 2018.
 [30] H. Liu, K. Simonyan, and Y. Yang. Darts: Differentiable architecture search. In International Conference on Learning Representations, 2019.
 [31] J.H. Luo, J. Wu, and W. Lin. Thinet: A filter level pruning method for deep neural network compression. In The IEEE International Conference on Computer Vision, pages 5058–5066, 2017.
 [32] R. Luo, F. Tian, T. Qin, E. Chen, and T.Y. Liu. Neural architecture optimization. In Advances in Neural Information Processing Systems, pages 7816–7827, 2018.

[33]
V. Nair and G. E. Hinton.
Rectified linear units improve restricted boltzmann machines.
In International Conference on Machine Learning, pages 807–814, 2010.  [34] C. S. Nam, A. Nijholt, and F. Lotte. Brain–computer interfaces handbook: technological and theoretical advances. CRC Press, 2018.
 [35] J. Pan, Y. Li, and J. Wang. An eegbased braincomputer interface for emotion recognition. In 2016 international joint conference on neural networks (IJCNN), pages 2063–2067. IEEE, 2016.
 [36] H. Pham, M. Guan, B. Zoph, Q. Le, and J. Dean. Efficient neural architecture search via parameter sharing. In International Conference on Machine Learning, pages 4095–4104, 2018.

[37]
E. Real, A. Aggarwal, Y. Huang, and Q. V. Le.
Regularized evolution for image classifier architecture search.
In AAAI Conference on Artificial Intelligence, volume 33, pages 4780–4789, 2019.  [38] M. Sandler, A. Howard, M. Zhu, A. Zhmoginov, and L.C. Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In The IEEE Conference on Computer Vision and Pattern Recognition, pages 4510–4520, 2018.
 [39] F. Schroff, D. Kalenichenko, and J. Philbin. Facenet: A Unified Embedding for Face Recognition and Clustering. In The IEEE Conference on Computer Vision and Pattern Recognition, pages 815–823, 2015.
 [40] J. Schulman, S. Levine, P. Abbeel, M. Jordan, and P. Moritz. Trust region policy optimization. In International Conference on Machine Learning, pages 1889–1897, 2015.
 [41] K. Simonyan and A. Zisserman. Very deep convolutional networks for largescale image recognition. In International Conference on Learning Representations, 2015.
 [42] D. R. So, C. Liang, and Q. V. Le. The evolved transformer. In International Conference on Machine Learning, 2019.
 [43] R. K. Srivastava, K. Greff, and J. Schmidhuber. Training Very Deep Networks. In Advances in Neural Information Processing Systems, pages 2377–2385, 2015.
 [44] Y. Sun, X. Wang, and X. Tang. Deeply Learned Face Representations are Sparse, Selective, and Robust. In The IEEE Conference on Computer Vision and Pattern Recognition, pages 2892–2900, 2015.
 [45] C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In The IEEE Conference on Computer Vision and Pattern Recognition, pages 1–9, 2015.

[46]
M. Tan, I. W. Tsang, and L. Wang.
Towards ultrahigh dimensional feature selection for big data.
The Journal of Machine Learning Research, 15(1):1371–1429, 2014.  [47] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pages 5998–6008, 2017.
 [48] L. Wang, Y. Xiong, Z. Wang, Y. Qiao, D. Lin, X. Tang, and L. Van Gool. Temporal segment networks: Towards good practices for deep action recognition. In The European Conference on Computer Vision, pages 20–36, 2016.
 [49] R. J. Williams. Simple statistical gradientfollowing algorithms for connectionist reinforcement learning. Machine Learning, 8(34):229–256, 1992.
 [50] S. Xie, H. Zheng, C. Liu, and L. Lin. Snas: Stochastic neural architecture search. In International Conference on Learning Representations, 2019.
 [51] T.J. Yang, A. Howard, B. Chen, X. Zhang, A. Go, M. Sandler, V. Sze, and H. Adam. Netadapt: Platformaware neural network adaptation for mobile applications. In The European Conference on Computer Vision, pages 285–300, 2018.
 [52] R. Zeng, C. Gan, P. Chen, W. Huang, Q. Wu, and M. Tan. Breaking winnertakesall: Iterativewinnersout networks for weakly supervised temporal action localization. IEEE Transactions on Image Processing, 28(12):5797–5808, 2019.
 [53] R. Zeng, W. Huang, M. Tan, Y. Rong, P. Zhao, J. Huang, and C. Gan. Graph convolutional networks for temporal action localization. In The IEEE International Conference on Computer Vision, Oct 2019.
 [54] C. Zhang, M. Ren, and R. Urtasun. Graph hypernetworks for neural architecture search. In International Conference on Learning Representations, 2019.
 [55] X. Zhang, Z. Huang, and N. Wang. You only search once: Single shot neural architecture search via direct sparse optimization. arXiv preprint arXiv:1811.01567, 2018.
 [56] Y. Zhang, H. Chen, Y. Wei, P. Zhao, J. Cao, X. Fan, X. Lou, H. Liu, J. Hou, X. Han, et al. From whole slide imaging to microscopy: Deep microscopy adaptation network for histopathology cancer image classification. In International Conference on Medical Image Computing and ComputerAssisted Intervention, pages 360–368. Springer, 2019.

[57]
Y. Zheng, C. Liu, B. Tang, and H. Zhou.
Neural autoregressive collaborative filtering for implicit feedback.
In
Proceedings of the 1st Workshop on Deep Learning for Recommender Systems
, pages 2–6. ACM, 2016.  [58] Y. Zheng, B. Tang, W. Ding, and H. Zhou. A neural autoregressive approach to collaborative filtering. In International Conference on Machine Learning, pages 764–773, 2016.
 [59] Y. Zheng, R. S. Zemel, Y.J. Zhang, and H. Larochelle. A neural autoregressive approach to attentionbased recognition. International Journal of Computer Vision, 113(1):67–79, 2015.
 [60] Y. Zheng, Y.J. Zhang, and H. Larochelle. Topic modeling of multimodal data: An autoregressive approach. In The IEEE Conference on Computer Vision and Pattern Recognition, pages 1370–1377, 2014.
 [61] Y. Zheng, Y.J. Zhang, and H. Larochelle. A deep and autoregressive approach for topic modeling of multimodal data. IEEE Transactions on Pattern Analysis and Machine Intelligence, 38(6):1056–1069, 2015.
 [62] Z. Zhong, J. Yan, W. Wu, J. Shao, and C.L. Liu. Practical blockwise neural network architecture generation. In The IEEE Conference on Computer Vision and Pattern Recognition, pages 2423–2432, 2018.
 [63] Z. Zhuang, M. Tan, B. Zhuang, J. Liu, Y. Guo, Q. Wu, J. Huang, and J. Zhu. Discriminationaware channel pruning for deep neural networks. In Advances in Neural Information Processing Systems, pages 875–886, 2018.
 [64] B. Zoph and Q. V. Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations, 2017.
 [65] B. Zoph, V. Vasudevan, J. Shlens, and Q. V. Le. Learning transferable architectures for scalable image recognition. In The IEEE Conference on Computer Vision and Pattern Recognition, pages 8697–8710, 2018.
Comments
There are no comments yet.