Add files using upload-large-folder tool

parse/train/BJxH22EKPS/BJxH22EKPS.md

@@ -0,0 +1,390 @@
+# UNDERSTANDING ARCHITECTURES LEARNT BY CELL-BASED NEURAL ARCHITECTURE SEARCH
+
+Yao Shu, Wei Wang & Shaofeng Cai
+
+School of Computing   
+National University of Singapore   
+{shuyao,wangwei,shaofeng}@comp.nus.edu.sg
+
+# ABSTRACT
+
+Neural architecture search (NAS) searches architectures automatically for given tasks, e.g., image classification and language modeling. Improving the search efficiency and effectiveness has attracted increasing attention in recent years. However, few efforts have been devoted to understanding the generated architectures. In this paper, we first reveal that existing NAS algorithms (e.g., DARTS, ENAS) tend to favor architectures with wide and shallow cell structures. These favorable architectures consistently achieve fast convergence and are consequently selected by NAS algorithms. Our empirical and theoretical study further confirms that their fast convergence derives from their smooth loss landscape and accurate gradient information. Nonetheless, these architectures may not necessarily lead to better generalization performance compared with other candidate architectures in the same search space, and therefore further improvement is possible by revising existing NAS algorithms.
+
+# 1 INTRODUCTION
+
+Various neural network architectures (Krizhevsky et al., 2012; Simonyan & Zisserman, 2015; He et al., 2016; Huang et al., 2017) have been devised over the past decades, achieving superhuman performance for a wide range of tasks. Designing these neural networks typically takes substantial efforts from domain experts by trial and error. Recently, there is a growing interest in neural architecture search (NAS), which automatically searches for high-performance architectures for the given task. The searched NAS architectures (Zoph et al., 2018; Real et al., 2019; Pham et al., 2018; Liu et al., 2019; Xie et al., 2019b; Luo et al., 2018; Cai et al., 2019; Akimoto et al., 2019; Nayman et al., 2019) have outperformed best expert-designed architectures on many computer vision and natural language processing tasks.
+
+Mainstream NAS algorithms typically search for the connection topology and transforming operation accompanying each connection from a predefined search space. Tremendous efforts have been exerted to develop efficient and effective NAS algorithms (Liu et al., 2019; Xie et al., 2019b; Luo et al., 2018; Akimoto et al., 2019; Nayman et al., 2019). However, less attention has been paid to these searched architectures for further insight. To our best knowledge, there is no related work in the literature examining whether these NAS architectures share any pattern, and how the pattern may impact the architecture search if there exists the pattern. These questions are fundamental to understand and improve existing NAS algorithms. In this paper, we endeavour to address these questions by examining the popular NAS architectures1.
+
+The recent work (Xie et al., 2019a) shows that the architectures with random connection topologies can achieve competitive performance on various tasks compared with expert-designed architectures. Inspired by this result, we examine the connection topologies of the architectures generated by popular NAS algorithms. In particular, we find a connection pattern of the popular NAS architectures. These architectures tend to favor wide and shallow cells, where the majority of intermediate nodes are directly connected to the input nodes.
+
+To appreciate this particular connection pattern, we first visualize the training process of the popular NAS architectures and their randomly connected variants. Fast and stable convergence is observed for the architectures with wide and shallow cells. We further empirically and theoretically show that the architectures with wider and shallower cells consistently enjoy a smoother loss landscape and smaller gradient variance than their random variants, which helps explain their better convergence and consequently the selection of these NAS architectures during the architecture search.
+
+We finally evaluate the generalization performance of the popular NAS architectures and their randomly connected variants. We find that the architectures with wide and shallow cells may not generalize better than other candidate architectures despite their faster convergence. We therefore believe that rethinking NAS from the perspective of the true generalization performance rather than the convergence of candidate architectures should potentially help generate better architectures.
+
+# 2 RELATED WORKS
+
+Neural Architecture Search Neural architecture search (NAS) searches for best-performing architectures automatically for a given task. It has received increasing attention in recent years due to its outstanding performance and the demand for automated machine learning (AutoML). There are three major components in NAS as summarized by Elsken et al. (2019), namely search space, search policy (or strategy, algorithm), and performance evaluation (or estimation). To define the search space, the prior knowledge extracted from expert-designed architectures is typically exploited. As for the search policy, different algorithms are proposed to improve the effectiveness (Zoph et al., 2018; Real et al., 2019; Tan et al., 2019; Cai et al., 2019) and the efficiency (Pham et al., 2018; Liu et al., 2019; Xie et al., 2019b; Luo et al., 2018; Nayman et al., 2019; Akimoto et al., 2019) of the architecture search. However, no effort has been devoted to understanding the best architectures generated by various NAS approaches. Detailed analysis of these architectures may give insights about the further improvement of existing NAS algorithms.
+
+Evaluation of NAS algorithms Recent works evaluate NAS algorithms by comparing them with random search. Li & Talwalkar (2019) and Sciuto et al. (2019) compare the generalization performance of architectures generated from random search and existing NAS algorithms. Interestingly, the random search can find architectures with comparable or even better generalization performance. Particularly, Sciuto et al. (2019) show empirically that the ineffectiveness of some NAS algorithms (Pham et al., 2018) could be the consequence of the weight sharing mechanism during the architecture search. While these evaluations help understand the general disadvantages of NAS algorithms, what kind of architectures the NAS algorithms are learning and why they learn these specific architectures are still not well understood.
+
+# 3 THE CONNECTION PATTERN OF POPULAR NAS CELLS
+
+Mainstream NAS algorithms (Zoph et al., 2018; Real et al., 2019; Pham et al., 2018; Liu et al., 2019; Xie et al., 2019b; Luo et al., 2018) typically search for the cell structure, including the connection topology and the corresponding operation (transformation) coupling each connection. The generated cell is then replicated to construct the entire neural network. We therefore mainly investigate these cell-based NAS architectures. In this section, we first introduce the commonly adopted cell representation, which is useful to understand the connection and computation in a cell space. We then sketch the connection topologies of popular cell-based NAS architectures to investigate their connection patterns. By comparison, we show that there is a common connection pattern among the cells learned by different NAS algorithms; particularly, these cells tend to be wide and shallow.
+
+# 3.1 CELL REPRESENTATION
+
+Following DARTS (Liu et al., 2019), we represent the cell topology as a directed acyclic graph (DAG) consisting of $N$ nodes, including $M$ input nodes, one output node and $( N - M - 1 )$ intermediate nodes. Each node forms a latent representation of the input instance. The input nodes consist of the outputs from $M$ preceding cells. And the output node aggregates (e.g., concatenate) the representations from all intermediate nodes. Each intermediate node is connected to $M$ proceeding nodes in the same cell. Each connection transforms the representation from one node via an operation from a predefined operation set, e.g., $3 \times 3$ convolution, $3 \times 3$ max pooling, etc. The target of NAS algorithm is to search for the best $M$ source nodes for each intermediate node and the best operation for each of the connections between nodes. In the literature, the searched cell is then replicated by $L$ times to build the entire neural network architecture2.
+
+![](images/34d71c834fcfb8840a6e01da4e102841579f1b781529f141661a58f7af780b9c.jpg)  
+Figure 1: Cell topologies of popular NAS architectures. Each sub-figure has three sets of nodes from left to right, i.e., the input nodes, intermediate nodes, and output node. The arrows (i.e., operations of the cell) represent the direction of information flow. The caption of each sub-figure reports the name of the architecture, width and depth of a cell following our definition. The width of a cell is computed with the assumption that all intermediate nodes share the same width $c$ .
+
+![](images/d9d135a75eadf88017dd1bc6a918c60302e5f2d074f53f8da16413b1615c3d40.jpg)  
+Figure 2: Topologies of DARTS (Liu et al., 2019) cell (leftmost) and its variants with random connections. The cell depth is increasing and width decreasing from left to right. In particular, the original DARTS cell $C ^ { d \bar { a } r t s }$ is widest and shallowest among these cells.
+
+We abuse the notation $C$ to denote a cell and also the architecture built with the specific cell in the following sections. Besides, we shall use $C ^ { A }$ to denote the best architecture (or cell) searched with the NAS algorithm $A$ (e.g., DARTS (Liu et al., 2019), ENAS (Pham et al., 2018)). Details on how to build the architecture with given cells are provided in Appendix A.3.
+
+# 3.2 THE COMMON CONNECTION PATTERN
+
+Recently, Xie et al. (2019a) shows that neural networks constructed by cells with random connection patterns can achieve compelling performance on multiple tasks. Taking this a step further, we wonder whether cells generated from popular NAS algorithms share any connection patterns, which may explain why these cells are chosen during the architecture search. To investigate the connection patterns, we sketch the topologies of the popular NAS cells with detailed operations omitted.
+
+Figure 1 illustrates topologies of 5 popular NAS cells3. To examine the connection pattern formally, we introduce the concept of ‘depth’ and ‘width’ for a cell. The depth of a cell is defined as the number of connections along the longest path from input nodes to the output node. The width of a cell is defined as the total width of the intermediate nodes that are connected to the input nodes. In particular, if some intermediate nodes are only partially connected to input nodes (i.e., have connections to other intermediate nodes), their width is reduced by the percentage of the number of connections to intermediate nodes over all connections. The width of a node is the number of channels for convolution operations; and the width is the dimension of the features for linear operations. Supposing that the width of each intermediate node is $c$ , as shown in Figure 1, the width and depth of the DARTS (Liu et al., 2019) cell are $3 . 5 c$ and 3 respectively, and the width and depth of the AmoebaNet (Real et al., 2019) cell are $_ { 4 c }$ and 4 correspondingly.
+
+Following the above definitions, the smallest depth and largest width for a cell with $N = 7$ and $M = 2$ are 2 and $_ { 4 c }$ respectively. Similarly, for a cell with $N = 8$ and $M = 2$ , the smallest depth and largest width are 2 and $5 c$ respectively. In Figure 1, we can observe that cells from popular NAS architectures tend to be the widest and shallowest ones (with width close to $4 c / 5 c$ and depth close to 2) among all candidate cells in the same search space. Regarding this as the common connection pattern, we have the following observation:
+
+Observation 3.1 (The Common Connection Pattern) NAS architectures generated by popular NAS algorithms tend to have the widest and shallowest cells among all candidate cells in the same search space.
+
+# 4 THE IMPACTS OF CELL WIDTH AND DEPTH ON OPTIMIZATION
+
+Given that popular NAS cells share the common connection pattern, we then explore the impact of this common connection pattern from the optimization perspective to answer the question: why the wide and shallow cells are selected during the architecture search? We sample and train variants of popular NAS architectures with random connections. Comparing randomly connected variants with the popular NAS architectures, we find that architectures with wider and shallower cells indeed converge faster so that they are selected by NAS algorithms (Section 4.1). To understand why the wider and shallower cell contributes to faster convergence, we further investigate the loss landscape and gradient variance of popular NAS architectures and their variants via both empirical experiments (Section 4.2) and theoretical analysis (Section 4.3).
+
+# 4.1 CONVERGENCE
+
+Popular NAS algorithms typically evaluate the performance of a candidate architecture prematurely before the convergence of its model parameters during the search process. For instance, DARTS (Liu et al., 2019), SNAS (Xie et al., 2019b) and ENAS (Pham et al., 2018) optimize hyper-parameters of architectures and model parameters concurrently. The amortized training time of each candidate architecture is insufficient and therefore far from the requirement for the full convergence. Likewise, AmoebaNet (Real et al., 2019) evaluates the performance of candidate architectures with the training of only a few epochs. In other words, these candidate architectures are not evaluated based on their generalization performance at convergence. As a result, architectures with faster convergence rates are more likely to be selected by existing NAS algorithms because they can obtain better evaluation performance given the same training budget. We therefore hypothesize that the popular NAS architectures may converge faster than other candidate architectures, which largely contributes to the selection of these architectures during the search.
+
+To support the hypothesis above, we compare the convergence of original NAS architectures and their variants with random connections via empirical studies. We first sample variants of popular NAS cells following the sampling method in Appendix A.2. Then, we train both original NAS architectures and their random variants on CIFAR-10 and CIFAR-100 following the training details in Appendix A.3. During training, we evaluate the testing loss and accuracy of these architectures. Since the convergence is dependent on optimization settings, we also evaluate the convergence performance under different learning rates.
+
+Take DARTS (Liu et al., 2019) for example, Figure 2 shows the connection topology of the original DARTS cell and its random variants. Figure 3 reports the test loss and accuracy curves of these architectures during training. As illustrated in Figure 3, the original cell $C ^ { d a r t s }$ , known as the widest and shallowest cell, has the fastest and most stable convergence compared with its variants. Further, as the width of a cell increases and the depth decreases (i.e., from $C _ { 4 }$ to $C _ { 1 }$ ), the convergence becomes faster. The results of other popular NAS architectures and their randomly connected variants are reported in Appendix B.2.
+
+![](images/4b7f687a7d11d4c2522cdab2c13528a5bfe595b3572f60a2628356f4c9f981fd.jpg)  
+Figure 3: Test loss and test accuracy $( \% )$ curves of DARTS and its randomly connected variants on CIFAR-10 and CIFAR-100 during training. The default learning rate is 0.025.
+
+![](images/310bd6537370e75f03d04960c20edab18f1af3b42e5dd70e3518656a25772dda.jpg)  
+Figure 4: Test accuracy $( \% )$ curves of DARTS and its randomly connected variants on CIFAR-10 and CIFAR-100 during training under different learning rates (0.0025 and 0.25). We only evaluate $C ^ { d a r t s }$ , $C _ { 1 } ^ { d a r t s }$ and $C _ { 3 } ^ { \breve { d } a r t s }$ for illustration. The caption of each sub-figure reports the dataset and the learning rate.
+
+Figure 4 further validates the difference of convergence under different learning rates. The original cell $C ^ { d a r t s }$ enjoys the fastest and the most stable convergence among these cells under various learning rates. The difference in terms of convergence rate and stability is more obvious between $C ^ { d a r t s }$ and its variants with a larger learning rate as shown in Figure 4. Interestingly, $C _ { 3 } ^ { d a r t s }$ completely fails to converge on both CIFAR-10 and CIFAR-100 with a larger learning rate of 0.25. While there is a minor difference among these cells with a lower learning rate of 0.0025, we still find that there is a decreasing performance of convergence (i.e., convergence rate and stability) from $C ^ { d a r t s }$ , $C _ { 1 } ^ { d a r t s }$ $C _ { 3 } ^ { d a r t s }$ . Overall, the observations are consistent with the results in Figure 3.
+
+We have also compared the convergence of popular NAS architectures and their random variants of different operations. Similarly, we sample and train the random variants of operations for popular NAS architectures following the details in Appendix A.2 and Appendix A.3. Figure 5 illustrates the convergence of these architectures. Surprisingly, with the same connection topologies as the popular NAS cells but different operations, all random variants achieve nearly the same convergence as these popular NAS architectures. Consistent results can be found in Figure 12 of Appendix B.2. We therefore believe that the types of operations have limited impacts on the convergence of NAS architectures and the connection topologies affect the convergence more significantly.
+
+With these observations, we conclude that the popular NAS architectures with wider and shallower cells indeed converge faster and more stably, which explains why these popular NAS cells are selected during the architecture search. The next question is then why the wider and shallower cell leads to a faster and more stable convergence?
+
+# 4.2 EMPIRICAL STUDY OF FACTORS AFFECTING CONVERGENCE
+
+Since the wide and shallow cell is related to fast convergence, we further conduct the theoretical convergence analysis to investigate the cause of fast convergence. In this section, we first introduce the convergence analysis (i.e., Theorem 4.1) of non-convex optimization with the randomized stochastic gradient method (Ghadimi & Lan, 2013). Based on the analysis, we introduce the possible factors related to the common connection pattern that may affect the convergence. We then examine these factors empirically in the following subsections.
+
+![](images/e5b4fedc6536d070c98dd2c26b526f2168abb1ab6798ff5d8d266659dd17e0b7.jpg)  
+Figure 5: Test accuracy $( \% )$ curves of DARTS, ENAS, AmoebaNet, NASNet and their random variants of operations on CIFAR-10 during training. The parameter size is attached in Table 3 of Appendix B.2.
+
+Theorem 4.1 (Ghadimi & Lan, 2013) Let $f$ be a $L$ -smooth non-convex function, and let $f ^ { * }$ be the minimal. Given repeated, independent accesses to stochastic gradients with variance bound $\sigma ^ { 2 }$ for $f ( w )$ , SGD with initial ${ \pmb w } _ { 0 }$ , total iterations $N > 0$ and learning rate $\begin{array} { r } { \gamma _ { k } \ < \ \frac { 1 } { L } } \end{array}$ achieves the following convergence by randomly choosing ${ \pmb w } _ { k }$ as the final output ${ \pmb w } _ { R }$ with probability $\frac { \gamma _ { k } } { H }$ where $\begin{array} { r } { H = \sum _ { k = 1 } ^ { N } \gamma _ { k } } \end{array}$ :
+
+$$
+\mathbb { E } [  \nabla f ( { \pmb w } _ { R } )  ^ { 2 } ] \le \frac { 2 ( f ( { \pmb w } _ { 0 } ) - f ^ { * } ) } { H } + \frac { L \sigma ^ { 2 } } { H } \sum _ { k = 1 } ^ { N } \gamma _ { k } ^ { 2 }
+$$
+
+In this paper, $f$ and $\pmb { w }$ denote the objective (loss) function and model parameters respectively. Based on the above theorem, Lipschitz smoothness $L$ and gradient variance $\bar { \sigma } ^ { 2 }$ significantly affect the convergence, including the rate and the stability of convergence. Particularly, given a specific number of iterations $N$ , a smaller Lipschitz constant $L$ or smaller gradient variance $\bar { \sigma } ^ { 2 }$ would lead to a smaller convergence error and less damped oscillations, which indicates a faster and more stable convergence. Since the Lipschitz constant $L$ and gradient variance $\sigma ^ { 2 }$ are highly related to the objective function, different NAS architectures result in different $L$ and $\sigma ^ { 2 }$ . In the following subsections, we therefore conduct empirical analysis for the impacts of the cell with and depth on the Lipschitz smoothness and gradient variance.
+
+# 4.2.1 LOSS LANDSCAPE
+
+The constant $L$ of Lipschitz smoothness is closely correlated with the Hessian matrix of the objective function as shown by Nesterov (2004), which requires substantial computation and can only represent the global smoothness. The loss contour, which has been widely adopted to visualize the loss landscape of neural networks by Goodfellow & Vinyals (2015); Li et al. (2018), is instead computationally efficient and is able to report the local smoothness of the objective function. To explore the loss landscape of different architectures, we adopt the method in Li et al. (2018) to plot the loss contour $s ( \alpha , \beta ) \ = \mathbb { E } _ { i \sim P } \big [ f _ { i } ( \pmb { w } ^ { * } + \alpha \pmb { w } _ { 1 } + \beta \pmb { w } _ { 2 } ) \big ]$ . The notation $f _ { i } ( \cdot )$ denotes the loss evaluated at $i _ { t h }$ instance in the dataset and $P$ denotes the distribution of dataset. The notation $\pmb { w } ^ { * }$ , ${ \pmb w } _ { 1 }$ and ${ \pmb w } _ { 2 }$ denote the (local) optimal and two direction vectors randomly sampled from Gaussian distribution respectively. And $\alpha$ , $\beta$ , which are the $x$ and $y$ axis of the plots, denote the step sizes to perturb $\boldsymbol { w } ^ { * }$ . The loss contour plotted here is therefore a two-dimensional approximation of the truly highdimensional loss contour. However, as shown in Li et al. (2018), the approximation is valid and effective to characterize the property of the true loss contour.
+
+To study the impact of the cell width and depth on Lipschitz smoothness, we compare the loss landscape between popular NAS architectures and their randomly connected variants trained in Section 4.1 on CIFAR-10 and CIFAR-100. Due to the space limitation, we only plot the loss landscape of DARTS (Liu et al., 2019) and its randomly connected variants in Figure 6. We observe that the connection topology has a significant influence on the smoothness of the loss landscape. With the widest and shallowest cell, $\bar { C } ^ { d a r t s }$ has a fairly benign and smooth landscape along with the widest near-convex region around the optimal. With a deeper and narrower cell, $\dot { C } _ { 1 } ^ { d a r t s }$ and $C _ { 2 } ^ { d a r t s }$ have a more agitated loss landscape compared with $C ^ { d \bar { a } r t s }$ . Further, $C _ { 3 } ^ { d a r t s }$ , with the smallest width and largest depth among these cells, has the most complicated loss landscape and the narrowest and steepest near-convex region around the optimum. The largest eigenvalue of the Hessian matrix, which indicates the maximum curvature of the objective function, is positively correlated with Lipschitz constant as shown by Nesterov (2004). A smoother loss landscape therefore corresponds to a smaller Lipschitz constant $L$ . $C ^ { d a r t s }$ is likely to achieve the smallest Lipschitz constant among these cells.
+
+![](images/bdd123502ed284d32fac3ada394817ba339128dee2582d9b5c2cd226f6fe60a2.jpg)  
+Figure 6: Loss contours of DARTS and its variants with random connections on the test dataset of CIFAR-10. The lighter color of the contour lines indicates a larger loss. Notably, the loss of the blank area, around the corners of each plot, is extremely large. Besides, the area with denser contour lines indicates a steeper loss surface.
+
+![](images/be3cf2e0de30d67001a33ff6c77f1f311b660ff7782ca80203d6c51b16ea2edb.jpg)  
+Figure 7: Heat maps of the gradient variance from DARTS and its randomly connected variants around the optimal on the test dataset of CIFAR-10. The lighter color indicates a larger gradient variance. Notably, the gradient variance of the yellow area, around the corners of each plot, is extremely large. Obviously, the region with relatively small gradient variance becomes smaller from left to right.
+
+Consistent results can be found in Appendix B.3 for the loss landscape of other popular NAS cells and their variants. Based on these results, we conclude that increasing the width and decreasing the depth of a cell widens the near-convex region around the optimal and smooths the loss landscape. The constant $L$ of Lipschitz smoothness therefore becomes smaller locally and globally. Following Theorem 4.1, architectures with wider and shallower cells shall converge faster and more stably.
+
+# 4.2.2 GRADIENT VARIANCE
+
+The gradient variance indicates the noise level of gradient by randomly selecting training instances in stochastic gradient descent (SGD) method. Large gradient variance indicates large noise in the gradient, which typically results in unstable updating of model parameters. Following Ghadimi $\&$ Lan (2013), gradient variance is defined as $\mathbf { \bar { V } a r } ( \bar { \nabla } f _ { i } ( \pmb { w } ) )$ . Similar to the visualization of loss landscape in Section 4.2.1, we visualize the gradient variance by $g ( \alpha , \beta ) = \mathrm { V a r } ( \nabla f _ { i } ( { \pmb w } ^ { * } + \alpha { \pmb w } _ { 1 } +$ $\beta \pmb { w } _ { 2 } )$ ). All other notations follow Section 4.2.1.
+
+To study the impact of the width and depth of a cell on the gradient variance, we compare the gradient variance between popular NAS architectures and their randomly connected variants trained in Section 4.1 on CIFAR-10 and CIFAR-100. We visualize the gradient variance of DARTS (Liu et al., 2019) and its randomly connected variants in Figure 7 and Figure 8. For better visualization, we plot the figures using the standard deviation (i.e., $\sqrt { g ( \alpha , \beta ) } )$ to avoid extremely large values in the visualization of DARTS. Obviously, as the cell width decreases and the cell depth increases (i.e., from $C ^ { d a r t s }$ to $C _ { 4 } ^ { d a r t s }$ ), the region with relatively small gradient variance becomes smaller as shown in Figure 7. Consistently, the gradient variance generally shows an increasing trend from $C ^ { d a r t s }$ to
+
+![](images/9f267a62ba4182f35a16326d86f8d819146fc3e2bf6de2627d1327ca6cb89bcd.jpg)  
+Figure 8: 3D surfaces of the gradient variance from DARTS and its randomly connected variants around the optimal on the test dataset of CIFAR-100. The height of the surface indicates the value of gradient variance. Notably, the height of the gradient variance surface is gradually increasing from left to right. Especially, $C ^ { d a r t s }$ has the smoothest and lowest surface of gradient variance among these architectures.
+
+$C _ { 4 } ^ { d a r t s }$ in Figure 8. Consequently, the gradient becomes noisier in the neighborhood of the optimal, which typically makes the optimization harder and unstable.
+
+Similar results from other popular NAS architectures and their random variants are provided in Appendix B.4. Based on these results, we conclude that the increase in width and the decrease in depth of a cell result in a smaller gradient variance, which makes the optimization process less noisy and more efficient. The convergence of wide and shallow cells therefore shall be fast and stable following Theorem 4.1.
+
+# 4.3 THEORETICAL ANALYSIS OF FACTORS AFFECTING CONVERGENCE
+
+Our empirical study so far suggests that larger cell width and smaller cell depth smooth the loss landscape and decrease the gradient variance. Consequently, popular NAS architectures with wide and shallow cells converge fast. In this section, we investigate the impacts of the cell width and depth on Lipschitz smoothness and gradient variance from a theoretical perspective.
+
+# 4.3.1 SETUP
+
+We analyze the impact of the cell width and depth by comparing architectures with the widest cell and the narrowest cell as shown in Figure 26 of Appendix C. To simplify the analysis, the cells we investigate contain only one input node $_ { \textbf { \em x } }$ and one output node. The input node may be training instances or output node from any proceeding cell. All operations in the cell are linear operations without any non-linearity. Suppose there are $n$ intermediate nodes in a cell, the $i _ { t h }$ intermediate node and its associated weight matrix are denoted as $\mathbf { \boldsymbol { y } } ^ { ( i ) }$ and $W ^ { ( i ) } ( i = 1 , \cdots , n )$ respectively. The output node $_ z$ denotes the concatenation of all intermediate nodes. Both cells have the same arbitrary objective function $f$ following the output node, which shall consist of the arbitrary number of activation functions and cells. For clarity, we refer to the objective function, intermediate nodes and output node of the architecture with the narrowest cell as $\hat { \widehat { f } } , \widehat { \pmb { y } } ^ { ( i ) }$ and $\widehat { z }$ respectively. As shown in Figure 26, the intermediate node $\mathbf { \boldsymbol { y } } ^ { ( i ) }$ and $\widehat { \pmb y } ^ { ( i ) }$ bcan be computed by $\mathbf { \boldsymbol { y } } ^ { ( i ) } \equiv W ^ { ( i ) } \dot { \mathbf { \boldsymbol { x } } }$ and $\begin{array} { r } { \widehat { \pmb y } ^ { ( i ) } = \prod _ { k = 1 } ^ { i } W ^ { ( k ) } \pmb x } \end{array}$ b respectively. Particularly, we set $\begin{array} { r } { \prod _ { k = 1 } ^ { i } W ^ { ( k ) } = W ^ { ( i ) } W ^ { ( i - 1 ) } \cdot \cdot \cdot W ^ { ( 1 ) } } \end{array}$ . And ball the related proofs of following theorems can be found in Appendix C.
+
+# 4.3.2 THEORETICAL RESULTS
+
+Due to the complexity of the standard Lipschitz smoothness, we instead investigate the block-wise Lipschitz smoothness (Beck & Tetruashvili, 2013) of the two cases shown in Figure 26. In Theo$\mathrm { r e m } 4 . 2$ , we show that the block-wise Lipschitz constant of the narrowest cell is scaled by the largest eigenvalues of the model parameters (i.e., $W ^ { ( i ) } ( i = 1 , \cdots , n ) )$ . Notably, the Lipschitz constant of the narrowest cell can be significantly larger than the one of the widest cell while most of the largest eigenvalues are larger than 1, which slows down the convergence substantially. The empirical study in Section 4.2.1 has validated the results.
+
+Theorem 4.2 (The impact of cell width and depth on block-wise Lipschitz smoothness ) Let $\lambda ^ { ( i ) }$ be the largest eigenvalue of $W ^ { ( i ) }$ . Given the widest cell with objective function $f$ and the narrowest cell with objective function ${ \widehat { f } } ,$ , by assuming the block-wise Lipschitz smoothness of the widest cell as $\begin{array} { r l r } { \left\| \frac { \partial f } { \partial W _ { 1 } ^ { ( i ) } } - \frac { \partial f } { \partial W _ { 2 } ^ { ( i ) } } \right\| } & { { } \le L ^ { ( i ) } \left\| W _ { 1 } ^ { ( i ) } - W _ { 2 } ^ { ( i ) } \right\| } & { } \end{array}$ for any $W _ { 1 } ^ { ( i ) }$ and $W _ { 2 } ^ { ( i ) }$ , the block-wise Lipschitz smoothness of the narrowest cell then can be represented as
+
+![](images/b2f93e7fd07134c171ffa0c6ff624333f895073657b036203d51f387940193f2.jpg)  
+Figure 9: Comparison of the test accuracy at the convergence between popular NAS architectures and their randomly connected variants on CIFAR-10. Each popular NAS architecture (index 0 on the $x$ -axis) is followed by 13 randomly connected variants (from index 1 to index 13 on the $x$ -axis), corresponding to $C _ { 1 }$ to $C _ { 1 3 }$ respectively. The width and depth of these random variants are shown in Table 2 in Appendix B.2. The dashed lines report the accuracy of the popular NAS architectures.
+
+$$
+\left\| \frac { \partial \widehat { f } } { \partial W _ { 1 } ^ { ( i ) } } - \frac { \partial \widehat { f } } { \partial W _ { 2 } ^ { ( i ) } } \right\| \leq ( \prod _ { j = 1 } ^ { i - 1 } \lambda ^ { ( j ) } ) L ^ { ( i ) } \left\| W _ { 1 } ^ { ( i ) } - W _ { 2 } ^ { ( i ) } \right\|
+$$
+
+We then compare the gradient variance of the two cases shown in Figure 26. Interestingly, gradient variance suggests a similar but more significant difference between the two cases compared with their difference in Lipschitz smoothness. As shown in Theorem 4.3, the gradient variance of the narrowest cell is not only scaled by the square of the largest eigenvalue of the weight matrix but also is scaled by the number of intermediate nodes (i.e., $n$ ). Moreover, the upper bound of its gradient variance has numbers of additional terms, leading to a significantly larger gradient variance. The empirical study in Section 4.2.2 has confirmed the results.
+
+Theorem 4.3 (The impact of cell width and depth on gradient variance ) Let $\lambda ^ { ( i ) }$ be the largest eigenvalue of $\dot { W } ^ { ( i ) }$ . Given the widest cell with objective function $f$ and the narrowest cell with objective function $\widehat { f } _ { \mathrm { i } }$ , by assuming the gradient variance of the widest cell as $\begin{array} { r } { \mathbb { E } \left\| \frac { \partial f } { \partial W ^ { ( i ) } } - \mathbb { E } \frac { \partial f } { \partial W ^ { ( i ) } } \right\| ^ { 2 } \leq } \end{array}$ $( \sigma ^ { ( i ) } ) ^ { 2 }$ for any $W ^ { ( i ) }$ , the gradient variance of the narrowest cell is then bounded by
+
+$$
+\mathbb { E } \left\| \frac { \partial \widehat { f } } { \partial W ^ { ( i ) } } - \mathbb { E } \frac { \partial \widehat { f } } { \partial W ^ { ( i ) } } \right\| ^ { 2 } \leq n \sum _ { k = i } ^ { n } ( \frac { \sigma ^ { ( k ) } } { \lambda ^ { ( i ) } } \prod _ { j = 1 } ^ { k } \lambda ^ { ( j ) } ) ^ { 2 }
+$$
+
+# 5 GENERALIZATION BEYOND THE COMMON CONNECTIONS
+
+Our empirical and theoretical results so far have demonstrated that the common connection pattern helps to smooth the loss landscape and make the gradient more accurate. Popular NAS architectures with wider and shallower cells therefore converge faster, which explains why popular NAS architectures are selected by the NAS algorithms. Nonetheless, we have ignored the generalization performance obtained by popular NAS architectures and their random variants. We therefore wonder whether popular NAS architectures with wide and shallow cells generalize better.
+
+In Figure 9, we visualize the test accuracy of popular NAS architectures and their randomly connected variants trained in Section 4.1. Notably, the popular NAS architectures can achieve competitive accuracy compared with most of the random variants. However, there are some random variants, which achieve higher accuracy than the popular architectures. Interestingly, there seems to be an optimal choice of depth and width for a cell to achieve higher test accuracy (i.e., $C _ { 7 }$ for DARTS and $C _ { 4 }$ for ENAS). Popular NAS architectures with wide and shallow cells therefore are not guaranteed to generalize better, although they typically converge faster than other random variants.
+
+We also adapt the connections of popular NAS architectures to obtain their widest and shallowest variants. The adaption is possible due to the fact that the cells (including normal and reduction cell)
+
+Table 1: Comparison of the test error at the convergence between the original and the adapted NAS architectures on CIFAR-10/100 and Tiny-ImageNet-200. The entire networks are constructed and trained following the experimental settings reported in Appendix A.3, which may slightly deviate from the original ones. The test errors (or the parameter sizes) of original and adapted architectures are reported on the left and right hand-side of slash respectively.
+
+<table><tr><td rowspan="2">Architecture</td><td colspan="2">CIFAR-10</td><td colspan="2">CIFAR-100</td><td colspan="2">Tiny-ImageNet-200</td></tr><tr><td>Error(%)</td><td>Params(M)</td><td>Error(%)</td><td>Params(M)</td><td>Error(%)</td><td>Params(M)</td></tr><tr><td>NASNet (Zoph et al., 2018)</td><td>2.65/2.80</td><td>4.29/4.32</td><td>17.06/16.86</td><td>4.42/4.45</td><td>31.88/32.05</td><td>4.57/4.60</td></tr><tr><td>AmoebaNet (Real etal.,2019)</td><td>2.76/2.91</td><td>3.60/3.60</td><td>17.55/17.28</td><td>3.71/3.71</td><td>32.22/33.16</td><td>3.83/3.83</td></tr><tr><td>ENAS (Pham et al., 2018)</td><td>2.64/2.76</td><td>4.32/4.32</td><td>16.67/16.04</td><td>4.45/4.45</td><td>30.68/31.36</td><td>4.60/4.60</td></tr><tr><td>DARTS (Liu et al., 2019)</td><td>2.67/2.73</td><td>3.83/3.90</td><td>16.41/16.15</td><td>3.95/4.03</td><td>30.58/31.33</td><td>4.08/4.16</td></tr><tr><td>SNAS (Xie et al., 2019b)</td><td>2.88/2.69</td><td>3.14/3.19</td><td>17.78/17.20</td><td>3.26/3.31</td><td>32.40/32.61</td><td>3.39/3.45</td></tr></table>
+
+of popular NAS architectures are generally not widest and narrowest as shown in Figure 1. While there are various widest and shallowest cells following our definition of cell width and depth, we apply the connection pattern of SNAS cell shown in Figure 1(e) to obtain the widest and shallowest cells. The adapted topologies are shown in Figure 25 of Appendix B.5.
+
+Table 1 illustrates the comparison of the test accuracy between our adapted NAS architectures and the original ones. As shown in Table 1, the adapted architectures achieve smaller test error on CIFAR-100. Nevertheless, most of the adapted architectures, obtain larger test error than the original NAS architectures on both CIFAR-10 and Tiny-ImageNet- $2 0 0 ^ { 4 }$ . The results again suggest that the widest and shallowest cells may not help architectures generalize better, while these architectures typically achieve compelling generalization performance.
+
+The results above have revealed that the architectures with wide and shallow cells may not generalize better despite their fast convergence. To improve current NAS algorithms, we therefore need to rethink the evaluation of the performance of candidate architectures during architecture search since the current NAS algorithms are not based on the generalization performance at convergence as mentioned in Section 4.1. Nonetheless, architectures with the wide and shallow cells usually guarantee a stable and fast convergence along with competitive generalization performance, which should be good prior knowledge for designing architectures and NAS algorithms.
+
+# 6 CONCLUSION AND DISCUSSION
+
+Recent works have been focusing on the design and evaluation of NAS algorithms. We instead endeavour to examine the architectures selected by the various popular NAS algorithms. Our study is the first to explore the common structural patterns selected by existing algorithms, why these architectures are selected, and why these algorithms may be flawed. In particular, we reveal that popular NAS algorithms tend to favor architectures with wide and shallow cells, which typically converge fast and consequently are likely be selected during the search process. However, these architectures may not generalize better than other candidates of narrow and deep cells.
+
+To further improve the performance of the selected NAS architectures, one promising direction for the current NAS research is to evaluate the generalization performance of candidate architectures more accurately and effectively. While popular NAS architectures appreciate fast and stable convergence along with competitive generalization performance, we believe that the wide and shallow cells are still useful prior knowledge for the design of the search space. We hope this work can attract more attention to the interpretation and understanding of existing popular NAS algorithms.
+
+# ACKNOWLEDGEMENT
+
+This research is supported by the National Research Foundation Singapore under its AI Singapore Programme [Award No. AISG-GC-2019-002] and Singapore Ministry of Education Academic Research Fund Tier 3 under MOEs official grant number MOE2017-T3-1-007.
+
+# REFERENCES
+
+Youhei Akimoto, Shinichi Shirakawa, Nozomu Yoshinari, Kento Uchida, Shota Saito, and Kouhei Nishida. Adaptive stochastic natural gradient method for one-shot neural architecture search. In ICML, volume 97 of Proceedings of Machine Learning Research, pp. 171–180. PMLR, 2019.
+
+Amir Beck and Luba Tetruashvili. On the convergence of block coordinate descent type methods. SIAM Journal on Optimization, 23(4):2037–2060, 2013.
+
+Han Cai, Ligeng Zhu, and Song Han. Proxylessnas: Direct neural architecture search on target task and hardware. In ICLR (Poster). OpenReview.net, 2019.
+
+Terrance Devries and Graham W. Taylor. Improved regularization of convolutional neural networks with cutout. CoRR, abs/1708.04552, 2017.
+
+Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Neural architecture search: A survey. Journal of Machine Learning Research, 20(55):1–21, 2019.
+
+Saeed Ghadimi and Guanghui Lan. Stochastic first- and zeroth-order methods for nonconvex stochastic programming. SIAM Journal on Optimization, 23(4):2341–2368, 2013.
+
+Ian J. Goodfellow and Oriol Vinyals. Qualitatively characterizing neural network optimization problems. In ICLR, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In CVPR, pp. 2261–2269. IEEE Computer Society, 2017.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, pp. 1106–1114, 2012.
+
+Gustav Larsson, Michael Maire, and Gregory Shakhnarovich. Fractalnet: Ultra-deep neural networks without residuals. In ICLR (Poster). OpenReview.net, 2017.
+
+Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. Visualizing the loss landscape of neural nets. In NeurIPS, pp. 6391–6401, 2018.
+
+Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. In UAI, pp. 129. AUAI Press, 2019.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: differentiable architecture search. In ICLR (Poster). OpenReview.net, 2019.
+
+Renqian Luo, Fei Tian, Tao Qin, Enhong Chen, and Tie-Yan Liu. Neural architecture optimization. In NeurIPS, pp. 7827–7838, 2018.
+
+Niv Nayman, Asaf Noy, Tal Ridnik, Itamar Friedman, Rong Jin, and Lihi Zelnik-Manor. XNAS: neural architecture search with expert advice. CoRR, abs/1906.08031, 2019.
+
+Yurii Nesterov. Introductory Lectures on Convex Optimization - A Basic Course, volume 87 of Applied Optimization. Springer, 2004.
+
+Hieu Pham, Melody Y. Guan, Barret Zoph, Quoc V. Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. In ICML, volume 80 of Proceedings of Machine Learning Research, pp. 4092–4101. PMLR, 2018.
+
+Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V. Le. Regularized evolution for image classifier architecture search. In AAAI, pp. 4780–4789. AAAI Press, 2019.
+
+Christian Sciuto, Kaicheng Yu, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. arXiv preprint arXiv:1902.08142, 2019.   
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, pp. 1–9. IEEE Computer Society, 2015.   
+Mingxing Tan, Bo Chen, Ruoming Pang, Vijay Vasudevan, Mark Sandler, Andrew Howard, and Quoc V. Le. Mnasnet: Platform-aware neural architecture search for mobile. In CVPR, pp. 2820– 2828. Computer Vision Foundation / IEEE, 2019.   
+Saining Xie, Alexander Kirillov, Ross Girshick, and Kaiming He. Exploring randomly wired neural networks for image recognition. arXiv preprint arXiv:1904.01569, 2019a.   
+Sirui Xie, Hehui Zheng, Chunxiao Liu, and Liang Lin. SNAS: stochastic neural architecture search. In ICLR (Poster). OpenReview.net, 2019b.   
+Zirui Zhou, Qi Zhang, and Anthony Man-Cho So. 1,p-norm regularization: Error bounds and convergence rate analysis of first-order methods. In ICML, pp. 1501–1510, 2015.   
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V. Le. Learning transferable architectures for scalable image recognition. In CVPR, pp. 8697–8710. IEEE Computer Society, 2018.
+
+# APPENDIX A EXPERIMENTAL SETUP
+
+# A.1 DATA PRE-PROCESSING AND AUGMENTATION
+
+Our experiments are conducted on CIFAR-10/100 (Krizhevsky et al., 2009) and Tiny-ImageNet200. CIFAR-10/100 contains 50,000 training images and 10,000 test images of $3 2 \times 3 2$ pixels in 10 and 100 classes respectively. Tiny-ImageNet-200 consists of 100,000 training images, 10,000 validation images and 10,000 test images5 in 200 classes. We adopt the same data pre-processing and argumentation as described in DARTS (Liu et al., 2019): zero padding the training images with 4 pixels on each side and then randomly cropping them back to $3 2 \times 3 2$ on CIFAR-10/100 and $6 4 \times 6 4$ on Tiny-ImageNet-200; randomly flipping training images horizontally; normalizing training images with the means and standard deviations along the channel dimension.
+
+# A.2 SAMPLING OF RANDOM VARIANTS
+
+For a $N$ -node NAS cell, there are $\frac { ( N - 2 ) ! } { ( M - 1 ) ! }$ possible connections with $M$ input nodes and one output node. There are therefore hundreds to thousands of possible randomly connected variants for each popular NAS cell. The random variants of operations consist of a similar or even higher amount of architectures. Due to the prohibitive cost of comparing popular NAS cells with all variants, we randomly sample some variants to understand why the popular NAS cells are selected.
+
+Given a NAS cell $C$ , we fix the partial order of intermediate nodes and their accompanying operations. We then replace the source node of their associated operations by uniformly randomly sampling a node from their proceeding nodes in the same cell to get their randomly connected variants. Similarly, given a NAS cell $C$ , we fix the partial order of intermediate nodes and their connection topologies. We then replace the operations couping each connection by uniformly randomly sampling from candidate operations to get their random variants of operations.
+
+# A.3 ARCHITECTURES AND TRAINING DETAILS
+
+For experiments on CIFAR-10/100 and Tiny-ImageNet-200, the neural network architectures are constructed by stacking $L = 2 0$ cells. Feature maps are down-sampled at the $L / 3$ -th and $2 L / 3$ -th cell of the entire architecture with stride 2. For Tiny-ImageNet-200, the stride of the first convolutional layer is adapted to 2 to reduce the input resolution from $6 4 \times 6 4$ to $3 2 \times 3 2$ . A more detailed building scheme can be found in DARTS (Liu et al., 2019).
+
+In the default training setting, we apply stochastic gradient descent (SGD) with learning rate 0.025, momentum 0.9, weight decay $3 \times \bar { 1 0 ^ { - 4 } }$ and batch size 80 to train the models for 600 epochs on CIFAR10/100 and 300 epochs on Tiny-ImageNet-200 to ensure the convergence. The learning rate is gradually annealed to zero following the standard cosine annealing schedule. To compare the convergence under different learning rates in Section 4.1, we change the initial learning rate from 0.025 to 0.25 and 0.0025 respectively.
+
+# A.4 REGULARIZATION
+
+Since regularization mechanisms shall affect the convergence (Zhou et al., 2015), architectures are trained without regularization for a neat empirical study in Section 4. The regularization mechanisms are only used in Section 5 to get the converged generalization performance of the original and adapted NAS architectures on CIFAR-10/100 and Tiny-ImageNet-200 as shown in Table 1.
+
+There are three adopted regularization mechanisms on CIFAR-10/100 and Tiny-ImageNet-200 in this paper: cutout (Devries & Taylor, 2017), auxiliary tower (Szegedy et al., 2015) and drop path (Larsson et al., 2017). We apply standard cutout regularization with cutout length 16. Moreover, the auxiliary tower is located at $2 L / 3$ -th cell of the entire architecture with weight 0.4. We apply the same linearly-increased drop path schedule as in NASNet (Zoph et al., 2018) with the maximum probability of 0.2.
+
+# APPENDIX B MORE RESULTS
+
+# B.1 NAS ARCHITECTURES AND THEIR VARIANTS
+
+We compare the width and depth of popular NAS architectures and their variants of random connections in Table 2. The random variants are sampled following the method in Appendix A.2. We further show the connection topologies of popular NAS and their partial random variants of connections in Figure 10 and Figure 11.
+
+Table 2: Comparison of the width and depth of popular NAS cells and their randomly variants of connections. The name of the popular NAS cell is followed by its width and depth, which is separated by a comma. The width of a cell is conventionally computed by assuming that each intermediate node shares the same width $c$ . Notably, the width and depth of random variants are in ascending and descending order respectively from $C _ { 1 }$ to $C _ { 1 3 }$ . Moreover, the popular NAS architectures achieve the largest width and nearly the smallest depth among all the variants.
+
+<table><tr><td>Base Cell</td><td>C</td><td>C</td><td>C3</td><td>C4</td><td>C5</td><td>C6</td><td>C7</td><td>C8</td><td>Cg</td><td>C10</td><td>C11</td><td>C12</td><td>C13</td></tr><tr><td>DARTS (3.5c,3)</td><td>2c,4</td><td>2c,4</td><td>2c,4</td><td>2.5c,4</td><td>2.5c,4</td><td>2.5c,3</td><td>2.5c,3</td><td>2.5c,3</td><td>3c,3</td><td>3c,3</td><td>3c,3</td><td>3.5c,3</td><td>3.5c,3</td></tr><tr><td>ENAS (5c,2)</td><td>1.5c,6</td><td>1.5c,5</td><td>2c,6</td><td>2c,6</td><td>2.5c,5</td><td>2.5c,5</td><td>3c,4</td><td>3c,3</td><td>3.5c,5</td><td>3.5c,4</td><td>3.5c,4</td><td>3.5c,3</td><td>3.5c,3</td></tr><tr><td>AmoebaNet (4c,4)</td><td>1.5c,6</td><td>1.5c,5</td><td>1.5c,5</td><td>1.5c,3</td><td>2c,6</td><td>2c,6</td><td>2c,4</td><td>2.5c,5</td><td>2.5c,3</td><td>2.5c,3</td><td>3c,3</td><td>3.5c,4</td><td>3.5c,3</td></tr><tr><td>NASNet (5c,2)</td><td>1.5c,6</td><td>1.5c,5</td><td>2c,6</td><td>2c,6</td><td>2.5c,5</td><td>2.5c,5</td><td>3c,4</td><td>3c,3</td><td>3.5c,5</td><td>3.5c,4</td><td>3.5c,4</td><td>3.5c,3</td><td>3.5c,3</td></tr></table>
+
+![](images/a7724974f63a6383403c4197297b234eadbbcf9e3272f88ee3d7fee52dc17f18.jpg)  
+Figure 10: Connection topology of AmoebaNet cell (Real et al., 2019) and its part of randomly connected variants. Each sub-figure reports the width and depth of a cell separated by a comma. The leftmost one is the original connection from AmoebaNet normal cell and others are the ones randomly sampled. The width of a cell is also computed by assuming that each intermediate node shares the same width $c$ . Notably, the original AmoebaNet cell has the largest width and almost the smallest depth among these cells.
+
+![](images/10ea54e0cac420bdd8e6e4a738562dc8c0e5a49d8f8e7e7e6aa5361d57f5afdd.jpg)  
+Figure 11: Connection topology of SNAS cell under mild constraint (Xie et al., 2019b) and its part of randomly connected variants. The width and depth of a cell are reported in the title of each plot. The leftmost one is the original connection from SNAS normal cell and others are the ones randomly sampled. The width of a cell is conventionally computed by assuming that each intermediate node shares the same width $c$ . Notably, the original SNAS cell has the largest width and the smallest depth among these cells.
+
+![](images/e6bd76aa9ea1e1bd74ad8e8e0b948d49fafddabbbaa73dfc8479eac00f6288e8.jpg)  
+Figure 12: More test accuracy $( \% )$ curves of DARTS, ENAS, AmoebaNet, NASNet and their random variants of operations on CIFAR-10 during training.
+
+Table 3: Comparison of the parameter size (MB) of popular NAS cells and their randomly variants of operations. $C _ { 0 }$ denotes the original NAS cell and $C _ { 1 }$ to $C _ { 1 0 }$ denote the random variants. Notably, there is a gap of $\sim 3 0 \%$ between the parameter size of the smallest architecture and one of the largest architecture.   
+
+<table><tr><td>Base cell</td><td>C</td><td>C1</td><td>C</td><td>C3</td><td>C4</td><td>C5</td><td>C6</td><td>C7</td><td>C8</td><td>C</td><td>C10</td></tr><tr><td>DARTS</td><td>3.35</td><td>3.37</td><td>2.84</td><td>2.70</td><td>2.98</td><td>3.19</td><td>2.43</td><td>3.49</td><td>2.88</td><td>3.31</td><td>2.81</td></tr><tr><td>ENAS</td><td>3.86</td><td>3.45</td><td>3.19</td><td>2.98</td><td>2.70</td><td>3.67</td><td>3.03</td><td>3.85</td><td>3.26</td><td>3.81</td><td>3.29</td></tr><tr><td>AmoebaNet</td><td>3.15</td><td>2.86</td><td>2.62</td><td>2.41</td><td>2.10</td><td>3.10</td><td>2.46</td><td>3.28</td><td>2.69</td><td>3.42</td><td>2.75</td></tr><tr><td>NASNet</td><td>3.83</td><td>3.45</td><td>3.19</td><td>2.98</td><td>2.70</td><td>3.67</td><td>3.03</td><td>3.85</td><td>3.26</td><td>3.81</td><td>3.29</td></tr></table>
+
+# B.2 CONVERGENCE
+
+In this section, we plot more test loss curves on CIFAR-10 (Krizhevsky et al., 2009) for original popular NAS architectures and their (12) randomly connected variants, as shown in Figure 13, Figure 14 and Figure 16. The depth and width of these 12 randomly connected variants can be found in Table 2. Notably, the width and depth of random variants (from $C _ { 1 }$ to $C _ { 1 2 }$ ) are in ascending and descending order respectively. Moreover, the popular NAS architectures achieve the largest width and nearly the smallest depth among all the variants. As shown in the following figures, the popular NAS cells, with larger width and smaller depth, typically achieve faster and more stable convergence than the random variants. Furthermore, with the increasing width and the decreasing depth, the convergence of random variants approaches to the original NAS architecture.
+
+![](images/a384e1b60ab3e477781a18041ad38cc4ed2f7071ced0d7f39f04d4a76ec0934b.jpg)  
+Figure 13: Test loss curves of DARTS and its variants on CIFAR-10 during training.
+
+![](images/2168351c98794c46ee4df88ceb09d96318ae37c2a8e767cd36bc3e9a1682598e.jpg)  
+Figure 14: Test loss curves of AmoebaNet and its variants on CIFAR-10 during training.
+
+![](images/5f07f0851085941cf22b4bc27af53caa0775369f959768e77ad1675dbd744317.jpg)  
+Figure 15: Test loss curves of ENAS and its variants on CIFAR-10 suring training.
+
+![](images/c12424586e5abfcec9920010a3461298db226a4841f82664368eb6a54eeb2dd8.jpg)  
+Figure 16: Test loss curves of NASNet and its variants on CIFAR-10 suring training.
+
+# B.3 LOSS LANDSCAPE
+
+In this section, we visualize loss landscapes for popular NAS architectures and their randomly connected variants. The depth and width of a cell are highly correlated. For example, the depth and width cannot reach their maximum simultaneously. With the increasing width, the average depth of cells grouped by the same width is decreasing as shown in Table 2. We therefore only group the results (including the ones from original NAS architectures) with various width levels of a cell for a better comparison. Notably, the architectures with wider and shallower cells have a smoother and benigner loss landscape, as shown in Figure 17, Figure 18, Figure 19 and Figure 20, which further supports the results in Section 4.2.1.
+
+![](images/d79e3165ac742d039b7801b7371e89d9c453596c9a0b9eb6655da27f4189a93e.jpg)  
+Figure 17: Loss contours of DARTS and its variants with random connections on the test dataset of CIFAR-10.
+
+![](images/60da9820e9d0dcbec387aaceb9c4b5ac1668ac2eb9eaee76f132c69ccd50826c.jpg)  
+Figure 18: Loss contours of AmoebaNet and its randomly connected variants on the test dataset of CIFAR-10.
+
+(a) 1.5c (b) 2c (c) 2.5c (d) 3c (e) 3.5c (a) 1.5c (b) 2c (c) 2.5c (d) 3c (e) 3.5c (a) 1.5c (b) 2c (c) 2.5c (d) 3c (e) 3.5c
+
+![](images/a39ea854736dc3fe04f8d3a558c095d617ac5d3f594a3affb6c4d9b31f3ec309.jpg)  
+Figure 19: Loss contours of ENAS and its randomly connected variants on the test dataset of CIFAR10.
+
+![](images/c7221a93195c9e8704d541292671df729c52182a14a87f5689b62a59eb96d9fb.jpg)  
+Figure 20: Loss contours of NASNet and its randomly connected variants on the test dataset of CIFAR-10.
+
+# B.4 GRADIENT VARIANCE
+
+In this section, we visualize the gradient variance (i.e., $g ( \alpha , \beta )$ as defined in Section 4.2.2) for the popular NAS architectures as well as their variants with random connection, such as AmoebaNet in Figure 21, DARTS in Figure 22, ENAS in Figure 23 and NASNet in Figure 23. The $z$ -axis has been scaled by $1 0 ^ { - 5 }$ for a better visualization. Similarly, we group the results based on the width of cells. Notably, architectures with wider and shallower cells achieve relatively smaller gradient variance, which further confirms the results in Section 4.2.2.
+
+![](images/6a67fdc40cdb4d5ffb4ee1e0d39c85baf4f3dd7956a3e28b2e760818c2bcdef3.jpg)  
+Figure 21: 3D surfaces of the gradient variance from AmoebaNet and its randomly connected variants on the test dataset of CIFAR-10.
+
+![](images/d7da322a4b900bf8b806504ba850de15ec9a3a68de9b0c58a6ff916c75179aa6.jpg)  
+Figure 22: 3D surfaces of the gradient variance from DARTS and its randomly connected variants on the test dataset of CIFAR-10.
+
+![](images/a873988d3264bf1bc288edc692cf810709287f9d2c206603ae04c540a64ea032.jpg)  
+Figure 23: 3D surfaces of the gradient variance from ENAS and its randomly connected variants on the test dataset of CIFAR-10.
+
+![](images/a52643ef9cedfd6008f7a9e1c67627c6fab5a49108f90964359bb86544cb73ae.jpg)  
+Figure 24: 3D surfaces of the gradient variance from NASNet and its randomly connected variants on the test dataset of CIFAR-10.
+
+# B.5 ADAPTED TOPOLOGIES
+
+In this section, we visualize the adapted architectures (in Figure 25) we investigate on in Section 5. Notably, The adapted connection topologies are not only applied in the normal cell but also the reduction cell. The adapted architectures are compared with popular NAS architectures to examine the impacts of the common connection pattern on generalization.
+
+![](images/86bd77ba63203744c1ff4e86e573165cc042d5d806aa8afbe1e03f058d334c89.jpg)  
+Figure 25: Adapted topologies of cells from popular NAS architectures. The title of each sub-figure includes the name of the architecture, width and depth of the cell following our definition. Notably, these cells achieve the largest width and smallest depth in their original search space.
+
+# APPENDIX C THEORETICAL ANALYSIS
+
+# C.1 SETUP
+
+![](images/86ac76a358165de58586c7f5f30f688e340f4cd4df0470f664c56902c0beb65b.jpg)  
+Figure 26: Two architectures to compare in the theoretical analysis: (a) architecture with widest cell; (b) architecture with narrowest cell. The notation $l$ and $\widehat { l }$ denote the values of objective function $f$ and $\widehat { f }$ evaluated at input $_ { \textbf { \em x } }$ respectively.
+
+# C.2 BASICS
+
+We firstly compare the gradient of case I and case $\mathrm { I I }$ shown in Figure 26. For case I, since $\begin{array} { r l } { \mathbf { \boldsymbol { y } } ^ { ( i ) } = } & { { } } \end{array}$ $W ^ { ( i ) } { \pmb x }$ , the gradient to each weight matrix $W ^ { ( i ) }$ is denoted by
+
+$$
+\frac { \partial f } { \partial W ^ { ( i ) } } = \frac { \partial f } { \partial \pmb { y } ^ { ( i ) } } \pmb { x } ^ { T }
+$$
+
+Similarly, since $\begin{array} { r } { \widehat { \pmb { y } } ^ { ( i ) } = \prod _ { k = 1 } ^ { i } W ^ { ( k ) } \pmb { x } } \end{array}$ for the case II, the gradient to each weight matrix $W ^ { ( i ) }$ is denoted by
+
+$$
+\begin{array} { l } { \displaystyle \frac { \partial \widehat { f } } { \partial W ^ { ( i ) } } = \sum _ { k = i } ^ { n } ( \prod _ { j = i + 1 } ^ { k } W ^ { ( j ) } ) ^ { T } \displaystyle \frac { \partial \widehat { f } } { \partial \widehat { y } ^ { ( k ) } } ( \prod _ { j = 1 } ^ { i - 1 } W ^ { ( j ) } { \pmb x } ) ^ { T } } \\ { = \sum _ { k = i } ^ { n } ( \prod _ { j = i + 1 } ^ { k } W ^ { ( j ) } ) ^ { T } \displaystyle \frac { \partial \widehat { f } } { \partial \widehat { y } ^ { ( k ) } } { \pmb x } ^ { T } ( \prod _ { j = 1 } ^ { i - 1 } W ^ { ( j ) } ) ^ { T } } \\ { = \displaystyle \sum _ { k = i } ^ { n } ( \prod _ { j = i + 1 } ^ { k } W ^ { ( j ) } ) ^ { T } \displaystyle \frac { \partial { f } } { \partial W ^ { ( k ) } } ( \prod _ { j = 1 } ^ { i - 1 } W ^ { ( j ) } ) ^ { T } } \end{array}
+$$
+
+Exploring the fact that $\begin{array} { r } { \frac { \partial \widehat { f } } { \partial \widehat { \pmb { y } } ^ { ( i ) } } = \frac { \partial f } { \partial \pmb { y } ^ { ( i ) } } } \end{array}$ ∂f∂y(i) , we get (4) by inserting (1) into (3).
+
+# C.3 PROOF OF THEOREM 4.2
+
+Due to the complexity of comparing the standard Lipschitz constant of the smoothness for these two cases, we instead investigate the block-wise Lipschitz constant (Beck & Tetruashvili, 2013). In other words, we evaluate the Lipschitz constant for each weight matrix $W ^ { ( i ) }$ while fixing all other matrices. Formally, we assume the block-wise Lipschitz smoothness of case I as
+
+$$
+\left\| \frac { \partial f } { \partial W _ { 1 } ^ { ( i ) } } - \frac { \partial f } { \partial W _ { 2 } ^ { ( i ) } } \right\| \leq L ^ { ( i ) } \left\| W _ { 1 } ^ { ( i ) } - W _ { 2 } ^ { ( i ) } \right\| \quad \forall W _ { 1 } ^ { ( i ) } , W _ { 2 } ^ { ( i ) }
+$$
+
+The default matrix norm we adopted is 2-norm. And $W _ { 1 } ^ { ( i ) } , W _ { 2 } ^ { ( i ) }$ denote possible assignments for $W ^ { ( i ) }$ .
+
+Denoting that $\lambda ^ { ( i ) } = \left\| W ^ { ( i ) } \right\|$ , which is the largest eigenvalue of matrix $W ^ { ( i ) }$ , we can get the smoothness of case $\mathrm { I I }$ as
+
+$$
+\begin{array} { r l } { \left| \frac { \partial \hat { f } } { \partial W _ { 1 } ^ { ( i ) } } - \frac { \partial \hat { f } } { \partial W _ { 2 } ^ { ( i ) } } \right| \Bigg | = \left| \displaystyle \sum _ { k = i } ^ { n } ( \displaystyle \prod _ { j = i + 1 } ^ { k } W ^ { ( j ) } ) ^ { T } \big ( \frac { \partial f } { \partial W _ { 1 } ^ { ( k ) } } - \frac { \partial f } { \partial W _ { 2 } ^ { ( k ) } } ) ( \displaystyle \prod _ { j = 1 } ^ { i - 1 } W ^ { ( j ) } ) ^ { T } \right| } & { } \\ { \displaystyle } & { \leq \displaystyle \sum _ { k = i } ^ { n } \left\| \big ( \displaystyle \prod _ { j = i + 1 } ^ { k } W ^ { ( j ) } \big ) ^ { T } \big ( \frac { \partial f } { \partial W _ { 1 } ^ { ( k ) } } - \frac { \partial f } { \partial W _ { 2 } ^ { ( k ) } } \big ) ( \displaystyle \prod _ { j = 1 } ^ { i - 1 } W ^ { ( j ) } ) ^ { T } \right| } \\ & { \displaystyle \leq \displaystyle \sum _ { k = i } ^ { n } ( \displaystyle \frac { 1 } { \lambda ^ { ( i ) } } \displaystyle \prod _ { j = 1 } ^ { k } \lambda ^ { ( j ) } ) L ^ { ( k ) } \left\| W _ { 1 } ^ { ( k ) } - W _ { 2 } ^ { ( k ) } \right\| } \\ & { \displaystyle \leq ( \displaystyle \prod _ { j = 1 } ^ { i - 1 } \lambda ^ { ( j ) } ) L ^ { ( i ) } \left\| W _ { 1 } ^ { ( i ) } - W _ { 2 } ^ { ( k ) } \right\| } \end{array}
+$$
+
+We get the equality in (6) since $j > i$ and $W ^ { ( j ) }$ keeps the same for the computation of block-wise Lipschitz constant of $W ^ { ( i ) }$ . Based on the triangle inequality of norm, we get (7) from (6). We get (8) from (7) based on the inequality $\lVert W V \rVert \leq \lVert W \rVert \lVert V \rVert$ and the assumption of the smoothness for case I in (5). Finally, since we are evaluating the block-wise Lipschitz constant for $W ^ { ( i ) }$ , $W _ { 1 } ^ { ( k ) } = W _ { 2 } ^ { ( k ) }$ while $k \neq i$ , which leads to the final inequality (9).
+
+# C.4 PROOF OF THEOREM 4.3
+
+Similarly, we assume the gradient variance of case I is bounded as
+
+$$
+\mathbb { E } \left\| \frac { \partial f } { \partial W ^ { ( i ) } } - \mathbb { E } \frac { \partial f } { \partial W ^ { ( i ) } } \right\| ^ { 2 } \leq ( \sigma ^ { ( i ) } ) ^ { 2 }
+$$
+
+The gradient variance of case $\mathrm { I I }$ is then bounded by
+
+$$
+\begin{array} { r l } { \mathbb { E } \left\| \displaystyle \frac { \partial \hat { f } } { \partial W ^ { ( i ) } } - \mathbb { E } \frac { \partial \hat { f } } { \partial W ^ { ( i ) } } \right\| ^ { 2 } = \mathbb { E } \left\| \displaystyle \sum _ { k = i } ^ { n } ( \displaystyle \prod _ { j = i + 1 } ^ { k } W ^ { ( j ) } ) ^ { T } ( \displaystyle \frac { \partial f } { \partial W ^ { ( k ) } } - \mathbb { E } \frac { \partial f } { \partial W ^ { ( k ) } } ) ( \displaystyle \prod _ { j = 1 } ^ { i - 1 } W ^ { ( j ) } ) ^ { T } \right\| ^ { 2 } } & { } \\ { \leq n \mathbb { E } \displaystyle \sum _ { k = i } ^ { n } \left\| ( \displaystyle \prod _ { j = i + 1 } ^ { k } W ^ { ( j ) } ) ^ { T } ( \displaystyle \frac { \partial f } { \partial W ^ { ( k ) } } - \mathbb { E } \frac { \partial f } { \partial W ^ { ( k ) } } ) ( \displaystyle \prod _ { j = 1 } ^ { i - 1 } W ^ { ( j ) } ) ^ { T } \right\| ^ { 2 } } & { } \\ { \leq n \displaystyle \sum _ { k = i } ^ { n } ( \displaystyle \frac { \sigma ^ { ( k ) } } { \lambda ^ { ( i ) } } \displaystyle \prod _ { j = 1 } ^ { k } \lambda ^ { ( j ) } ) ^ { 2 } } & { } \end{array}
+$$
+
+We get (12) from (11) based on Cauchy-Schwarz inequality. Based on the inequality $\| W V \| \leq$ $\| W \| \| V \|$ and the assumption of bounded gradient variance for case I in (10), we get the final inequality.

parse/train/HJxyZkBKDr/HJxyZkBKDr.md

@@ -0,0 +1,307 @@
+# NAS-BENCH-201: EXTENDING THE SCOPE OF REPRODUCIBLE NEURAL ARCHITECTURE SEARCH
+
+Xuanyi Dong†‡ ∗and Yi Yang† †ReLER, CAI, University of Technology Sydney, ‡Baidu Research
+
+# ABSTRACT
+
+Neural architecture search (NAS) has achieved breakthrough success in a great number of applications in the past few years. It could be time to take a step back and analyze the good and bad aspects in the field of NAS. A variety of algorithms search architectures under different search space. These searched architectures are trained using different setups, e.g., hyper-parameters, data augmentation, regularization. This raises a comparability problem when comparing the performance of various NAS algorithms. NAS-Bench-101 has shown success to alleviate this problem. In this work, we propose an extension to NAS-Bench-101: NAS-Bench201 with a different search space, results on multiple datasets, and more diagnostic information. NAS-Bench-201 has a fixed search space and provides a unified benchmark for almost any up-to-date NAS algorithms. The design of our search space is inspired from the one used in the most popular cell-based searching algorithms, where a cell is represented as a directed acyclic graph. Each edge here is associated with an operation selected from a predefined operation set. For it to be applicable for all NAS algorithms, the search space defined in NAS-Bench-201 includes all possible architectures generated by 4 nodes and 5 associated operation options, which results in 15,625 neural cell candidates in total. The training log using the same setup and the performance for each architecture candidate are provided for three datasets. This allows researchers to avoid unnecessary repetitive training for selected architecture and focus solely on the search algorithm itself. The training time saved for every architecture also largely improves the efficiency of most NAS algorithms and brings a more computational cost friendly NAS community for a broader range of researchers. We provide additional diagnostic information such as fine-grained loss and accuracy, which can give inspirations to new designs of NAS algorithms. In further support of the proposed NAS-Bench201, we have analyzed it from many aspects and benchmarked 10 recent NAS algorithms, which verify its applicability.
+
+# 1 INTRODUCTION
+
+The deep learning community is undergoing a transition from hand-designed neural architecture (He et al., 2016; Krizhevsky et al., 2012; Szegedy et al., 2015) to automatically designed neural architecture (Zoph & Le, 2017; Pham et al., 2018; Real et al., 2019; Dong & Yang, 2019b; Liu et al., 2019). In its early era, the great success of deep learning was promoted by novel neural architectures, such as ResNet (He et al., 2016), Inception (Szegedy et al., 2015), VGGNet (Simonyan & Zisserman, 2015), and Transformer (Vaswani et al., 2017). However, manually designing one architecture requires human experts to try numerous different operation and connection choices (Zoph & Le, 2017). In contrast to architectures that are manually designed, those automatically found by neural architecture search (NAS) algorithms require much less human interaction and expert effort. These NAS-generated architectures have shown promising results in many domains, such as image recognition (Zoph & Le, 2017; Pham et al., 2018; Real et al., 2019), sequence modeling (Pham et al., 2018; Dong & Yang, 2019b; Liu et al., 2019), etc.
+
+Recently, a variety of NAS algorithms have been increasingly proposed. While these NAS methods are methodically designed and show promising improvements, many setups in their algorithms are different. (1) Different search space is utilized, e.g., different macro skeletons of the whole architecture (Zoph et al., 2018; Tan et al., 2019) and a different operation set for the micro cell within the skeleton (Pham et al., 2018), etc. (2) After a good architecture is selected, various strategies can be employed to train this architecture and report the performance, e.g., different data augmentation (Ghiasi et al., 2018; Zhang et al., 2018), different regularization (Zoph et al., 2018), different scheduler (Loshchilov & Hutter, 2017), and different selections of hyper-parameters (Liu et al., 2018; Dong & Yang, 2019a). (3) The validation set for testing the performance of the selected architecture is not split in the same way (Liu et al., 2019; Pham et al., 2018). These discrepancies raise a comparability problem when comparing the performance of various NAS algorithms, making it difficult to conclude their contributions.
+
+![](images/ef948e0a6ab15e4c383b46de048586c46f5264daa6a5c300a880d48b7f656296.jpg)  
+Figure 1: Top: the macro skeleton of each architecture candidate. Bottom-left: examples of neural cell with 4 nodes. Each cell is a directed acyclic graph, where each edge is associated with an operation selected from a predefined operation set as shown in the Bottom-right.
+
+In response to this problem, NAS-Bench-101 (Ying et al., 2019) and NAS-HPO-Bench (Klein & Hutter, 2019) are proposed. However, some NAS algorithms can not be applied directly on NASBench-101, and NAS-HPO-Bench only has 144 candidate architectures, which maybe insufficient to evaluate NAS algorithms. To extend these two benchmarks and towards better reproducibility of NAS methods1, we propose NAS-Bench-201 with a fixed cell search space, inspired from the search space used in the most popular neural cell-based searching algorithms (Zoph et al., 2018; Liu et al., 2019). As shown in Figure 1, each architecture consists of a predefined skeleton with a stack of the searched cell. In this way, architecture search is transformed into the problem of searching a good cell. Each cell is represented as a densely-connected directed acyclic graph (DAG) as shown in the bottom section of Figure 1. Here the node represents the sum of the feature maps and each edge is associated with an operation transforming the feature maps from the source node to the target node. The size of the search space is related to the number of nodes defined for the DAG and the size of the operation set. In NAS-Bench-201, we choose 4 nodes and 5 representative operation candidates for the operation set, which generates a total search space of 15,625 cells/architectures. Each architecture is trained multiple times on three different datasets. The training log and performance of each architecture are provided for each run. The training accuracy/test accuracy/training loss/test loss after every training epoch for each architecture plus the number of parameters and floating point operations (FLOPs) are accessible.
+
+Hopefully, NAS-Bench-201 will show its value in the field of NAS research. (1) It provides a unified benchmark for most up-to-date NAS algorithms including all cell-based NAS methods. With NASBench-201, researchers can focus on designing robust searching algorithm while avoiding tedious hyper-parameter tuning of the searched architecture. Thus, NAS-Bench-201 provides a relatively fair benchmark for the comparison of different NAS algorithms. (2) It provides the full training log of each architecture. Unnecessary repetitive training procedure of each selected architecture can be avoided (Liu et al., 2018; Zoph & Le, 2017) so that researchers can target on the essence of NAS, i.e., search algorithm. Another benefit is that the validation time for NAS largely decreases when testing in NAS-Bench-201, which provides a computational power friendly environment for more participations in NAS. (3) It provides results of each architecture on multiple datasets. The model transferability can be thoroughly evaluated for most NAS algorithms. (4) In NAS-Bench-201, we provide systematic analysis of the proposed search space. We also evaluate 10 recent advanced NAS algorithms including reinforcement learning (RL)-based methods, evolutionary strategy (ES)-based methods, differentiable-based methods, etc. We hope our empirical analysis can bring some insights to the future designs of NAS algorithms.
+
+# 2 NAS-Bench-201
+
+Our NAS-Bench-201 is algorithm-agnostic. Put simply, it is applicable to almost any up-to-date NAS algorithms. In this section, we will briefly introduce our NAS-Bench-201. The search space of NASBench-201 is inspired by cell-based NAS algorithms (Section 2.1). NAS-Bench-201 evaluates each architecture on three different datasets (Section 2.2). All implementation details of NAS-Bench-201 are introduced in Section 2.3. NAS-Bench-201 also provides some diagnostic information which can be used for potentially better designs of future NAS algorithms (discussed in Section 2.4).
+
+# 2.1 ARCHITECTURES IN THE SEARCH SPACE
+
+Macro Skeleton. Our search space follows the design of its counterpart as used in the recent neural cell-based NAS algorithms (Liu et al., 2019; Zoph et al., 2018; Pham et al., 2018). As shown in the top of Figure 1, the skeleton is initiated with one 3-by-3 convolution with 16 output channels and a batch normalization layer (Ioffe & Szegedy, 2015). The main body of the skeleton includes three stacks of cells, connected by a residual block. Each cell is stacked $N = 5$ times, with the number of output channels as 16, 32 and 64 for the first, second and third stages, respectively. The intermediate residual block is the basic residual block with a stride of 2 (He et al., 2016), which serves to downsample the spatial size and double the channels of an input feature map. The shortcut path in this residual block consists of a 2-by-2 average pooling layer with stride of 2 and a 1-by-1 convolution. The skeleton ends up with a global average pooling layer to flatten the feature map into a feature vector. Classification uses a fully connected layer with a softmax layer to transform the feature vector into the final prediction.
+
+Searched Cell. Each cell in the search space is represented as a densely connected DAG. The densely connected DAG is obtained by assigning a direction from the $i$ -th node to the $j$ -th node $( i < j )$ for each edge in an undirected complete graph. Each edge in this DAG is associated with an operation transforming the feature map from the source node to the target node. All possible operations are selected from a predefined operation set, as shown in Figure 1(bottom-right). In our NAS-Bench-201, the predefined operation set $\mathcal { O }$ has $L = 5$ representative operations: (1) zeroize, (2) skip connection, (3) 1-by-1 convolution, (4) 3-by-3 convolution, and (5) 3-by-3 average pooling layer. The convolution in this operation set is an abbreviation of an operation sequence of ReLU, convolution, and batch normalization. The DAG has $V = 4$ nodes, where each node represents the sum of all feature maps transformed through the associated operations of the edges pointing to this node. We choose $V = 4$ to allow the search space to contain basic residual block-like cells, which requires 4 nodes. Densely connected DAG does not restrict the searched topology of the cell to be densely connected, since we include zeroize in the operation set, which is an operation of dropping the associated edge. Besides, since we do not impose the constraint on the maximum number of edges (Ying et al., 2019), our search space is applicable to most NAS algorithms, including all cell-based NAS algorithms.
+
+# 2.2 DATASETS
+
+We train and evaluate each architecture on CIFAR-10, CIFAR-100 (Krizhevsky et al., 2009), and ImageNet-16-120 (Chrabaszcz et al., 2017). We choose these three datasets because CIFAR and ImageNet (Russakovsky et al., 2015) are the most popular image classification datasets.
+
+We split each dataset into training, validation and test sets to provide a consistent training and evaluation settings for previous NAS algorithms (Liu et al., 2019). Most NAS methods use the validation set to evaluate architectures after the architecture is optimized on the training set. The validation performance of the architectures serves as supervision signals to update the searching algorithm. The test set is to evaluate the performance of each searching algorithm by comparing the indicators (e.g., accuracy, model size, speed) of their selected architectures. Previous methods use different splitting strategies, which may result in various searching costs and unfair comparisons. We hope to use the proposed splits to unify the training, validation and test sets for a fairer comparison.
+
+CIFAR-10: It is a standard image classification dataset and consists of 60K $3 2 \times 3 2$ colour images in 10 classes. The original training set contains 50K images, with 5K images per class. The original test set contains 10K images, with 1K images per class. Due to the need of validation set, we split all 50K training images in CIFAR-10 into two groups. Each group contains 25K images with 10 classes. We regard the first group as the new training set and the second group as the validation set.
+
+CIFAR-100: This dataset is just like CIFAR-10. It has the same images as CIFAR-10 but categorizes each image into 100 fine-grained classes. The original training set on CIFAR-100 has 50K images, and the original test set has 10K images. We randomly split the original test set into two group of equal size — 5K images per group. One group is regarded as the validation set, and another one is regarded as the new test set.
+
+ImageNet-16-120: We build ImageNet-16-120 from the down-sampled variant of ImageNet (ImageNet $1 6 \times 1 6$ ). As indicated in Chrabaszcz et al. (2017), down-sampling images in ImageNet can largely reduce the computation costs for optimal hyper-parameters of some classical models while maintaining similar searching results. Chrabaszcz et al. (2017) down-sampled the original ImageNet to $1 6 \times 1 6$ pixels to form ImageNet $. 6 \times 1 6$ , from which we select all images with label $\in [ 1 , 1 2 0 ]$ to construct ImageNet-16-120. In sum, ImageNet-16-120 contains 151.7K training images, 3K validation images, and 3K test images with 120 classes.
+
+By default, in this paper, “the training set”, “the validation set”, “the test set” indicate the new training, validation, and test sets, respectively.
+
+# 2.3 ARCHITECTURE PERFORMANCE
+
+Training Architectures. In order to unify the performance of every architecture, we give the performance of every architecture in our search space. In our NAS-Bench-201, we follow previous literature to set up the hyper-parameters and training strategies (Zoph et al., 2018; Loshchilov & Hutter, 2017; He et al., 2016). We train each architecture with the same strategy, which is shown in Table 1. For simplification, we denote all hyperparameters for training a model as a set $\mathcal { H }$ , and we use $\mathcal { H } ^ { \dagger }$ to denote the values of hyper-parameter that we use. Specifically, we train each architecture via Nesterov momentum SGD, using the cross-entropy loss for 200 epochs in total. We set the weight decay as 0.0005 and decay the learning rate from 0.1 to 0 with a cosine annealing (Loshchilov & Hutter, 2017). We use the same $\mathcal { H } ^ { \dagger }$ on different datasets, except for the data augmentation which is slightly different due to the image resolution. On CIFAR, we use the random flip with probability of 0.5, the random crop $3 2 \times 3 2$ patch with 4 pixels padding on each border, and the normalization over RGB channels. On ImageNet-16-120, we use a similar strategy but random crop $1 6 \times 1 6$ patch with 2 pixels padding on each border. Apart from using $\mathcal { H } ^ { \dagger }$ for all datasets, we also use a different hyper-parameter set $\bar { \mathcal { H } } ^ { \dagger }$ for CIFAR-10. It is similar to $\mathcal { H } ^ { \dagger }$ but its total number of training epochs is 12. In this way, we could provide bandit-based algorithms (Falkner et al., 2018; Li et al., 2018) more options for the usage of short training budget (see more details in appendix).
+
+Table 1: The training hyper-parameter set $\mathcal { H } ^ { \dagger }$ .   
+
+<table><tr><td rowspan=2 colspan=1>optimizerNesterovmomentumweight decaybatch sizeVrandom flipnormalization</td><td rowspan=1 colspan=1>SGD</td><td rowspan=2 colspan=1>initialLRending LRLR scheduleepochinitial channelNrandom crop</td><td rowspan=2 colspan=1>0.10cosine200165</td></tr><tr><td rowspan=1 colspan=1>√0.90.00052564p=0.5&lt;</td></tr></table>
+
+Metrics. We train each architecture with different random seeds on different datasets. We evaluate each architecture $A$ after every training epoch. NAS-Bench-201 provides the training, validation,
+
+and test loss as well as accuracy. We show the supported metrics on different datasets in Table 2. Users can easily use our API to query the results of each trial of $A$ , which has negligible computational costs. In this way, researchers could significantly speed up their searching algorithm on these datasets and focus solely on the essence of NAS.
+
+We list the training/test loss/accuracies over
+
+Table 2: NAS-Bench-201 provides the following metrics with $\mathcal { H } ^ { \dagger }$ . ‘Acc.’ means accuracy.   
+
+<table><tr><td>Dataset</td><td>TrainLoss/Acc.Eval Loss/Acc.</td><td></td></tr><tr><td>CIFAR-10</td><td>train set</td><td>valid set</td></tr><tr><td>CIFAR-10</td><td>train+valid set</td><td>test set</td></tr><tr><td>CIFAR-100</td><td>train set</td><td>valid set</td></tr><tr><td>CIFAR-100</td><td>train set</td><td>test set</td></tr><tr><td>ImageNet-16-120</td><td>train set</td><td>valid set</td></tr><tr><td>ImageNet-16-120</td><td>train set</td><td>test set</td></tr></table>
+
+different split sets on four datasets in Table 2. On CIFAR-10, we train the model on the training set and evaluate it on the validation set. We also train the model on the training and validation set and evaluate it on the test set. These two paradigm follow the typical experimental setup on CIFAR-10 in previous literature (Liu et al., 2018; Zoph et al., 2018; Liu et al., 2018; Pham et al., 2018). On CIFAR-100 and ImageNet-16-120, we train the model on the training set and evaluate it on both validation and test sets.
+
+Table 3: We summarize some characteristics of NAS-Bench-101 and NAS-Bench-201. Our NASBench-201 can directly be applicable to almost any up-to-date NAS algorithms. In contrast, as pointed in (Ying et al., 2019), NAS algorithms based on parameter sharing or network morphisms cannot be directly evaluated on NAS-Bench-101. Besides, NAS-Bench-201 provides train/validation/test performance on three (one for NAS-Bench-101) different datasets so that the generality of NAS algorithms can be evaluated. It also provides some diagnostic information that may provide insights to design better NAS algorithms.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">#archit -ectures</td><td rowspan="2">#data -sets</td><td rowspan="2">10</td><td rowspan="2">search space constraint</td><td colspan="4">Supported NAS algorithms</td><td rowspan="2">Diagnostic information</td></tr><tr><td>RL</td><td>ES</td><td>|Diff.]</td><td>HPO</td></tr><tr><td>NAS-Bench-101</td><td>510M</td><td>1</td><td>3</td><td>constrain #edges1</td><td>partial</td><td>partial</td><td>none</td><td>most</td><td></td></tr><tr><td>NAS-Bench-201</td><td>15.6K</td><td>3</td><td>5</td><td>no constraint</td><td>all</td><td>all</td><td>all</td><td>most</td><td>fine-grained info., param., etc</td></tr></table>
+
+# 2.4 DIAGNOSTIC INFORMATION
+
+Validation accuracy is a commonly used supervision signal for NAS. However, considering the expensive computational costs for evaluating the architecture, the signal is too sparse. In our NASBench-201, we also provide some diagnostic information which is some extra statistics obtained during training each architecture. Collecting these statistics almost involves no extra computation cost but may provide insights for better designs and training strategies of different NAS algorithms, such as platform-aware NAS (Tan et al., 2019), accuracy prediction (Baker et al., 2018), mutationbased NAS (Cai et al., 2018; Chen et al., 2016), etc.
+
+Architecture Computational Costs: NAS-Bench-201 provides three computation metrics for each architecture — the number of parameters, FLOPs, and latency. Algorithms that target on searching architectures with computational constraints, such as models on edge devices, can use these metrics directly in their algorithm designs without extra calculations.
+
+Fine-grained training and evaluation information. NAS-Bench-201 tracks the changes in loss and accuracy of every architecture after every training epochs. These fine-grained training and evaluation information shows the tendency of the architecture performance and could indicate some attributes of the model, such as the speed of convergence, the stability, the over-fitting or under-fitting levels, etc. These attributes may benefit the designs of NAS algorithms. Besides, some methods learn to predict the final accuracy of an architecture based on the results of few early training epochs (Baker et al., 2018). These algorithm can be trained faster and the performance of the accuracy prediction can be evaluated using the fine-grained evaluation information.
+
+Parameters of optimized architecture. Our NAS-Bench-201 releases the trained parameters for each architecture. This can provide ground truth label for hypernetwork-based NAS methods (Zhang et al., 2019; Brock et al., 2018), which learn to generate parameters of an architecture. Other methods mutate an architecture to become another one (Real et al., 2019; Cai et al., 2018). With NAS-Bench-201, researchers could directly use the off-the-shelf parameters instead of training from scratch and analyze how to transfer parameters from one architecture to another.
+
+# 3 DIFFERENCE WITH EXISTING NAS BENCHMARKS
+
+To the best of our knowledge, NAS-Bench-101 (Ying et al., 2019) is the only existing large-scale architecture dataset. Similar to NAS-Bench-201, NAS-Bench-101 also transforms the problem of architecture search into the problem of searching neural cells, represented as a DAG. Differently, NAS-Bench-101 defines operation candidates on the node, whereas we associate operations on the edge as inspired from (Liu et al., 2019; Dong & Yang, 2019b; Zoph et al., 2018). We summarize characteristics of our NAS-Bench-201 and NAS-Bench-101 in Table 3. The main highlights of our NAS-Bench-201 are as follows. (1) NAS-Bench-201 is algorithm-agnostic while NAS-Bench
+
+![](images/88962deb55fbfd45703cae2a047041476b98a3f9ea5092d466ba1eb7ef13ff89.jpg)  
+Figure 2: Training, validation, test accuracy of each architecture on CIFAR-10, CIFAR-100, and ImageNet-16-120. We also visualize the results of ResNet in the orange star marker.
+
+101 without any modification is only applicable to selected algorithms (Yu et al., 2020; Zela et al., 2020). The original complete search space, based on the nodes in NAS-Bench-101, is extremely huge. So, it is exceedingly difficult to efficiently traverse the training of all architectures. To trade off the computational cost and the size of the search space, they constrain the maximum number of edges in the DAG. However, it is difficult to incorporate this constraint in all NAS algorithms, such as NAS algorithms based on parameter-sharing (Liu et al., 2019; Pham et al., 2018). Therefore, many NAS algorithms cannot be directly evaluated on NAS-Bench-101. Our NAS-Bench-201 solves this problem by sacrificing the number of nodes and including all possible edges so that our search space is algorithm-agnostic. (2) We provide extra diagnostic information, such as architecture computational cost, fine-grained training and evaluation time, etc., which give inspirations to better and efficient designs of NAS algorithms utilizing these diagnostic information.
+
+NAS-HPO-Bench (Klein & Hutter, 2019) evaluated 62208 configurations in the joint NAS and hyper-parameter space for a simple 2-layer feed-forward network. Since NAS-HPO-Bench has only 144 architectures, it could be insufficient to evaluate different NAS algorithms.
+
+# 4 ANALYSIS OF NAS-Bench-201
+
+An overview of architecture performance. The performance of each architecture is shown in Figure 2. We show the test accuracy of every architecture in our search space in the left column of Figure 2. The training, validation and test accuracy with respect to the number of parameters are shown in the rest three columns, respectively. Results show that a different number of parameters will affect the performance of the architectures, which indicates that the choices of operations are essential in NAS. We also observe that the performance of the architecture can vary even when the number of parameters stays the same. This observation indicates the importance of how the operations/cells are connected. We compare the architectures with a classical human-designed architecture (ResNet) in all cases, which is indicated by an orange star mark. ResNet shows competitive performance in three datasets, however, it still has room to improve, i.e., about $2 \%$ compared to the best architecture in CIFAR-100 and ImageNet-16-120, about $1 \%$ compared to the best one with the same amount of parameters in CIFAR-100 and ImageNet-16-120.
+
+![](images/775c3b04e237a87001c8ea71bbec6cd669f6173ca15dea4ff91446a5f23adf33.jpg)  
+Figure 3: The ranking of each architecture on three datasets, sorted by the ranking in CIFAR-10.
+
+Architecture ranking on three datasets. The ranking of every architecture in our search space is shown in Figure 3, where the architecture ranked in CIFAR-10 $\mathbf { \dot { X } } \mathbf { \cdot }$ -axis) is ranked as in y-axis in CIFAR-100 and ImageNet-16-120, indicated by green and red markers respectively. The performance of the architectures shows a generally consistent ranking over the three datasets with slightly different variance, which serves to test the generality of the searching algorithm.
+
+Correlations of validation and test accuracies. We visualize the correlation between the validation and test accuracy within one dataset and across datasets in Figure 4. The correlation within one dataset is high compared to cross-dataset correlation. The correlation dramatically decreases as we
+
+only pick the top performing architectures. When we directly transfer the best architecture in one dataset to another (a vanilla strategy), it can not $100 \%$ secure a good performance. This phenomena is a call for better transferable NAS algorithms instead of vanilla strategy.
+
+Dynamic ranking of architectures. We show the ranking of the performance of all architectures in different time stamps in Figure 5. The ranking based on the validation set (y axis) gradually converges to the ranking ba
+
+![](images/298e44fc9560f470cc253b2deef1100f0997c742c59b4514ae7c3b31300e0144.jpg)  
+Figure 4: We report the correlation coefficient between the accuracy on 6 sets, i.e., CIFAR-10 validation set (C10- V), CIFAR-10 test set (C10-T), CIFAR-100 validation set (C100-V), CIFAR-100 test set (C100-T), ImageNet-16-120 validation set (I120-V), ImageNet-16-120 test set (I120-T). ed on the final test accuracy (x axis).
+
+![](images/8b8b883e15a206f2b0604391871a50b6fe31f6240057ee9a0d08f4e4b5052c5f.jpg)  
+Figure 5: The ranking of all architectures based on the validation accuracy at different time stamps (y axis) sorted by the final test accuracy (x axis).
+
+# 5 BENCHMARK
+
+In this section, we evaluate 10 recent searching methods on our NAS-Bench-201, which can serve as baselines for future NAS algorithms in our dataset. Specifically, we evaluate some typical NAS algorithms: (I) Random Search algorithms, e.g., random search (RS) (Bergstra & Bengio, 2012), random search with parameter sharing (RSPS) (Li & Talwalkar, 2019). (II) ES methods, e.g., REA (Real et al., 2019). (III) RL algorithms, e.g., REINFORCE (Williams, 1992), ENAS (Pham et al., 2018). (IV) Differentiable algorithms. e.g., first order DARTS (DARTS-V1) (Liu et al., 2019), second order DARTS (DARTS-V2), GDAS (Dong & Yang, 2019b), and SETN (Dong & Yang, 2019a). (V) HPO methods, e.g., BOHB (Falkner et al., 2018). We experimented all NAS algorithms on a single GeForce GTX 1080 Ti GPU.
+
+Table 4: The utility of our NAS-Bench-201 for different NAS algorithms. We show whether a NAS algorithm can use our NAS-Bench-201 to accelerate the searching and evaluation procedure.   
+
+<table><tr><td rowspan=1 colspan=1>accelerate</td><td rowspan=1 colspan=1>RS</td><td rowspan=1 colspan=1>RSPS</td><td rowspan=1 colspan=1>DARTS-V1</td><td rowspan=1 colspan=1>DARTS-V2</td><td rowspan=1 colspan=1>GDAS</td><td rowspan=1 colspan=1>SETN</td><td rowspan=1 colspan=1>REA</td><td rowspan=1 colspan=1>REINFORCE</td><td rowspan=1 colspan=1>ENAS</td><td rowspan=1 colspan=1>BOHB</td></tr><tr><td rowspan=1 colspan=1>searchevaluation</td><td rowspan=1 colspan=1>V</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>V</td><td rowspan=1 colspan=1>1√</td><td rowspan=1 colspan=1>V</td><td rowspan=1 colspan=1>√√</td></tr></table>
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Search (seconds)</td><td colspan="2">CIFAR-10</td><td colspan="2">CIFAR-100</td><td colspan="2">ImageNet-16-120</td></tr><tr><td>validation</td><td>test</td><td>validation</td><td>test</td><td>validation</td><td>test</td></tr><tr><td>RSPS</td><td>8007.13</td><td>80.42±3.58</td><td>84.07±3.61</td><td>52.12±5.55</td><td>52.31±5.77</td><td>27.22±3.24</td><td>26.28±3.09</td></tr><tr><td>DARTS-V1</td><td>11625.77</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00</td><td>16.32±0.00</td></tr><tr><td>DARTS-V2</td><td>35781.80</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00</td><td>16.32±0.00</td></tr><tr><td>GDAS</td><td>31609.80</td><td>89.89±0.08</td><td>93.61±0.09</td><td>71.34±0.04</td><td>70.70±0.30</td><td>41.59±1.33</td><td>41.71±0.98</td></tr><tr><td>SETN</td><td>34139.53</td><td>84.04±0.28</td><td>87.64±0.00</td><td>58.86±0.06</td><td>59.05±0.24</td><td>33.06±0.02</td><td>32.52±0.21</td></tr><tr><td>ENAS</td><td>14058.80</td><td>37.51±3.19</td><td>53.89±0.58</td><td>13.37±2.35</td><td>13.96±2.33</td><td>15.06±1.95</td><td>14.84±2.10</td></tr><tr><td>RSPSt</td><td>7587.12</td><td>84.16±1.69</td><td>87.66±1.69</td><td>59.00±4.60</td><td>58.33±4.34</td><td>31.56±3.28</td><td>31.14±3.88</td></tr><tr><td>DARTS-V1†</td><td>10889.87</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00</td><td>16.32±0.00</td></tr><tr><td>DARTS-V2t</td><td>29901.67</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00</td><td>16.32±0.00</td></tr><tr><td>GDASt</td><td>28925.91</td><td>90.00±0.21</td><td>93.51±0.13</td><td>71.14±0.27</td><td>70.61±0.26</td><td>41.70±1.26</td><td>41.84±0.90</td></tr><tr><td>SETNt</td><td>31009.81</td><td>82.25±5.17</td><td>86.19±4.63</td><td>56.86±7.59</td><td>56.87±7.77</td><td>32.54±3.63</td><td>31.90±4.07</td></tr><tr><td>ENASt</td><td>13314.51</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00</td><td>16.32±0.00</td></tr><tr><td>REA RS</td><td>0.02</td><td>91.19±0.31</td><td>93.92±0.30</td><td>71.81±1.12</td><td>71.84±0.99</td><td>45.15±0.89</td><td>45.54±1.03</td></tr><tr><td></td><td>0.01</td><td>90.93±0.36</td><td>93.70±0.36</td><td>70.93±1.09</td><td>71.04±1.07</td><td>44.45±1.10</td><td>44.57±1.25</td></tr><tr><td>REINFORCE</td><td>0.12</td><td>91.09±0.37</td><td>93.85±0.37</td><td>71.61±1.12</td><td>71.71±1.09</td><td>45.05±1.02</td><td>45.24±1.18</td></tr><tr><td>BOHB</td><td>3.59</td><td>90.82±0.53</td><td>93.61±0.52</td><td>70.74±1.29</td><td>70.85±1.28</td><td>44.26±1.36</td><td>44.42±1.49</td></tr><tr><td>ResNet</td><td rowspan="2">N/A</td><td>90.83</td><td>93.97</td><td>70.42</td><td>70.86</td><td>44.53</td><td>43.63</td></tr><tr><td>optimal</td><td>91.61</td><td>94.37</td><td>73.49</td><td>73.51</td><td>46.77</td><td>47.31</td></tr></table>
+
+Table 5: We evaluate $I O$ different searching algorithms in our NAS-Bench-201. The first block shows results of parameter sharing based NAS methods. The second block is similar to the first one, however, BN layers in the searching cells do not keep running estimates but always use batch statistics. The third block shows results of NAS methods without parameter sharing. Each algorithm uses the training and validation set of CIFAR-10 for searching. We show results of their searched architectures for (1) training on the CIFAR-10 train set and evaluating on its validation set; (2) training on the CIFAR-10 train+validation sets and evaluating on its test set; (3) training on the CIFAR-10 or ImageNet-16-120 train set and evaluating on their validation or test sets. “optimal” indicates the highest mean accuracy for each set. We report the mean and std of 500 runs for RS, REA, REINFORCE, and BOHB and of 3 runs for RSPS, DARTS, GDAS, SETN, and ENAS.
+
+![](images/46bf8e1d5028fd58ba84d178b04a3d22a07d1e669ace1579b1a8879b51c298f7.jpg)  
+Figure 6: We show results of 500 runs for RS, REA, REINFORCE, and BOHB on CIFAR-10. The architecture is searched on CIFAR-10 and we report its validation accuracy (solid line) and test accuracy (dashed line) on three datasets. Each individual run is sorted by the validation accuracy of the searched architecture.
+
+We show the benefits for speed using our NAS-Bench-201 for different NAS algorithms in Table 4. For each NAS algorithm, once the searching procedure finished and the final architecture is found, our NAS-Bench-201 can directly return the performance of this architecture. With NAS-Bench-201, NAS algorithms without parameter sharing can significantly reduce the searching time into seconds. Notably, it still requires several GPU hours for NAS algorithms with parameter sharing to complete the searching.
+
+All algorithms use the training and validation set of CIFAR-10 to search architectures. In Table 5, Figure 6, Figure 7, and Figure 8, we report the performance of the searched architectures plus the optimal architecture on three datasets. We make the following observations: (1) NAS methods without parameter sharing (REA, RS, REINFORCE, and BOHB) outperform others. This be because training a model for a few epochs with the converged LR scheduler $( { \mathcal { H } } ^ { \ddagger } )$ can provide a good relative ranking of each architecture. (2) DARTS-V1 and DARTS-V2 quickly converge to find the architecture whose edges are all skip connection. A possible reason is that the original hyper-parameters of DARTS are chosen for their search space instead of ours. (3) The strategy of BN layers can significantly effect the NAS methods with parameter sharing. Using batch statistics are better than keep running estimates of the mean and variance. (4) Using our fine-grained information, REA, REINFORCE and RS can be finished in seconds which could significantly reduce the search costs and let researchers focus solely on the search algorithm itself.
+
+![](images/bfcdbc0617ecf87fe75943c147160d323c1666b859f183fc6073b370e8bc4d90.jpg)  
+Figure 7: Results keeping keep running estimates for BN layers in each searching cell. We use parameter sharing based NAS methods to search the architecture on CIFAR-10. After each searching epoch, we derive the architecture and show its validation accuracy (VALID) and test accuracy (TEST) on CIFAR-10. The 0-th epoch indicates the architecture is derived from the randomly initialized architecture encoding.
+
+![](images/5085f515858c5ad523ff941b52ac8d6a01ebfa36bc15acd511fdae755f620adc.jpg)  
+Figure 8: Results using batch statistics without keeping keep running estimates for BN layers in each searching cell. We use parameter sharing based NAS methods to search the architecture on CIFAR-10. After each searching epoch, we derive the architecture and show its validation accuracy (VALID) and test accuracy (TEST) on CIFAR-10. The 0-th epoch indicates the architecture is derived from the randomly initialized architecture encoding.
+
+In Figure 7 and Figure 8, we show the performance of the architecture derived from each algorithm per searching epoch. DARTS-V1 will gradually over-fit to an architecture with all skip-connection operations. DARTS-V2 can alleviate this problem to some extent but will still over-fit after more epochs. It can further alleviate this problem by using batch statistics for BN layers. We train RSPS, GDAS, SETN, and ENAS five times longer than DARTS (250 epochs vs. 50 epochs). This is because at every iteration, RSPS, GDAS, SETN, and ENAS only optimize 1|O|=5 parameters of the shared parameters, whereas DARTS optimize all shared parameters. The searched architecture performs similar for GDAS after 50 searching epochs. RSPS and SETN show a higher variance of the searched architecture compared to GDAS.
+
+Clarification. We have tried our best to implement each method. However, still, some algorithms might obtain non-optimal results since their hyper-parameters might not fit our NAS-Bench-201. We empirically found that some NAS algorithms are sensitive to some hyper-parameters, whereas we try to compare them in a fair way as we can (Please see more explanation in Appendix). If researchers can provide better results with different hyper-parameters, we are happy to update results according to the new experimental results. We also welcome more NAS algorithms to test on our dataset and would include them accordingly.
+
+# 6 DISCUSSION
+
+How to avoid over-fitting on NAS-Bench-201? Our NAS-Bench-201 provides a benchmark for NAS algorithms, aiming to provide a fair and computational cost-friendly environment to the NAS community. The trained architecture and the easy-to-access performance of each architecture might provide some insidious ways for designing algorithms to over-fit the best architecture in our NASBench-201. Thus, we propose some rules which we wish the users will follow to achieve the original intention of NAS-Bench-201, a fair and efficient benchmark.
+
+1. No regularization for a specific operation. Since the best architecture is known in our benchmark, specific designs to fit the structural attributes of the best performed architecture are insidious ways to fit our NAS-Bench-201. For example, as mentioned in Section 5, we found that the best architecture with the same amount of parameters for CIFAR10 on NAS-Bench-201 is ResNet. Restrictions on the number of residual connections is a way to over-fit the CIFAR10 benchmark. While this can give a good result on this benchmark, the searching algorithm might not generalize to other benchmarks.
+
+2. Use the provided performance. The training strategy affects the performance of the architecture. We suggest the users stick to the performance provided in our benchmark even if it is feasible to use other $\mathcal { H }$ to get a better performance. This provides a fair comparison with other algorithms.
+
+3. Report results of multiple searching runs. Since our benchmark can help to largely decrease the computational cost for a number of algorithms. Multiple searching runs give stable results of the searching algorithm with acceptable time cost.
+
+Limitation regarding to hyper-parameter optimization (HPO). The performance of an architecture depends on the hyper-parameters $\mathcal { H }$ for its training and the optimal configuration of $\mathcal { H }$ may vary for different architectures. In NAS-Bench-201, we use the same configuration for all architectures, which may bring biases to the performance of some architectures. One related solution is HPO, which aims to search the optimal hyper-parameter configuration. However, searching the optimal hyper-parameter configurations and the architecture in one shot is too computationally expensive and still is an open problem.
+
+Potential designs using diagnostic information in NAS-Bench-201. As pointed in Section 2.4, different kinds of diagnostic information are provided. We hope that more insights about NAS could be found by analyzing these diagnostic information and further motivate potential solutions for NAS. For example, parameter sharing (Pham et al., 2018) is the crucial technique to improve the searching efficiency, but the shared parameter would sacrifice the accuracy of each architecture. Could we find a better way to share parameters of each architecture from the learned 15,625 models’ parameters?
+
+Generalization ability of the search space. It is important to test the generalization of observations on this dataset. An idea strategy is to do all benchmark experiments on a much larger search space. Unfortunately, it is prohibitive regarding the expensive computational cost. We bring some results from (Ying et al., 2019) and (Zela et al., 2020) to provide some preliminary evidence of generalization. In Figure 2, we show the rankings of RS, REA, and REINFORCE is ( REA $>$ REINFORCE $> \mathrm { R } S$ ). This is consistent with results in NAS-Bench-101, which contains more architecture candidates. For NAS methods with parameter sharing, we find that $\mathrm { G D A S } \geq \mathrm { D A R T S } \geq \mathrm { E N A S }$ , which is also consistent with results in NAS-Bench-1SHOT1. Therefore, observations from our NAS-Bench201 may generalize to other search spaces.
+
+# 7 CONCLUSION & FUTURE WORK
+
+In this paper, we introduce NAS-Bench-201 that extends the scope of reproducible NAS. In NASBench-201, almost any NAS algorithms can be directly evaluated. We train and evaluate 15,625 architecture on three different datasets, and we provide results regarding different metrics. We comprehensively analyze our dataset and test some recent NAS algorithms on NAS-Bench-201 to serve as baselines for future works. In future, we will (1) consider HPO and NAS together and (2) much larger search space. We welcome researchers to try their NAS algorithms on our NAS-Bench201 and would update the paper to include their results.
+
+Acknowledgements. We thank the ICLR area chair, ICLR reviewers, and authors of NAS-Bench101 for the constructive suggestions during the rebuttal and revision period.
+
+# REFERENCES
+
+Bowen Baker, Otkrist Gupta, Ramesh Raskar, and Nikhil Naik. Accelerating neural architecture search using performance prediction. In International Conference on Learning Representations Workshop (ICLR-W), 2018.
+
+James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. The Journal of Machine Learning Research (JMLR), 13(Feb):281–305, 2012.
+
+Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. SMASH: one-shot model architecture search through hypernetworks. In International Conference on Learning Representations (ICLR), 2018.
+
+Han Cai, Tianyao Chen, Weinan Zhang, Yong Yu, and Jun Wang. Efficient architecture search by network transformation. In AAAI Conference on Artificial Intelligence (AAAI), pp. 2787–2794, 2018.
+
+Tianqi Chen, Ian Goodfellow, and Jonathon Shlens. Net2net: Accelerating learning via knowledge transfer. In International Conference on Learning Representations (ICLR), 2016.
+
+Patryk Chrabaszcz, Ilya Loshchilov, and Frank Hutter. A downsampled variant of imagenet as an alternative to the cifar datasets. arXiv preprint arXiv:1707.08819, 2017.
+
+Xuanyi Dong and Yi Yang. One-shot neural architecture search via self-evaluated template network. In Proc. of the IEEE International Conference on Computer Vision (ICCV), pp. 3681–3690, 2019a.
+
+Xuanyi Dong and Yi Yang. Searching for a robust neural architecture in four gpu hours. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1761–1770, 2019b.
+
+Stefan Falkner, Aaron Klein, and Frank Hutter. BOHB: Robust and efficient hyperparameter optimization at scale. In The International Conference on Machine Learning (ICML), pp. 1436–1445, 2018.
+
+Golnaz Ghiasi, Tsung-Yi Lin, and Quoc V Le. Dropblock: A regularization method for convolutional networks. In The Conference on Neural Information Processing Systems (NeurIPS), pp. 10727–10737, 2018.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 770–778, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Aaron Klein and Frank Hutter. Tabular benchmarks for joint architecture and hyperparameter optimization. arXiv preprint arXiv:1905.04970, 2019.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In The Conference on Neural Information Processing Systems (NeurIPS), pp. 1097–1105, 2012.
+
+Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. In The Conference on Uncertainty in Artificial Intelligence (UAI), 2019.
+
+Lisha Li, Kevin Jamieson, Giulia DeSalvo, Afshin Rostamizadeh, and Ameet Talwalkar. Hyperband: A novel bandit-based approach to hyperparameter optimization. The Journal of Machine Learning Research (JMLR), 18(1):6765–6816, 2018.
+
+Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proc. of the European Conference on Computer Vision (ECCV), pp. 19–34, 2018.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture search. In International Conference on Learning Representations (ICLR), 2019.
+
+Ilya Loshchilov and Frank Hutter. SGDR: Stochastic gradient descent with warm restarts. In International Conference on Learning Representations (ICLR), 2017.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In The Conference on Neural Information Processing Systems Workshop (NeurIPS-W), 2017.
+
+Hieu Pham, Melody Guan, Barret Zoph, Quoc Le, and Jeff Dean. Efficient neural architecture search via parameters sharing. In The International Conference on Machine Learning (ICML), pp. 4095–4104, 2018.
+
+Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. In AAAI Conference on Artificial Intelligence (AAAI), pp. 4780– 4789, 2019.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. ImageNet large scale visual recognition challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations (ICLR), 2015.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1–9, 2015.
+
+Mingxing Tan, Bo Chen, Ruoming Pang, Vijay Vasudevan, Mark Sandler, Andrew Howard, and Quoc V Le. Mnasnet: Platform-aware neural architecture search for mobile. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2820–2828, 2019.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In The Conference on Neural Information Processing Systems (NeurIPS), pp. 5998–6008, 2017.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 8(3-4):229–256, 1992.
+
+Chris Ying, Aaron Klein, Esteban Real, Eric Christiansen, Kevin Murphy, and Frank Hutter. Nasbench-101: Towards reproducible neural architecture search. In The International Conference on Machine Learning (ICML), pp. 7105–7114, 2019.
+
+Kaicheng Yu, Christian Sciuto, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. In International Conference on Learning Representations (ICLR), 2020.
+
+Arber Zela, Julien Siems, and Frank Hutter. Nas-bench-1shot1: Benchmarking and dissecting one shot neural architecture search. In International Conference on Learning Representations (ICLR), 2020.
+
+Chris Zhang, Mengye Ren, and Raquel Urtasun. Graph hypernetworks for neural architecture search. In International Conference on Learning Representations (ICLR), 2019.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In International Conference on Learning Representations (ICLR), 2018.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations (ICLR), 2017.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 8697–8710, 2018.
+
+<table><tr><td rowspan="2">EPOCHS</td><td rowspan="2">TOTAL</td><td colspan="2">CIFAR-10</td><td colspan="2">CIFAR-100</td><td colspan="2">ImageNet-16-120</td></tr><tr><td>validation</td><td>test</td><td>validation</td><td>test</td><td>validation</td><td>test</td></tr><tr><td>6</td><td>12 (H)</td><td>0.7767</td><td>0.7627</td><td>0.8086</td><td>0.8095</td><td>0.8052</td><td>0.7941</td></tr><tr><td>12</td><td>12 (H+)</td><td>0.9110</td><td>0.8983</td><td>0.9361</td><td>0.9368</td><td>0.9062</td><td>0.8952</td></tr><tr><td>12</td><td>200 (H+)</td><td>0.7520</td><td>0.7396</td><td>0.8071</td><td>0.8080</td><td>0.8167</td><td>0.8092</td></tr><tr><td>24</td><td>200 (H+)</td><td>0.7705</td><td>0.7594</td><td>0.8280</td><td>0.8290</td><td>0.8286</td><td>0.8217</td></tr><tr><td>100</td><td>200 (H+)</td><td>0.7938</td><td>0.7900</td><td>0.8529</td><td>0.8540</td><td>0.8262</td><td>0.8211</td></tr><tr><td>150</td><td>200 (H+)</td><td>0.8955</td><td>0.8926</td><td>0.9239</td><td>0.9246</td><td>0.8506</td><td>0.8425</td></tr><tr><td>175</td><td>200 (H+)</td><td>0.9834</td><td>0.9782</td><td>0.9743</td><td>0.9744</td><td>0.8539</td><td>0.8423</td></tr><tr><td>200</td><td>200 (Ht+)</td><td>0.9993</td><td>0.9937</td><td>0.9672</td><td>0.9671</td><td>0.8259</td><td>0.8124</td></tr></table>
+
+Table 6: We compare the correlation of different training strategies. The correlation coefficient between the validation accuracy after several training epochs on CIFAR-10 and (1) the validation accuracy of full trained models on the CIFAR-10 training set, (2) the test accuracy on CIFAR-10 trained with the training and validation sets, (3) the validation/test accuracy on CIFAR-100 trained with the CIFAR-100 training set, (4) the validation/test accuracy on ImageNet-16-120 trained with the ImageNet-16-120 training set. We use the validation accuracy after “EPOCHS“ training epochs, where the the cosine annealing converged after “TOTAL” epochs.
+
+# A MORE DETAILS OF NAS-Bench-201
+
+Number of unique architectures. In our NAS-Bench-201, we encode each architecture by a 6- dimensional vector. The $i$ -th value in this vector indicates the operation in the $i \cdot$ -th edge in a cell. Since we have 5 possible operations, there are $5 ^ { 6 } = 1 5 6 2 5$ total unique models in this encoding. If we identify the isomorphic cell caused by the “skip-connect” operation, there are 12751 unique topology structures. If we identify the isomorphic cell caused by both “skip-connect” and “zeroize” operations, there are only 6466 unique topology structures. Note that, due to the numerical error, when given the same inputs, two architectures with the isomorphic cell might have different outputs.
+
+Note that, when we build our NAS-Bench-201, we train and evaluate every architecture without considering isomorphism.
+
+NAS-Bench-201 with bandit-based algorithms. Bandit-based algorithms, such as Hyperband (Li et al., 2018) and BOHB (Falkner et al., 2018), usually train models with a short time budget. In our NAS-Bench-201, on CIFAR-10, we provide two options if you want to obtain the performance of a model trained with a short time budget: (1) Results from $\mathcal { H } ^ { \ddag }$ , where the cosine annealing converged at the 12-th epoch. (2) Results from $\mathcal { H } ^ { \dagger }$ , where the cosine annealing converged at the 200-th epoch. As shown in Table 6, the performance of these converged networks is much more likely to correlate highly with the performance after a larger number of iterations than just taking an earlier point of a single cosine annealing trajectory. Therefore, we choose the first option for all NAS algorithms that do not use parameter sharing.
+
+# B IMPLEMENTATION DETAILS
+
+Based on the publicly available codes, we re-implement 10 NAS algorithms by ourselves to search architectures on our NAS-Bench-201. We provide the implementation details of each searching algorithm below.
+
+We consider the searching time of the first order DARTS as a baseline (about 12000 seconds on CIFAR-10). When evaluating RS, REINFORCE, ENAS, and BOHB, we set the total time budget as 12000 seconds for them. By default, for NAS algorithms with parameter sharing, we follow most hyper-parameters from DARTS and do not learn the scale and shift parameters for BN layers in each searching cell. We setup the searching procedure of RSPS, GDAS, SETN, ENAS five times longer than DARTS, because they optimize $\textcircled { \frac { 1 } { 5 } }$ of parameters but DARTS optimize all parameters per iteration. Most configurations can be found at https://github.com/D-X-Y/ AutoDL-Projects/tree/master/configs/nas-benchmark/algos.
+
+Random search (RS) (Bergstra & Bengio, 2012). We randomly select architectures until the total training time plus the time of one evaluation procedure reaches the total budget. We use the validation accuracy after 12 training epochs $( { \mathcal { H } } ^ { \ddagger } )$ , which can be obtained directly in our NAS-Bench-201 as discussed in Section 2.4. The architecture with the highest validation accuracy is selected as the final searched architecture.
+
+Regularized evolution for image classifier architecture search (REA) (Real et al., 2019). We set the initial population size as 10, the number of cycles as infinity. The sample size is chosen as 10 from [3, 5, 10], according to Figure 9. We finish the algorithm once the simulated training time of the traversed architecture reaches the time budgets (12000 seconds). We use the validation accuracy after 12 training epochs $( { \mathcal { H } } ^ { \ddagger } )$ as the fitness.
+
+![](images/3285b7ca5c40bc09586d55b9900b6fc30ebf214d06a87a399aed6e5bc83d38d6.jpg)  
+Figure 9: The effect of different sample sizes for REA on the CIFAR-10 validation set.
+
+REINFORCE (Williams, 1992). We follow (Ying et al., 2019) to use the REINFORCE algorithm as a baseline RL method. We use an architecture encoding to parameterize each candidate in our search space as (Liu et al., 2019; Dong & Yang, 2019b). We use the validation accuracy after 12 training epochs $\mathcal { H } ^ { \ddag }$ as the reward in REINFORCE. The architecture encoding is optimized via Adam. We evaluate the learning rate from [0.01, 0.02, 0.05, 0.1, 0.2, 0.5] following (Ying et al., 2019). According to Figure 10, the learning date is set as . The momentum for exponential moving average of 0.9. We finish the training once the simulated training time reaches the time budgets (12000 seconds).
+
+The first order and second order DARTS (DARTS-V1 and DARTS-V2) (Liu et al., 2019). We train the shared parameters via Nesterov momentum SGD, using the cross-entropy loss for 50 epochs in total. We set weight decay as 0.0005 and momentum of 0.9. We decay the learning rate from 0.025 to 0.001 via cosine learning rate scheduler and clip the gradient by 5. We train the architecture encoding via Adam with the learning rate of 0.0003 and the weight decay of 0.001. We use the batch size of 64. The random horizontal flipping, random cropping with padding, and normalization are used for data augmentation. We choose these hyper-parameters following (Liu et al., 2019).
+
+![](images/59d4bc392632ea80c7311e57578785579486be405277417101ea456bcbb9031d.jpg)  
+Figure 10: We evaluate the effect of different learning rates for REINFORCE, and report the CIFAR-10 validation accuracy of the searched architecture.
+
+Random search with parameter sharing (RSPS) (Li & Talwalkar, 2019). We train RSPS with the similar hyper-parameters as that of DARTS. Differently, we train the algorithm in 250 epochs in total. During each searching iteration, we randomly sample one architecture in each batch training. Each architecture uses the training mode for BN during training and the evaluation mode during evaluation (Paszke et al., 2017). After training the shared parameters, we evaluate 100 randomly selected architectures with the shared parameters. For each architecture, we randomly choose one mini-batch with 256 validation samples to estimate the validation accuracy instead of using the whole validation set to calculate the precise validation accuracy. The one with the highest estimated validation accuracy will be selected. With the size of this mini-batch increasing, the more precise validation accuracy would be obtained and the better architecture would be selected. However, the searching costs will also be increased. We use the size of 256 to trade-off the accuracy and cost.
+
+Gradient-based search using differentiable architecture sampler (GDAS) (Dong & Yang, 2019b). We use the most hyper-parameters as that of DARTS but train it for 250 epochs in total. The Gumbel-Softmax temperature is linearly decayed from 10 to 0.1.
+
+Self-Evaluated Template Network (SETN) (Dong & Yang, 2019a). We use the most hyperparameters as that of DARTS but train it for 250 epochs in total. After training the shared parameters, we select 100 architectures with the highest probabilities (encoded by the learned architecture encoding). We evaluate these 100 selected architectures with the shared parameters. The evaluation procedure for these 100 architectures are the same as RSPS.
+
+Table 7: The correlation between the probability or the one-shot validation accuracy (OSVA) and the ground truth accuracy on the CIFAR-10 validation set. “BN with Train” indicates that, during evaluation, the mean and variance of BN layers are calculated within each mini-batch. “BN with Eval” indicates that we accumulate mean and variance of BN layers in the training set and use these accumulated mean and variance for evaluation. We report the correlation as the average of 3 runs.   
+
+<table><tr><td rowspan="2">Methods</td><td colspan="3">CIFAR-1OValidation Set</td></tr><tr><td>Probability</td><td>OSVA (BN with Train)</td><td>OSVA (BN with Eval)</td></tr><tr><td>DARTS-V1</td><td>0.0779</td><td>0.0039</td><td>-0.0071</td></tr><tr><td>DARTS-V2</td><td>0.0862</td><td>0.0355</td><td>0.0109</td></tr><tr><td>SETN</td><td>0.0682</td><td>0.9049</td><td>0.0862</td></tr><tr><td>GDAS</td><td>0.2714</td><td>0.8141</td><td>0.2466</td></tr></table>
+
+ENAS (Pham et al., 2018). We use a two layer LSTM as the controller with the hidden size of 32. We use the temperature of 5 and the tanh constant of 2.5 for the sampling logits Following (Pham et al., 2018), we also add the the controller’s sample entropy to the reward, weighted by 0.0001. We optimize the controller with Adam using the constant learning rate of 0.001. We optimize the network weights with SGD following the learning rate scheduler as the original paper and the batch size of 128. We did not impose any penalty to a specific operation.
+
+BOHB (Falkner et al., 2018). We choose to use BOHB as an HPO algorithm on our NAS-Bench201. We follow (Ying et al., 2019) to set up the hyper-parameters for BOHB. We set the number of samples for the acquisition function to 4, the random fraction to $0 \%$ , the minimum-bandwidth to 0.3, the bandwidth factor to 3. We finish the algorithm once the simulated training time reaches the time budgets (12000 seconds).
+
+# C DISCUSSION FOR NAS WITH PARAMETER SHARING
+
+Parameter sharing (Pham et al., 2018) becomes a common technique to improve the efficiency of differentiable neural architecture search methods (Liu et al., 2019; Dong & Yang, 2019b;a). The shared parameters are shared over millions of architecture candidates. It is almost impossible for the shared parameters to be optimal for all candidates. We hope to evaluate the trained shared parameters quantitatively. Specially, we use DARTS, GDAS, and SETN to optimize the shared parameters and the architecture encoding on CIFAR-10. For each architecture candidate, we can calculate its probability of being a good architecture from the architecture encoding following SETN (Dong & Yang, 2019a). In addition, we can also evaluate a candidate using the shared parameters on the validation set to obtain “the one-shot validation accuracy”. It is computationally expensive to evaluate all candidates on the whole validation set. To accelerate this procedure, we evaluate each architecture on a mini-batch with the size of 2048, and use the accuracy on this mini-batch to approximate “the one-shot validation accuracy”. Ideally, the architecture ranking sorted by the probability or the one-shot validation accuracy should be similar to the ground truth ranking. We show the correlation between the proxy metric and the ground truth validation accuracy in Table 7. There are several observations: (1) The correlation between the probability (encoded by the architecture encoding) and the ground truth accuracy is low. It suggests that the argmax-based deriving strategy (Liu et al., 2019) can not secure a good architecture. It remains open on how to derive a good architecture after optimizing the shared parameters. (2) The behavior of BN layers is important to one-shot validation accuracy. The accumulated mean and variance from the training set are harmful to one-shot accuracy. Instead, each architecture candidate should re-calculate the mean and variance of the BN layers. (3) GDAS introduced Gumbel-softmax sampling when optimizing the architecture encoding. This strategy leads to a high correlation for the learned probability than that of DARTS. (4) The uniform sampling strategy for training the shared parameters (Dong & Yang, 2019a) can increase the correlation for one-shot accuracy compared to the strategy of the joint optimizing strategy (Dong & Yang, 2019b; Liu et al., 2019).
+
+# D DETAILED INFORMATION OF NAS-Bench-201
+
+In NAS-Bench-201 (version 1.0), every architecture is trained at least once. To be specific, 6219 architectures are trained once, 1621 architectures are trained twice, 7785 architectures are trained three times with different random seeds. Moreover, we are actively training all architectures with more seeds and will continue updating our NAS-Bench-201.
+
+The latency in our NAS-Bench-201 (version 1.0) is computed by running each model on a single GPU (GeForce GTX 1080 Ti) with a batch size of 256. We report the latency on CIFAR-100 and ImageNet-16-120, and the latency on CIFAR-10 should be similar to CIFAR-10.
+
+The usage of API. We provide convenient APIs to access our NAS-Bench-201, which can be easily installed via “pip install nas-bench-201”. Some examples are shown as follows:
+
+from nas_201_api import NASBench201API as API   
+2 api $=$ API(’NAS-Bench-201-v1_0-e61699.pth’) for i, arch_str in enumerate(api): # show every architecturre print (’{:5d}/{:5d} : {:}’.format(i, len(api), arch_str)) 5 info $=$ api.query_meta_info_by_index(1) # get metrics of the 1-th arch res_dict $=$ info.get_metrics(’cifar10’, ’train’) # a dict saving loss/acc print (’The accuracy is {:.2f}’.format(res_dict[’accuracy’]))   
+8 print (’The loss is {:.2f}’.format(res_dict[’loss’])) 9 cos_dict $=$ info.get_comput_costs(’cifar100’) # a dict saving costs   
+10 print (’The flops is {:.2f} M’.format(cos_dict[’flops’]))   
+11 print (’The #parameters is {:.2f} MB’.format(cos_dict[’params’]))   
+12 print (’The latency is {:.3f} s’.format(cos_dict[’latency’]))   
+13 # query the index of a specific architecture from API   
+14 arch_index $=$ api.query_index_by_arch(’|nor_conv_3x3\~0|+|nor_conv_3x3\~0| avg_pool_3x3\~1|+|skip_connect\~0|nor_conv_3x3\~1|skip_connect\~2|’)   
+15 # get results of each trial for a specific architecture   
+16 results $=$ api.query_by_index(arch_index, ’cifar100’)   
+17 print (’There are {:} trials for this architecture [{:}] on cifar100’. format(len(results), api[arch_index]))
+
+Please see https://github.com/D-X-Y/NAS-Bench-201 for more kinds of usages. The benchmark data file for API can be downloaded online from https://drive.google.com/ file/d/1SKW0Cu0u8-gb18zDpaAGi0f74UdXeGKs/view.

parse/train/HJxyZkBKDr/HJxyZkBKDr_content_list.json

@@ -0,0 +1,1774 @@
+[
+    {
+        "type": "text",
+        "text": "NAS-BENCH-201: EXTENDING THE SCOPE OF REPRODUCIBLE NEURAL ARCHITECTURE SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong†‡ ∗and Yi Yang† †ReLER, CAI, University of Technology Sydney, ‡Baidu Research ",
+        "bbox": [
+            184,
+            167,
+            622,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural architecture search (NAS) has achieved breakthrough success in a great number of applications in the past few years. It could be time to take a step back and analyze the good and bad aspects in the field of NAS. A variety of algorithms search architectures under different search space. These searched architectures are trained using different setups, e.g., hyper-parameters, data augmentation, regularization. This raises a comparability problem when comparing the performance of various NAS algorithms. NAS-Bench-101 has shown success to alleviate this problem. In this work, we propose an extension to NAS-Bench-101: NAS-Bench201 with a different search space, results on multiple datasets, and more diagnostic information. NAS-Bench-201 has a fixed search space and provides a unified benchmark for almost any up-to-date NAS algorithms. The design of our search space is inspired from the one used in the most popular cell-based searching algorithms, where a cell is represented as a directed acyclic graph. Each edge here is associated with an operation selected from a predefined operation set. For it to be applicable for all NAS algorithms, the search space defined in NAS-Bench-201 includes all possible architectures generated by 4 nodes and 5 associated operation options, which results in 15,625 neural cell candidates in total. The training log using the same setup and the performance for each architecture candidate are provided for three datasets. This allows researchers to avoid unnecessary repetitive training for selected architecture and focus solely on the search algorithm itself. The training time saved for every architecture also largely improves the efficiency of most NAS algorithms and brings a more computational cost friendly NAS community for a broader range of researchers. We provide additional diagnostic information such as fine-grained loss and accuracy, which can give inspirations to new designs of NAS algorithms. In further support of the proposed NAS-Bench201, we have analyzed it from many aspects and benchmarked 10 recent NAS algorithms, which verify its applicability. ",
+        "bbox": [
+            232,
+            267,
+            764,
+            640
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            667,
+            334,
+            683
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The deep learning community is undergoing a transition from hand-designed neural architecture (He et al., 2016; Krizhevsky et al., 2012; Szegedy et al., 2015) to automatically designed neural architecture (Zoph & Le, 2017; Pham et al., 2018; Real et al., 2019; Dong & Yang, 2019b; Liu et al., 2019). In its early era, the great success of deep learning was promoted by novel neural architectures, such as ResNet (He et al., 2016), Inception (Szegedy et al., 2015), VGGNet (Simonyan & Zisserman, 2015), and Transformer (Vaswani et al., 2017). However, manually designing one architecture requires human experts to try numerous different operation and connection choices (Zoph & Le, 2017). In contrast to architectures that are manually designed, those automatically found by neural architecture search (NAS) algorithms require much less human interaction and expert effort. These NAS-generated architectures have shown promising results in many domains, such as image recognition (Zoph & Le, 2017; Pham et al., 2018; Real et al., 2019), sequence modeling (Pham et al., 2018; Dong & Yang, 2019b; Liu et al., 2019), etc. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, a variety of NAS algorithms have been increasingly proposed. While these NAS methods are methodically designed and show promising improvements, many setups in their algorithms are different. (1) Different search space is utilized, e.g., different macro skeletons of the whole architecture (Zoph et al., 2018; Tan et al., 2019) and a different operation set for the micro cell within the skeleton (Pham et al., 2018), etc. (2) After a good architecture is selected, various strategies can be employed to train this architecture and report the performance, e.g., different data augmentation (Ghiasi et al., 2018; Zhang et al., 2018), different regularization (Zoph et al., 2018), different scheduler (Loshchilov & Hutter, 2017), and different selections of hyper-parameters (Liu et al., 2018; Dong & Yang, 2019a). (3) The validation set for testing the performance of the selected architecture is not split in the same way (Liu et al., 2019; Pham et al., 2018). These discrepancies raise a comparability problem when comparing the performance of various NAS algorithms, making it difficult to conclude their contributions. ",
+        "bbox": [
+            176,
+            873,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ef948e0a6ab15e4c383b46de048586c46f5264daa6a5c300a880d48b7f656296.jpg",
+        "image_caption": [
+            "Figure 1: Top: the macro skeleton of each architecture candidate. Bottom-left: examples of neural cell with 4 nodes. Each cell is a directed acyclic graph, where each edge is associated with an operation selected from a predefined operation set as shown in the Bottom-right. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            823,
+            257
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            323,
+            825,
+            462
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In response to this problem, NAS-Bench-101 (Ying et al., 2019) and NAS-HPO-Bench (Klein & Hutter, 2019) are proposed. However, some NAS algorithms can not be applied directly on NASBench-101, and NAS-HPO-Bench only has 144 candidate architectures, which maybe insufficient to evaluate NAS algorithms. To extend these two benchmarks and towards better reproducibility of NAS methods1, we propose NAS-Bench-201 with a fixed cell search space, inspired from the search space used in the most popular neural cell-based searching algorithms (Zoph et al., 2018; Liu et al., 2019). As shown in Figure 1, each architecture consists of a predefined skeleton with a stack of the searched cell. In this way, architecture search is transformed into the problem of searching a good cell. Each cell is represented as a densely-connected directed acyclic graph (DAG) as shown in the bottom section of Figure 1. Here the node represents the sum of the feature maps and each edge is associated with an operation transforming the feature maps from the source node to the target node. The size of the search space is related to the number of nodes defined for the DAG and the size of the operation set. In NAS-Bench-201, we choose 4 nodes and 5 representative operation candidates for the operation set, which generates a total search space of 15,625 cells/architectures. Each architecture is trained multiple times on three different datasets. The training log and performance of each architecture are provided for each run. The training accuracy/test accuracy/training loss/test loss after every training epoch for each architecture plus the number of parameters and floating point operations (FLOPs) are accessible. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            718
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Hopefully, NAS-Bench-201 will show its value in the field of NAS research. (1) It provides a unified benchmark for most up-to-date NAS algorithms including all cell-based NAS methods. With NASBench-201, researchers can focus on designing robust searching algorithm while avoiding tedious hyper-parameter tuning of the searched architecture. Thus, NAS-Bench-201 provides a relatively fair benchmark for the comparison of different NAS algorithms. (2) It provides the full training log of each architecture. Unnecessary repetitive training procedure of each selected architecture can be avoided (Liu et al., 2018; Zoph & Le, 2017) so that researchers can target on the essence of NAS, i.e., search algorithm. Another benefit is that the validation time for NAS largely decreases when testing in NAS-Bench-201, which provides a computational power friendly environment for more participations in NAS. (3) It provides results of each architecture on multiple datasets. The model transferability can be thoroughly evaluated for most NAS algorithms. (4) In NAS-Bench-201, we provide systematic analysis of the proposed search space. We also evaluate 10 recent advanced NAS algorithms including reinforcement learning (RL)-based methods, evolutionary strategy (ES)-based methods, differentiable-based methods, etc. We hope our empirical analysis can bring some insights to the future designs of NAS algorithms. ",
+        "bbox": [
+            173,
+            726,
+            825,
+            892
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 NAS-Bench-201 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            165,
+            330,
+            181
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our NAS-Bench-201 is algorithm-agnostic. Put simply, it is applicable to almost any up-to-date NAS algorithms. In this section, we will briefly introduce our NAS-Bench-201. The search space of NASBench-201 is inspired by cell-based NAS algorithms (Section 2.1). NAS-Bench-201 evaluates each architecture on three different datasets (Section 2.2). All implementation details of NAS-Bench-201 are introduced in Section 2.3. NAS-Bench-201 also provides some diagnostic information which can be used for potentially better designs of future NAS algorithms (discussed in Section 2.4). ",
+        "bbox": [
+            174,
+            196,
+            825,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 ARCHITECTURES IN THE SEARCH SPACE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            299,
+            495,
+            313
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Macro Skeleton. Our search space follows the design of its counterpart as used in the recent neural cell-based NAS algorithms (Liu et al., 2019; Zoph et al., 2018; Pham et al., 2018). As shown in the top of Figure 1, the skeleton is initiated with one 3-by-3 convolution with 16 output channels and a batch normalization layer (Ioffe & Szegedy, 2015). The main body of the skeleton includes three stacks of cells, connected by a residual block. Each cell is stacked $N = 5$ times, with the number of output channels as 16, 32 and 64 for the first, second and third stages, respectively. The intermediate residual block is the basic residual block with a stride of 2 (He et al., 2016), which serves to downsample the spatial size and double the channels of an input feature map. The shortcut path in this residual block consists of a 2-by-2 average pooling layer with stride of 2 and a 1-by-1 convolution. The skeleton ends up with a global average pooling layer to flatten the feature map into a feature vector. Classification uses a fully connected layer with a softmax layer to transform the feature vector into the final prediction. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            491
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Searched Cell. Each cell in the search space is represented as a densely connected DAG. The densely connected DAG is obtained by assigning a direction from the $i$ -th node to the $j$ -th node $( i < j )$ for each edge in an undirected complete graph. Each edge in this DAG is associated with an operation transforming the feature map from the source node to the target node. All possible operations are selected from a predefined operation set, as shown in Figure 1(bottom-right). In our NAS-Bench-201, the predefined operation set $\\mathcal { O }$ has $L = 5$ representative operations: (1) zeroize, (2) skip connection, (3) 1-by-1 convolution, (4) 3-by-3 convolution, and (5) 3-by-3 average pooling layer. The convolution in this operation set is an abbreviation of an operation sequence of ReLU, convolution, and batch normalization. The DAG has $V = 4$ nodes, where each node represents the sum of all feature maps transformed through the associated operations of the edges pointing to this node. We choose $V = 4$ to allow the search space to contain basic residual block-like cells, which requires 4 nodes. Densely connected DAG does not restrict the searched topology of the cell to be densely connected, since we include zeroize in the operation set, which is an operation of dropping the associated edge. Besides, since we do not impose the constraint on the maximum number of edges (Ying et al., 2019), our search space is applicable to most NAS algorithms, including all cell-based NAS algorithms. ",
+        "bbox": [
+            173,
+            498,
+            825,
+            719
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            737,
+            287,
+            751
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We train and evaluate each architecture on CIFAR-10, CIFAR-100 (Krizhevsky et al., 2009), and ImageNet-16-120 (Chrabaszcz et al., 2017). We choose these three datasets because CIFAR and ImageNet (Russakovsky et al., 2015) are the most popular image classification datasets. ",
+        "bbox": [
+            176,
+            763,
+            823,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We split each dataset into training, validation and test sets to provide a consistent training and evaluation settings for previous NAS algorithms (Liu et al., 2019). Most NAS methods use the validation set to evaluate architectures after the architecture is optimized on the training set. The validation performance of the architectures serves as supervision signals to update the searching algorithm. The test set is to evaluate the performance of each searching algorithm by comparing the indicators (e.g., accuracy, model size, speed) of their selected architectures. Previous methods use different splitting strategies, which may result in various searching costs and unfair comparisons. We hope to use the proposed splits to unify the training, validation and test sets for a fairer comparison. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10: It is a standard image classification dataset and consists of 60K $3 2 \\times 3 2$ colour images in 10 classes. The original training set contains 50K images, with 5K images per class. The original test set contains 10K images, with 1K images per class. Due to the need of validation set, we split all 50K training images in CIFAR-10 into two groups. Each group contains 25K images with 10 classes. We regard the first group as the new training set and the second group as the validation set. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-100: This dataset is just like CIFAR-10. It has the same images as CIFAR-10 but categorizes each image into 100 fine-grained classes. The original training set on CIFAR-100 has 50K images, and the original test set has 10K images. We randomly split the original test set into two group of equal size — 5K images per group. One group is regarded as the validation set, and another one is regarded as the new test set. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "ImageNet-16-120: We build ImageNet-16-120 from the down-sampled variant of ImageNet (ImageNet $1 6 \\times 1 6$ ). As indicated in Chrabaszcz et al. (2017), down-sampling images in ImageNet can largely reduce the computation costs for optimal hyper-parameters of some classical models while maintaining similar searching results. Chrabaszcz et al. (2017) down-sampled the original ImageNet to $1 6 \\times 1 6$ pixels to form ImageNet $. 6 \\times 1 6$ , from which we select all images with label $\\in [ 1 , 1 2 0 ]$ to construct ImageNet-16-120. In sum, ImageNet-16-120 contains 151.7K training images, 3K validation images, and 3K test images with 120 classes. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By default, in this paper, “the training set”, “the validation set”, “the test set” indicate the new training, validation, and test sets, respectively. ",
+        "bbox": [
+            174,
+            361,
+            821,
+            390
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 ARCHITECTURE PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            436,
+            424
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Training Architectures. In order to unify the performance of every architecture, we give the performance of every architecture in our search space. In our NAS-Bench-201, we follow previous literature to set up the hyper-parameters and training strategies (Zoph et al., 2018; Loshchilov & Hutter, 2017; He et al., 2016). We train each architecture with the same strategy, which is shown in Table 1. For simplification, we denote all hyperparameters for training a model as a set $\\mathcal { H }$ , and we use $\\mathcal { H } ^ { \\dagger }$ to denote the values of hyper-parameter that we use. Specifically, we train each architecture via Nesterov momentum SGD, using the cross-entropy loss for 200 epochs in total. We set the weight decay as 0.0005 and decay the learning rate from 0.1 to 0 with a cosine annealing (Loshchilov & Hutter, 2017). We use the same $\\mathcal { H } ^ { \\dagger }$ on different datasets, except for the data augmentation which is slightly different due to the image resolution. On CIFAR, we use the random flip with probability of 0.5, the random crop $3 2 \\times 3 2$ patch with 4 pixels padding on each border, and the normalization over RGB channels. On ImageNet-16-120, we use a similar strategy but random crop $1 6 \\times 1 6$ patch with 2 pixels padding on each border. Apart from using $\\mathcal { H } ^ { \\dagger }$ for all datasets, we also use a different hyper-parameter set $\\bar { \\mathcal { H } } ^ { \\dagger }$ for CIFAR-10. It is similar to $\\mathcal { H } ^ { \\dagger }$ but its total number of training epochs is 12. In this way, we could provide bandit-based algorithms (Falkner et al., 2018; Li et al., 2018) more options for the usage of short training budget (see more details in appendix). ",
+        "bbox": [
+            173,
+            438,
+            821,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            467,
+            506,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/d5cb1dd96187930495d84dd569d48e4fbafbf5f9433dad5fe206c30ac3138626.jpg",
+        "table_caption": [
+            "Table 1: The training hyper-parameter set $\\mathcal { H } ^ { \\dagger }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>optimizerNesterovmomentumweight decaybatch sizeVrandom flipnormalization</td><td rowspan=1 colspan=1>SGD</td><td rowspan=2 colspan=1>initialLRending LRLR scheduleepochinitial channelNrandom crop</td><td rowspan=2 colspan=1>0.10cosine200165</td></tr><tr><td rowspan=1 colspan=1>√0.90.00052564p=0.5&lt;</td></tr></table>",
+        "bbox": [
+            521,
+            484,
+            821,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            604,
+            825,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Metrics. We train each architecture with different random seeds on different datasets. We evaluate each architecture $A$ after every training epoch. NAS-Bench-201 provides the training, validation, ",
+        "bbox": [
+            174,
+            736,
+            823,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and test loss as well as accuracy. We show the supported metrics on different datasets in Table 2. Users can easily use our API to query the results of each trial of $A$ , which has negligible computational costs. In this way, researchers could significantly speed up their searching algorithm on these datasets and focus solely on the essence of NAS. ",
+        "bbox": [
+            174,
+            763,
+            473,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We list the training/test loss/accuracies over ",
+        "bbox": [
+            176,
+            882,
+            473,
+            896
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e4effadbdc57d72b31200953c519e00bf2e2993789bb5072ee6dfcfc0ef4ab0.jpg",
+        "table_caption": [
+            "Table 2: NAS-Bench-201 provides the following metrics with $\\mathcal { H } ^ { \\dagger }$ . ‘Acc.’ means accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>TrainLoss/Acc.Eval Loss/Acc.</td><td></td></tr><tr><td>CIFAR-10</td><td>train set</td><td>valid set</td></tr><tr><td>CIFAR-10</td><td>train+valid set</td><td>test set</td></tr><tr><td>CIFAR-100</td><td>train set</td><td>valid set</td></tr><tr><td>CIFAR-100</td><td>train set</td><td>test set</td></tr><tr><td>ImageNet-16-120</td><td>train set</td><td>valid set</td></tr><tr><td>ImageNet-16-120</td><td>train set</td><td>test set</td></tr></table>",
+        "bbox": [
+            486,
+            795,
+            820,
+            895
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "different split sets on four datasets in Table 2. On CIFAR-10, we train the model on the training set and evaluate it on the validation set. We also train the model on the training and validation set and evaluate it on the test set. These two paradigm follow the typical experimental setup on CIFAR-10 in previous literature (Liu et al., 2018; Zoph et al., 2018; Liu et al., 2018; Pham et al., 2018). On CIFAR-100 and ImageNet-16-120, we train the model on the training set and evaluate it on both validation and test sets. ",
+        "bbox": [
+            173,
+            896,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/2aa7b5ac984e85f4596de66e0de1885490bd59eb3565bc27056e7c2bd10da459.jpg",
+        "table_caption": [
+            "Table 3: We summarize some characteristics of NAS-Bench-101 and NAS-Bench-201. Our NASBench-201 can directly be applicable to almost any up-to-date NAS algorithms. In contrast, as pointed in (Ying et al., 2019), NAS algorithms based on parameter sharing or network morphisms cannot be directly evaluated on NAS-Bench-101. Besides, NAS-Bench-201 provides train/validation/test performance on three (one for NAS-Bench-101) different datasets so that the generality of NAS algorithms can be evaluated. It also provides some diagnostic information that may provide insights to design better NAS algorithms. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">#archit -ectures</td><td rowspan=\"2\">#data -sets</td><td rowspan=\"2\">10</td><td rowspan=\"2\">search space constraint</td><td colspan=\"4\">Supported NAS algorithms</td><td rowspan=\"2\">Diagnostic information</td></tr><tr><td>RL</td><td>ES</td><td>|Diff.]</td><td>HPO</td></tr><tr><td>NAS-Bench-101</td><td>510M</td><td>1</td><td>3</td><td>constrain #edges1</td><td>partial</td><td>partial</td><td>none</td><td>most</td><td></td></tr><tr><td>NAS-Bench-201</td><td>15.6K</td><td>3</td><td>5</td><td>no constraint</td><td>all</td><td>all</td><td>all</td><td>most</td><td>fine-grained info., param., etc</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            820,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            306,
+            825,
+            362
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 DIAGNOSTIC INFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            378,
+            406,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Validation accuracy is a commonly used supervision signal for NAS. However, considering the expensive computational costs for evaluating the architecture, the signal is too sparse. In our NASBench-201, we also provide some diagnostic information which is some extra statistics obtained during training each architecture. Collecting these statistics almost involves no extra computation cost but may provide insights for better designs and training strategies of different NAS algorithms, such as platform-aware NAS (Tan et al., 2019), accuracy prediction (Baker et al., 2018), mutationbased NAS (Cai et al., 2018; Chen et al., 2016), etc. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Architecture Computational Costs: NAS-Bench-201 provides three computation metrics for each architecture — the number of parameters, FLOPs, and latency. Algorithms that target on searching architectures with computational constraints, such as models on edge devices, can use these metrics directly in their algorithm designs without extra calculations. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fine-grained training and evaluation information. NAS-Bench-201 tracks the changes in loss and accuracy of every architecture after every training epochs. These fine-grained training and evaluation information shows the tendency of the architecture performance and could indicate some attributes of the model, such as the speed of convergence, the stability, the over-fitting or under-fitting levels, etc. These attributes may benefit the designs of NAS algorithms. Besides, some methods learn to predict the final accuracy of an architecture based on the results of few early training epochs (Baker et al., 2018). These algorithm can be trained faster and the performance of the accuracy prediction can be evaluated using the fine-grained evaluation information. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            684
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Parameters of optimized architecture. Our NAS-Bench-201 releases the trained parameters for each architecture. This can provide ground truth label for hypernetwork-based NAS methods (Zhang et al., 2019; Brock et al., 2018), which learn to generate parameters of an architecture. Other methods mutate an architecture to become another one (Real et al., 2019; Cai et al., 2018). With NAS-Bench-201, researchers could directly use the off-the-shelf parameters instead of training from scratch and analyze how to transfer parameters from one architecture to another. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 DIFFERENCE WITH EXISTING NAS BENCHMARKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            795,
+            614,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, NAS-Bench-101 (Ying et al., 2019) is the only existing large-scale architecture dataset. Similar to NAS-Bench-201, NAS-Bench-101 also transforms the problem of architecture search into the problem of searching neural cells, represented as a DAG. Differently, NAS-Bench-101 defines operation candidates on the node, whereas we associate operations on the edge as inspired from (Liu et al., 2019; Dong & Yang, 2019b; Zoph et al., 2018). We summarize characteristics of our NAS-Bench-201 and NAS-Bench-101 in Table 3. The main highlights of our NAS-Bench-201 are as follows. (1) NAS-Bench-201 is algorithm-agnostic while NAS-Bench",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/88962deb55fbfd45703cae2a047041476b98a3f9ea5092d466ba1eb7ef13ff89.jpg",
+        "image_caption": [
+            "Figure 2: Training, validation, test accuracy of each architecture on CIFAR-10, CIFAR-100, and ImageNet-16-120. We also visualize the results of ResNet in the orange star marker. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            98,
+            823,
+            454
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "101 without any modification is only applicable to selected algorithms (Yu et al., 2020; Zela et al., 2020). The original complete search space, based on the nodes in NAS-Bench-101, is extremely huge. So, it is exceedingly difficult to efficiently traverse the training of all architectures. To trade off the computational cost and the size of the search space, they constrain the maximum number of edges in the DAG. However, it is difficult to incorporate this constraint in all NAS algorithms, such as NAS algorithms based on parameter-sharing (Liu et al., 2019; Pham et al., 2018). Therefore, many NAS algorithms cannot be directly evaluated on NAS-Bench-101. Our NAS-Bench-201 solves this problem by sacrificing the number of nodes and including all possible edges so that our search space is algorithm-agnostic. (2) We provide extra diagnostic information, such as architecture computational cost, fine-grained training and evaluation time, etc., which give inspirations to better and efficient designs of NAS algorithms utilizing these diagnostic information. ",
+        "bbox": [
+            173,
+            501,
+            825,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "NAS-HPO-Bench (Klein & Hutter, 2019) evaluated 62208 configurations in the joint NAS and hyper-parameter space for a simple 2-layer feed-forward network. Since NAS-HPO-Bench has only 144 architectures, it could be insufficient to evaluate different NAS algorithms. ",
+        "bbox": [
+            179,
+            660,
+            821,
+            675
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            676,
+            584,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 ANALYSIS OF NAS-Bench-201 ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            738,
+            446,
+            753
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "An overview of architecture performance. The performance of each architecture is shown in Figure 2. We show the test accuracy of every architecture in our search space in the left column of Figure 2. The training, validation and test accuracy with respect to the number of parameters are shown in the rest three columns, respectively. Results show that a different number of parameters will affect the performance of the architectures, which indicates that the choices of operations are essential in NAS. We also observe that the performance of the architecture can vary even when the number of parameters stays the same. This observation indicates the importance of how the operations/cells are connected. We compare the architectures with a classical human-designed architecture (ResNet) in all cases, which is indicated by an orange star mark. ResNet shows competitive performance in three datasets, however, it still has room to improve, i.e., about $2 \\%$ compared to the best architecture in CIFAR-100 and ImageNet-16-120, about $1 \\%$ compared to the best one with the same amount of parameters in CIFAR-100 and ImageNet-16-120. ",
+        "bbox": [
+            176,
+            771,
+            583,
+            905
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/775c3b04e237a87001c8ea71bbec6cd669f6173ca15dea4ff91446a5f23adf33.jpg",
+        "image_caption": [
+            "Figure 3: The ranking of each architecture on three datasets, sorted by the ranking in CIFAR-10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            598,
+            678,
+            823,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            897,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Architecture ranking on three datasets. The ranking of every architecture in our search space is shown in Figure 3, where the architecture ranked in CIFAR-10 $\\mathbf { \\dot { X } } \\mathbf { \\cdot }$ -axis) is ranked as in y-axis in CIFAR-100 and ImageNet-16-120, indicated by green and red markers respectively. The performance of the architectures shows a generally consistent ranking over the three datasets with slightly different variance, which serves to test the generality of the searching algorithm. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            237
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Correlations of validation and test accuracies. We visualize the correlation between the validation and test accuracy within one dataset and across datasets in Figure 4. The correlation within one dataset is high compared to cross-dataset correlation. The correlation dramatically decreases as we ",
+        "bbox": [
+            176,
+            243,
+            820,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "only pick the top performing architectures. When we directly transfer the best architecture in one dataset to another (a vanilla strategy), it can not $100 \\%$ secure a good performance. This phenomena is a call for better transferable NAS algorithms instead of vanilla strategy. ",
+        "bbox": [
+            173,
+            286,
+            419,
+            396
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dynamic ranking of architectures. We show the ranking of the performance of all architectures in different time stamps in Figure 5. The ranking based on the validation set (y axis) gradually converges to the ranking ba ",
+        "bbox": [
+            174,
+            404,
+            419,
+            487
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/298e44fc9560f470cc253b2deef1100f0997c742c59b4514ae7c3b31300e0144.jpg",
+        "image_caption": [
+            "Figure 4: We report the correlation coefficient between the accuracy on 6 sets, i.e., CIFAR-10 validation set (C10- V), CIFAR-10 test set (C10-T), CIFAR-100 validation set (C100-V), CIFAR-100 test set (C100-T), ImageNet-16-120 validation set (I120-V), ImageNet-16-120 test set (I120-T). ed on the final test accuracy (x axis). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            431,
+            289,
+            825,
+            405
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/8b8b883e15a206f2b0604391871a50b6fe31f6240057ee9a0d08f4e4b5052c5f.jpg",
+        "image_caption": [
+            "Figure 5: The ranking of all architectures based on the validation accuracy at different time stamps (y axis) sorted by the final test accuracy (x axis). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            505,
+            823,
+            616
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 BENCHMARK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            676,
+            316,
+            693
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate 10 recent searching methods on our NAS-Bench-201, which can serve as baselines for future NAS algorithms in our dataset. Specifically, we evaluate some typical NAS algorithms: (I) Random Search algorithms, e.g., random search (RS) (Bergstra & Bengio, 2012), random search with parameter sharing (RSPS) (Li & Talwalkar, 2019). (II) ES methods, e.g., REA (Real et al., 2019). (III) RL algorithms, e.g., REINFORCE (Williams, 1992), ENAS (Pham et al., 2018). (IV) Differentiable algorithms. e.g., first order DARTS (DARTS-V1) (Liu et al., 2019), second order DARTS (DARTS-V2), GDAS (Dong & Yang, 2019b), and SETN (Dong & Yang, 2019a). (V) HPO methods, e.g., BOHB (Falkner et al., 2018). We experimented all NAS algorithms on a single GeForce GTX 1080 Ti GPU. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            837
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2189058b86da12e12f1606389e5782b037c5bde85e9f884069858ee376263bfa.jpg",
+        "table_caption": [
+            "Table 4: The utility of our NAS-Bench-201 for different NAS algorithms. We show whether a NAS algorithm can use our NAS-Bench-201 to accelerate the searching and evaluation procedure. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>accelerate</td><td rowspan=1 colspan=1>RS</td><td rowspan=1 colspan=1>RSPS</td><td rowspan=1 colspan=1>DARTS-V1</td><td rowspan=1 colspan=1>DARTS-V2</td><td rowspan=1 colspan=1>GDAS</td><td rowspan=1 colspan=1>SETN</td><td rowspan=1 colspan=1>REA</td><td rowspan=1 colspan=1>REINFORCE</td><td rowspan=1 colspan=1>ENAS</td><td rowspan=1 colspan=1>BOHB</td></tr><tr><td rowspan=1 colspan=1>searchevaluation</td><td rowspan=1 colspan=1>V</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>V</td><td rowspan=1 colspan=1>1√</td><td rowspan=1 colspan=1>V</td><td rowspan=1 colspan=1>√√</td></tr></table>",
+        "bbox": [
+            178,
+            854,
+            816,
+            897
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4e199d377fa9800027f50f8b52d6ce7b494f09d17eb98eb6fdce8eefe615635b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">Search (seconds)</td><td colspan=\"2\">CIFAR-10</td><td colspan=\"2\">CIFAR-100</td><td colspan=\"2\">ImageNet-16-120</td></tr><tr><td>validation</td><td>test</td><td>validation</td><td>test</td><td>validation</td><td>test</td></tr><tr><td>RSPS</td><td>8007.13</td><td>80.42±3.58</td><td>84.07±3.61</td><td>52.12±5.55</td><td>52.31±5.77</td><td>27.22±3.24</td><td>26.28±3.09</td></tr><tr><td>DARTS-V1</td><td>11625.77</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00</td><td>16.32±0.00</td></tr><tr><td>DARTS-V2</td><td>35781.80</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00</td><td>16.32±0.00</td></tr><tr><td>GDAS</td><td>31609.80</td><td>89.89±0.08</td><td>93.61±0.09</td><td>71.34±0.04</td><td>70.70±0.30</td><td>41.59±1.33</td><td>41.71±0.98</td></tr><tr><td>SETN</td><td>34139.53</td><td>84.04±0.28</td><td>87.64±0.00</td><td>58.86±0.06</td><td>59.05±0.24</td><td>33.06±0.02</td><td>32.52±0.21</td></tr><tr><td>ENAS</td><td>14058.80</td><td>37.51±3.19</td><td>53.89±0.58</td><td>13.37±2.35</td><td>13.96±2.33</td><td>15.06±1.95</td><td>14.84±2.10</td></tr><tr><td>RSPSt</td><td>7587.12</td><td>84.16±1.69</td><td>87.66±1.69</td><td>59.00±4.60</td><td>58.33±4.34</td><td>31.56±3.28</td><td>31.14±3.88</td></tr><tr><td>DARTS-V1†</td><td>10889.87</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00</td><td>16.32±0.00</td></tr><tr><td>DARTS-V2t</td><td>29901.67</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00</td><td>16.32±0.00</td></tr><tr><td>GDASt</td><td>28925.91</td><td>90.00±0.21</td><td>93.51±0.13</td><td>71.14±0.27</td><td>70.61±0.26</td><td>41.70±1.26</td><td>41.84±0.90</td></tr><tr><td>SETNt</td><td>31009.81</td><td>82.25±5.17</td><td>86.19±4.63</td><td>56.86±7.59</td><td>56.87±7.77</td><td>32.54±3.63</td><td>31.90±4.07</td></tr><tr><td>ENASt</td><td>13314.51</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00</td><td>16.32±0.00</td></tr><tr><td>REA RS</td><td>0.02</td><td>91.19±0.31</td><td>93.92±0.30</td><td>71.81±1.12</td><td>71.84±0.99</td><td>45.15±0.89</td><td>45.54±1.03</td></tr><tr><td></td><td>0.01</td><td>90.93±0.36</td><td>93.70±0.36</td><td>70.93±1.09</td><td>71.04±1.07</td><td>44.45±1.10</td><td>44.57±1.25</td></tr><tr><td>REINFORCE</td><td>0.12</td><td>91.09±0.37</td><td>93.85±0.37</td><td>71.61±1.12</td><td>71.71±1.09</td><td>45.05±1.02</td><td>45.24±1.18</td></tr><tr><td>BOHB</td><td>3.59</td><td>90.82±0.53</td><td>93.61±0.52</td><td>70.74±1.29</td><td>70.85±1.28</td><td>44.26±1.36</td><td>44.42±1.49</td></tr><tr><td>ResNet</td><td rowspan=\"2\">N/A</td><td>90.83</td><td>93.97</td><td>70.42</td><td>70.86</td><td>44.53</td><td>43.63</td></tr><tr><td>optimal</td><td>91.61</td><td>94.37</td><td>73.49</td><td>73.51</td><td>46.77</td><td>47.31</td></tr></table>",
+        "bbox": [
+            176,
+            93,
+            821,
+            358
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 5: We evaluate $I O$ different searching algorithms in our NAS-Bench-201. The first block shows results of parameter sharing based NAS methods. The second block is similar to the first one, however, BN layers in the searching cells do not keep running estimates but always use batch statistics. The third block shows results of NAS methods without parameter sharing. Each algorithm uses the training and validation set of CIFAR-10 for searching. We show results of their searched architectures for (1) training on the CIFAR-10 train set and evaluating on its validation set; (2) training on the CIFAR-10 train+validation sets and evaluating on its test set; (3) training on the CIFAR-10 or ImageNet-16-120 train set and evaluating on their validation or test sets. “optimal” indicates the highest mean accuracy for each set. We report the mean and std of 500 runs for RS, REA, REINFORCE, and BOHB and of 3 runs for RSPS, DARTS, GDAS, SETN, and ENAS. ",
+        "bbox": [
+            173,
+            367,
+            825,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/46bf8e1d5028fd58ba84d178b04a3d22a07d1e669ace1579b1a8879b51c298f7.jpg",
+        "image_caption": [
+            "Figure 6: We show results of 500 runs for RS, REA, REINFORCE, and BOHB on CIFAR-10. The architecture is searched on CIFAR-10 and we report its validation accuracy (solid line) and test accuracy (dashed line) on three datasets. Each individual run is sorted by the validation accuracy of the searched architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            521,
+            825,
+            661
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We show the benefits for speed using our NAS-Bench-201 for different NAS algorithms in Table 4. For each NAS algorithm, once the searching procedure finished and the final architecture is found, our NAS-Bench-201 can directly return the performance of this architecture. With NAS-Bench-201, NAS algorithms without parameter sharing can significantly reduce the searching time into seconds. Notably, it still requires several GPU hours for NAS algorithms with parameter sharing to complete the searching. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "All algorithms use the training and validation set of CIFAR-10 to search architectures. In Table 5, Figure 6, Figure 7, and Figure 8, we report the performance of the searched architectures plus the optimal architecture on three datasets. We make the following observations: (1) NAS methods without parameter sharing (REA, RS, REINFORCE, and BOHB) outperform others. This be because training a model for a few epochs with the converged LR scheduler $( { \\mathcal { H } } ^ { \\ddagger } )$ can provide a good relative ranking of each architecture. (2) DARTS-V1 and DARTS-V2 quickly converge to find the architecture whose edges are all skip connection. A possible reason is that the original hyper-parameters of DARTS are chosen for their search space instead of ours. (3) The strategy of BN layers can significantly effect the NAS methods with parameter sharing. Using batch statistics are better than keep running estimates of the mean and variance. (4) Using our fine-grained information, REA, REINFORCE and RS can be finished in seconds which could significantly reduce the search costs and let researchers focus solely on the search algorithm itself. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/bfcdbc0617ecf87fe75943c147160d323c1666b859f183fc6073b370e8bc4d90.jpg",
+        "image_caption": [
+            "Figure 7: Results keeping keep running estimates for BN layers in each searching cell. We use parameter sharing based NAS methods to search the architecture on CIFAR-10. After each searching epoch, we derive the architecture and show its validation accuracy (VALID) and test accuracy (TEST) on CIFAR-10. The 0-th epoch indicates the architecture is derived from the randomly initialized architecture encoding. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            825,
+            239
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/5085f515858c5ad523ff941b52ac8d6a01ebfa36bc15acd511fdae755f620adc.jpg",
+        "image_caption": [
+            "Figure 8: Results using batch statistics without keeping keep running estimates for BN layers in each searching cell. We use parameter sharing based NAS methods to search the architecture on CIFAR-10. After each searching epoch, we derive the architecture and show its validation accuracy (VALID) and test accuracy (TEST) on CIFAR-10. The 0-th epoch indicates the architecture is derived from the randomly initialized architecture encoding. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            337,
+            825,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            587,
+            825,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Figure 7 and Figure 8, we show the performance of the architecture derived from each algorithm per searching epoch. DARTS-V1 will gradually over-fit to an architecture with all skip-connection operations. DARTS-V2 can alleviate this problem to some extent but will still over-fit after more epochs. It can further alleviate this problem by using batch statistics for BN layers. We train RSPS, GDAS, SETN, and ENAS five times longer than DARTS (250 epochs vs. 50 epochs). This is because at every iteration, RSPS, GDAS, SETN, and ENAS only optimize 1|O|=5 parameters of the shared parameters, whereas DARTS optimize all shared parameters. The searched architecture performs similar for GDAS after 50 searching epochs. RSPS and SETN show a higher variance of the searched architecture compared to GDAS. ",
+        "bbox": [
+            173,
+            691,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Clarification. We have tried our best to implement each method. However, still, some algorithms might obtain non-optimal results since their hyper-parameters might not fit our NAS-Bench-201. We empirically found that some NAS algorithms are sensitive to some hyper-parameters, whereas we try to compare them in a fair way as we can (Please see more explanation in Appendix). If researchers can provide better results with different hyper-parameters, we are happy to update results according to the new experimental results. We also welcome more NAS algorithms to test on our dataset and would include them accordingly. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            310,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "How to avoid over-fitting on NAS-Bench-201? Our NAS-Bench-201 provides a benchmark for NAS algorithms, aiming to provide a fair and computational cost-friendly environment to the NAS community. The trained architecture and the easy-to-access performance of each architecture might provide some insidious ways for designing algorithms to over-fit the best architecture in our NASBench-201. Thus, we propose some rules which we wish the users will follow to achieve the original intention of NAS-Bench-201, a fair and efficient benchmark. ",
+        "bbox": [
+            174,
+            135,
+            825,
+            218
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "1. No regularization for a specific operation. Since the best architecture is known in our benchmark, specific designs to fit the structural attributes of the best performed architecture are insidious ways to fit our NAS-Bench-201. For example, as mentioned in Section 5, we found that the best architecture with the same amount of parameters for CIFAR10 on NAS-Bench-201 is ResNet. Restrictions on the number of residual connections is a way to over-fit the CIFAR10 benchmark. While this can give a good result on this benchmark, the searching algorithm might not generalize to other benchmarks. ",
+        "bbox": [
+            174,
+            226,
+            825,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "2. Use the provided performance. The training strategy affects the performance of the architecture. We suggest the users stick to the performance provided in our benchmark even if it is feasible to use other $\\mathcal { H }$ to get a better performance. This provides a fair comparison with other algorithms. ",
+        "bbox": [
+            176,
+            316,
+            823,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "3. Report results of multiple searching runs. Since our benchmark can help to largely decrease the computational cost for a number of algorithms. Multiple searching runs give stable results of the searching algorithm with acceptable time cost. ",
+        "bbox": [
+            176,
+            366,
+            821,
+            407
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitation regarding to hyper-parameter optimization (HPO). The performance of an architecture depends on the hyper-parameters $\\mathcal { H }$ for its training and the optimal configuration of $\\mathcal { H }$ may vary for different architectures. In NAS-Bench-201, we use the same configuration for all architectures, which may bring biases to the performance of some architectures. One related solution is HPO, which aims to search the optimal hyper-parameter configuration. However, searching the optimal hyper-parameter configurations and the architecture in one shot is too computationally expensive and still is an open problem. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            512
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Potential designs using diagnostic information in NAS-Bench-201. As pointed in Section 2.4, different kinds of diagnostic information are provided. We hope that more insights about NAS could be found by analyzing these diagnostic information and further motivate potential solutions for NAS. For example, parameter sharing (Pham et al., 2018) is the crucial technique to improve the searching efficiency, but the shared parameter would sacrifice the accuracy of each architecture. Could we find a better way to share parameters of each architecture from the learned 15,625 models’ parameters? ",
+        "bbox": [
+            174,
+            518,
+            825,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Generalization ability of the search space. It is important to test the generalization of observations on this dataset. An idea strategy is to do all benchmark experiments on a much larger search space. Unfortunately, it is prohibitive regarding the expensive computational cost. We bring some results from (Ying et al., 2019) and (Zela et al., 2020) to provide some preliminary evidence of generalization. In Figure 2, we show the rankings of RS, REA, and REINFORCE is ( REA $>$ REINFORCE $> \\mathrm { R } S$ ). This is consistent with results in NAS-Bench-101, which contains more architecture candidates. For NAS methods with parameter sharing, we find that $\\mathrm { G D A S } \\geq \\mathrm { D A R T S } \\geq \\mathrm { E N A S }$ , which is also consistent with results in NAS-Bench-1SHOT1. Therefore, observations from our NAS-Bench201 may generalize to other search spaces. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            734
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION & FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            757,
+            473,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce NAS-Bench-201 that extends the scope of reproducible NAS. In NASBench-201, almost any NAS algorithms can be directly evaluated. We train and evaluate 15,625 architecture on three different datasets, and we provide results regarding different metrics. We comprehensively analyze our dataset and test some recent NAS algorithms on NAS-Bench-201 to serve as baselines for future works. In future, we will (1) consider HPO and NAS together and (2) much larger search space. We welcome researchers to try their NAS algorithms on our NAS-Bench201 and would update the paper to include their results. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            888
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements. We thank the ICLR area chair, ICLR reviewers, and authors of NAS-Bench101 for the constructive suggestions during the rebuttal and revision period. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bowen Baker, Otkrist Gupta, Ramesh Raskar, and Nikhil Naik. Accelerating neural architecture search using performance prediction. In International Conference on Learning Representations Workshop (ICLR-W), 2018. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. The Journal of Machine Learning Research (JMLR), 13(Feb):281–305, 2012. ",
+        "bbox": [
+            169,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. SMASH: one-shot model architecture search through hypernetworks. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            174,
+            218,
+            826,
+            261
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Han Cai, Tianyao Chen, Weinan Zhang, Yong Yu, and Jun Wang. Efficient architecture search by network transformation. In AAAI Conference on Artificial Intelligence (AAAI), pp. 2787–2794, 2018. ",
+        "bbox": [
+            173,
+            271,
+            825,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen, Ian Goodfellow, and Jonathon Shlens. Net2net: Accelerating learning via knowledge transfer. In International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            173,
+            325,
+            823,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Patryk Chrabaszcz, Ilya Loshchilov, and Frank Hutter. A downsampled variant of imagenet as an alternative to the cifar datasets. arXiv preprint arXiv:1707.08819, 2017. ",
+        "bbox": [
+            171,
+            364,
+            823,
+            395
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong and Yi Yang. One-shot neural architecture search via self-evaluated template network. In Proc. of the IEEE International Conference on Computer Vision (ICCV), pp. 3681–3690, 2019a. ",
+        "bbox": [
+            174,
+            404,
+            823,
+            446
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong and Yi Yang. Searching for a robust neural architecture in four gpu hours. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1761–1770, 2019b. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            500
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stefan Falkner, Aaron Klein, and Frank Hutter. BOHB: Robust and efficient hyperparameter optimization at scale. In The International Conference on Machine Learning (ICML), pp. 1436–1445, 2018. ",
+        "bbox": [
+            173,
+            510,
+            825,
+            553
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Golnaz Ghiasi, Tsung-Yi Lin, and Quoc V Le. Dropblock: A regularization method for convolutional networks. In The Conference on Neural Information Processing Systems (NeurIPS), pp. 10727–10737, 2018. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            616,
+            823,
+            660
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            173,
+            670,
+            823,
+            699
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron Klein and Frank Hutter. Tabular benchmarks for joint architecture and hyperparameter optimization. arXiv preprint arXiv:1905.04970, 2019. ",
+        "bbox": [
+            173,
+            709,
+            823,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. ",
+        "bbox": [
+            173,
+            748,
+            823,
+            779
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In The Conference on Neural Information Processing Systems (NeurIPS), pp. 1097–1105, 2012. ",
+        "bbox": [
+            173,
+            787,
+            823,
+            832
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. In The Conference on Uncertainty in Artificial Intelligence (UAI), 2019. ",
+        "bbox": [
+            169,
+            842,
+            825,
+            871
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lisha Li, Kevin Jamieson, Giulia DeSalvo, Afshin Rostamizadeh, and Ameet Talwalkar. Hyperband: A novel bandit-based approach to hyperparameter optimization. The Journal of Machine Learning Research (JMLR), 18(1):6765–6816, 2018. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proc. of the European Conference on Computer Vision (ECCV), pp. 19–34, 2018. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture search. In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. SGDR: Stochastic gradient descent with warm restarts. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            223
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In The Conference on Neural Information Processing Systems Workshop (NeurIPS-W), 2017. ",
+        "bbox": [
+            173,
+            231,
+            826,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hieu Pham, Melody Guan, Barret Zoph, Quoc Le, and Jeff Dean. Efficient neural architecture search via parameters sharing. In The International Conference on Machine Learning (ICML), pp. 4095–4104, 2018. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            340
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. In AAAI Conference on Artificial Intelligence (AAAI), pp. 4780– 4789, 2019. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            392
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. ImageNet large scale visual recognition challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. ",
+        "bbox": [
+            176,
+            401,
+            821,
+            445
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            171,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1–9, 2015. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mingxing Tan, Bo Chen, Ruoming Pang, Vijay Vasudevan, Mark Sandler, Andrew Howard, and Quoc V Le. Mnasnet: Platform-aware neural architecture search for mobile. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2820–2828, 2019. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            602
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In The Conference on Neural Information Processing Systems (NeurIPS), pp. 5998–6008, 2017. ",
+        "bbox": [
+            174,
+            609,
+            826,
+            654
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            691
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chris Ying, Aaron Klein, Esteban Real, Eric Christiansen, Kevin Murphy, and Frank Hutter. Nasbench-101: Towards reproducible neural architecture search. In The International Conference on Machine Learning (ICML), pp. 7105–7114, 2019. ",
+        "bbox": [
+            176,
+            700,
+            825,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaicheng Yu, Christian Sciuto, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. In International Conference on Learning Representations (ICLR), 2020. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            795
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arber Zela, Julien Siems, and Frank Hutter. Nas-bench-1shot1: Benchmarking and dissecting one shot neural architecture search. In International Conference on Learning Representations (ICLR), 2020. ",
+        "bbox": [
+            174,
+            804,
+            823,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chris Zhang, Mengye Ren, and Raquel Urtasun. Graph hypernetworks for neural architecture search. In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            173,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 8697–8710, 2018. ",
+        "bbox": [
+            178,
+            141,
+            823,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/c715beb616c6fd4268086aee819702b5af303beb9a4cb91599cae448a8b15776.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">EPOCHS</td><td rowspan=\"2\">TOTAL</td><td colspan=\"2\">CIFAR-10</td><td colspan=\"2\">CIFAR-100</td><td colspan=\"2\">ImageNet-16-120</td></tr><tr><td>validation</td><td>test</td><td>validation</td><td>test</td><td>validation</td><td>test</td></tr><tr><td>6</td><td>12 (H)</td><td>0.7767</td><td>0.7627</td><td>0.8086</td><td>0.8095</td><td>0.8052</td><td>0.7941</td></tr><tr><td>12</td><td>12 (H+)</td><td>0.9110</td><td>0.8983</td><td>0.9361</td><td>0.9368</td><td>0.9062</td><td>0.8952</td></tr><tr><td>12</td><td>200 (H+)</td><td>0.7520</td><td>0.7396</td><td>0.8071</td><td>0.8080</td><td>0.8167</td><td>0.8092</td></tr><tr><td>24</td><td>200 (H+)</td><td>0.7705</td><td>0.7594</td><td>0.8280</td><td>0.8290</td><td>0.8286</td><td>0.8217</td></tr><tr><td>100</td><td>200 (H+)</td><td>0.7938</td><td>0.7900</td><td>0.8529</td><td>0.8540</td><td>0.8262</td><td>0.8211</td></tr><tr><td>150</td><td>200 (H+)</td><td>0.8955</td><td>0.8926</td><td>0.9239</td><td>0.9246</td><td>0.8506</td><td>0.8425</td></tr><tr><td>175</td><td>200 (H+)</td><td>0.9834</td><td>0.9782</td><td>0.9743</td><td>0.9744</td><td>0.8539</td><td>0.8423</td></tr><tr><td>200</td><td>200 (Ht+)</td><td>0.9993</td><td>0.9937</td><td>0.9672</td><td>0.9671</td><td>0.8259</td><td>0.8124</td></tr></table>",
+        "bbox": [
+            191,
+            196,
+            807,
+            348
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 6: We compare the correlation of different training strategies. The correlation coefficient between the validation accuracy after several training epochs on CIFAR-10 and (1) the validation accuracy of full trained models on the CIFAR-10 training set, (2) the test accuracy on CIFAR-10 trained with the training and validation sets, (3) the validation/test accuracy on CIFAR-100 trained with the CIFAR-100 training set, (4) the validation/test accuracy on ImageNet-16-120 trained with the ImageNet-16-120 training set. We use the validation accuracy after “EPOCHS“ training epochs, where the the cosine annealing converged after “TOTAL” epochs. ",
+        "bbox": [
+            173,
+            358,
+            825,
+            457
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A MORE DETAILS OF NAS-Bench-201 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            483,
+            498,
+            500
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Number of unique architectures. In our NAS-Bench-201, we encode each architecture by a 6- dimensional vector. The $i$ -th value in this vector indicates the operation in the $i \\cdot$ -th edge in a cell. Since we have 5 possible operations, there are $5 ^ { 6 } = 1 5 6 2 5$ total unique models in this encoding. If we identify the isomorphic cell caused by the “skip-connect” operation, there are 12751 unique topology structures. If we identify the isomorphic cell caused by both “skip-connect” and “zeroize” operations, there are only 6466 unique topology structures. Note that, due to the numerical error, when given the same inputs, two architectures with the isomorphic cell might have different outputs. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            613
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Note that, when we build our NAS-Bench-201, we train and evaluate every architecture without considering isomorphism. ",
+        "bbox": [
+            176,
+            619,
+            820,
+            648
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "NAS-Bench-201 with bandit-based algorithms. Bandit-based algorithms, such as Hyperband (Li et al., 2018) and BOHB (Falkner et al., 2018), usually train models with a short time budget. In our NAS-Bench-201, on CIFAR-10, we provide two options if you want to obtain the performance of a model trained with a short time budget: (1) Results from $\\mathcal { H } ^ { \\ddag }$ , where the cosine annealing converged at the 12-th epoch. (2) Results from $\\mathcal { H } ^ { \\dagger }$ , where the cosine annealing converged at the 200-th epoch. As shown in Table 6, the performance of these converged networks is much more likely to correlate highly with the performance after a larger number of iterations than just taking an earlier point of a single cosine annealing trajectory. Therefore, we choose the first option for all NAS algorithms that do not use parameter sharing. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            781
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            801,
+            439,
+            816
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Based on the publicly available codes, we re-implement 10 NAS algorithms by ourselves to search architectures on our NAS-Bench-201. We provide the implementation details of each searching algorithm below. ",
+        "bbox": [
+            176,
+            833,
+            825,
+            875
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We consider the searching time of the first order DARTS as a baseline (about 12000 seconds on CIFAR-10). When evaluating RS, REINFORCE, ENAS, and BOHB, we set the total time budget as 12000 seconds for them. By default, for NAS algorithms with parameter sharing, we follow most hyper-parameters from DARTS and do not learn the scale and shift parameters for BN layers in each searching cell. We setup the searching procedure of RSPS, GDAS, SETN, ENAS five times longer than DARTS, because they optimize $\\textcircled { \\frac { 1 } { 5 } }$ of parameters but DARTS optimize all parameters per iteration. Most configurations can be found at https://github.com/D-X-Y/ AutoDL-Projects/tree/master/configs/nas-benchmark/algos. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Random search (RS) (Bergstra & Bengio, 2012). We randomly select architectures until the total training time plus the time of one evaluation procedure reaches the total budget. We use the validation accuracy after 12 training epochs $( { \\mathcal { H } } ^ { \\ddagger } )$ , which can be obtained directly in our NAS-Bench-201 as discussed in Section 2.4. The architecture with the highest validation accuracy is selected as the final searched architecture. ",
+        "bbox": [
+            174,
+            180,
+            821,
+            195
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            196,
+            612,
+            263
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Regularized evolution for image classifier architecture search (REA) (Real et al., 2019). We set the initial population size as 10, the number of cycles as infinity. The sample size is chosen as 10 from [3, 5, 10], according to Figure 9. We finish the algorithm once the simulated training time of the traversed architecture reaches the time budgets (12000 seconds). We use the validation accuracy after 12 training epochs $( { \\mathcal { H } } ^ { \\ddagger } )$ as the fitness. ",
+        "bbox": [
+            174,
+            271,
+            614,
+            368
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/3285b7ca5c40bc09586d55b9900b6fc30ebf214d06a87a399aed6e5bc83d38d6.jpg",
+        "image_caption": [
+            "Figure 9: The effect of different sample sizes for REA on the CIFAR-10 validation set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            627,
+            200,
+            821,
+            315
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "REINFORCE (Williams, 1992). We follow (Ying et al., 2019) to use the REINFORCE algorithm as a baseline RL method. We use an architecture encoding to parameterize each candidate in our search space as (Liu et al., 2019; Dong & Yang, 2019b). We use the validation accuracy after 12 training epochs $\\mathcal { H } ^ { \\ddag }$ as the reward in REINFORCE. The architecture encoding is optimized via Adam. We evaluate the learning rate from [0.01, 0.02, 0.05, 0.1, 0.2, 0.5] following (Ying et al., 2019). According to Figure 10, the learning date is set as . The momentum for exponential moving average of 0.9. We finish the training once the simulated training time reaches the time budgets (12000 seconds). ",
+        "bbox": [
+            173,
+            375,
+            823,
+            390
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            388,
+            614,
+            515
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The first order and second order DARTS (DARTS-V1 and DARTS-V2) (Liu et al., 2019). We train the shared parameters via Nesterov momentum SGD, using the cross-entropy loss for 50 epochs in total. We set weight decay as 0.0005 and momentum of 0.9. We decay the learning rate from 0.025 to 0.001 via cosine learning rate scheduler and clip the gradient by 5. We train the architecture encoding via Adam with the learning rate of 0.0003 and the weight decay of 0.001. We use the batch size of 64. The random horizontal flipping, random cropping with padding, and normalization are used for data augmentation. We choose these hyper-parameters following (Liu et al., 2019). ",
+        "bbox": [
+            174,
+            521,
+            612,
+            604
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/59d4bc392632ea80c7311e57578785579486be405277417101ea456bcbb9031d.jpg",
+        "image_caption": [
+            "Figure 10: We evaluate the effect of different learning rates for REINFORCE, and report the CIFAR-10 validation accuracy of the searched architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            627,
+            395,
+            821,
+            511
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            606,
+            820,
+            660
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Random search with parameter sharing (RSPS) (Li & Talwalkar, 2019). We train RSPS with the similar hyper-parameters as that of DARTS. Differently, we train the algorithm in 250 epochs in total. During each searching iteration, we randomly sample one architecture in each batch training. Each architecture uses the training mode for BN during training and the evaluation mode during evaluation (Paszke et al., 2017). After training the shared parameters, we evaluate 100 randomly selected architectures with the shared parameters. For each architecture, we randomly choose one mini-batch with 256 validation samples to estimate the validation accuracy instead of using the whole validation set to calculate the precise validation accuracy. The one with the highest estimated validation accuracy will be selected. With the size of this mini-batch increasing, the more precise validation accuracy would be obtained and the better architecture would be selected. However, the searching costs will also be increased. We use the size of 256 to trade-off the accuracy and cost. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            820
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Gradient-based search using differentiable architecture sampler (GDAS) (Dong & Yang, 2019b). We use the most hyper-parameters as that of DARTS but train it for 250 epochs in total. The Gumbel-Softmax temperature is linearly decayed from 10 to 0.1. ",
+        "bbox": [
+            174,
+            827,
+            818,
+            869
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Self-Evaluated Template Network (SETN) (Dong & Yang, 2019a). We use the most hyperparameters as that of DARTS but train it for 250 epochs in total. After training the shared parameters, we select 100 architectures with the highest probabilities (encoded by the learned architecture encoding). We evaluate these 100 selected architectures with the shared parameters. The evaluation procedure for these 100 architectures are the same as RSPS. ",
+        "bbox": [
+            174,
+            876,
+            825,
+            917
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/54bde9d5cc482527acf876b6d3c335fafafadbd36730a638afd45a0107ed0c34.jpg",
+        "table_caption": [
+            "Table 7: The correlation between the probability or the one-shot validation accuracy (OSVA) and the ground truth accuracy on the CIFAR-10 validation set. “BN with Train” indicates that, during evaluation, the mean and variance of BN layers are calculated within each mini-batch. “BN with Eval” indicates that we accumulate mean and variance of BN layers in the training set and use these accumulated mean and variance for evaluation. We report the correlation as the average of 3 runs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Methods</td><td colspan=\"3\">CIFAR-1OValidation Set</td></tr><tr><td>Probability</td><td>OSVA (BN with Train)</td><td>OSVA (BN with Eval)</td></tr><tr><td>DARTS-V1</td><td>0.0779</td><td>0.0039</td><td>-0.0071</td></tr><tr><td>DARTS-V2</td><td>0.0862</td><td>0.0355</td><td>0.0109</td></tr><tr><td>SETN</td><td>0.0682</td><td>0.9049</td><td>0.0862</td></tr><tr><td>GDAS</td><td>0.2714</td><td>0.8141</td><td>0.2466</td></tr></table>",
+        "bbox": [
+            246,
+            101,
+            751,
+            188
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            306,
+            823,
+            334
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "ENAS (Pham et al., 2018). We use a two layer LSTM as the controller with the hidden size of 32. We use the temperature of 5 and the tanh constant of 2.5 for the sampling logits Following (Pham et al., 2018), we also add the the controller’s sample entropy to the reward, weighted by 0.0001. We optimize the controller with Adam using the constant learning rate of 0.001. We optimize the network weights with SGD following the learning rate scheduler as the original paper and the batch size of 128. We did not impose any penalty to a specific operation. ",
+        "bbox": [
+            174,
+            342,
+            825,
+            425
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "BOHB (Falkner et al., 2018). We choose to use BOHB as an HPO algorithm on our NAS-Bench201. We follow (Ying et al., 2019) to set up the hyper-parameters for BOHB. We set the number of samples for the acquisition function to 4, the random fraction to $0 \\%$ , the minimum-bandwidth to 0.3, the bandwidth factor to 3. We finish the algorithm once the simulated training time reaches the time budgets (12000 seconds). ",
+        "bbox": [
+            173,
+            431,
+            825,
+            502
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C DISCUSSION FOR NAS WITH PARAMETER SHARING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            640,
+            553
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Parameter sharing (Pham et al., 2018) becomes a common technique to improve the efficiency of differentiable neural architecture search methods (Liu et al., 2019; Dong & Yang, 2019b;a). The shared parameters are shared over millions of architecture candidates. It is almost impossible for the shared parameters to be optimal for all candidates. We hope to evaluate the trained shared parameters quantitatively. Specially, we use DARTS, GDAS, and SETN to optimize the shared parameters and the architecture encoding on CIFAR-10. For each architecture candidate, we can calculate its probability of being a good architecture from the architecture encoding following SETN (Dong & Yang, 2019a). In addition, we can also evaluate a candidate using the shared parameters on the validation set to obtain “the one-shot validation accuracy”. It is computationally expensive to evaluate all candidates on the whole validation set. To accelerate this procedure, we evaluate each architecture on a mini-batch with the size of 2048, and use the accuracy on this mini-batch to approximate “the one-shot validation accuracy”. Ideally, the architecture ranking sorted by the probability or the one-shot validation accuracy should be similar to the ground truth ranking. We show the correlation between the proxy metric and the ground truth validation accuracy in Table 7. There are several observations: (1) The correlation between the probability (encoded by the architecture encoding) and the ground truth accuracy is low. It suggests that the argmax-based deriving strategy (Liu et al., 2019) can not secure a good architecture. It remains open on how to derive a good architecture after optimizing the shared parameters. (2) The behavior of BN layers is important to one-shot validation accuracy. The accumulated mean and variance from the training set are harmful to one-shot accuracy. Instead, each architecture candidate should re-calculate the mean and variance of the BN layers. (3) GDAS introduced Gumbel-softmax sampling when optimizing the architecture encoding. This strategy leads to a high correlation for the learned probability than that of DARTS. (4) The uniform sampling strategy for training the shared parameters (Dong & Yang, 2019a) can increase the correlation for one-shot accuracy compared to the strategy of the joint optimizing strategy (Dong & Yang, 2019b; Liu et al., 2019). ",
+        "bbox": [
+            173,
+            577,
+            825,
+            922
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D DETAILED INFORMATION OF NAS-Bench-201 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            576,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In NAS-Bench-201 (version 1.0), every architecture is trained at least once. To be specific, 6219 architectures are trained once, 1621 architectures are trained twice, 7785 architectures are trained three times with different random seeds. Moreover, we are actively training all architectures with more seeds and will continue updating our NAS-Bench-201. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            189
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The latency in our NAS-Bench-201 (version 1.0) is computed by running each model on a single GPU (GeForce GTX 1080 Ti) with a batch size of 256. We report the latency on CIFAR-100 and ImageNet-16-120, and the latency on CIFAR-10 should be similar to CIFAR-10. ",
+        "bbox": [
+            174,
+            195,
+            825,
+            238
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The usage of API. We provide convenient APIs to access our NAS-Bench-201, which can be easily installed via “pip install nas-bench-201”. Some examples are shown as follows: ",
+        "bbox": [
+            173,
+            246,
+            820,
+            273
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "from nas_201_api import NASBench201API as API   \n2 api $=$ API(’NAS-Bench-201-v1_0-e61699.pth’) for i, arch_str in enumerate(api): # show every architecturre print (’{:5d}/{:5d} : {:}’.format(i, len(api), arch_str)) 5 info $=$ api.query_meta_info_by_index(1) # get metrics of the 1-th arch res_dict $=$ info.get_metrics(’cifar10’, ’train’) # a dict saving loss/acc print (’The accuracy is {:.2f}’.format(res_dict[’accuracy’]))   \n8 print (’The loss is {:.2f}’.format(res_dict[’loss’])) 9 cos_dict $=$ info.get_comput_costs(’cifar100’) # a dict saving costs   \n10 print (’The flops is {:.2f} M’.format(cos_dict[’flops’]))   \n11 print (’The #parameters is {:.2f} MB’.format(cos_dict[’params’]))   \n12 print (’The latency is {:.3f} s’.format(cos_dict[’latency’]))   \n13 # query the index of a specific architecture from API   \n14 arch_index $=$ api.query_index_by_arch(’|nor_conv_3x3\\~0|+|nor_conv_3x3\\~0| avg_pool_3x3\\~1|+|skip_connect\\~0|nor_conv_3x3\\~1|skip_connect\\~2|’)   \n15 # get results of each trial for a specific architecture   \n16 results $=$ api.query_by_index(arch_index, ’cifar100’)   \n17 print (’There are {:} trials for this architecture [{:}] on cifar100’. format(len(results), api[arch_index])) ",
+        "bbox": [
+            158,
+            281,
+            816,
+            521
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Please see https://github.com/D-X-Y/NAS-Bench-201 for more kinds of usages. The benchmark data file for API can be downloaded online from https://drive.google.com/ file/d/1SKW0Cu0u8-gb18zDpaAGi0f74UdXeGKs/view. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            577
+        ],
+        "page_idx": 15
+    }
+]

parse/train/MNVjrDpu6Yo/MNVjrDpu6Yo.md

@@ -0,0 +1,285 @@
+# Sparse Training via Boosting Pruning Plasticity with Neuroregeneration
+
+Shiwei Liu1∗, Tianlong Chen2, Xiaohan Chen2, Zahra Atashgahi3, $\mathbf { L u \ Y i n ^ { 1 } }$ , Huanyu $\mathbf { K o u } ^ { 4 }$ , Li Shen5, Mykola Pechenizkiy1,6, Zhangyang Wang2, Decebal Constantin Mocanu1,3 1Eindhoven University of Technology, 2University of Texas at Austin 3University of Twente,4University of Leeds, $^ 5 \mathrm { J D }$ Explore Academy, 6University of Jyväskylä {s.liu3,l.yin,m.pechenizkiy}@tue.nl, {tianlong.chen,xiaohan.chen,atlaswang}@utexas.edu {z.atashgahi,d.c.mocanu}@utwente.nl, {khydouble1,mathshenli}@gmail.com
+
+# Abstract
+
+Works on lottery ticket hypothesis (LTH) and single-shot network pruning (SNIP) have raised a lot of attention currently on post-training pruning (iterative magnitude pruning), and before-training pruning (pruning at initialization). The former method suffers from an extremely large computation cost and the latter usually struggles with insufficient performance. In comparison, during-training pruning, a class of pruning methods that simultaneously enjoys the training/inference efficiency and the comparable performance, temporarily, has been less explored. To better understand during-training pruning, we quantitatively study the effect of pruning throughout training from the perspective of pruning plasticity (the ability of the pruned networks to recover the original performance). Pruning plasticity can help explain several other empirical observations about neural network pruning in literature. We further find that pruning plasticity can be substantially improved by injecting a brain-inspired mechanism called neuroregeneration, i.e., to regenerate the same number of connections as pruned. We design a novel gradual magnitude pruning (GMP) method, named gradual pruning with zerocost neuroregeneration (GraNet), that advances state of the art. Perhaps most impressively, its sparse-to-sparse version for the first time boosts the sparse-tosparse training performance over various dense-to-sparse methods with ResNet50 on ImageNet without extending the training time. We release all codes in https://github.com/Shiweiliuiiiiiii/GraNet.
+
+# 1 Introduction
+
+Neural network pruning is the most common technique to reduce the parameter count, storage requirements, and computational costs of modern neural network architectures. Recently, posttraining pruning [49, 29, 18, 47, 10, 54, 74, 5, 57, 75] and before-training pruning [31, 30, 67, 63, 6, 11] have been two fast-rising fields, boosted by lottery tickets hypothesis (LTH) [10] and singleshot network pruning (SNIP) [31]. The process of post-training pruning typically involves fully pre-training a dense network as well as many cycles of retraining (either fine-tuning [18, 17, 39] or rewinding [12, 54]). As the training costs of the state-of-the-art models, e.g., GPT-3 [4] and FixEfficientNet-L2 [64] have exploded, this process can lead to a large amount of overhead cost.
+
+Recently emerged methods for pruning at initialization significantly reduce the training cost by identifying a trainable sub-network before the main training process. While promising, the existing methods fail to match the performance achieved by the magnitude pruning after training [11].
+
+![](images/af59a1e56490518e8d401f0013dfad93dbe5e7acc35baaaec44d4e8e171492f4.jpg)  
+Figure 1: Schematic view of GraNet. Left: Gradual pruning starts with a sparse subnetwork and gradually prune the subnetwork to the target sparsity during training. Right: We perform zero-cost neuroregeneration after each gradual pruning step. Light blue blocks/lines refer to the “damaged” connections and orange blocks/lines refer to the regenerated new connections.
+
+Compared with the above-mentioned two classes of pruning, during-training pruning is a class of methods that reap the acceleration benefits of sparsity early on the training and meanwhile achieve promising performance by consulting the information obtained during training. There are some works [77, 13, 33] attempting to gradually prune the network to the desired sparsity during training, while they mainly focus on the performance improvement. Up to now, the understanding of duringtraining pruning has been less explored due to its more complicated dynamical process, and the performance gap still exists between pruning during training and full dense training.
+
+To better understand the effect of pruning during the optimization process (not at inference), we study the ability of the pruned models to recover the original performance after a short continued training with the current learning rate, which we call pruning plasticity (see Section 3.1 for a more formal definition). Inspired by the neuroregeneration mechanism in the nervous system where new neurons and connections are synthesized to recover the damage in the nervous system [26, 41, 73], we examine if allowing the pruned network to regenerate new connections can improve pruning plasticity, and hence contribute to pruning during training. We consequently propose a parameter-efficient method to regenerate new connections during the gradual pruning process. Different from the existing works for pruning understanding which mainly focus on dense-to-sparse training [42] (training a dense model and prune it to the target sparsity), we also consider sparse-to-sparse training (training a sparse model yet adaptively re-creating the sparsity pattern) which recently has received an upsurge of interest in machine learning [44, 3, 9, 48, 8, 37, 36].
+
+In short, we have the following main findings during the course of the study:
+
+#1. Both pruning rate and learning rate matter for pruning plasticity. When pruned with low pruning rates (e.g., 0.2), both dense-to-sparse training and sparse-to-sparse training can easily recover from pruning. On the contrary, if too many parameters are removed at one time, almost all models suffer from accuracy drops. This finding makes a connection to the success of the iterative magnitude pruning [10, 54, 5, 6, 65], where usually a pruning process with a small pruning rate (e.g., 0.2) needs to be iteratively repeated for good performance.
+
+Pruning plasticity also gradually decreases as the learning rate drops. When pruning happens during the training phase with large learning rates, models can easily recover from pruning (up to a certain level). However, pruning plasticity drops significantly after the second learning rate decay, leading to a situation where the pruned networks can not recover with continued training. This finding helps to explain several observations (1) for gradual magnitude pruning (GMP), it is always optimal to end pruning before the second learning rate drop [77, 13]; (2) dynamic sparse training (DST) benefits from a monotonically decreasing pruning rate with cosine or linear update schedule [8, 9]; (3) rewinding techniques [12, 54] outperform fine-tuning as rewinding retrains subnetworks with the original learning rate schedule whereas fine-tuning often retrains with the smallest learning rate.
+
+#2. Neuroregeneration improves pruning plasticity. Neuroregeneration [41, 73] refers to the regrowth or repair of nervous tissues, cells, or cell products. Conceptually, it involves synthesizing new neurons, glia, axons, myelin, or synapses, providing extra resources in the long term to replace those damaged by the injury, and achieving a lasting functional recovery. Such mechanism is closely related to the brain plasticity [51], and we borrow this concept to developing a computational regime.
+
+We show that, while regenerating the same number of connections as pruned, the pruning plasticity is observed to improve remarkably, indicating a more neuroplastic model being developed. However, it increases memory and computational overheads and seems to contradict the benefits of pruningduring-training. This however raises the question: can we achieve efficient neuroregeneration during training with no extra costs? We provide an affirmative answer to this question.
+
+#3. Pruning plasticity with neuroregeneration can be leveraged to substantially boost sparse training performance. The above-mentioned findings of pruning plasticity can generalize to the final performance level under a full continued training to the end. Imitating the neuroregeneration behavior [41, 73], we propose a new sparse training method – gradual pruning with zero-cost neuroregeneration (GraNet), which is capable of performing regeneration without increasing the parameter count.
+
+In experiments, GraNet establishes the new state-of-the-art performance bar for dense-to-sparse training and sparse-to-sparse training, respectively. Particularly, the latter for the first time boosts the sparse-to-sparse training performance over various dense-to-sparse methods by a large margin without extending the training time, with ResNet-50 on ImageNet. Besides the consistent performance improvement, we find the subnetworks that GraNet learns are more accurate than the ones learned by the existing gradual pruning method, providing explanations for the success of GraNet.
+
+# 2 Related Work
+
+Post-Training Pruning. Methods that yield a sparse neural network from a pre-trained network by pruning the unimportant weights or neurons, to the best of our knowledge, were proposed in [24] and [50]. After that, various pruning methods have emerged to provide increasingly efficient methods to identify sparse neural networks for inference. The pruning criterion includes weight magnitude [18, 10], gradient [61] Hessian [29, 19, 59], Taylor expansion [47, 46], etc. Low-rank decomposition [7, 23, 17, 71] are also used to induce structured sparsity in terms of channels or filters. Most of the above-mentioned pruning methods require many pruning and re-training cycles to achieve the desired performance.
+
+During-Training Pruning. Instead of inheriting weights from a pre-trained model, some works attempt to discover well-performing sparse neural networks with one single training process.
+
+Gradual Magnitude Pruning (GMP), introduced in [77] and studied further in [13], gradually sparsifies the neural network during the training process until the desired sparsity is reached. Besides, [40] and [68] are prior works that enforce the network to sparse during training via $L _ { 0 }$ and $L _ { 1 }$ regularization, respectively. [60, 34, 55, 70, 28] moved further by introducing trainable sparsity heuristics to learn the sparse masks and weights simultaneously. These methods are all classified as dense-to-sparse training as they start from a dense network.
+
+Dynamic Sparse Training (DST) [44, 3, 48, 8, 9, 36, 35, 25] is another class of methods that prune models during training. The key factor of DST is that it starts from a random initialized sparse network and optimizes the sparse topology as well as the weights simultaneously during training (sparse-to-sparse training). Without an extended training time [37], sparse-to-sparse training usually falls short of dense-to-sparse training in terms of the prediction accuracy. For further details, see the survey of [43, 21].
+
+Before-Training Pruning. Motivated by SNIP [31], many works [67, 63, 6] have emerged recently to explore the possibility of obtaining a trainable sparse neural network before the main training process. [11] demonstrates that the existing methods for pruning at initialization perform equally well when the unpruned weights are randomly shuffled, which reveals that what these methods discover is the layer-wise sparsity ratio, rather than the indispensable weight values and positions. Our analysis shows that both the mask positions and weight values are crucial for GraNet.
+
+# 3 Methodology for Pruning Plasticity
+
+The primary goal of this paper is to study the effect of pruning as well as neuroregeneration on neural networks during the standard training process. Therefore, we do not consider post-training pruning and before-training pruning. Below, we introduce in detail the definition of pruning plasticity and the experimental design that we used to study pruning plasticity.
+
+# 3.1 Metrics
+
+Let us denote $W _ { t } \in \mathbb { R } ^ { d }$ as the weights of the network and $m _ { t } \in \{ 0 , 1 \} ^ { d }$ as the binary mask yielded from the pruning method at epoch $t$ . Thus, the pruned network can be denoted as $W _ { t } \odot m _ { t }$ . Let $T$ be the total number of epochs the model should be trained. Let $\mathbf { C O N T R A I N } ^ { k } ( W _ { t } \odot m _ { t } , a )$ refers to the function that continues to train the pruned model for $k$ epochs with the learning rate schedule $a$ .
+
+Definition of Pruning plasticity. We define pruning plasticity as $t _ { \mathrm { C O N T R A I N } ^ { k } ( W _ { t } \odot m _ { t } , a _ { t } ) } - t _ { \mathrm { P R E } }$ , where $t _ { \mathrm { P R E } }$ is the test accuracy measured before pruning and $t _ { \mathrm { C O N T R A I N } ^ { k } \left( W _ { t } \odot m _ { t } , a _ { t } \right) }$ is the test accuracy measured after $k$ epoch of continued training $\mathbf { C O N T R A I N } ^ { k } ( W _ { t } \odot m _ { t } , a _ { t } )$ . Specifically, to better understand the effect of pruning on the current model status and to avoid the effect of learning rate decay, we fix the learning rate as the one when the model is pruned, i.e, $a _ { t }$ . This setting is also appealing to GMP [77, 13] and DST [44, 9, 48, 37] in which most of the pruned models are continually trained with the current learning rate for some time.
+
+Final performance gap. Nevertheless, we also investigate the effect of pruning on the final performance, that is, continually training the pruned networks to the end with the remaining learning rate schedule CONTRAINT −t(Wt  mt, a[t+1:T ]). In this case, we report tCONTRAINT−t(Wtmt,a[t+1:T]) − $t _ { \mathrm { F I N A L } }$ , where $t _ { \mathrm { F I N A L } }$ is the final test accuracy of the unpruned models.
+
+# 3.2 Architectures and Datasets
+
+We choose two commonly used architectures to study pruning plasticity, VGG-19 [58] with batch normalization on CIFAR-10 [27], and ResNet-20 [20] on CIFAR-10.
+
+We share the summary of the networks, data, and hyperparameters of dense-to-sparse training in Table 1. We use standard implementations and hyperparameters available online, with the exception of the small batch size for the ResNet-50 on ImageNet due to the limited hardware resources $( 2 \times$ Tesla V100). All accuracies are in line with the baselines reported in the references [8, 11, 67, 9, 37].
+
+Table 1: Summary of the architectures and hyperparameters we study in this paper.   
+
+<table><tr><td>Model</td><td>Data</td><td>#Epoch</td><td>Batch Size</td><td>LR</td><td>LR Decay, Epoch</td><td>Weight Decay</td><td>Test Accuracy</td></tr><tr><td>ResNet-20</td><td>CIFAR-10</td><td>160</td><td>128</td><td>0.1(β= 0.9)</td><td>10×,[80,120]</td><td>0.0005</td><td>92.41±0.04</td></tr><tr><td rowspan="2">VGG-19</td><td>CIFAR-10</td><td>160</td><td>128</td><td>0.1(β=0.9)</td><td>10×,[80,120]</td><td>0.0005</td><td>93.85±0.05</td></tr><tr><td>CIFAR-100</td><td>160</td><td>128</td><td>0.1 (β=0.9)</td><td>10×,[80,120]</td><td>0.0005</td><td>73.43±0.08</td></tr><tr><td rowspan="3">ResNet-50</td><td>CIFAR-10</td><td>160</td><td>128</td><td>0.1(β=0.9)</td><td>10×,[80,120]</td><td>0.0005</td><td>94.75±0.01</td></tr><tr><td>CIFAR-100</td><td>160</td><td>128</td><td>0.1 (β=0.9)</td><td>10×,[80,120]</td><td>0.0005</td><td>78.23±0.18</td></tr><tr><td>ImageNet</td><td>100</td><td>64</td><td>0.1(β=0.9)</td><td>10×,[30,60,90]</td><td>0.0004</td><td>76.80±0.09</td></tr></table>
+
+# 3.3 How to Prune, and How to Regenerate
+
+Structured and Unstructured Pruning. We consider unstructured and structured pruning in this paper. Structured pruning prunes weights in groups, or removes the entire neurons, convolutional filters, or channels, enabling acceleration with the off-the-shelf hardware. In particular, we choose the filter pruning method used in Li et al. [32]. Unstructured sparsity is a more promising direction not only due to its outstanding performance at extreme sparsities but the increasing support for sparse operation in the practical hardware [35, 14, 52, 76, 22]. For example, Liu et al. [35] illustrated for the first time the true potential of DST, demonstrating significant training/inference efficiency improvement over the dense training. Different from prior conventions [77, 13, 33, 2] where values of the pruned weights are kept, we set the pruned weights to zero to eliminate the historical information for all implementations in this paper.
+
+Magnitude pruning. We prune the weights with the smallest magnitude, as it has evolved as the standard method when pruning happens during training, e.g., GMP [77, 13] and DST [44, 9, 37]. We are also aware of other pruning criteria including but not limited to Hessian [29, 19, 59], Taylor expansion [47, 46], connection sensitivity [31], Gradient Flow [67], Neural Tangent Kernel [38, 16].
+
+One-shot pruning. To isolate the pruning effect at different training stages and to avoid the interaction between two iterations of pruning, we focus on one-shot pruning. Please note that iterative pruning can also be generalized in our setting, as our experimental design includes neural networks trained at various sparsities and each of them is further pruned with various pruning rates.
+
+Layer-wise pruning and global pruning. We study both the layer-wise magnitude pruning and global magnitude pruning for pruning plasticity. Global magnitude pruning prunes different layers together and leads to non-uniform sparsity distributions; layer-wise pruning operates layer by layer, resulting in uniform distributions.
+
+Gradient-based regeneration. The simplest regeneration scheme is to randomly activate new connections [3, 44]. However, it would take a lot of time for random regeneration to discover the important connections, especially for the very extreme sparsities. Alternatively, gradients, including those for the connections with zero weights, provide good indicators for the connection importance. For this reason, we focus on gradient-based regeneration proposed in Rigged Lottery ( RigL) [9], i.e., regenerating the same number of connections as pruned with the largest gradient magnitude.
+
+# 3.4 Experimental Results
+
+We study pruning plasticity during training with/without regeneration, for both dense training and sparse training. We report the results of ResNet-20 on CIFAR-10 with unstructured global pruning in the main body of the paper. The rest of the experiments are given in Appendix A. Unless otherwise stated, results are qualitatively similar across all networks. Concretely, we first pre-train networks at four sparsity levels, including 0, 0.5, 0.9, and 0.98. The sparse neural networks are trained with uniform distribution (i.e., all layers have the same sparsity). We further choose four pruning rates, e.g., 0.2, 0.5, 0.9, and 0.98, to measure the corresponding pruning plasticity of the pre-trained networks.
+
+Pruning plasticity. We continue to train the pruned model for 30 epochs and report pruning plasticity in Figure 2. Overall, the learning rate schedule, the pruning rate, and the sparsity of the original models all have a big impact on pruning plasticity. Pruning plasticity decreases as the learning rate decays for all models with different sparsity levels. The models trained with a large learning rate 0.1 can easily recover, or exceed the original performance except for the extremely large pruning rate 0.98. However, the models obtained during the later training phases can recover only with the mild pruning rate choices, e.g., 0.2 (orange lines) and 0.5 (green lines).
+
+We next demonstrate the effect of connection regeneration on pruning plasticity in the bottom row of Figure 2. It is clear to see that connection regeneration significantly improves pruning plasticity of all the cases, especially for the models that are over-pruned (purple lines). Still, even with connection regeneration, pruning plasticity suffers from performance degradation when pruning occurs after the learning rate drops.
+
+![](images/c338301a4ebef994b551eeb1f67f260d2b4f5344dde37b82b7c5b30eebc84265.jpg)  
+Figure 2: Unstructured Pruning: Pruning plasticity (see Section 3.1 for definition) under a 30- epoch continued training with and without connection regeneration for ResNet-20 on CIFAR-10. The vertical red lines refer to the points when the learning rate is decayed. “Pre-trained Sparsity” refers to the original sparsity of the pre-trained networks before pruning. The pruning method is the magnitude global pruning.
+
+Final performance gap. Compared with the current model status, people might be more interested in the effect of pruning on the final performance. We further measure the performance gap between the original test accuracy of the unpruned models and the final test accuracy of the pruned model under a full continued training $\mathrm { C O N T R A I N } ^ { T - t } ( W _ { t } \odot m _ { t } , a _ { [ t + 1 : T ] } )$ in Figure 3.
+
+We observe that, in this case, large learning rates do not enjoy large performance improvement, but still, the performance gap increases as the learning rate drops. It is reasonable to conjecture that the accuracy improvement of pruning plasticity with the large learning rate, 0.1, is due to the unconverged performance during the early phase of training. Besides, it is surprising to find that the final performance of extreme sparse networks (e.g., the third column and the fourth column) significantly benefits from mild pruning. Again, the ability of the pruned model to recover from pruning remarkably improves after regenerating the connections back.
+
+![](images/78e7ffb5d0599e001dd0778df1062b6ee6477a20a43770d2c2a2cc2ef03df9be.jpg)  
+Figure 3: Unstructured Pruning: Final performance gap between the unpruned models and the pruned models for ResNet-20 on CIFAR-10. The vertical red lines refer to the points when the learning rate is decayed. “Pre-trained Sparsity” refers to the original sparsity of the pre-trained networks before pruning. The pruning method is the magnitude global pruning.
+
+# 4 Gradual Pruning with Zero-Cost Neuroregeneration
+
+So far, we have known that regenerating the important connections to the pruned models during training substantially improves pruning plasticity as well as the final performance. However, naively regenerating extra connections increases the parameter count and conflicts with the motivation of gradual pruning.
+
+Inspired by the mechanism of neuroregeneration in the nervous system, we propose a novel sparse training method which we call gradual pruning with zero-cost neuroregeneration (GraNet). GraNet consults the information produced throughout training and regenerates important connections during training in a parameter-efficient fashion. See Appendix B.1 for the pseudocode of GraNet. We introduce the main components of GraNet below.
+
+# 4.1 Gradual Pruning
+
+We follow the gradual pruning scheme used in [77] and gradually sparsifies the dense network to the target sparsity level over $n$ pruning iterations. Let us define $s _ { i }$ is the initial sparsity, $s _ { f }$ is the target sparsity, $t _ { 0 }$ is is the starting epoch of gradual pruning, $t _ { f }$ is the end epoch of gradual pruning, and $\Delta t$ is the pruning frequency. The pruning rate of each pruning iteration is:
+
+$$
+s _ { t } = s _ { f } + ( s _ { i } - s _ { f } ) \left( 1 - \frac { t - t _ { 0 } } { n \Delta t } \right) ^ { 3 } , t \in \left\{ t _ { 0 } , t _ { 0 } + \Delta t , . . . , t _ { 0 } + n \Delta t \right\} .
+$$
+
+We choose global pruning for our method as it generally achieves better performance than uniform pruning. We also report the performance of the uniform sparsity as used in [13] in Appendix C.3.
+
+The conventional gradual pruning methods [77, 13] change the mask (not the weight values) to fulfill the pruning operation, so that the pruned connections have the possibility to be reactivated in the later training phases. Despite this, since the weights of the pruned connections are not updated, they have a small chance to receive sufficient updates to exceed the pruning threshold. This hinders the regeneration of the important connections.
+
+# 4.2 Zero-Cost Neuroregeneration
+
+The main difference between GraNet and the conventional GMP methods [77, 13] is the Zero-Cost Neuroregeneration. Imitating the neuroregeneration of the peripheral nervous system [41, 73] where new neurons and connections are synthesized to replace the damaged ones, we first detect and eliminate the “damaged” connections, and then regenerate the same number of new connections. By doing this, we can achieve connection regeneration without increasing the number of connections.
+
+Concretely, we identify the “damaged” connections as the ones with the smallest weight magnitudes. Small magnitude indicates that either the weight’s gradient is small or a large number of oscillations occur to the gradient direction. Therefore, these weights have a small contribution to the training loss and can be removed. Again, we use the gradient as the importance score for regeneration, same as the regrow method as used in RigL [9].
+
+Why we call it “Zero-Cost Neuroregeneration"? In addition to not increasing the connection (parameter) count, the backward pass of our method is sparse most of the time even though our regeneration utilizes the dense gradient to identify the important connections. We perform neuroregeneration immediately after each gradual pruning step, meaning that the regeneration occurs only once every several thousand iterations. The extra overhead to calculate the dense gradient can be amortized compared with the whole training costs. Compared with the methods [33, 69] that require updating all the weights in the backward pass, our method is much more training efficient, as around 2/3 of the training FLOPs is owing to the backward pass [9, 72].
+
+Let us denote $r$ as the ratio of the number of the regenerated connections to the total number of connections; $W$ is the network weight. We first remove $r$ proportion of “damaged” weights with the smallest magnitude by:
+
+$$
+W ^ { \prime } = \mathrm { T o p K } \left( | W | , 1 - r \right) .
+$$
+
+Here $\mathrm { T o p K } ( v , k )$ returns the weight tensor retaining the top $k$ -proportion of elements from $v$ . Immediately after that, we regenerate $r$ proportion of new connections based on the gradient magnitude:
+
+$$
+W = W ^ { \prime } + \mathrm { T o p K } \left( | \mathbf { g } _ { i \notin W ^ { \prime } } | , r \right) ,
+$$
+
+where $\left| { \bf g } _ { i \notin W ^ { \prime } } \right|$ are the gradient magnitude of the zero weights. We perform Zero-Cost Neuroregeneration layer by layer from the beginning of the training to the end.
+
+GraNet can naturally generalize to the dense-to-sparse training scenario and the sparse-to-sparse training scenario by setting the initial sparsity level $s _ { i } = 0$ and $s _ { i } > 0$ in Eq. (1), respectively. For simplicity, we set $s _ { i } = 0 . 5$ , $t _ { 0 } = 0$ , and $t _ { f }$ as the epoch when performing the first learning rate decay for the sparse-to-sparse training. Different from the existing sparse-to-sparse training methods, i.e., SET [44], RigL [9], and ITOP [37], in which the sparsity is fixed throughout training, GraNet starts from a denser yet still sparse model and gradually prunes the sparse model to the desired sparsity. Although starting with more parameters, the global pruning technique of gradual pruning helps GraNet quickly evolve to a better sparsity distribution than RigL with lower feedforward FLOPs and higher test accuracy. What’s more, GraNet sparsifies all layers including the first convolutional layer and the last fully-connected layer.
+
+# 4.3 Experimental Results
+
+We conduct various experiments to evaluate the effectiveness of GraNet. We compare GraNet with various dense-to-sparse methods and sparse-to-sparse methods. The results of Rigged Lottery (RigL) and GMP with CIFAR-10/100 were reproduced by our implementation with PyTorch so that the only difference between GraNet and GMP is the Zero-Cost Neuroregeneration. For each model, we divide the results into three groups from top to bottom: pruning at initialization, dynamic sparse training and dense-to-sparse methods. See Appendix B for more implementation details used in the experiments. GraNet $\mathit { s } _ { i } = 0 . 5$ ) refers to the sparse-to-sparse version and the and GraNet ${ \bf \nabla } _ { s _ { i } } = 0$ ) refers to the dense-to-sparse version.
+
+CIFAR-10/100. The results of CIFAR-10/100 are shared in Table 2. We can observe that performance differences among different methods on CIFAR-10 are generally small, but still, GraNet ${ \bf \Phi } _ { s _ { i } } = 0 $ ) consistently improves the performance over GMP except for the sparsity $9 5 \%$ , and achieves the highest accuracy in 4 out of 6 cases. In terms of the more complex data CIFAR-100, the performance differences between the during-training pruning methods and before-training pruning methods are much larger. GraNet $( s _ { i } = 0$ ) again consistently outperforms GMP with all sparsities, highlighting the benefits of Zero-Cost Neuroregeneration. It is maybe more interesting that GraNet ${ \bf \nabla } _ { s _ { i } } = 0$ ) even outperforms the post-training method, subdifferential inclusion for sparsity (SIS), by a large margin.
+
+In terms of sparse-to-sparse training, our proposed GraNet ( $s _ { i } = 0 . 5$ ) has a dominant performance over other methods. Especially at the very extreme sparsity 0.98, our method outperforms RigL by $1 . 4 0 \%$ and $2 . 2 2 \%$ with VGG-19 on CIFAR-10 and CIFAR-100, respectively.
+
+ImageNet. Due to the small data size, the experiments with CIFAR-10/100 may not be sufficient to draw a solid conclusion. We further evaluate our method with ResNet-50 on ImageNet in Table 3.
+
+Table 2: Test accuracy of pruned VGG-19 and ResNet-50 on CIFAR-10/100. We mark the best sparse-to-sparse training results in blue and the best dense-to-sparse training results in bold. The results reported with (mean $\pm$ std) are run with three different random seeds by us. The rest are obtained from [66] and [67]. Note that the accuracy of RigL is higher than the ones reported in [66], as we choose a large update interval following the In-Time Over-Parameterization strategy [37]. $s _ { i }$ refers to the initial sparsity of GraNet.   
+
+<table><tr><td>Dataset</td><td colspan="3">CIFAR-10</td><td colspan="3">CIFAR-100</td></tr><tr><td>Pruning ratio</td><td>90%</td><td>95%</td><td>98%</td><td>90%</td><td>95%</td><td>98%</td></tr><tr><td>VGG-19 (Dense)</td><td>93.85±0.05</td><td>1</td><td>1</td><td>73.43±0.08</td><td>1</td><td>=</td></tr><tr><td>SNIP [31]</td><td>93.63</td><td>93.43</td><td>92.05</td><td>72.84</td><td>71.83</td><td>58.46</td></tr><tr><td>GraSP[67]</td><td>93.30</td><td>93.04</td><td>92.19</td><td>71.95</td><td>71.23</td><td>68.90</td></tr><tr><td>SynFlow [63]</td><td>93.35</td><td>93.45</td><td>92.24</td><td>71.77</td><td>71.72</td><td>70.94</td></tr><tr><td>Deep-R [3]</td><td>90.81</td><td>89.59</td><td>86.77</td><td>66.83</td><td>63.46</td><td>59.58</td></tr><tr><td>SET[44]</td><td>92.46</td><td>91.73</td><td>89.18</td><td>72.36</td><td>69.81</td><td>65.94</td></tr><tr><td>RigL[9]</td><td>93.38±0.11</td><td>93.06±0.09</td><td>91.98±0.09</td><td>73.13±0.28</td><td>72.14±0.15</td><td>69.82±0.09</td></tr><tr><td>GraNet (si= 0.5) (ours)</td><td>93.73±0.08</td><td>93.66±0.07</td><td>93.38±0.15</td><td>73.30±0.13</td><td>73.18±0.31</td><td>72.04±0.13</td></tr><tr><td>STR [28]</td><td>93.73</td><td>93.27</td><td>92.21</td><td>71.93</td><td>71.14</td><td>69.89</td></tr><tr><td>SIS [66]</td><td>93.99</td><td>93.31</td><td>93.16</td><td>72.06</td><td>71.85</td><td>71.17</td></tr><tr><td>GMP [13]</td><td>93.59±0.10</td><td>93.58±0.07</td><td>93.52±0.03</td><td>73.10±0.12</td><td>72.30±0.15</td><td>72.07±0.37</td></tr><tr><td>GraNet (si= O) (ours)</td><td>93.80±0.10</td><td>93.72±0.11</td><td>93.63±0.08</td><td>73.74±0.30</td><td>73.10±0.04</td><td>72.35±0.26</td></tr><tr><td>ResNet-50 (Dense)</td><td>94.75±0.01</td><td></td><td></td><td>78.23±0.18</td><td></td><td></td></tr><tr><td>SNIP [31]</td><td>92.65</td><td>90.86</td><td>87.21</td><td>73.14</td><td>69.25</td><td>58.43</td></tr><tr><td>GraSP [67]</td><td>92.47</td><td>91.32</td><td>88.77</td><td>73.28</td><td>70.29</td><td>62.12</td></tr><tr><td>SynFlow [63]</td><td>92.49</td><td>91.22</td><td>88.82</td><td>73.37</td><td>70.37</td><td>62.17</td></tr><tr><td>RigL [9]</td><td>94.45±0.43</td><td>93.86±0.25</td><td>93.26±0.22</td><td>76.50±0.33</td><td>76.03±0.34</td><td>75.06±0.27</td></tr><tr><td>GraNet (si= 0.5) (ours)</td><td>94.64±0.27</td><td>94.38±0.28</td><td>94.01±0.23</td><td>77.89±0.33</td><td>77.16±0.52</td><td>77.14±0.45</td></tr><tr><td>STR [28]</td><td>92.59</td><td>91.35</td><td>88.75</td><td>73.45</td><td>70.45</td><td>62.34</td></tr><tr><td>SIS [66]</td><td>92.81</td><td>91.69</td><td>90.11</td><td>73.81</td><td>70.62</td><td>62.75</td></tr><tr><td>GMP[13]</td><td>94.34±0.09</td><td>94.52±0.08</td><td>94.19±0.04</td><td>76.91±0.23</td><td>76.42±0.51</td><td>75.58±0.20</td></tr><tr><td>GraNet (si = O) (ours)</td><td>94.49±0.08</td><td>94.44±0.01</td><td>94.34±0.17</td><td>77.29±0.45</td><td>76.71±0.26</td><td>76.10±0.20</td></tr></table>
+
+Table 3: Test accuracy of pruned ResNet-50 on ImageNet dataset. The best results of DST methods are marked as blue and the best results of pruning during training methods are marked in bold. The training/test FLOPs are normalized with the FLOPs of a dense model. $s _ { i }$ refers to the initial sparsity of GraNet.   
+
+<table><tr><td>Method</td><td>Top-1 Accuracy</td><td>FLOPs (Train)</td><td>FLOPs (Test)</td><td>TOP-1 Accuracy</td><td>FLOPs (Train)</td><td>FLOPs (Test)</td></tr><tr><td>Dense</td><td>76.8±0.09</td><td>1x (3.2e18)</td><td>1x (8.2e9)</td><td>76.8±0.09</td><td>1x (3.2e18)</td><td>1x (8.2e9)</td></tr><tr><td>Pruning ratio</td><td></td><td>80%</td><td></td><td></td><td>90%</td><td></td></tr><tr><td rowspan="3">Static (ERK) Small-Dense</td><td>72.1±0.04</td><td>0.42×</td><td>0.42×</td><td>67.7±0.12</td><td>0.24×</td><td>0.24×</td></tr><tr><td>72.1±0.06</td><td>0.23×</td><td>0.23×</td><td>67.2±0.12</td><td>0.10×</td><td>0.10×</td></tr><tr><td>72.0±0.06</td><td>0.23×</td><td>0.23×</td><td>67.2±0.12</td><td>0.10×</td><td>0.10×</td></tr><tr><td rowspan="5">SET [44] DSR[48] RigL (ERK) [9]</td><td>72.9±0.39</td><td>0.23×</td><td>0.23×</td><td>69.6±0.23</td><td>0.10×</td><td>0.10×</td></tr><tr><td>73.3</td><td>0.40×</td><td>0.40×</td><td>71.6</td><td>0.30×</td><td>0.30×</td></tr><tr><td>75.1±0.05</td><td>0.42×</td><td>0.42×</td><td>73.0±0.04</td><td>0.25×</td><td>0.24×</td></tr><tr><td>75.2±0.11</td><td>0.61×</td><td>0.42×</td><td>72.9±0.06</td><td>0.50×</td><td>0.24×</td></tr><tr><td>76.0</td><td>0.37×</td><td>0.35×</td><td>74.5</td><td>0.25×</td><td>0.20×</td></tr><tr><td>STR [28]</td><td>76.1</td><td>n/a</td><td>0.17×</td><td>74.0</td><td>n/a</td><td>0.08×</td></tr><tr><td>DPF [33]</td><td>75.1</td><td>0.71×</td><td>0.23×</td><td>n/a</td><td>n/a</td><td>n/a</td></tr><tr><td>GMP[13]</td><td>75.6</td><td>0.56×</td><td>0.23×</td><td>73.9</td><td>0.51×</td><td>0.10×</td></tr><tr><td>GraNet (si = 0) (ours)</td><td>75.8</td><td>0.34×</td><td>0.28×</td><td>74.2</td><td>0.23×</td><td>0.16×</td></tr></table>
+
+We only run this experiment once due to the limited resources. We set $t _ { 0 } = 0$ and $t _ { f } = 3 0$ for both GraNet $( s _ { i } = 0$ ) and GraNet ${ \mathit { s } } _ { i } = 0 . 5 { \mathit { \Sigma } }$ ) on ImageNet. Again, GraNet $( s _ { i } = 0$ ) outperforms GMP consistently with only half training FLOPs and achieves the highest accuracy among all the dense-to-sparse methods at sparsity of 0.9. Surprisingly, GraNet ${ \mathit { s } } _ { i } = 0 . 5 { \mathit { \Sigma } }$ ) significantly boosts the sparse-to-sparse training performance, even over the dense-to-sparse training. Concretely, GraNet
+
+$s _ { i } = 0 . 5 )$ ) outperforms RigL by $0 . 9 \%$ and $1 . 5 \%$ at sparsity 0.8 and 0.9, respectively. To the best of our knowledge, this is the first time in the literature that sparse-to-sparse training reaches a test accuracy of $76 \%$ with ResNet-50 on ImageNet at sparsity 0.8, without extension of training time. It is reasonable for GraNet $\mathit { s } _ { i } = 0 . 5$ ) to achieve better accuracy than RigL, since the denser models at the beginning help GraNet explore more the parameter space. According to the In-Time Over-Parameterization hypothesis [37], the performance of sparse training methods is highly correlated with the total number of parameters that the sparse model has visited.
+
+We further report the training/inference FLOPs required by all pruning methods. Compared with other dense-to-sparse methods, the final networks learned by GraNet $( s _ { i } = 0 )$ ) require more FLOPs to test, whereas the overall training FLOPs required by GraNet ${ { s } _ { i } } = 0$ ) are smaller than others. Even though starting from a denser model, GraNet $\mathit { s } _ { i } = 0 . 5$ ) requires less training and inference FLOPs than the state-of-the-art method, i.e., RigL. The sparsity budgets for 0.9 sparse ResNet-50 on ImageNet-1K learned by our methods are reported in Appendix D. We also report how FLOPs of the pruned ResNet-50 evolve during the course of training in Appendix E.
+
+# 4.4 Effect of the Initial Sparsity
+
+As we mentioned earlier, the denser initial network is the key factor in the success of GraNet. We conducted experiments to study the effect of the initial sparsity on GraNet with ResNet-50 on ImageNet. The initial sparsity is chosen from [0.0, 0.5, 0.6, 0.7, 0.8, 0.9] and the final sparsity is fixed as 0.9. The results are shared in Table 4. We can see the training FLOPs of GraNet are quite robust to the initial sparsity. Surprisingly yet reasonably, it seems that the the smaller the initial sparsity is (up to 0.5), the better final sparsity distribution GraNet finds, with higher test accuracy and fewer feedforward FLOPs. The lower feedforward FLOPs of the final network perfectly balance the overhead caused by the denser initial network.
+
+Table 4: Effect of the initial sparsity on GraNet with ResNet-50 on ImageNet. The training/test FLOPs are normalized with the FLOPs of a dense model.   
+
+<table><tr><td>Method</td><td>Si</td><td>Sf</td><td>Top-1 [%] Accuracy</td><td>FLOPs (Train)</td><td>FLOPs (Test)</td></tr><tr><td>GraNet</td><td>0.0</td><td>0.9</td><td>74.2</td><td>0.23×</td><td>0.16×</td></tr><tr><td>GraNet</td><td>0.5</td><td>0.9</td><td>74.5</td><td>0.25×</td><td>0.20×</td></tr><tr><td>GraNet</td><td>0.6</td><td>0.9</td><td>74.4</td><td>0.25×</td><td>0.22×</td></tr><tr><td>GraNet</td><td>0.7</td><td>0.9</td><td>74.2</td><td>0.24×</td><td>0.22×</td></tr><tr><td>GraNet</td><td>0.8</td><td>0.9</td><td>74.1</td><td>0.25×</td><td>0.24×</td></tr><tr><td>RigL</td><td>0.9</td><td>0.9</td><td>73.0</td><td>0.25×</td><td>0.24×</td></tr></table>
+
+# 4.5 Performance of GraNet at Extreme Sparsities
+
+In this section, we share the results of GraNet and RigL at extreme sparsities. The initial sparsity is set as 0.5. When the final sparsity is relatively smaller (e.g., 0.8, 0.9), GraNet requires a lower (or the same) number of training FLOPs than RigL, whereas GraNet requires more training FLOPs than RigL when the final sparsity is extremely high (e.g., 0.95, 0.965). This makes sense since when the sparsity is extremely high, the saved FLOPs count of the distribution discovered by GraNet is too small to amortize the overhead caused by denser initial models. Yet, the increased number of training FLOPs of GraNet leads to substantial accuracy improvement $( > 2 \% )$ over RigL. The efficiency of GraNet ( $s _ { i } = 0 . 5$ ) comes from two important technical differences compared with RigL: (1) better final sparse distribution discovered by global pruning; (2) a shorter period of gradual pruning time (the first 30 epochs for ResNet-50 on ImageNet). Although starting with more parameters, the global pruning enables GraNet to quickly (first 30 epochs) evolve to a better sparsity distribution with lower test FLOPs than ERK. After 30 epochs of gradual pruning, the network continues to be trained with this better distribution for 70 epochs, so that the overhead in the early training phase with larger training FLOPs is amortized by the later and longer training phase with fewer training FLOPs.
+
+Table 5: Comparison between GraNet and RigL at extreme sparsities with ResNet-50 on ImageNet. The training/test FLOPs are normalized with the FLOPs of a dense model.   
+
+<table><tr><td>Method</td><td>Si</td><td>sf</td><td>Top-1[%] Accuracy</td><td>FLOPs (Train)</td><td>FLOPs (Test)</td></tr><tr><td>RigL GraNet</td><td>0.8</td><td>0.8</td><td>75.1</td><td>0.42×</td><td>0.42×</td></tr><tr><td>RigL</td><td>0.5 0.9</td><td>0.8 0.9</td><td>76.0 73.0</td><td>0.37× 0.25×</td><td>0.35× 0.24×</td></tr><tr><td>GraNet</td><td>0.5</td><td>0.9</td><td>74.5</td><td>0.25×</td><td>0.20×</td></tr><tr><td>RigL GraNet</td><td>0.95 0.5</td><td>0.95 0.95</td><td>69.7 72.3</td><td>0.12× 0.17×</td><td>0.12× 0.12×</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>RigL</td><td>0.965</td><td>0.965</td><td>67.2</td><td>0.11×</td><td>0.11×</td></tr><tr><td>GraNet</td><td>0.5</td><td>0.965</td><td>70.5</td><td>0.15×</td><td>0.09×</td></tr></table>
+
+# 4.6 Ablation Study of Random Reinitialization
+
+Next, we ask whether what GraNet learned are the specific sparse connectivity or the sparse connectivity together with the weight values. We randomly reinitialize the pruned network with the same mask and retrain it. The results are given in Figure 4. The performance of the reinitialized networks falls significantly short of the performance achieved by GraNet $( s _ { i } = 0 )$ ), indicating that what was learned by GraNet is the sparse connectivity together with the weight values. Besides, we find that the retraining performance of GraNet is higher than GMP. This further confirms that Zero-Cost Neuroregeneration helps the gradual pruning find more accurate mask positions.
+
+![](images/b4612ffd943999f6ebf8e6d2174a5adff7df303bbba6e527696f4121417ff7ad.jpg)  
+Figure 4: Reinitialization ablation on subnetworks discovered by GMP and GraNet $( s _ { i } = 0$
+
+# 4.7 Comparison between Re-training and Extended Training
+
+In this section, we study if re-training techniques can further improve the performance of the subnetworks discovered by GraNet. The authors of Lottery Ticket Hypothesis (LTH) [10] introduced a retraining technique, even if they did not evaluate it as such, where the subnetworks discovered by iterative magnitude pruning can be re-trained in isolation to full accuracy with the original initializations. Later on, learning rate rewinding (LRR) [54] was proposed further to improve the re-training performance by only rewinding the learning rate. Since GraNet also utilizes magnitude pruning to discover subnetworks, it is natural to test if these re-training techniques can bring benefits to GraNet. As shown in Table 6, both re-training techniques do not bring benefits to GraNet. Instead of re-training the subnetworks, we find that simply extending the training time significantly boosts the performance of GraNet with similar computational costs.
+
+Table 6: Effects of LTH and LRR on the subnetworks learned by GraNet. Methods with $_ 2 \times$ refer to extending the training steps by 2 times. The results are reported with top-1 test accuracy $[ \% ]$ .   
+
+<table><tr><td>Dataset</td><td colspan="3">CIFAR-10</td><td colspan="3">CIFAR-100</td></tr><tr><td>Pruning ratio</td><td>90%</td><td>95%</td><td>98%</td><td>90%</td><td>95%</td><td>98%</td></tr><tr><td>VGG-19 (Dense)</td><td>93.85±0.05</td><td>=</td><td></td><td>73.43±0.08</td><td>=</td><td>1</td></tr><tr><td>GraNet (si = 0)</td><td>93.80±0.10</td><td>93.72±0.11</td><td>93.63±0.08</td><td>73.74±0.30</td><td>73.10±0.04</td><td>72.35±0.26</td></tr><tr><td>+Lottery Ticket Hypothesis</td><td>93.63±0.04</td><td>93.29±0.05</td><td>92.46±0.08</td><td>72.97±0.25</td><td>71.76±0.22</td><td>69.28±0.36</td></tr><tr><td>+ Learning Rate Rewinding</td><td>93.84±0.14</td><td>93.72±0.06</td><td>93.53±0.04</td><td>73.71±0.08</td><td>73.24±0.24</td><td>72.50±0.26</td></tr><tr><td>GraNet2x (si = 0)</td><td>94.17±0.03</td><td>93.98±0.07</td><td>93.94±0.11</td><td>74.80±0.29</td><td>73.65±0.32</td><td>73.63±0.05</td></tr><tr><td>ResNet-50 (Dense)</td><td>94.75±0.01</td><td></td><td></td><td>78.23±0.18</td><td></td><td></td></tr><tr><td>GraNet (si = 0)</td><td>94.49±0.08</td><td>94.44±0.01</td><td>94.34±0.17</td><td>77.29±0.45</td><td>76.71±0.26</td><td>76.10±0.20</td></tr><tr><td>+Lottery Ticket Hypothesis</td><td>93.96±0.10</td><td>93.70±0.15</td><td>92.94±0.14</td><td>75.74±0.19</td><td>74.31±0.10</td><td>71.99±0.08</td></tr><tr><td>+ Learning Rate Rewinding</td><td>94.55±0.13</td><td>94.39±0.13</td><td>94.20±0.25</td><td>77.40±0.14</td><td>76.90±0.19</td><td>75.75±0.25</td></tr><tr><td>GraNet2× (si= 0)</td><td>95.09±0.15</td><td>94.84±0.11</td><td>94.69±0.24</td><td>78.18±0.20</td><td>78.17±0.20</td><td>77.15±0.29</td></tr></table>
+
+# 5 Conclusion, and Reflection of Broader Impacts
+
+In this paper, we re-emphasize the merit of during-training pruning. Compared with the recently proposed works, i.e., LTH and SNIP, during-training pruning is an efficient yet performant class of pruning methods that have received much less attention. We quantitatively study pruning during training from the perspective of pruning plasticity. Inspired by the findings from pruning plasticity and the mechanism of neuroregeneration in the nervous system, we further proposed a novel sparse training method, GraNet, that performs the cost-free connection regeneration during training. GraNet advances the state of the art in both dense-to-sparse training and sparse-to-sparse training.
+
+Our paper re-emphasizes the great potential of during-training pruning in reducing the training/inference resources required by ML models without sacrificing accuracy. It has a significant environmental impact on reducing the energy cost of the ML models and CO2 emissions [1, 53, 15, 56, 62].
+
+# 6 Acknowledgement
+
+This project is partially financed by the Dutch Research Council (NWO). We thank the reviewers for the constructive comments and questions, which improved the quality of our paper.
+
+# References
+
+[1] Z. Atashgahi, G. Sokar, T. van der Lee, E. Mocanu, D. C. Mocanu, R. Veldhuis, and M. Pechenizkiy. Quick and robust feature selection: the strength of energy-efficient sparse training for autoencoders. arXiv:2012.00560, 2020.   
+[2] B. Bartoldson, A. Morcos, A. Barbu, and G. Erlebacher. The generalization-stability tradeoff in neural network pruning. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 20852–20864. Curran Associates, Inc., 2020.   
+[3] G. Bellec, D. Kappel, W. Maass, and R. Legenstein. Deep rewiring: Training very sparse deep networks. In International Conference on Learning Representations, 2018. arXiv:1711.05136 (2017).   
+[4] T. Brown, B. Mann, N. Ryder, M. Subbiah, J. D. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, S. Agarwal, A. Herbert-Voss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. Ziegler, J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner, S. McCandlish, A. Radford, I. Sutskever, and D. Amodei. Language models are few-shot learners. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 1877–1901. Curran Associates, Inc., 2020.   
+[5] T. Chen, J. Frankle, S. Chang, S. Liu, Y. Zhang, M. Carbin, and Z. Wang. The lottery tickets hypothesis for supervised and self-supervised pre-training in computer vision models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 16306–16316, June 2021.   
+[6] P. de Jorge, A. Sanyal, H. Behl, P. Torr, G. Rogez, and P. K. Dokania. Progressive skeletonization: Trimming more fat from a network at initialization. In International Conference on Learning Representations, 2021. arXiv:cs.CV/2006.09081.   
+[7] E. Denton, W. Zaremba, J. Bruna, Y. LeCun, and R. Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. Twenty-eighth Conference on Neural Information Processing Systems. arXiv:1404.0736, 2014.   
+[8] T. Dettmers and L. Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. arXiv preprint arXiv:1907.04840, 2019.   
+[9] U. Evci, T. Gale, J. Menick, P. S. Castro, and E. Elsen. Rigging the lottery: Making all tickets winners. In International Conference on Machine Learning, pages 2943–2952. PMLR, 2020.   
+[10] J. Frankle and M. Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2019. arXiv:1803.03635.   
+[11] J. Frankle, G. K. Dziugaite, D. Roy, and M. Carbin. Pruning neural networks at initialization: Why are we missing the mark? In International Conference on Learning Representations, 2021. arXiv:2009.08576.   
+[12] J. Frankle, G. K. Dziugaite, D. M. Roy, and M. Carbin. The lottery ticket hypothesis at scale. arXiv preprint arXiv:1903.01611, 2019.   
+[13] T. Gale, E. Elsen, and S. Hooker. The state of sparsity in deep neural networks. arXiv preprint arXiv:1902.09574, 2019.   
+[14] T. Gale, M. Zaharia, C. Young, and E. Elsen. Sparse gpu kernels for deep learning. arXiv preprint arXiv:2006.10901, 2020.   
+[15] E. García-Martín, C. F. Rodrigues, G. Riley, and H. Grahn. Estimation of energy consumption in machine learning. Journal of Parallel and Distributed Computing, 134:75–88, 2019.   
+[16] T. Gebhart, U. Saxena, and P. Schrater. A unified paths perspective for pruning at initialization. arXiv preprint arXiv:2101.10552, 2021.   
+[17] J. Guo, Y. Li, W. Lin, Y. Chen, and J. Li. Network decoupling: From regular to depthwise separable convolutions. arXiv preprint arXiv:1808.05517, 2018.   
+[18] S. Han, J. Pool, J. Tran, and W. Dally. Learning both weights and connections for efficient neural network. In Advances in neural information processing systems, pages 1135–1143, 2015.   
+[19] B. Hassibi and D. G. Stork. Second order derivatives for network pruning: Optimal brain surgeon. Morgan Kaufmann, 1993.   
+[20] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770– 778, 2016.   
+[21] T. Hoefler, D. Alistarh, T. Ben-Nun, N. Dryden, and A. Peste. Sparsity in deep learning: Pruning and growth for efficient inference and training in neural networks. Journal of Machine Learning Research, 22(241):1–124, 2021.   
+[22] I. Hubara, B. Chmiel, M. Island, R. Banner, S. Naor, and D. Soudry. Accelerated sparse neural training: A provable and efficient method to find n: M transposable masks. arXiv preprint arXiv:2102.08124, 2021.   
+[23] M. Jaderberg, A. Vedaldi, and A. Zisserman. Speeding up convolutional neural networks with low rank expansions. arXiv preprint arXiv:1405.3866, 2014.   
+[24] S. A. Janowsky. Pruning versus clipping in neural networks. Physical Review A, 39(12):6600, 1989.   
+[25] S. Jayakumar, R. Pascanu, J. Rae, S. Osindero, and E. Elsen. Top-kast: Top-k always sparse training. Advances in Neural Information Processing Systems, 33:20744–20754, 2020.   
+[26] E. R. Kandel, J. H. Schwartz, T. M. Jessell, S. Siegelbaum, A. J. Hudspeth, and S. Mack. Principles of neural science, volume 4. McGraw-hill New York, 2000.   
+[27] A. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images. Master’s thesis, Department of Computer Science, University of Toronto, 2009.   
+[28] A. Kusupati, V. Ramanujan, R. Somani, M. Wortsman, P. Jain, S. Kakade, and A. Farhadi. Soft threshold weight reparameterization for learnable sparsity. In International Conference on Machine Learning, pages 5544–5555. PMLR, 2020.   
+[29] Y. LeCun, J. S. Denker, and S. A. Solla. Optimal brain damage. In Advances in neural information processing systems, pages 598–605, 1990.   
+[30] N. Lee, T. Ajanthan, S. Gould, and P. H. S. Torr. A signal propagation perspective for pruning neural networks at initialization. In International Conference on Learning Representations, 2020. arXiv:1906.06307.   
+[31] N. Lee, T. Ajanthan, and P. H. Torr. Snip: Single-shot network pruning based on connection sensitivity. International Conference on Learning Representations, 2018.   
+[32] H. Li, A. Kadav, I. Durdanovic, H. Samet, and H. P. Graf. Pruning filters for efficient convnets. International Conference on Learning Representations, 2016.   
+[33] T. Lin, S. U. Stich, L. Barba, D. Dmitriev, and M. Jaggi. Dynamic model pruning with feedback. In International Conference on Learning Representations, 2020.   
+[34] J. Liu, Z. Xu, R. Shi, R. C. C. Cheung, and H. K. So. Dynamic sparse training: Find efficient sparse network from scratch with trainable masked layers. In International Conference on Learning Representations, 2020.   
+[35] S. Liu, D. C. Mocanu, A. R. R. Matavalam, Y. Pei, and M. Pechenizkiy. Sparse evolutionary deep learning with over one million artificial neurons on commodity hardware. Neural Computing and Applications, 33(7):2589–2604, 2021.   
+[36] S. Liu, D. C. Mocanu, Y. Pei, and M. Pechenizkiy. Selfish sparse rnn training. In Proceedings of the 39th International Conference on Machine Learning, pages 6893–6904. PMLR, 2021.   
+[37] S. Liu, L. Yin, D. C. Mocanu, and M. Pechenizkiy. Do we actually need dense overparameterization? in-time over-parameterization in sparse training. In Proceedings of the 39th International Conference on Machine Learning, pages 6989–7000. PMLR, 2021.   
+[38] T. Liu and F. Zenke. Finding trainable sparse networks through neural tangent transfer. In International Conference on Machine Learning, pages 6336–6347. PMLR, 2020.   
+[39] Z. Liu, M. Sun, T. Zhou, G. Huang, and T. Darrell. Rethinking the value of network pruning. International Conference on Learning Representations, 2019.   
+[40] C. Louizos, M. Welling, and D. P. Kingma. Learning sparse neural networks through l_0 regularization. International Conference on Learning Representations, 2018.   
+[41] M. Mahar and V. Cavalli. Intrinsic mechanisms of neuronal axon regeneration. Nature Reviews Neuroscience, 19(6):323–337, 2018.   
+[42] D. Mittal, S. Bhardwaj, M. M. Khapra, and B. Ravindran. Recovering from random pruning: On the plasticity of deep convolutional neural networks. In 2018 IEEE Winter Conference on Applications of Computer Vision (WACV), pages 848–857. IEEE, 2018.   
+[43] D. C. Mocanu, E. Mocanu, T. Pinto, S. Curci, P. H. Nguyen, M. Gibescu, D. Ernst, and Z. A. Vale. Sparse training theory for scalable and efficient agents. International Conference on Autonomous Agents and Multiagent Systems (AAMAS). arXiv:2103.01636, 2021.   
+[44] D. C. Mocanu, E. Mocanu, P. Stone, P. H. Nguyen, M. Gibescu, and A. Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature communications, 9(1):2383, 2018.   
+[45] D. Molchanov, A. Ashukha, and D. Vetrov. Variational dropout sparsifies deep neural networks. In International Conference on Machine Learning, pages 2498–2507. PMLR, 2017.   
+[46] P. Molchanov, A. Mallya, S. Tyree, I. Frosio, and J. Kautz. Importance estimation for neural network pruning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11264–11272, 2019.   
+[47] P. Molchanov, S. Tyree, T. Karras, T. Aila, and J. Kautz. Pruning convolutional neural networks for resource efficient inference. International Conference on Learning Representations, 2016.   
+[48] H. Mostafa and X. Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization. International Conference on Machine Learning, 2019.   
+[49] M. C. Mozer and P. Smolensky. Skeletonization: A technique for trimming the fat from a network via relevance assessment. In Advances in neural information processing systems, pages 107–115, 1989.   
+[50] M. C. Mozer and P. Smolensky. Using relevance to reduce network size automatically. Connection Science, 1(1):3–16, 1989.   
+[51] P. G. Nagappan, H. Chen, and D.-Y. Wang. Neuroregeneration and plasticity: a review of the physiological mechanisms for achieving functional recovery postinjury. Military Medical Research, 7(1):1–16, 2020.   
+[52] Nvidia. Nvidia a100 tensor core gpu architecture. https://www.nvidia.com/content/dam/enzz/Solutions/Data-Center/nvidia-ampere-architecture-whitepaper.pdf, 2020.   
+[53] D. Patterson, J. Gonzalez, Q. Le, C. Liang, L.-M. Munguia, D. Rothchild, D. So, M. Texier, and J. Dean. Carbon emissions and large neural network training. arXiv preprint arXiv:2104.10350, 2021.   
+[54] A. Renda, J. Frankle, and M. Carbin. Comparing rewinding and fine-tuning in neural network pruning. In International Conference on Learning Representations, 2020. arXiv:2003.02389.   
+[55] P. Savarese, H. Silva, and M. Maire. Winning the lottery with continuous sparsification. arXiv preprint arXiv:1912.04427, 2019.   
+[56] R. Schwartz, J. Dodge, N. A. Smith, and O. Etzioni. Green ai. arXiv preprint arXiv:1907.10597, 2019.   
+[57] Y. Shen, L. Shen, H.-Z. Huang, X. Wang, and W. Liu. Cpot: Channel pruning via optimal transport. arXiv preprint arXiv:2005.10451, 2020.   
+[58] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. International Conference on Learning Representations, 2014.   
+[59] S. P. Singh and D. Alistarh. Woodfisher: Efficient second-order approximation for neural network compression. Advances in Neural Information Processing Systems, 33, 2020.   
+[60] S. Srinivas, A. Subramanya, and R. Venkatesh Babu. Training sparse neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pages 138–145, 2017.   
+[61] N. Strom. Scalable distributed dnn training using commodity gpu cloud computing. In Sixteenth Annual Conference of the International Speech Communication Association, 2015.   
+[62] E. Strubell, A. Ganesh, and A. McCallum. Energy and policy considerations for deep learning in nlp. arXiv preprint arXiv:1906.02243, 2019.   
+[63] H. Tanaka, D. Kunin, D. L. Yamins, and S. Ganguli. Pruning neural networks without any data by iteratively conserving synaptic flow. Advances in Neural Information Processing Systems. arXiv:2006.05467, 2020.   
+[64] H. Touvron, A. Vedaldi, M. Douze, and H. Jegou. Fixing the train-test resolution discrepancy. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   
+[65] S. Verdenius, M. Stol, and P. Forré. Pruning via iterative ranking of sensitivity statistics. arXiv preprint arXiv:2006.00896, 2020.   
+[66] S. Verma and J.-C. Pesquet. Sparsifying networks via subdifferential inclusion. In M. Meila and T. Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 10542–10552. PMLR, 18–24 Jul 2021.   
+[67] C. Wang, G. Zhang, and R. Grosse. Picking winning tickets before training by preserving gradient flow. In International Conference on Learning Representations, 2020.   
+[68] W. Wen, C. Wu, Y. Wang, Y. Chen, and H. Li. Learning structured sparsity in deep neural networks. In D. Lee, M. Sugiyama, U. Luxburg, I. Guyon, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.   
+[69] M. Wortsman, A. Farhadi, and M. Rastegari. Discovering neural wirings. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   
+[70] X. Xiao, Z. Wang, and S. Rajasekaran. Autoprune: Automatic network pruning by regularizing auxiliary parameters. Advances in neural information processing systems, 32, 2019.   
+[71] Y. Xu, Y. Li, S. Zhang, W. Wen, B. Wang, Y. Qi, Y. Chen, W. Lin, and H. Xiong. Trained rank pruning for efficient deep neural networks. arXiv preprint arXiv:1812.02402, 2018.   
+[72] D. Yang, A. Ghasemazar, X. Ren, M. Golub, G. Lemieux, and M. Lis. Procrustes: a dataflow and accelerator for sparse deep neural network training. In 2020 53rd Annual IEEE/ACM International Symposium on Microarchitecture (MICRO), pages 711–724. IEEE, 2020.   
+[73] G. Yiu and Z. He. Glial inhibition of cns axon regeneration. Nature Reviews Neuroscience, 7(8):617–627, 2006.   
+[74] H. You, C. Li, P. Xu, Y. Fu, Y. Wang, X. Chen, R. G. Baraniuk, Z. Wang, and Y. Lin. Drawing early-bird tickets: Towards more efficient training of deep networks. arXiv preprint arXiv:1909.11957, 2019.   
+[75] G. Yuan, L. Shen, and W.-S. Zheng. A block decomposition algorithm for sparse optimization. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 275–285, 2020.   
+[76] A. Zhou, Y. Ma, J. Zhu, J. Liu, Z. Zhang, K. Yuan, W. Sun, and H. Li. Learning n:m fine-grained structured sparse neural networks from scratch. In International Conference on Learning Representations, 2021.   
+[77] M. H. Zhu and S. Gupta. To prune, or not to prune: Exploring the efficacy of pruning for model compression, 2018.

parse/train/MNVjrDpu6Yo/MNVjrDpu6Yo_content_list.json

@@ -0,0 +1,1218 @@
+[
+    {
+        "type": "text",
+        "text": "Sparse Training via Boosting Pruning Plasticity with Neuroregeneration ",
+        "text_level": 1,
+        "bbox": [
+            214,
+            122,
+            784,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shiwei Liu1∗, Tianlong Chen2, Xiaohan Chen2, Zahra Atashgahi3, $\\mathbf { L u \\ Y i n ^ { 1 } }$ , Huanyu $\\mathbf { K o u } ^ { 4 }$ , Li Shen5, Mykola Pechenizkiy1,6, Zhangyang Wang2, Decebal Constantin Mocanu1,3 1Eindhoven University of Technology, 2University of Texas at Austin 3University of Twente,4University of Leeds, $^ 5 \\mathrm { J D }$ Explore Academy, 6University of Jyväskylä {s.liu3,l.yin,m.pechenizkiy}@tue.nl, {tianlong.chen,xiaohan.chen,atlaswang}@utexas.edu {z.atashgahi,d.c.mocanu}@utwente.nl, {khydouble1,mathshenli}@gmail.com ",
+        "bbox": [
+            179,
+            223,
+            839,
+            311
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            348,
+            535,
+            364
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Works on lottery ticket hypothesis (LTH) and single-shot network pruning (SNIP) have raised a lot of attention currently on post-training pruning (iterative magnitude pruning), and before-training pruning (pruning at initialization). The former method suffers from an extremely large computation cost and the latter usually struggles with insufficient performance. In comparison, during-training pruning, a class of pruning methods that simultaneously enjoys the training/inference efficiency and the comparable performance, temporarily, has been less explored. To better understand during-training pruning, we quantitatively study the effect of pruning throughout training from the perspective of pruning plasticity (the ability of the pruned networks to recover the original performance). Pruning plasticity can help explain several other empirical observations about neural network pruning in literature. We further find that pruning plasticity can be substantially improved by injecting a brain-inspired mechanism called neuroregeneration, i.e., to regenerate the same number of connections as pruned. We design a novel gradual magnitude pruning (GMP) method, named gradual pruning with zerocost neuroregeneration (GraNet), that advances state of the art. Perhaps most impressively, its sparse-to-sparse version for the first time boosts the sparse-tosparse training performance over various dense-to-sparse methods with ResNet50 on ImageNet without extending the training time. We release all codes in https://github.com/Shiweiliuiiiiiii/GraNet. ",
+        "bbox": [
+            233,
+            381,
+            766,
+            656
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            685,
+            310,
+            703
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural network pruning is the most common technique to reduce the parameter count, storage requirements, and computational costs of modern neural network architectures. Recently, posttraining pruning [49, 29, 18, 47, 10, 54, 74, 5, 57, 75] and before-training pruning [31, 30, 67, 63, 6, 11] have been two fast-rising fields, boosted by lottery tickets hypothesis (LTH) [10] and singleshot network pruning (SNIP) [31]. The process of post-training pruning typically involves fully pre-training a dense network as well as many cycles of retraining (either fine-tuning [18, 17, 39] or rewinding [12, 54]). As the training costs of the state-of-the-art models, e.g., GPT-3 [4] and FixEfficientNet-L2 [64] have exploded, this process can lead to a large amount of overhead cost. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            823
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently emerged methods for pruning at initialization significantly reduce the training cost by identifying a trainable sub-network before the main training process. While promising, the existing methods fail to match the performance achieved by the magnitude pruning after training [11]. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/af59a1e56490518e8d401f0013dfad93dbe5e7acc35baaaec44d4e8e171492f4.jpg",
+        "image_caption": [
+            "Figure 1: Schematic view of GraNet. Left: Gradual pruning starts with a sparse subnetwork and gradually prune the subnetwork to the target sparsity during training. Right: We perform zero-cost neuroregeneration after each gradual pruning step. Light blue blocks/lines refer to the “damaged” connections and orange blocks/lines refer to the regenerated new connections. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            88,
+            776,
+            262
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Compared with the above-mentioned two classes of pruning, during-training pruning is a class of methods that reap the acceleration benefits of sparsity early on the training and meanwhile achieve promising performance by consulting the information obtained during training. There are some works [77, 13, 33] attempting to gradually prune the network to the desired sparsity during training, while they mainly focus on the performance improvement. Up to now, the understanding of duringtraining pruning has been less explored due to its more complicated dynamical process, and the performance gap still exists between pruning during training and full dense training. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To better understand the effect of pruning during the optimization process (not at inference), we study the ability of the pruned models to recover the original performance after a short continued training with the current learning rate, which we call pruning plasticity (see Section 3.1 for a more formal definition). Inspired by the neuroregeneration mechanism in the nervous system where new neurons and connections are synthesized to recover the damage in the nervous system [26, 41, 73], we examine if allowing the pruned network to regenerate new connections can improve pruning plasticity, and hence contribute to pruning during training. We consequently propose a parameter-efficient method to regenerate new connections during the gradual pruning process. Different from the existing works for pruning understanding which mainly focus on dense-to-sparse training [42] (training a dense model and prune it to the target sparsity), we also consider sparse-to-sparse training (training a sparse model yet adaptively re-creating the sparsity pattern) which recently has received an upsurge of interest in machine learning [44, 3, 9, 48, 8, 37, 36]. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            622
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In short, we have the following main findings during the course of the study: ",
+        "bbox": [
+            174,
+            628,
+            674,
+            642
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "#1. Both pruning rate and learning rate matter for pruning plasticity. When pruned with low pruning rates (e.g., 0.2), both dense-to-sparse training and sparse-to-sparse training can easily recover from pruning. On the contrary, if too many parameters are removed at one time, almost all models suffer from accuracy drops. This finding makes a connection to the success of the iterative magnitude pruning [10, 54, 5, 6, 65], where usually a pruning process with a small pruning rate (e.g., 0.2) needs to be iteratively repeated for good performance. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Pruning plasticity also gradually decreases as the learning rate drops. When pruning happens during the training phase with large learning rates, models can easily recover from pruning (up to a certain level). However, pruning plasticity drops significantly after the second learning rate decay, leading to a situation where the pruned networks can not recover with continued training. This finding helps to explain several observations (1) for gradual magnitude pruning (GMP), it is always optimal to end pruning before the second learning rate drop [77, 13]; (2) dynamic sparse training (DST) benefits from a monotonically decreasing pruning rate with cosine or linear update schedule [8, 9]; (3) rewinding techniques [12, 54] outperform fine-tuning as rewinding retrains subnetworks with the original learning rate schedule whereas fine-tuning often retrains with the smallest learning rate. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "#2. Neuroregeneration improves pruning plasticity. Neuroregeneration [41, 73] refers to the regrowth or repair of nervous tissues, cells, or cell products. Conceptually, it involves synthesizing new neurons, glia, axons, myelin, or synapses, providing extra resources in the long term to replace those damaged by the injury, and achieving a lasting functional recovery. Such mechanism is closely related to the brain plasticity [51], and we borrow this concept to developing a computational regime. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We show that, while regenerating the same number of connections as pruned, the pruning plasticity is observed to improve remarkably, indicating a more neuroplastic model being developed. However, it increases memory and computational overheads and seems to contradict the benefits of pruningduring-training. This however raises the question: can we achieve efficient neuroregeneration during training with no extra costs? We provide an affirmative answer to this question. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "#3. Pruning plasticity with neuroregeneration can be leveraged to substantially boost sparse training performance. The above-mentioned findings of pruning plasticity can generalize to the final performance level under a full continued training to the end. Imitating the neuroregeneration behavior [41, 73], we propose a new sparse training method – gradual pruning with zero-cost neuroregeneration (GraNet), which is capable of performing regeneration without increasing the parameter count. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            271
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In experiments, GraNet establishes the new state-of-the-art performance bar for dense-to-sparse training and sparse-to-sparse training, respectively. Particularly, the latter for the first time boosts the sparse-to-sparse training performance over various dense-to-sparse methods by a large margin without extending the training time, with ResNet-50 on ImageNet. Besides the consistent performance improvement, we find the subnetworks that GraNet learns are more accurate than the ones learned by the existing gradual pruning method, providing explanations for the success of GraNet. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            376,
+            321,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Post-Training Pruning. Methods that yield a sparse neural network from a pre-trained network by pruning the unimportant weights or neurons, to the best of our knowledge, were proposed in [24] and [50]. After that, various pruning methods have emerged to provide increasingly efficient methods to identify sparse neural networks for inference. The pruning criterion includes weight magnitude [18, 10], gradient [61] Hessian [29, 19, 59], Taylor expansion [47, 46], etc. Low-rank decomposition [7, 23, 17, 71] are also used to induce structured sparsity in terms of channels or filters. Most of the above-mentioned pruning methods require many pruning and re-training cycles to achieve the desired performance. ",
+        "bbox": [
+            174,
+            402,
+            825,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "During-Training Pruning. Instead of inheriting weights from a pre-trained model, some works attempt to discover well-performing sparse neural networks with one single training process. ",
+        "bbox": [
+            174,
+            520,
+            821,
+            547
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Gradual Magnitude Pruning (GMP), introduced in [77] and studied further in [13], gradually sparsifies the neural network during the training process until the desired sparsity is reached. Besides, [40] and [68] are prior works that enforce the network to sparse during training via $L _ { 0 }$ and $L _ { 1 }$ regularization, respectively. [60, 34, 55, 70, 28] moved further by introducing trainable sparsity heuristics to learn the sparse masks and weights simultaneously. These methods are all classified as dense-to-sparse training as they start from a dense network. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dynamic Sparse Training (DST) [44, 3, 48, 8, 9, 36, 35, 25] is another class of methods that prune models during training. The key factor of DST is that it starts from a random initialized sparse network and optimizes the sparse topology as well as the weights simultaneously during training (sparse-to-sparse training). Without an extended training time [37], sparse-to-sparse training usually falls short of dense-to-sparse training in terms of the prediction accuracy. For further details, see the survey of [43, 21]. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            727
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Before-Training Pruning. Motivated by SNIP [31], many works [67, 63, 6] have emerged recently to explore the possibility of obtaining a trainable sparse neural network before the main training process. [11] demonstrates that the existing methods for pruning at initialization perform equally well when the unpruned weights are randomly shuffled, which reveals that what these methods discover is the layer-wise sparsity ratio, rather than the indispensable weight values and positions. Our analysis shows that both the mask positions and weight values are crucial for GraNet. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Methodology for Pruning Plasticity ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            832,
+            500,
+            849
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The primary goal of this paper is to study the effect of pruning as well as neuroregeneration on neural networks during the standard training process. Therefore, we do not consider post-training pruning and before-training pruning. Below, we introduce in detail the definition of pruning plasticity and the experimental design that we used to study pruning plasticity. ",
+        "bbox": [
+            174,
+            859,
+            823,
+            915
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Metrics ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            266,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let us denote $W _ { t } \\in \\mathbb { R } ^ { d }$ as the weights of the network and $m _ { t } \\in \\{ 0 , 1 \\} ^ { d }$ as the binary mask yielded from the pruning method at epoch $t$ . Thus, the pruned network can be denoted as $W _ { t } \\odot m _ { t }$ . Let $T$ be the total number of epochs the model should be trained. Let $\\mathbf { C O N T R A I N } ^ { k } ( W _ { t } \\odot m _ { t } , a )$ refers to the function that continues to train the pruned model for $k$ epochs with the learning rate schedule $a$ . ",
+        "bbox": [
+            174,
+            109,
+            825,
+            165
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition of Pruning plasticity. We define pruning plasticity as $t _ { \\mathrm { C O N T R A I N } ^ { k } ( W _ { t } \\odot m _ { t } , a _ { t } ) } - t _ { \\mathrm { P R E } }$ , where $t _ { \\mathrm { P R E } }$ is the test accuracy measured before pruning and $t _ { \\mathrm { C O N T R A I N } ^ { k } \\left( W _ { t } \\odot m _ { t } , a _ { t } \\right) }$ is the test accuracy measured after $k$ epoch of continued training $\\mathbf { C O N T R A I N } ^ { k } ( W _ { t } \\odot m _ { t } , a _ { t } )$ . Specifically, to better understand the effect of pruning on the current model status and to avoid the effect of learning rate decay, we fix the learning rate as the one when the model is pruned, i.e, $a _ { t }$ . This setting is also appealing to GMP [77, 13] and DST [44, 9, 48, 37] in which most of the pruned models are continually trained with the current learning rate for some time. ",
+        "bbox": [
+            173,
+            171,
+            825,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Final performance gap. Nevertheless, we also investigate the effect of pruning on the final performance, that is, continually training the pruned networks to the end with the remaining learning rate schedule CONTRAINT −t(Wt \f mt, a[t+1:T ]). In this case, we report tCONTRAINT−t(Wt\fmt,a[t+1:T]) − $t _ { \\mathrm { F I N A L } }$ , where $t _ { \\mathrm { F I N A L } }$ is the final test accuracy of the unpruned models. ",
+        "bbox": [
+            174,
+            279,
+            825,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Architectures and Datasets ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            345,
+            400,
+            361
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We choose two commonly used architectures to study pruning plasticity, VGG-19 [58] with batch normalization on CIFAR-10 [27], and ResNet-20 [20] on CIFAR-10. ",
+        "bbox": [
+            171,
+            364,
+            823,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We share the summary of the networks, data, and hyperparameters of dense-to-sparse training in Table 1. We use standard implementations and hyperparameters available online, with the exception of the small batch size for the ResNet-50 on ImageNet due to the limited hardware resources $( 2 \\times$ Tesla V100). All accuracies are in line with the baselines reported in the references [8, 11, 67, 9, 37]. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/f60248aece3e7e739cad8460ad70963720acdb9a0619561d4133fee2fa2b3431.jpg",
+        "table_caption": [
+            "Table 1: Summary of the architectures and hyperparameters we study in this paper. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Data</td><td>#Epoch</td><td>Batch Size</td><td>LR</td><td>LR Decay, Epoch</td><td>Weight Decay</td><td>Test Accuracy</td></tr><tr><td>ResNet-20</td><td>CIFAR-10</td><td>160</td><td>128</td><td>0.1(β= 0.9)</td><td>10×,[80,120]</td><td>0.0005</td><td>92.41±0.04</td></tr><tr><td rowspan=\"2\">VGG-19</td><td>CIFAR-10</td><td>160</td><td>128</td><td>0.1(β=0.9)</td><td>10×,[80,120]</td><td>0.0005</td><td>93.85±0.05</td></tr><tr><td>CIFAR-100</td><td>160</td><td>128</td><td>0.1 (β=0.9)</td><td>10×,[80,120]</td><td>0.0005</td><td>73.43±0.08</td></tr><tr><td rowspan=\"3\">ResNet-50</td><td>CIFAR-10</td><td>160</td><td>128</td><td>0.1(β=0.9)</td><td>10×,[80,120]</td><td>0.0005</td><td>94.75±0.01</td></tr><tr><td>CIFAR-100</td><td>160</td><td>128</td><td>0.1 (β=0.9)</td><td>10×,[80,120]</td><td>0.0005</td><td>78.23±0.18</td></tr><tr><td>ImageNet</td><td>100</td><td>64</td><td>0.1(β=0.9)</td><td>10×,[30,60,90]</td><td>0.0004</td><td>76.80±0.09</td></tr></table>",
+        "bbox": [
+            176,
+            483,
+            825,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 How to Prune, and How to Regenerate ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            594,
+            482,
+            609
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Structured and Unstructured Pruning. We consider unstructured and structured pruning in this paper. Structured pruning prunes weights in groups, or removes the entire neurons, convolutional filters, or channels, enabling acceleration with the off-the-shelf hardware. In particular, we choose the filter pruning method used in Li et al. [32]. Unstructured sparsity is a more promising direction not only due to its outstanding performance at extreme sparsities but the increasing support for sparse operation in the practical hardware [35, 14, 52, 76, 22]. For example, Liu et al. [35] illustrated for the first time the true potential of DST, demonstrating significant training/inference efficiency improvement over the dense training. Different from prior conventions [77, 13, 33, 2] where values of the pruned weights are kept, we set the pruned weights to zero to eliminate the historical information for all implementations in this paper. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            753
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Magnitude pruning. We prune the weights with the smallest magnitude, as it has evolved as the standard method when pruning happens during training, e.g., GMP [77, 13] and DST [44, 9, 37]. We are also aware of other pruning criteria including but not limited to Hessian [29, 19, 59], Taylor expansion [47, 46], connection sensitivity [31], Gradient Flow [67], Neural Tangent Kernel [38, 16]. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One-shot pruning. To isolate the pruning effect at different training stages and to avoid the interaction between two iterations of pruning, we focus on one-shot pruning. Please note that iterative pruning can also be generalized in our setting, as our experimental design includes neural networks trained at various sparsities and each of them is further pruned with various pruning rates. ",
+        "bbox": [
+            174,
+            820,
+            825,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Layer-wise pruning and global pruning. We study both the layer-wise magnitude pruning and global magnitude pruning for pruning plasticity. Global magnitude pruning prunes different layers together and leads to non-uniform sparsity distributions; layer-wise pruning operates layer by layer, resulting in uniform distributions. ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Gradient-based regeneration. The simplest regeneration scheme is to randomly activate new connections [3, 44]. However, it would take a lot of time for random regeneration to discover the important connections, especially for the very extreme sparsities. Alternatively, gradients, including those for the connections with zero weights, provide good indicators for the connection importance. For this reason, we focus on gradient-based regeneration proposed in Rigged Lottery ( RigL) [9], i.e., regenerating the same number of connections as pruned with the largest gradient magnitude. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            219,
+            362,
+            233
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We study pruning plasticity during training with/without regeneration, for both dense training and sparse training. We report the results of ResNet-20 on CIFAR-10 with unstructured global pruning in the main body of the paper. The rest of the experiments are given in Appendix A. Unless otherwise stated, results are qualitatively similar across all networks. Concretely, we first pre-train networks at four sparsity levels, including 0, 0.5, 0.9, and 0.98. The sparse neural networks are trained with uniform distribution (i.e., all layers have the same sparsity). We further choose four pruning rates, e.g., 0.2, 0.5, 0.9, and 0.98, to measure the corresponding pruning plasticity of the pre-trained networks. ",
+        "bbox": [
+            173,
+            238,
+            825,
+            335
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pruning plasticity. We continue to train the pruned model for 30 epochs and report pruning plasticity in Figure 2. Overall, the learning rate schedule, the pruning rate, and the sparsity of the original models all have a big impact on pruning plasticity. Pruning plasticity decreases as the learning rate decays for all models with different sparsity levels. The models trained with a large learning rate 0.1 can easily recover, or exceed the original performance except for the extremely large pruning rate 0.98. However, the models obtained during the later training phases can recover only with the mild pruning rate choices, e.g., 0.2 (orange lines) and 0.5 (green lines). ",
+        "bbox": [
+            173,
+            342,
+            825,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We next demonstrate the effect of connection regeneration on pruning plasticity in the bottom row of Figure 2. It is clear to see that connection regeneration significantly improves pruning plasticity of all the cases, especially for the models that are over-pruned (purple lines). Still, even with connection regeneration, pruning plasticity suffers from performance degradation when pruning occurs after the learning rate drops. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            513
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c338301a4ebef994b551eeb1f67f260d2b4f5344dde37b82b7c5b30eebc84265.jpg",
+        "image_caption": [
+            "Figure 2: Unstructured Pruning: Pruning plasticity (see Section 3.1 for definition) under a 30- epoch continued training with and without connection regeneration for ResNet-20 on CIFAR-10. The vertical red lines refer to the points when the learning rate is decayed. “Pre-trained Sparsity” refers to the original sparsity of the pre-trained networks before pruning. The pruning method is the magnitude global pruning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            523,
+            821,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Final performance gap. Compared with the current model status, people might be more interested in the effect of pruning on the final performance. We further measure the performance gap between the original test accuracy of the unpruned models and the final test accuracy of the pruned model under a full continued training $\\mathrm { C O N T R A I N } ^ { T - t } ( W _ { t } \\odot m _ { t } , a _ { [ t + 1 : T ] } )$ in Figure 3. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            864
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We observe that, in this case, large learning rates do not enjoy large performance improvement, but still, the performance gap increases as the learning rate drops. It is reasonable to conjecture that the accuracy improvement of pruning plasticity with the large learning rate, 0.1, is due to the unconverged performance during the early phase of training. Besides, it is surprising to find that the final performance of extreme sparse networks (e.g., the third column and the fourth column) significantly benefits from mild pruning. Again, the ability of the pruned model to recover from pruning remarkably improves after regenerating the connections back. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/78e7ffb5d0599e001dd0778df1062b6ee6477a20a43770d2c2a2cc2ef03df9be.jpg",
+        "image_caption": [
+            "Figure 3: Unstructured Pruning: Final performance gap between the unpruned models and the pruned models for ResNet-20 on CIFAR-10. The vertical red lines refer to the points when the learning rate is decayed. “Pre-trained Sparsity” refers to the original sparsity of the pre-trained networks before pruning. The pruning method is the magnitude global pruning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            84,
+            821,
+            273
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            357,
+            825,
+            412
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Gradual Pruning with Zero-Cost Neuroregeneration ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            424,
+            643,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "So far, we have known that regenerating the important connections to the pruned models during training substantially improves pruning plasticity as well as the final performance. However, naively regenerating extra connections increases the parameter count and conflicts with the motivation of gradual pruning. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            506
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the mechanism of neuroregeneration in the nervous system, we propose a novel sparse training method which we call gradual pruning with zero-cost neuroregeneration (GraNet). GraNet consults the information produced throughout training and regenerates important connections during training in a parameter-efficient fashion. See Appendix B.1 for the pseudocode of GraNet. We introduce the main components of GraNet below. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            582
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Gradual Pruning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            590,
+            334,
+            606
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We follow the gradual pruning scheme used in [77] and gradually sparsifies the dense network to the target sparsity level over $n$ pruning iterations. Let us define $s _ { i }$ is the initial sparsity, $s _ { f }$ is the target sparsity, $t _ { 0 }$ is is the starting epoch of gradual pruning, $t _ { f }$ is the end epoch of gradual pruning, and $\\Delta t$ is the pruning frequency. The pruning rate of each pruning iteration is: ",
+        "bbox": [
+            174,
+            609,
+            825,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9bf367fa1fdfd3467d05e4953540c0784910fef6cbe185b69b2fa0465a23c5d1.jpg",
+        "text": "$$\ns _ { t } = s _ { f } + ( s _ { i } - s _ { f } ) \\left( 1 - \\frac { t - t _ { 0 } } { n \\Delta t } \\right) ^ { 3 } , t \\in \\left\\{ t _ { 0 } , t _ { 0 } + \\Delta t , . . . , t _ { 0 } + n \\Delta t \\right\\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            669,
+            733,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We choose global pruning for our method as it generally achieves better performance than uniform pruning. We also report the performance of the uniform sparsity as used in [13] in Appendix C.3. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The conventional gradual pruning methods [77, 13] change the mask (not the weight values) to fulfill the pruning operation, so that the pruned connections have the possibility to be reactivated in the later training phases. Despite this, since the weights of the pruned connections are not updated, they have a small chance to receive sufficient updates to exceed the pruning threshold. This hinders the regeneration of the important connections. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            813
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Zero-Cost Neuroregeneration ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            823,
+            419,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The main difference between GraNet and the conventional GMP methods [77, 13] is the Zero-Cost Neuroregeneration. Imitating the neuroregeneration of the peripheral nervous system [41, 73] where new neurons and connections are synthesized to replace the damaged ones, we first detect and eliminate the “damaged” connections, and then regenerate the same number of new connections. By doing this, we can achieve connection regeneration without increasing the number of connections. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Concretely, we identify the “damaged” connections as the ones with the smallest weight magnitudes. Small magnitude indicates that either the weight’s gradient is small or a large number of oscillations occur to the gradient direction. Therefore, these weights have a small contribution to the training loss and can be removed. Again, we use the gradient as the importance score for regeneration, same as the regrow method as used in RigL [9]. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Why we call it “Zero-Cost Neuroregeneration\"? In addition to not increasing the connection (parameter) count, the backward pass of our method is sparse most of the time even though our regeneration utilizes the dense gradient to identify the important connections. We perform neuroregeneration immediately after each gradual pruning step, meaning that the regeneration occurs only once every several thousand iterations. The extra overhead to calculate the dense gradient can be amortized compared with the whole training costs. Compared with the methods [33, 69] that require updating all the weights in the backward pass, our method is much more training efficient, as around 2/3 of the training FLOPs is owing to the backward pass [9, 72]. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Let us denote $r$ as the ratio of the number of the regenerated connections to the total number of connections; $W$ is the network weight. We first remove $r$ proportion of “damaged” weights with the smallest magnitude by: ",
+        "bbox": [
+            174,
+            284,
+            825,
+            327
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9bfeecb2ed0c3d53dc156061d578db34e56cc1d8b45beed17d29a3cb906477a8.jpg",
+        "text": "$$\nW ^ { \\prime } = \\mathrm { T o p K } \\left( | W | , 1 - r \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            329,
+            591,
+            345
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here $\\mathrm { T o p K } ( v , k )$ returns the weight tensor retaining the top $k$ -proportion of elements from $v$ . Immediately after that, we regenerate $r$ proportion of new connections based on the gradient magnitude: ",
+        "bbox": [
+            174,
+            349,
+            826,
+            377
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41ee1f2f90933d74bbcec14eece9a6d4e46490ae7e0ec9ec0f5cee4a2d701c33.jpg",
+        "text": "$$\nW = W ^ { \\prime } + \\mathrm { T o p K } \\left( | \\mathbf { g } _ { i \\notin W ^ { \\prime } } | , r \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            380,
+            606,
+            398
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\left| { \\bf g } _ { i \\notin W ^ { \\prime } } \\right|$ are the gradient magnitude of the zero weights. We perform Zero-Cost Neuroregeneration layer by layer from the beginning of the training to the end. ",
+        "bbox": [
+            176,
+            400,
+            825,
+            428
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "GraNet can naturally generalize to the dense-to-sparse training scenario and the sparse-to-sparse training scenario by setting the initial sparsity level $s _ { i } = 0$ and $s _ { i } > 0$ in Eq. (1), respectively. For simplicity, we set $s _ { i } = 0 . 5$ , $t _ { 0 } = 0$ , and $t _ { f }$ as the epoch when performing the first learning rate decay for the sparse-to-sparse training. Different from the existing sparse-to-sparse training methods, i.e., SET [44], RigL [9], and ITOP [37], in which the sparsity is fixed throughout training, GraNet starts from a denser yet still sparse model and gradually prunes the sparse model to the desired sparsity. Although starting with more parameters, the global pruning technique of gradual pruning helps GraNet quickly evolve to a better sparsity distribution than RigL with lower feedforward FLOPs and higher test accuracy. What’s more, GraNet sparsifies all layers including the first convolutional layer and the last fully-connected layer. ",
+        "bbox": [
+            173,
+            433,
+            826,
+            573
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            362,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conduct various experiments to evaluate the effectiveness of GraNet. We compare GraNet with various dense-to-sparse methods and sparse-to-sparse methods. The results of Rigged Lottery (RigL) and GMP with CIFAR-10/100 were reproduced by our implementation with PyTorch so that the only difference between GraNet and GMP is the Zero-Cost Neuroregeneration. For each model, we divide the results into three groups from top to bottom: pruning at initialization, dynamic sparse training and dense-to-sparse methods. See Appendix B for more implementation details used in the experiments. GraNet $\\mathit { s } _ { i } = 0 . 5$ ) refers to the sparse-to-sparse version and the and GraNet ${ \\bf \\nabla } _ { s _ { i } } = 0$ ) refers to the dense-to-sparse version. ",
+        "bbox": [
+            173,
+            601,
+            825,
+            712
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10/100. The results of CIFAR-10/100 are shared in Table 2. We can observe that performance differences among different methods on CIFAR-10 are generally small, but still, GraNet ${ \\bf \\Phi } _ { s _ { i } } = 0 $ ) consistently improves the performance over GMP except for the sparsity $9 5 \\%$ , and achieves the highest accuracy in 4 out of 6 cases. In terms of the more complex data CIFAR-100, the performance differences between the during-training pruning methods and before-training pruning methods are much larger. GraNet $( s _ { i } = 0$ ) again consistently outperforms GMP with all sparsities, highlighting the benefits of Zero-Cost Neuroregeneration. It is maybe more interesting that GraNet ${ \\bf \\nabla } _ { s _ { i } } = 0$ ) even outperforms the post-training method, subdifferential inclusion for sparsity (SIS), by a large margin. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            829
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In terms of sparse-to-sparse training, our proposed GraNet ( $s _ { i } = 0 . 5$ ) has a dominant performance over other methods. Especially at the very extreme sparsity 0.98, our method outperforms RigL by $1 . 4 0 \\%$ and $2 . 2 2 \\%$ with VGG-19 on CIFAR-10 and CIFAR-100, respectively. ",
+        "bbox": [
+            174,
+            835,
+            825,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ImageNet. Due to the small data size, the experiments with CIFAR-10/100 may not be sufficient to draw a solid conclusion. We further evaluate our method with ResNet-50 on ImageNet in Table 3. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6b93365227e21ce81ed1eaf026753c08bea0df95ca598698d6b999dfddc3c4e3.jpg",
+        "table_caption": [
+            "Table 2: Test accuracy of pruned VGG-19 and ResNet-50 on CIFAR-10/100. We mark the best sparse-to-sparse training results in blue and the best dense-to-sparse training results in bold. The results reported with (mean $\\pm$ std) are run with three different random seeds by us. The rest are obtained from [66] and [67]. Note that the accuracy of RigL is higher than the ones reported in [66], as we choose a large update interval following the In-Time Over-Parameterization strategy [37]. $s _ { i }$ refers to the initial sparsity of GraNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td colspan=\"3\">CIFAR-10</td><td colspan=\"3\">CIFAR-100</td></tr><tr><td>Pruning ratio</td><td>90%</td><td>95%</td><td>98%</td><td>90%</td><td>95%</td><td>98%</td></tr><tr><td>VGG-19 (Dense)</td><td>93.85±0.05</td><td>1</td><td>1</td><td>73.43±0.08</td><td>1</td><td>=</td></tr><tr><td>SNIP [31]</td><td>93.63</td><td>93.43</td><td>92.05</td><td>72.84</td><td>71.83</td><td>58.46</td></tr><tr><td>GraSP[67]</td><td>93.30</td><td>93.04</td><td>92.19</td><td>71.95</td><td>71.23</td><td>68.90</td></tr><tr><td>SynFlow [63]</td><td>93.35</td><td>93.45</td><td>92.24</td><td>71.77</td><td>71.72</td><td>70.94</td></tr><tr><td>Deep-R [3]</td><td>90.81</td><td>89.59</td><td>86.77</td><td>66.83</td><td>63.46</td><td>59.58</td></tr><tr><td>SET[44]</td><td>92.46</td><td>91.73</td><td>89.18</td><td>72.36</td><td>69.81</td><td>65.94</td></tr><tr><td>RigL[9]</td><td>93.38±0.11</td><td>93.06±0.09</td><td>91.98±0.09</td><td>73.13±0.28</td><td>72.14±0.15</td><td>69.82±0.09</td></tr><tr><td>GraNet (si= 0.5) (ours)</td><td>93.73±0.08</td><td>93.66±0.07</td><td>93.38±0.15</td><td>73.30±0.13</td><td>73.18±0.31</td><td>72.04±0.13</td></tr><tr><td>STR [28]</td><td>93.73</td><td>93.27</td><td>92.21</td><td>71.93</td><td>71.14</td><td>69.89</td></tr><tr><td>SIS [66]</td><td>93.99</td><td>93.31</td><td>93.16</td><td>72.06</td><td>71.85</td><td>71.17</td></tr><tr><td>GMP [13]</td><td>93.59±0.10</td><td>93.58±0.07</td><td>93.52±0.03</td><td>73.10±0.12</td><td>72.30±0.15</td><td>72.07±0.37</td></tr><tr><td>GraNet (si= O) (ours)</td><td>93.80±0.10</td><td>93.72±0.11</td><td>93.63±0.08</td><td>73.74±0.30</td><td>73.10±0.04</td><td>72.35±0.26</td></tr><tr><td>ResNet-50 (Dense)</td><td>94.75±0.01</td><td></td><td></td><td>78.23±0.18</td><td></td><td></td></tr><tr><td>SNIP [31]</td><td>92.65</td><td>90.86</td><td>87.21</td><td>73.14</td><td>69.25</td><td>58.43</td></tr><tr><td>GraSP [67]</td><td>92.47</td><td>91.32</td><td>88.77</td><td>73.28</td><td>70.29</td><td>62.12</td></tr><tr><td>SynFlow [63]</td><td>92.49</td><td>91.22</td><td>88.82</td><td>73.37</td><td>70.37</td><td>62.17</td></tr><tr><td>RigL [9]</td><td>94.45±0.43</td><td>93.86±0.25</td><td>93.26±0.22</td><td>76.50±0.33</td><td>76.03±0.34</td><td>75.06±0.27</td></tr><tr><td>GraNet (si= 0.5) (ours)</td><td>94.64±0.27</td><td>94.38±0.28</td><td>94.01±0.23</td><td>77.89±0.33</td><td>77.16±0.52</td><td>77.14±0.45</td></tr><tr><td>STR [28]</td><td>92.59</td><td>91.35</td><td>88.75</td><td>73.45</td><td>70.45</td><td>62.34</td></tr><tr><td>SIS [66]</td><td>92.81</td><td>91.69</td><td>90.11</td><td>73.81</td><td>70.62</td><td>62.75</td></tr><tr><td>GMP[13]</td><td>94.34±0.09</td><td>94.52±0.08</td><td>94.19±0.04</td><td>76.91±0.23</td><td>76.42±0.51</td><td>75.58±0.20</td></tr><tr><td>GraNet (si = O) (ours)</td><td>94.49±0.08</td><td>94.44±0.01</td><td>94.34±0.17</td><td>77.29±0.45</td><td>76.71±0.26</td><td>76.10±0.20</td></tr></table>",
+        "bbox": [
+            181,
+            181,
+            816,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ee05e1e780968851b6368809394c2729ceb3cf62632bcb60e96977c1dd3c9516.jpg",
+        "table_caption": [
+            "Table 3: Test accuracy of pruned ResNet-50 on ImageNet dataset. The best results of DST methods are marked as blue and the best results of pruning during training methods are marked in bold. The training/test FLOPs are normalized with the FLOPs of a dense model. $s _ { i }$ refers to the initial sparsity of GraNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Top-1 Accuracy</td><td>FLOPs (Train)</td><td>FLOPs (Test)</td><td>TOP-1 Accuracy</td><td>FLOPs (Train)</td><td>FLOPs (Test)</td></tr><tr><td>Dense</td><td>76.8±0.09</td><td>1x (3.2e18)</td><td>1x (8.2e9)</td><td>76.8±0.09</td><td>1x (3.2e18)</td><td>1x (8.2e9)</td></tr><tr><td>Pruning ratio</td><td></td><td>80%</td><td></td><td></td><td>90%</td><td></td></tr><tr><td rowspan=\"3\">Static (ERK) Small-Dense</td><td>72.1±0.04</td><td>0.42×</td><td>0.42×</td><td>67.7±0.12</td><td>0.24×</td><td>0.24×</td></tr><tr><td>72.1±0.06</td><td>0.23×</td><td>0.23×</td><td>67.2±0.12</td><td>0.10×</td><td>0.10×</td></tr><tr><td>72.0±0.06</td><td>0.23×</td><td>0.23×</td><td>67.2±0.12</td><td>0.10×</td><td>0.10×</td></tr><tr><td rowspan=\"5\">SET [44] DSR[48] RigL (ERK) [9]</td><td>72.9±0.39</td><td>0.23×</td><td>0.23×</td><td>69.6±0.23</td><td>0.10×</td><td>0.10×</td></tr><tr><td>73.3</td><td>0.40×</td><td>0.40×</td><td>71.6</td><td>0.30×</td><td>0.30×</td></tr><tr><td>75.1±0.05</td><td>0.42×</td><td>0.42×</td><td>73.0±0.04</td><td>0.25×</td><td>0.24×</td></tr><tr><td>75.2±0.11</td><td>0.61×</td><td>0.42×</td><td>72.9±0.06</td><td>0.50×</td><td>0.24×</td></tr><tr><td>76.0</td><td>0.37×</td><td>0.35×</td><td>74.5</td><td>0.25×</td><td>0.20×</td></tr><tr><td>STR [28]</td><td>76.1</td><td>n/a</td><td>0.17×</td><td>74.0</td><td>n/a</td><td>0.08×</td></tr><tr><td>DPF [33]</td><td>75.1</td><td>0.71×</td><td>0.23×</td><td>n/a</td><td>n/a</td><td>n/a</td></tr><tr><td>GMP[13]</td><td>75.6</td><td>0.56×</td><td>0.23×</td><td>73.9</td><td>0.51×</td><td>0.10×</td></tr><tr><td>GraNet (si = 0) (ours)</td><td>75.8</td><td>0.34×</td><td>0.28×</td><td>74.2</td><td>0.23×</td><td>0.16×</td></tr></table>",
+        "bbox": [
+            181,
+            590,
+            818,
+            827
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We only run this experiment once due to the limited resources. We set $t _ { 0 } = 0$ and $t _ { f } = 3 0$ for both GraNet $( s _ { i } = 0$ ) and GraNet ${ \\mathit { s } } _ { i } = 0 . 5 { \\mathit { \\Sigma } }$ ) on ImageNet. Again, GraNet $( s _ { i } = 0$ ) outperforms GMP consistently with only half training FLOPs and achieves the highest accuracy among all the dense-to-sparse methods at sparsity of 0.9. Surprisingly, GraNet ${ \\mathit { s } } _ { i } = 0 . 5 { \\mathit { \\Sigma } }$ ) significantly boosts the sparse-to-sparse training performance, even over the dense-to-sparse training. Concretely, GraNet ",
+        "bbox": [
+            173,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "$s _ { i } = 0 . 5 )$ ) outperforms RigL by $0 . 9 \\%$ and $1 . 5 \\%$ at sparsity 0.8 and 0.9, respectively. To the best of our knowledge, this is the first time in the literature that sparse-to-sparse training reaches a test accuracy of $76 \\%$ with ResNet-50 on ImageNet at sparsity 0.8, without extension of training time. It is reasonable for GraNet $\\mathit { s } _ { i } = 0 . 5$ ) to achieve better accuracy than RigL, since the denser models at the beginning help GraNet explore more the parameter space. According to the In-Time Over-Parameterization hypothesis [37], the performance of sparse training methods is highly correlated with the total number of parameters that the sparse model has visited. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We further report the training/inference FLOPs required by all pruning methods. Compared with other dense-to-sparse methods, the final networks learned by GraNet $( s _ { i } = 0 )$ ) require more FLOPs to test, whereas the overall training FLOPs required by GraNet ${ { s } _ { i } } = 0$ ) are smaller than others. Even though starting from a denser model, GraNet $\\mathit { s } _ { i } = 0 . 5$ ) requires less training and inference FLOPs than the state-of-the-art method, i.e., RigL. The sparsity budgets for 0.9 sparse ResNet-50 on ImageNet-1K learned by our methods are reported in Appendix D. We also report how FLOPs of the pruned ResNet-50 evolve during the course of training in Appendix E. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            292
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Effect of the Initial Sparsity ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            296,
+            406,
+            311
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As we mentioned earlier, the denser initial network is the key factor in the success of GraNet. We conducted experiments to study the effect of the initial sparsity on GraNet with ResNet-50 on ImageNet. The initial sparsity is chosen from [0.0, 0.5, 0.6, 0.7, 0.8, 0.9] and the final sparsity is fixed as 0.9. The results are shared in Table 4. We can see the training FLOPs of GraNet are quite robust to the initial sparsity. Surprisingly yet reasonably, it seems that the the smaller the initial sparsity is (up to 0.5), the better final sparsity distribution GraNet finds, with higher test accuracy and fewer feedforward FLOPs. The lower feedforward FLOPs of the final network perfectly balance the overhead caused by the denser initial network. ",
+        "bbox": [
+            174,
+            316,
+            501,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c7a1c15cb9248308fa4493a9e8755d51ff731ecbc74817a30490fcfb63f08eba.jpg",
+        "table_caption": [
+            "Table 4: Effect of the initial sparsity on GraNet with ResNet-50 on ImageNet. The training/test FLOPs are normalized with the FLOPs of a dense model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Si</td><td>Sf</td><td>Top-1 [%] Accuracy</td><td>FLOPs (Train)</td><td>FLOPs (Test)</td></tr><tr><td>GraNet</td><td>0.0</td><td>0.9</td><td>74.2</td><td>0.23×</td><td>0.16×</td></tr><tr><td>GraNet</td><td>0.5</td><td>0.9</td><td>74.5</td><td>0.25×</td><td>0.20×</td></tr><tr><td>GraNet</td><td>0.6</td><td>0.9</td><td>74.4</td><td>0.25×</td><td>0.22×</td></tr><tr><td>GraNet</td><td>0.7</td><td>0.9</td><td>74.2</td><td>0.24×</td><td>0.22×</td></tr><tr><td>GraNet</td><td>0.8</td><td>0.9</td><td>74.1</td><td>0.25×</td><td>0.24×</td></tr><tr><td>RigL</td><td>0.9</td><td>0.9</td><td>73.0</td><td>0.25×</td><td>0.24×</td></tr></table>",
+        "bbox": [
+            527,
+            381,
+            812,
+            478
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            496,
+            707,
+            510
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 Performance of GraNet at Extreme Sparsities ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            518,
+            531,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we share the results of GraNet and RigL at extreme sparsities. The initial sparsity is set as 0.5. When the final sparsity is relatively smaller (e.g., 0.8, 0.9), GraNet requires a lower (or the same) number of training FLOPs than RigL, whereas GraNet requires more training FLOPs than RigL when the final sparsity is extremely high (e.g., 0.95, 0.965). This makes sense since when the sparsity is extremely high, the saved FLOPs count of the distribution discovered by GraNet is too small to amortize the overhead caused by denser initial models. Yet, the increased number of training FLOPs of GraNet leads to substantial accuracy improvement $( > 2 \\% )$ over RigL. The efficiency of GraNet ( $s _ { i } = 0 . 5$ ) comes from two important technical differences compared with RigL: (1) better final sparse distribution discovered by global pruning; (2) a shorter period of gradual pruning time (the first 30 epochs for ResNet-50 on ImageNet). Although starting with more parameters, the global pruning enables GraNet to quickly (first 30 epochs) evolve to a better sparsity distribution with lower test FLOPs than ERK. After 30 epochs of gradual pruning, the network continues to be trained with this better distribution for 70 epochs, so that the overhead in the early training phase with larger training FLOPs is amortized by the later and longer training phase with fewer training FLOPs. ",
+        "bbox": [
+            174,
+            537,
+            503,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/8a60c1b6d85709828f0331300372576c9a0ae918ece228e1531f354a25a273dd.jpg",
+        "table_caption": [
+            "Table 5: Comparison between GraNet and RigL at extreme sparsities with ResNet-50 on ImageNet. The training/test FLOPs are normalized with the FLOPs of a dense model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Si</td><td>sf</td><td>Top-1[%] Accuracy</td><td>FLOPs (Train)</td><td>FLOPs (Test)</td></tr><tr><td>RigL GraNet</td><td>0.8</td><td>0.8</td><td>75.1</td><td>0.42×</td><td>0.42×</td></tr><tr><td>RigL</td><td>0.5 0.9</td><td>0.8 0.9</td><td>76.0 73.0</td><td>0.37× 0.25×</td><td>0.35× 0.24×</td></tr><tr><td>GraNet</td><td>0.5</td><td>0.9</td><td>74.5</td><td>0.25×</td><td>0.20×</td></tr><tr><td>RigL GraNet</td><td>0.95 0.5</td><td>0.95 0.95</td><td>69.7 72.3</td><td>0.12× 0.17×</td><td>0.12× 0.12×</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>RigL</td><td>0.965</td><td>0.965</td><td>67.2</td><td>0.11×</td><td>0.11×</td></tr><tr><td>GraNet</td><td>0.5</td><td>0.965</td><td>70.5</td><td>0.15×</td><td>0.09×</td></tr></table>",
+        "bbox": [
+            522,
+            621,
+            826,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            786,
+            825,
+            856
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.6 Ablation Study of Random Reinitialization ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            863,
+            511,
+            878
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Next, we ask whether what GraNet learned are the specific sparse connectivity or the sparse connectivity together with the weight values. We randomly reinitialize the pruned network with the same mask and retrain it. The results are given in Figure 4. The performance of the reinitialized networks falls significantly short of the performance achieved by GraNet $( s _ { i } = 0 )$ ), indicating that what was learned by GraNet is the sparse connectivity together with the weight values. Besides, we find that the retraining performance of GraNet is higher than GMP. This further confirms that Zero-Cost Neuroregeneration helps the gradual pruning find more accurate mask positions. ",
+        "bbox": [
+            173,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4612ffd943999f6ebf8e6d2174a5adff7df303bbba6e527696f4121417ff7ad.jpg",
+        "image_caption": [
+            "Figure 4: Reinitialization ablation on subnetworks discovered by GMP and GraNet $( s _ { i } = 0$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            233,
+            176,
+            746,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.7 Comparison between Re-training and Extended Training ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            362,
+            609,
+            377
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this section, we study if re-training techniques can further improve the performance of the subnetworks discovered by GraNet. The authors of Lottery Ticket Hypothesis (LTH) [10] introduced a retraining technique, even if they did not evaluate it as such, where the subnetworks discovered by iterative magnitude pruning can be re-trained in isolation to full accuracy with the original initializations. Later on, learning rate rewinding (LRR) [54] was proposed further to improve the re-training performance by only rewinding the learning rate. Since GraNet also utilizes magnitude pruning to discover subnetworks, it is natural to test if these re-training techniques can bring benefits to GraNet. As shown in Table 6, both re-training techniques do not bring benefits to GraNet. Instead of re-training the subnetworks, we find that simply extending the training time significantly boosts the performance of GraNet with similar computational costs. ",
+        "bbox": [
+            173,
+            383,
+            825,
+            521
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/e71234256df4ea71e83b52915d227c04cb86dfa2b8c0c1e45f286c448cf74380.jpg",
+        "table_caption": [
+            "Table 6: Effects of LTH and LRR on the subnetworks learned by GraNet. Methods with $_ 2 \\times$ refer to extending the training steps by 2 times. The results are reported with top-1 test accuracy $[ \\% ]$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td colspan=\"3\">CIFAR-10</td><td colspan=\"3\">CIFAR-100</td></tr><tr><td>Pruning ratio</td><td>90%</td><td>95%</td><td>98%</td><td>90%</td><td>95%</td><td>98%</td></tr><tr><td>VGG-19 (Dense)</td><td>93.85±0.05</td><td>=</td><td></td><td>73.43±0.08</td><td>=</td><td>1</td></tr><tr><td>GraNet (si = 0)</td><td>93.80±0.10</td><td>93.72±0.11</td><td>93.63±0.08</td><td>73.74±0.30</td><td>73.10±0.04</td><td>72.35±0.26</td></tr><tr><td>+Lottery Ticket Hypothesis</td><td>93.63±0.04</td><td>93.29±0.05</td><td>92.46±0.08</td><td>72.97±0.25</td><td>71.76±0.22</td><td>69.28±0.36</td></tr><tr><td>+ Learning Rate Rewinding</td><td>93.84±0.14</td><td>93.72±0.06</td><td>93.53±0.04</td><td>73.71±0.08</td><td>73.24±0.24</td><td>72.50±0.26</td></tr><tr><td>GraNet2x (si = 0)</td><td>94.17±0.03</td><td>93.98±0.07</td><td>93.94±0.11</td><td>74.80±0.29</td><td>73.65±0.32</td><td>73.63±0.05</td></tr><tr><td>ResNet-50 (Dense)</td><td>94.75±0.01</td><td></td><td></td><td>78.23±0.18</td><td></td><td></td></tr><tr><td>GraNet (si = 0)</td><td>94.49±0.08</td><td>94.44±0.01</td><td>94.34±0.17</td><td>77.29±0.45</td><td>76.71±0.26</td><td>76.10±0.20</td></tr><tr><td>+Lottery Ticket Hypothesis</td><td>93.96±0.10</td><td>93.70±0.15</td><td>92.94±0.14</td><td>75.74±0.19</td><td>74.31±0.10</td><td>71.99±0.08</td></tr><tr><td>+ Learning Rate Rewinding</td><td>94.55±0.13</td><td>94.39±0.13</td><td>94.20±0.25</td><td>77.40±0.14</td><td>76.90±0.19</td><td>75.75±0.25</td></tr><tr><td>GraNet2× (si= 0)</td><td>95.09±0.15</td><td>94.84±0.11</td><td>94.69±0.24</td><td>78.18±0.20</td><td>78.17±0.20</td><td>77.15±0.29</td></tr></table>",
+        "bbox": [
+            181,
+            561,
+            820,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion, and Reflection of Broader Impacts ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            748,
+            596,
+            766
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we re-emphasize the merit of during-training pruning. Compared with the recently proposed works, i.e., LTH and SNIP, during-training pruning is an efficient yet performant class of pruning methods that have received much less attention. We quantitatively study pruning during training from the perspective of pruning plasticity. Inspired by the findings from pruning plasticity and the mechanism of neuroregeneration in the nervous system, we further proposed a novel sparse training method, GraNet, that performs the cost-free connection regeneration during training. GraNet advances the state of the art in both dense-to-sparse training and sparse-to-sparse training. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            873
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our paper re-emphasizes the great potential of during-training pruning in reducing the training/inference resources required by ML models without sacrificing accuracy. It has a significant environmental impact on reducing the energy cost of the ML models and CO2 emissions [1, 53, 15, 56, 62]. ",
+        "bbox": [
+            174,
+            878,
+            825,
+            921
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            359,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This project is partially financed by the Dutch Research Council (NWO). We thank the reviewers for the constructive comments and questions, which improved the quality of our paper. ",
+        "bbox": [
+            174,
+            121,
+            823,
+            150
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            162,
+            266,
+            179
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Z. Atashgahi, G. Sokar, T. van der Lee, E. Mocanu, D. C. Mocanu, R. Veldhuis, and M. Pechenizkiy. Quick and robust feature selection: the strength of energy-efficient sparse training for autoencoders. arXiv:2012.00560, 2020.   \n[2] B. Bartoldson, A. Morcos, A. Barbu, and G. Erlebacher. The generalization-stability tradeoff in neural network pruning. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 20852–20864. Curran Associates, Inc., 2020.   \n[3] G. Bellec, D. Kappel, W. Maass, and R. Legenstein. Deep rewiring: Training very sparse deep networks. In International Conference on Learning Representations, 2018. arXiv:1711.05136 (2017).   \n[4] T. Brown, B. Mann, N. Ryder, M. Subbiah, J. D. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, S. Agarwal, A. Herbert-Voss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. Ziegler, J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner, S. McCandlish, A. Radford, I. Sutskever, and D. Amodei. Language models are few-shot learners. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 1877–1901. Curran Associates, Inc., 2020.   \n[5] T. Chen, J. Frankle, S. Chang, S. Liu, Y. Zhang, M. Carbin, and Z. Wang. The lottery tickets hypothesis for supervised and self-supervised pre-training in computer vision models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 16306–16316, June 2021.   \n[6] P. de Jorge, A. Sanyal, H. Behl, P. Torr, G. Rogez, and P. K. Dokania. Progressive skeletonization: Trimming more fat from a network at initialization. In International Conference on Learning Representations, 2021. arXiv:cs.CV/2006.09081.   \n[7] E. Denton, W. Zaremba, J. Bruna, Y. LeCun, and R. Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. Twenty-eighth Conference on Neural Information Processing Systems. arXiv:1404.0736, 2014.   \n[8] T. Dettmers and L. Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. arXiv preprint arXiv:1907.04840, 2019.   \n[9] U. Evci, T. Gale, J. Menick, P. S. Castro, and E. Elsen. Rigging the lottery: Making all tickets winners. In International Conference on Machine Learning, pages 2943–2952. PMLR, 2020.   \n[10] J. Frankle and M. Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2019. arXiv:1803.03635.   \n[11] J. Frankle, G. K. Dziugaite, D. Roy, and M. Carbin. Pruning neural networks at initialization: Why are we missing the mark? In International Conference on Learning Representations, 2021. arXiv:2009.08576.   \n[12] J. Frankle, G. K. Dziugaite, D. M. Roy, and M. Carbin. The lottery ticket hypothesis at scale. arXiv preprint arXiv:1903.01611, 2019.   \n[13] T. Gale, E. Elsen, and S. Hooker. The state of sparsity in deep neural networks. arXiv preprint arXiv:1902.09574, 2019.   \n[14] T. Gale, M. Zaharia, C. Young, and E. Elsen. Sparse gpu kernels for deep learning. arXiv preprint arXiv:2006.10901, 2020.   \n[15] E. García-Martín, C. F. Rodrigues, G. Riley, and H. Grahn. Estimation of energy consumption in machine learning. Journal of Parallel and Distributed Computing, 134:75–88, 2019.   \n[16] T. Gebhart, U. Saxena, and P. Schrater. A unified paths perspective for pruning at initialization. arXiv preprint arXiv:2101.10552, 2021.   \n[17] J. Guo, Y. Li, W. Lin, Y. Chen, and J. Li. Network decoupling: From regular to depthwise separable convolutions. arXiv preprint arXiv:1808.05517, 2018.   \n[18] S. Han, J. Pool, J. Tran, and W. Dally. Learning both weights and connections for efficient neural network. In Advances in neural information processing systems, pages 1135–1143, 2015.   \n[19] B. Hassibi and D. G. Stork. Second order derivatives for network pruning: Optimal brain surgeon. Morgan Kaufmann, 1993.   \n[20] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770– 778, 2016.   \n[21] T. Hoefler, D. Alistarh, T. Ben-Nun, N. Dryden, and A. Peste. Sparsity in deep learning: Pruning and growth for efficient inference and training in neural networks. Journal of Machine Learning Research, 22(241):1–124, 2021.   \n[22] I. Hubara, B. Chmiel, M. Island, R. Banner, S. Naor, and D. Soudry. Accelerated sparse neural training: A provable and efficient method to find n: M transposable masks. arXiv preprint arXiv:2102.08124, 2021.   \n[23] M. Jaderberg, A. Vedaldi, and A. Zisserman. Speeding up convolutional neural networks with low rank expansions. arXiv preprint arXiv:1405.3866, 2014.   \n[24] S. A. Janowsky. Pruning versus clipping in neural networks. Physical Review A, 39(12):6600, 1989.   \n[25] S. Jayakumar, R. Pascanu, J. Rae, S. Osindero, and E. Elsen. Top-kast: Top-k always sparse training. Advances in Neural Information Processing Systems, 33:20744–20754, 2020.   \n[26] E. R. Kandel, J. H. Schwartz, T. M. Jessell, S. Siegelbaum, A. J. Hudspeth, and S. Mack. Principles of neural science, volume 4. McGraw-hill New York, 2000.   \n[27] A. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images. Master’s thesis, Department of Computer Science, University of Toronto, 2009.   \n[28] A. Kusupati, V. Ramanujan, R. Somani, M. Wortsman, P. Jain, S. Kakade, and A. Farhadi. Soft threshold weight reparameterization for learnable sparsity. In International Conference on Machine Learning, pages 5544–5555. PMLR, 2020.   \n[29] Y. LeCun, J. S. Denker, and S. A. Solla. Optimal brain damage. In Advances in neural information processing systems, pages 598–605, 1990.   \n[30] N. Lee, T. Ajanthan, S. Gould, and P. H. S. Torr. A signal propagation perspective for pruning neural networks at initialization. In International Conference on Learning Representations, 2020. arXiv:1906.06307.   \n[31] N. Lee, T. Ajanthan, and P. H. Torr. Snip: Single-shot network pruning based on connection sensitivity. International Conference on Learning Representations, 2018.   \n[32] H. Li, A. Kadav, I. Durdanovic, H. Samet, and H. P. Graf. Pruning filters for efficient convnets. International Conference on Learning Representations, 2016.   \n[33] T. Lin, S. U. Stich, L. Barba, D. Dmitriev, and M. Jaggi. Dynamic model pruning with feedback. In International Conference on Learning Representations, 2020.   \n[34] J. Liu, Z. Xu, R. Shi, R. C. C. Cheung, and H. K. So. Dynamic sparse training: Find efficient sparse network from scratch with trainable masked layers. In International Conference on Learning Representations, 2020.   \n[35] S. Liu, D. C. Mocanu, A. R. R. Matavalam, Y. Pei, and M. Pechenizkiy. Sparse evolutionary deep learning with over one million artificial neurons on commodity hardware. Neural Computing and Applications, 33(7):2589–2604, 2021.   \n[36] S. Liu, D. C. Mocanu, Y. Pei, and M. Pechenizkiy. Selfish sparse rnn training. In Proceedings of the 39th International Conference on Machine Learning, pages 6893–6904. PMLR, 2021.   \n[37] S. Liu, L. Yin, D. C. Mocanu, and M. Pechenizkiy. Do we actually need dense overparameterization? in-time over-parameterization in sparse training. In Proceedings of the 39th International Conference on Machine Learning, pages 6989–7000. PMLR, 2021.   \n[38] T. Liu and F. Zenke. Finding trainable sparse networks through neural tangent transfer. In International Conference on Machine Learning, pages 6336–6347. PMLR, 2020.   \n[39] Z. Liu, M. Sun, T. Zhou, G. Huang, and T. Darrell. Rethinking the value of network pruning. International Conference on Learning Representations, 2019.   \n[40] C. Louizos, M. Welling, and D. P. Kingma. Learning sparse neural networks through l_0 regularization. International Conference on Learning Representations, 2018.   \n[41] M. Mahar and V. Cavalli. Intrinsic mechanisms of neuronal axon regeneration. Nature Reviews Neuroscience, 19(6):323–337, 2018.   \n[42] D. Mittal, S. Bhardwaj, M. M. Khapra, and B. Ravindran. Recovering from random pruning: On the plasticity of deep convolutional neural networks. In 2018 IEEE Winter Conference on Applications of Computer Vision (WACV), pages 848–857. IEEE, 2018.   \n[43] D. C. Mocanu, E. Mocanu, T. Pinto, S. Curci, P. H. Nguyen, M. Gibescu, D. Ernst, and Z. A. Vale. Sparse training theory for scalable and efficient agents. International Conference on Autonomous Agents and Multiagent Systems (AAMAS). arXiv:2103.01636, 2021.   \n[44] D. C. Mocanu, E. Mocanu, P. Stone, P. H. Nguyen, M. Gibescu, and A. Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature communications, 9(1):2383, 2018.   \n[45] D. Molchanov, A. Ashukha, and D. Vetrov. Variational dropout sparsifies deep neural networks. In International Conference on Machine Learning, pages 2498–2507. PMLR, 2017.   \n[46] P. Molchanov, A. Mallya, S. Tyree, I. Frosio, and J. Kautz. Importance estimation for neural network pruning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11264–11272, 2019.   \n[47] P. Molchanov, S. Tyree, T. Karras, T. Aila, and J. Kautz. Pruning convolutional neural networks for resource efficient inference. International Conference on Learning Representations, 2016.   \n[48] H. Mostafa and X. Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization. International Conference on Machine Learning, 2019.   \n[49] M. C. Mozer and P. Smolensky. Skeletonization: A technique for trimming the fat from a network via relevance assessment. In Advances in neural information processing systems, pages 107–115, 1989.   \n[50] M. C. Mozer and P. Smolensky. Using relevance to reduce network size automatically. Connection Science, 1(1):3–16, 1989.   \n[51] P. G. Nagappan, H. Chen, and D.-Y. Wang. Neuroregeneration and plasticity: a review of the physiological mechanisms for achieving functional recovery postinjury. Military Medical Research, 7(1):1–16, 2020.   \n[52] Nvidia. Nvidia a100 tensor core gpu architecture. https://www.nvidia.com/content/dam/enzz/Solutions/Data-Center/nvidia-ampere-architecture-whitepaper.pdf, 2020.   \n[53] D. Patterson, J. Gonzalez, Q. Le, C. Liang, L.-M. Munguia, D. Rothchild, D. So, M. Texier, and J. Dean. Carbon emissions and large neural network training. arXiv preprint arXiv:2104.10350, 2021.   \n[54] A. Renda, J. Frankle, and M. Carbin. Comparing rewinding and fine-tuning in neural network pruning. In International Conference on Learning Representations, 2020. arXiv:2003.02389.   \n[55] P. Savarese, H. Silva, and M. Maire. Winning the lottery with continuous sparsification. arXiv preprint arXiv:1912.04427, 2019.   \n[56] R. Schwartz, J. Dodge, N. A. Smith, and O. Etzioni. Green ai. arXiv preprint arXiv:1907.10597, 2019.   \n[57] Y. Shen, L. Shen, H.-Z. Huang, X. Wang, and W. Liu. Cpot: Channel pruning via optimal transport. arXiv preprint arXiv:2005.10451, 2020.   \n[58] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. International Conference on Learning Representations, 2014.   \n[59] S. P. Singh and D. Alistarh. Woodfisher: Efficient second-order approximation for neural network compression. Advances in Neural Information Processing Systems, 33, 2020.   \n[60] S. Srinivas, A. Subramanya, and R. Venkatesh Babu. Training sparse neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pages 138–145, 2017.   \n[61] N. Strom. Scalable distributed dnn training using commodity gpu cloud computing. In Sixteenth Annual Conference of the International Speech Communication Association, 2015.   \n[62] E. Strubell, A. Ganesh, and A. McCallum. Energy and policy considerations for deep learning in nlp. arXiv preprint arXiv:1906.02243, 2019.   \n[63] H. Tanaka, D. Kunin, D. L. Yamins, and S. Ganguli. Pruning neural networks without any data by iteratively conserving synaptic flow. Advances in Neural Information Processing Systems. arXiv:2006.05467, 2020.   \n[64] H. Touvron, A. Vedaldi, M. Douze, and H. Jegou. Fixing the train-test resolution discrepancy. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   \n[65] S. Verdenius, M. Stol, and P. Forré. Pruning via iterative ranking of sensitivity statistics. arXiv preprint arXiv:2006.00896, 2020.   \n[66] S. Verma and J.-C. Pesquet. Sparsifying networks via subdifferential inclusion. In M. Meila and T. Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 10542–10552. PMLR, 18–24 Jul 2021.   \n[67] C. Wang, G. Zhang, and R. Grosse. Picking winning tickets before training by preserving gradient flow. In International Conference on Learning Representations, 2020.   \n[68] W. Wen, C. Wu, Y. Wang, Y. Chen, and H. Li. Learning structured sparsity in deep neural networks. In D. Lee, M. Sugiyama, U. Luxburg, I. Guyon, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.   \n[69] M. Wortsman, A. Farhadi, and M. Rastegari. Discovering neural wirings. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   \n[70] X. Xiao, Z. Wang, and S. Rajasekaran. Autoprune: Automatic network pruning by regularizing auxiliary parameters. Advances in neural information processing systems, 32, 2019.   \n[71] Y. Xu, Y. Li, S. Zhang, W. Wen, B. Wang, Y. Qi, Y. Chen, W. Lin, and H. Xiong. Trained rank pruning for efficient deep neural networks. arXiv preprint arXiv:1812.02402, 2018.   \n[72] D. Yang, A. Ghasemazar, X. Ren, M. Golub, G. Lemieux, and M. Lis. Procrustes: a dataflow and accelerator for sparse deep neural network training. In 2020 53rd Annual IEEE/ACM International Symposium on Microarchitecture (MICRO), pages 711–724. IEEE, 2020.   \n[73] G. Yiu and Z. He. Glial inhibition of cns axon regeneration. Nature Reviews Neuroscience, 7(8):617–627, 2006.   \n[74] H. You, C. Li, P. Xu, Y. Fu, Y. Wang, X. Chen, R. G. Baraniuk, Z. Wang, and Y. Lin. Drawing early-bird tickets: Towards more efficient training of deep networks. arXiv preprint arXiv:1909.11957, 2019.   \n[75] G. Yuan, L. Shen, and W.-S. Zheng. A block decomposition algorithm for sparse optimization. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 275–285, 2020.   \n[76] A. Zhou, Y. Ma, J. Zhu, J. Liu, Z. Zhang, K. Yuan, W. Sun, and H. Li. Learning n:m fine-grained structured sparse neural networks from scratch. In International Conference on Learning Representations, 2021.   \n[77] M. H. Zhu and S. Gupta. To prune, or not to prune: Exploring the efficacy of pruning for model compression, 2018. ",
+        "bbox": [
+            178,
+            172,
+            826,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            58,
+            828,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            69,
+            828,
+            916
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            45,
+            828,
+            912
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            313
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SJxzPsAqFQ/SJxzPsAqFQ.md

@@ -0,0 +1,298 @@
+# MULTI-TURN DIALOGUE RESPONSE GENERATION IN AN ADVERSARIAL LEARNING FRAMEWORK
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose an adversarial learning approach to the generation of multi-turn dialogue responses. Our proposed framework, hredGAN, is based on conditional generative adversarial networks (GANs). The GAN’s generator is a modified hierarchical recurrent encoder-decoder network (HRED) and the discriminator is a word-level bidirectional RNN that shares context and word embedding with the generator. During inference, noise samples conditioned on the dialogue history are used to perturb the generator’s latent space to generate several possible responses. The final response is the one ranked best by the discriminator. The hredGAN shows major advantages over existing methods: (1) it generalizes better than networks trained using only the log-likelihood criterion, and (2) it generates longer, more informative and more diverse responses with high utterance and topic relevance even with limited training data. This superiority is demonstrated on the Movie triples and Ubuntu dialogue datasets with both the automatic and human evaluations.
+
+# 1 INTRODUCTION
+
+Recent advances in deep neural network architectures have enabled tremendous success on a number of difficult machine learning problems. While these results are impressive, producing a deployable neural network–based conversation model that can engage in open domain discussion still remains elusive. A dialogue system needs to be able to generate meaningful and diverse responses that are simultaneously coherent with the input utterance and the overall dialogue topic. Unfortunately, earlier conversation models trained with naturalistic dialogue data suffered greatly from limited contextual information (Sutskever et al., 2014; Vinyals & Le, 2015), and lack diversity (Li et al., 2016a). These problems often leads to generic and safe utterance in response to varieties of input utterance.
+
+Serban et al. (2016) and Xing et al. (2017) proposed the Hierarchical Recurrent Encoder-Decoder (HRED) network to capture long temporal dependencies in multi-turn conversations to address the limited contextual information but the diversity problem remained. On the other hand, some HRED variants such as variational (Serban et al., 2017b) and multi-resolution (Serban et al., 2017a) HREDs attempt to alleviate the diversity problem by injecting noise at the utterance level and by extracting additional context to condition the generator on. While these approaches achieve certain measures of success over the basic HRED, generated responses are still mostly generic since they do not control the generator’s output as the output conditional distribution is not calibrated. Li et al. (2016a), on the other hand, consider diversity promoting training objective but their model is for single turn conversations, cannot not be trained end-to-end and therefore achieves little.
+
+The generative adversarial network (GAN) (Goodfellow et al., 2014) seems to be an appropriate solution to the diversity problem. GAN matches data from two different distributions by introducing an adversarial game between a generator and a discriminator. We explore hredGAN: conditional GANs for multi-turn dialogue models with HRED generator and discriminator. hredGAN combines both generative and retrieval-based multi-turn dialogue systems to improve their individual performances. This is achieved by sharing the context and word embedding between the generator and the discriminator allowing for joint end-to-end training using back-propagation. To the best of our knowledge, no existing work has applied conditional GANs to multi-turn dialogue models and especially with HRED generators and discriminators. We demonstrate the effectiveness of hredGAN over the VHRED for dialogue modeling with evaluations on the Movie triples and Ubuntu technical support datasets.
+
+# 2 ADVERSARIAL FRAMEWORK FOR MULTI-TURN DIALOGUE
+
+Consider a dialogue consisting of a sequence of $N$ utterances, $\pmb { X } = \left( X _ { 1 } , X _ { 2 } , \cdots , X _ { N } \right)$ , where each utterance $X _ { i } ~ = ~ \left( X _ { i } ^ { 1 } , X _ { i } ^ { 2 } , \cdot \cdot \cdot , X _ { i } ^ { M _ { i } } \right)$ contains a variable-length sequence of $M _ { i }$ word tokens such that $X _ { i } ^ { \mathcal { j } } ~ \in ~ V$ for vocabulary $V$ . At any time step $i$ , the dialogue history is given by $\boldsymbol { X _ { i } } = \left( X _ { 1 } , X _ { 2 } , \cdot \cdot \cdot , X _ { i } \right)$ . The dialogue response generation task can be defined as follows: Given a dialogue history $X _ { i }$ , generate a response $Y _ { i } = \left( Y _ { i } ^ { 1 } , Y _ { i } ^ { 2 } , \cdots , Y _ { i } ^ { T _ { i } } \right)$ , where $T _ { i }$ is the number of generated tokens. We also want the distribution of the generated response $P ( Y _ { i } )$ to be indistinguishable from that of the ground truth $P ( X _ { i + 1 } )$ and $T _ { i } = M _ { i + 1 }$ . Conditional GAN learns a mapping from an observed dialogue history, $X _ { i }$ , and a sequence of random noise vectors, $Z _ { i }$ to a sequence of output tokens, $Y _ { i }$ , $G : \{ X _ { i } , Z _ { i } \}  Y _ { i }$ . The generator $G$ is trained to produce output sequences that cannot be distinguished from the ground truth sequence by an adversarially trained discriminator $D$ that is trained to do well at detecting generator’s fakes. The distribution of the generator output sequence can be factored by the product rule:
+
+$$
+\begin{array} { r } { P ( Y _ { i } | \boldsymbol { X _ { i } } ) = P ( Y _ { i } ^ { 1 } ) \displaystyle \prod _ { j = 2 } ^ { T _ { i } } P \big ( Y _ { i } ^ { j } | Y _ { i } ^ { 1 } , \cdot \cdot \cdot , Y _ { i } ^ { j - 1 } , \pmb { X _ { i } } \big ) } \\ { P \big ( Y _ { i } ^ { j } | Y _ { i } ^ { 1 } , \cdot \cdot \cdot , Y _ { i } ^ { j - 1 } , \pmb { X _ { i } } \big ) = P _ { \theta _ { G } } \big ( Y _ { i } ^ { 1 : j - 1 } , \pmb { X _ { i } } \big ) } \end{array}
+$$
+
+where Y i:j−1 $\begin{array} { r c l } { Y _ { i } ^ { i : j - 1 } } & { = } & { ( Y _ { i } ^ { 1 } , \cdot \cdot \cdot , Y _ { i } ^ { j - 1 } ) } \end{array}$ and $\theta _ { G }$ are the parameters of the generator model. $P _ { \theta _ { G } } \left( Y _ { i } ^ { i : j - 1 } , X _ { i } \right)$ is an autoregressive generative model where the probability of the current token depends on the past generated sequence. Training the generator $G$ with the log-likelihood criterion is unstable in practice, and therefore the past generated sequence is substituted with the ground truth, a method known as teacher forcing (Williams & Zipser, 1989), i.e.,
+
+$$
+P \left( Y _ { i } ^ { j } | Y _ { i } ^ { 1 } , \cdot \cdot \cdot , Y _ { i } ^ { j - 1 } , \pmb { X } _ { i } \right) \approx P _ { \theta _ { G } } \left( X _ { i + 1 } ^ { 1 : j - 1 } , \pmb { X } _ { i } \right)
+$$
+
+Using equation 3 in relation to GAN, we define our fake sample as the teacher forcing output with some input noise $Z _ { i }$
+
+$$
+Y _ { i } ^ { j } \sim P _ { \theta _ { G } } ( X _ { i + 1 } ^ { 1 : j - 1 } , X _ { i } , Z _ { i } )
+$$
+
+and the corresponding real sample as ground truth $X _ { i + 1 } ^ { j }$
+
+With the GAN objective, we can match the noise distribution, $P ( Z _ { i } )$ to the distribution of the ground truth response, $P ( X _ { i + 1 } | X _ { i } )$ . Varying the noise input then allows us to generate diverse responses to the same dialogue history. Furthermore, the discriminator, since it is calibrated, is used during inference to rank the generated responses, providing a means of controlling the generator output.
+
+# 2.1 OBJECTIVES
+
+The objective of a conditional GAN can be expressed as
+
+$$
+\begin{array} { r l } { \mathcal { L } _ { c G A N } ( G , D ) } & { = \ \mathbb { E } _ { X _ { i } , X _ { i + 1 } } [ \log \ D ( X _ { i + 1 } , X _ { i } ) ] + \mathbb { E } _ { X _ { i } , Z _ { i } } [ 1 - \log D ( G ( X _ { i } , Z _ { i } ) , X _ { i } ) ] } \end{array}
+$$
+
+where $G$ tries to minimize this objective against an adversarial $D$ that tries to maximize it:
+
+$$
+G ^ { * } , D ^ { * } = a r g m i n m a x \mathcal { L } _ { c G A N } ( G , D ) .
+$$
+
+Previous approaches have shown that it is beneficial to mix the GAN objective with a more traditional loss such as cross-entropy loss (Lamb et al., 2016; Li et al., 2017). The discriminator’s job remains unchanged, but the generator is tasked not only to fool the discriminator but also to be near the ground truth $X _ { i + 1 }$ in the cross-entropy sense:
+
+$$
+\mathcal { L } _ { M L E } ( G ) = \mathbb { E } _ { X _ { i } , X _ { i + 1 } , Z _ { i } } [ - l o g ~ P _ { \theta _ { G } } \left( X _ { i + 1 } , X _ { i } , Z _ { i } \right) ] .
+$$
+
+Our final objective is,
+
+$$
+G ^ { * } , D ^ { * } = a r g m i n m a x \left( \lambda _ { G } \mathcal { L } _ { c G A N } ( G , D ) + \lambda _ { M } \mathcal { L } _ { M L E } ( G ) \right) .
+$$
+
+![](images/852da0ca9237240374ebfc9d038dc21e91c90ceba20f242e189d501a14252f14.jpg)  
+Figure 1: Left: The hredGAN architecture - The generator makes predictions conditioned on the dialogue history, $\boldsymbol { h } _ { i }$ , attention, $A _ { i } ^ { j }$ , noise sample, $Z _ { i } ^ { j }$ , and ground truth, $X _ { i + 1 } ^ { j - 1 }$ . Right: RNN-based discriminator that discriminates bidirectionally at the word level.
+
+It is worth mentioning that, without $Z _ { i }$ , the net could still learn a mapping from $X _ { i }$ to $Y _ { i }$ , but would produce deterministic outputs and fail to match any distribution other than a delta function (Isola et al., 2017). This is one key area where our work is different from Lamb et al.’s and Li et al.’s. The schematic of the proposed hredGAN is depicted at the right hand side of Figure 1.
+
+# 2.2 GENERATOR
+
+We adopted an HRED dialogue generator similar to (Serban et al., 2016; 2017a;b; Xing et al., 2017). The HRED contains three recurrent structures, i.e. the encoder $( e R N N )$ , context $( c R N N )$ , and decoder $( d R N N )$ RNN. The conditional probability modeled by the HRED per output word token is given by
+
+$$
+P _ { \theta _ { G } } \left( Y _ { i } ^ { j } | X _ { i + 1 } ^ { 1 : j - 1 } , \pmb { X } _ { i } \right) = d R N N \left( E ( X _ { i + 1 } ^ { j - 1 } ) , h _ { i } ^ { j - 1 } , { h _ { i } } \right)
+$$
+
+where $E ( . )$ is the embedding lookup, $h _ { i } \ = \ c R N N ( e R N N ( E ( X _ { i } ) , h _ { i - 1 } )$ , $e R N N ( . )$ maps a sequence of input symbols into fixed-length vector, and $h$ and $^ { h }$ are the hidden states of the decoder and context RNN, respectively.
+
+In the multi-resolution HRED, (Serban et al., 2017a), high-level tokens are extracted and processed by another RNN to improve performance. We circumvent the need for this extra processing by allowing the decoder to attend to different parts of the input utterance during response generation (Bahdanau et al., 2015; Luong et al., 2015). We introduce a local attention into equation 9 and encode the attention memory differently from the context through an attention encoder RNN $( a R N N )$ , yielding:
+
+$$
+P _ { \theta _ { G } } \left( Y _ { i } ^ { j } | X _ { i + 1 } ^ { 1 : j - 1 } , X _ { i } \right) = d R N N \big ( E ( X _ { i + 1 } ^ { j - 1 } ) , h _ { i } ^ { j - 1 } , A _ { i } ^ { j } , h _ { i } \big )
+$$
+
+where $\begin{array} { r } { A _ { i } ^ { j } = \sum _ { m = 1 } ^ { M _ { i } } \frac { e x p ( \alpha _ { m } ) } { \sum _ { m = 1 } ^ { M _ { i } } e x p ( \alpha _ { m } ) } h _ { i } ^ { ' m } } \end{array}$ h 0 m , $h _ { i } ^ { ' m } = a R N N ( E ( X _ { i } ^ { m } ) , h _ { i } ^ { ' m - 1 } ) , h ^ { ' }$ is the hidden state of the attention RNN and $\alpha _ { k }$ is either a logit projection of $( h _ { i } ^ { j - 1 } , h _ { i } ^ { ' m } )$ in the case of Bahdanau et al. (2015) or $( h _ { i } ^ { j - 1 } ) ^ { T } \cdot h _ { i } ^ { ' m }$ in the case of Luong et al. (2015). The modified HRED architecture is shown in Figure 2.
+
+Noise Injection: We inject Gaussian noise at the input of the decoder RNN. Noise samples could be injected at the utterance or word level. With noise injection, the conditional probability of the decoder output becomes
+
+$$
+P _ { \theta _ { G } } \left( Y _ { i } ^ { j } | X _ { i + 1 } ^ { 1 : j - 1 } , Z _ { i } ^ { j } , \boldsymbol { X } _ { i } \right) = d R N N \left( E ( X _ { i + 1 } ^ { j - 1 } ) , h _ { i } ^ { j - 1 } , A _ { i } ^ { j } , Z _ { i } ^ { j } , h _ { i } \right)
+$$
+
+where $Z _ { i } ^ { j } \sim \mathcal { N } _ { i } ( 0 , I )$ , for utterance-level noise and $Z _ { i } ^ { j } \sim \mathcal { N } _ { i } ^ { j } ( 0 , I )$ , for word-level noise.
+
+# 2.3 DISCRIMINATOR
+
+The discriminator shares context and word embedding with the generator and can discriminate at the word level (Lamb et al., 2016). The word-level discrimination is achieved through a bidirectional RNN and is able to capture both syntactic and conceptual differences between the generator output
+
+![](images/0da47b8b0a595d5ad9dff357a0ff6a87f0afab17a3d46c003f6518c7b53b3ae4.jpg)  
+Figure 2: The HRED generator with local attention - The attention RNN ensures local relevance while the context RNN ensures global relevance. Their states are combined to initialize the decoder RNN and the discriminator BiRNN.
+
+and the ground truth. The aggregate classification of an input sequence, $\chi$ can be factored over word-level discrimination and expressed as
+
+$$
+D ( X _ { i } , \chi ) = D ( h _ { i } , \chi ) = \bigg [ \prod _ { j = 1 } ^ { J } D _ { R N N } ( h _ { i } , E ( \chi ^ { j } ) ) \bigg ] ^ { \frac { 1 } { J } }
+$$
+
+where $D _ { R N N } ( . )$ is the word discriminator RNN, $\boldsymbol { h } _ { i }$ is an encoded vector of the dialogue history $X _ { i }$ obtained from the generator’s $c R N N ( . )$ output, and $\chi ^ { j }$ is the jth word or token of the input sequence $\chi$ . $\chi = Y _ { i }$ and $J = T _ { i }$ for the case of generator’s decoder output, $\chi = X _ { i + 1 }$ and $J = M _ { i + 1 }$ for the case of ground truth. The discriminator architecture is depicted on the left hand side of Figure 1.
+
+2.4 ADVERSARIAL GENERATION OF MULTI-TURN DIALOGUE RESPONSE
+
+In this section, we describe the generation process during inference. The generation objective can be mathematically described as
+
+$$
+Y _ { i } ^ { * } = a r g m a x \left\{ P ( Y _ { i , l } | X _ { i } ) + D ^ { * } ( X _ { i } , Y _ { i , l } ) \right\} _ { l = 1 } ^ { L }
+$$
+
+where $Y _ { i , l } = G ^ { * } ( X _ { i } , Z _ { i , l } )$ , $Z _ { i , l }$ is the lth noise samples at dialogue step $i$ , and $L$ is the number of response samples. Equation 13 shows that our inference objective is the same as the training objective (8), combining both the MLE and adversarial criteria. This is in contrast to existing work where the discriminator is usually discarded during inference.
+
+The inference described by equation 13 is intractable due to the enormous search space of $Y _ { i , l }$ . Therefore, we turn to an approximate solution where we use greedy decoding (MLE) on the first part of the objective function to generate $L$ lists of responses based on noise samples $\{ Z _ { i , l } \} _ { l = 1 } ^ { L }$ . In order to facilitate the exploration of the generator’s latent space, we sample a modified noise distribution, $Z _ { i , l } ^ { j } \sim \mathcal { N } _ { i , l } ( 0 , \alpha I )$ , or $Z _ { i , l } ^ { j } \sim \mathcal { N } _ { i , l } ^ { j } ( 0 , \alpha I )$ where $\alpha > 1 . 0$ , is the exploration factor that increases the noise variance. We then rank the $L$ lists using the discriminator score, $\left\{ D _ { . } ^ { * } ( X _ { i } , Y _ { i , l } ) \right\} _ { l = 1 } ^ { L } .$ . The response with the highest discriminator ranking is the optimum response for the dialogue context.
+
+# 3 TRAINING OF HREDGAN
+
+We trained both the generator and the discriminator simultaneously as highlighted in Algorithm 1 with $\lambda _ { G } = \lambda _ { M } = 1$ . GAN training is prone to instability due to competition between the generator and the discriminator. Therefore, parameter updates are conditioned on the discriminator performance (Lamb et al., 2016).
+
+The generator consists of four RNNs with different parameters, that is, $a R N N , e R N N , c R N N$ and dRNN. aRNN and eRNN are both bidirectional, while $c R N N$ and dRNN are unidirec
+
+# Algorithm 1 Adversarial Learning of hredGAN
+
+Require: A generator $G$ with parameters $\theta _ { G }$ .   
+Require: A discriminator $D$ with parameters $\theta _ { D }$ . for number of training iterations do Initialize $c R N N$ to zero state, $\scriptstyle h _ { 0 }$ 0Sample a mini-batch of conversations, $\pmb { X } = \{ X _ { i } \} _ { i = 1 } ^ { N }$ , $\pmb { X _ { i } } = \left( X _ { 1 } , X _ { 2 } , \cdot \cdot \cdot , X _ { i } \right)$ with $N$ utterances. Each utterance mini batch $_ i$ contains $M _ { i }$ word tokens. for $i = 1$ to $N - 1$ do Update the context state. $\begin{array} { r } { \dot { \pmb { h _ { i } } } = c R N N ( e R N N ( E ( X _ { i } ) ) , \pmb { h _ { i - 1 } } ) } \end{array}$ $P _ { \theta _ { G } } \left( Y _ { i } | , Z _ { i } , \boldsymbol { X } _ { i } \right) = \left\{ P _ { \theta _ { G } } \left( Y _ { i } ^ { j } | \boldsymbol { X } _ { i + 1 } ^ { 1 : j - 1 } , Z _ { i } ^ { j } , \boldsymbol { X } _ { i } \right) \right\} _ { j = 1 } ^ { M _ { i + 1 } }$ $Y _ { i }$ $Y _ { i } \stackrel { \cdot } { \sim } P _ { \theta _ { G } } ( Y _ { i } | , Z _ { i } , \stackrel { \cdot } { X } _ { i } )$ end forCompute the discriminator accuracy $D _ { a c c }$ over $N - 1$ utterances $\{ Y _ { i } \} _ { i = 1 } ^ { N - 1 }$ 1 nd {Xi+1}N−1i=1 a Update $\theta _ { D }$ with gradient of the discriminator loss. $\underset { i } { \overset { \cdot } { \sum } } [ \nabla _ { \theta _ { D } } \log \bar { D ( } h _ { i } , X _ { i + 1 } ) + \nabla _ { \theta _ { D } } l o g \big ( 1 - D ( h _ { i } , Y _ { i } ) \big ) ]$ end if if $D _ { a c c } < a c c _ { G _ { t h } }$ Update $\begin{array} { r } { { \prec } \ { a c c } _ { G _ { t } } } \\ { \ \mathrm { e } \ \theta _ { G } \ \mathrm { w i t } } \end{array}$ with the generator’s MLE loss only. then $\underset { i } { \mathop { \sum } } [ \nabla _ { \theta _ { G } } \log P _ { \theta _ { G } } ( Y _ { i } | , Z _ { i } , \mathbf { X } _ { i } ) ]$ else Update $\theta _ { G }$ with both adversarial and MLE losses. $\sum _ { i } [ \lambda _ { G } \nabla _ { \theta _ { G } }$ log $D ( h _ { i } , Y _ { i } ) + \lambda _ { M } \nabla _ { \theta _ { G } }$ l $\arg P _ { \theta _ { G } } ( Y _ { i } | , Z _ { i } , X _ { i } ) ]$ end if end for
+
+tional. Each RNN has 3 layers, and the hidden state size is 512. The dRNN and $a R N N$ are connected using an additive attention mechanism (Bahdanau et al., 2015).
+
+The discriminator shares $a R N N , e R N N$ , and $c R N N$ with the generator. $D _ { R N N }$ , is a stacked bidirectional RNN with 3 layers and a hidden state size of 512. The $c R N N$ states are used to initialize the states of $D _ { R N N }$ . The output of both the forward and the backward cells for each word are concatenated and passed to a fully-connected layer with binary output. The output is the probability that the word is from the ground truth given the past and future words of the sequence.
+
+Others: All RNNs used are gated recurrent unit (GRU) cells (Cho et al., 2014). The word embedding size is 512 and shared between the generator and the discriminator. The initial learning rate is 0.5 with decay rate factor of 0.99, applied when the adversarial loss has increased over two iterations. We use a batch size of 64 and clip gradients around 5.0. As in Lamb et al. (2016), we find $a c c _ { D _ { t h } } = 0 . 9 9$ and $a c c _ { G _ { t h } } = 0 . 7 5$ to be good enough. All parameters are initialized with Xavier uniform random initialization (Glorot & Bengio, 2010). The vocabulary size $V$ is 50, 000. Due to the large vocabulary size, we use sampled softmax loss (Jean et al., 2015) for MLE loss to expedite the training process. However, we use full softmax for evaluation. The model is trained end-to-end using the stochastic gradient descent algorithm.
+
+# 4 EXPERIMENTS AND RESULTS
+
+We consider the task of generating dialogue responses conditioned on the dialogue history and the current input utterance. We compare the proposed hredGAN model against some alternatives on publicly available datasets.
+
+# 4.1 DATASETS
+
+Movie Triples Corpus, (MTC) dataset (Serban et al., 2016). This dataset was derived from the Movie-DiC dataset by Banchs (2012). Although this dataset spans a wide range of topics with few spelling mistakes, its small size of only about 240,000 dialogue triples makes it difficult to train a dialogue model, as pointed out by Serban et al. (2016). We thought that this scenario would really benefit from the proposed adversarial generation.
+
+Ubuntu Dialogue Corpus, (UDC) dataset (Serban et al., 2017b). This dataset was extracted from the Ubuntu Relay Chat Channel. Although the topics in the dataset are not as diverse as in the MTC, the dataset is very large, containing about 1.85 million conversations with an average of 5 utterances per conversation.
+
+We split both MTC and UDC into training, validation, and test sets, using $90 \%$ , $5 \%$ , and $5 \%$ proportions, respectively. We performed minimal preprocessing of the datasets by replacing all words except the top 50,000 most frequent words by an UNK symbol.
+
+# 4.2 EVALUATION METRICS
+
+Accurate evaluation of dialogue models is still an open challenge. In this paper, we employ both automatic and human evaluations.
+
+# 4.2.1 AUTOMATIC EVALUATION
+
+We employed some of the automatic evaluation metrics that are used in probabilistic language and dialogue models, and statistical machine translation. Although these metrics may not correlate well with human judgment of dialogue responses (Liu et al., 2016), they provide a good baseline for comparing dialogue model performance.
+
+Perplexity - For a model with parameter $\theta$ , we define perplexity as:
+
+$$
+e x p \bigg [ - \frac { 1 } { N _ { W } } \sum _ { k = 1 } ^ { K } l o g P _ { \theta } ( Y _ { 1 } , Y _ { 2 } , \ldots , Y _ { N _ { k } - 1 } ) \bigg ]
+$$
+
+where $K$ is the number of conversations in the dataset, $N _ { k }$ is the number of utterances in conversation $k$ , and $N _ { W }$ is the total number of word tokens in the entire dataset. The lower the perplexity, the better. The perplexity measures the likelihood of generating the ground truth given the model parameters. While a generative model can generate a diversity of responses, it should still assign a high probability to the ground truth utterance.
+
+BLEU - The BLEU score, (Papineni et al., 2002) provides a measure of overlap between the generated response (candidate) and the ground truth (reference) using a modified n-gram precision. According to Liu et. al. (Liu et al., 2016), BLEU-2 score is fairly correlated with human judgment for non-technical dialogue (such as MTC).
+
+ROUGE - The ROUGE score, (Lin, 2014) is similar to BLEU but it is recall oriented instead. It is used for automatic evaluation of text summarization and machine translation. To compliment the BLEU score, we use ROUGE-N with $N = 2$ for our evaluation.
+
+Distinct n-gram - This is the fraction of unique n-grams in the generated responses. It provides a measure of diversity. Models with higher number of distinct n-grams tend to produce more diverse responses (Li et al., 2016a). For our evaluation, we use 1- and 2- grams.
+
+Normalized Average Sequence Length (NASL) - This measures the average number of words in model generated responses normalized by the average number of words in the groundtruth.
+
+# 4.2.2 HUMAN EVALUATION
+
+For human evaluation, we follow a similar setup as Li et al. (2016a), employing crowd-sourced judges to evaluate a random selection of 200 samples. We present both the multi-turn context and the generated responses from the models to 3 judges and asked them to rank the general response quality in terms of relevance and informativeness. For $N$ models, the model with the lowest quality is assigned a score 0 and the highest is assigned a score N-1. Ties are not allowed. The scores are normalized between 0 and 1 and averaged over the total number of samples and judges.
+
+# 4.3 BASELINE
+
+We compare the performance of our model to (V)HRED (Serban et al., 2016; 2017b), since they are the closest to our approach in implementation and are the current state of the art in open-domain dialogue models. HRED is very similar to our proposed generator, but without the input utterance attention and noise samples. VHRED introduces a latent variable to the HRED between the $c R N N$ and the dRNN and was trained using the variational lower bound on the log-likelihood.
+
+Table 1: Generator Performance Evaluation   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Teacher Forcing</td><td colspan="4">Autoregression</td><td rowspan="2">Human Evaluation</td></tr><tr><td>Perplexity</td><td>-logD(G(.))</td><td>BLEU-2</td><td>ROUGE-2</td><td>DISTINCT-1/2</td><td>NASL1</td></tr><tr><td>MTC</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>HRED</td><td>31.92/36.00</td><td>NA</td><td>0.0474</td><td>0.0384</td><td>0.0026/0.0056</td><td>0.535</td><td>0.2560</td></tr><tr><td>VHRED</td><td>42.61/44.97</td><td>NA</td><td>0.0606</td><td>0.1181</td><td>0.0048/0.0163</td><td>0.831</td><td>0.3909</td></tr><tr><td>hredGAN_u</td><td>23.57/23.54</td><td>23.57/23.54</td><td>0.0493</td><td>0.2416</td><td>0.0167/0.1306</td><td>0.884</td><td>0.5582</td></tr><tr><td>hredGAN_w</td><td>24.20/24.14</td><td>13.35/13.40</td><td>0.0613</td><td>0.3244</td><td>0.0179/0.1720</td><td>1.540</td><td>0.7869</td></tr><tr><td>UDC</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>HRED</td><td>69.39/86.40</td><td>NA</td><td>0.0177</td><td>0.0483</td><td>0.0203/0.0466</td><td>0.892</td><td>0.3475</td></tr><tr><td>VHRED</td><td>98.50/105.20</td><td>NA</td><td>0.0171</td><td>0.0855</td><td>0.0297/0.0890</td><td>0.873</td><td>0.4046</td></tr><tr><td>hredGAN_u</td><td>56.82/57.32</td><td>10.09/10.08</td><td>0.0137</td><td>0.0716</td><td>0.0260/0.0847</td><td>1.379</td><td>0.6133</td></tr><tr><td>hredGAN_w</td><td>47.73/48.18</td><td>8.37/8.36</td><td>0.0216</td><td>0.1168</td><td>0.0516/0.1821</td><td>1.098</td><td>0.6905</td></tr></table>
+
+The VHRED can generate multiple responses per context like hredGAN, but has no specific criteria for selecting the best response.
+
+The HRED and VHRED models are both trained using the Theano-based implementation obtained from https://github.com/julianser/hed-dlg-truncated. The training and validation sets used for UDC and MTC dataset were obtained directly from the authors1 of (V)HRED. For model comparison, we use a test set that is disjoint from the training and validation sets.
+
+# 4.4 RESULTS
+
+We have two variants of hredGAN based on the noise injection approach, i.e., hredGAN with utterance-level (hredGAN u) and word-level (hredGAN w) noise injections.
+
+We compare the performance of these two variants with HRED and VHRED models.
+
+Perplexity: The average perplexity per word performance of all the four models on MTC and UDC datasets (validation/test) are reported in the first column on Table 1. The table indicates that both variants of the hredGAN model perform better than the HRED and VHRED models in terms of the perplexity measure. However, using the adversarial loss criterion (Eq. equation 8), the hredGAN u model performs better on MTC and worse on UDC. Note that, for this experiment, we run all models in teacher forcing mode.
+
+Generation Hyperparameter: For adversarial generation, we perform a linear search for $\alpha$ between 1 and 20 at an increment of 1 using Eq. equation 13, with sample size $L = 6 4$ , on validation sets with models run in autoregression. The optimum values of $\alpha$ for hredGAN u and hredGAN w for UDC are 7.0 and 9.0 respectively. The values for MTC are not convex, probably due to small size of the dataset, so we use the same $\alpha$ values as UDC. We however note that for both datasets, any integer value between 3 and 10 (inclusive) works well in practice.
+
+Quantitative Generator Performance: We run autoregressive inference for all the models (using optimum $\alpha$ values for hredGAN models and selecting the best of $L = 6 4$ responses using a discriminator) with dialogue contexts from a unique test set. Also, we compute the average BLEU-2, ROUGE-2(f1), Distinct(1/2) and normalized average sequence length (NASL) scores for each model and summarize the results in the middle of Table 1. Distinct(1/2) largely agrees with the perplexity score. Most scores, similar to the perplexity, indicate that hredGAN models perform better than (V)HRED on both datasets. However, on the UDC and MTC, ROUGE and BLUE, respectively scores VHRED slightly better than hredGAN u but still worse than hredGAN w.
+
+A good dialogue model should find the right balance between precision (BLEU) and diversity. We strongly believe that our adversarial approach is better suited to solving this problem. As hredGAN generators explore diversity, the discriminator ranking gives hredGAN an edge over (V)HRED because it helps detect responses that are out of context and the natural language structure (Table 2). Also, the ROGUE(f1) performance indicates that hredGAN w strikes a better balance between precision (BLEU) and diversity than the rest of the models. This is also obvious from the quality of generated responses.
+
+Table 2: Example of Discriminator Ranking with hredGAN w   
+
+<table><tr><td>Item</td><td>D(G(.))</td><td>Utterance</td></tr><tr><td colspan="3">MTC</td></tr><tr><td>Context_0</td><td>NA</td><td>perhaps &lt;person&gt; had a word with the man upstairs.</td></tr><tr><td>Context_1</td><td>NA</td><td>a word ?i’m sure by now he’s engineered a hostile takeover .</td></tr><tr><td>Response_0 0.996</td><td></td><td>&lt;person&gt;,i know what you’re saying， &lt;person&gt;,that’s not whati’m saying.</td></tr><tr><td>Response-1 0.991</td><td></td><td>&lt;person&gt;,i know .i was just about to help</td></tr><tr><td>Response_2 0.315</td><td></td><td>the guy. &lt;person&gt;,i&#x27;m sorry.</td></tr><tr><td>Response_3</td><td>0.203</td><td>&lt;person&gt;,i’ma litle out .</td></tr><tr><td>Context_0</td><td>NA</td><td>says he wanted food.&lt;person&gt;.he wanted the gold .</td></tr><tr><td>Context_1</td><td>NA</td><td>how’s he going to want the gold ? he couldn &#x27; t even know we had it.</td></tr><tr><td>Response_0 0.998</td><td></td><td>&lt;person&gt;,i know .but it’s not him,it’s the only way he’s got it all figured</td></tr><tr><td>Response_1 0.981</td><td></td><td>&lt;person&gt;,i know．but i have to tell you . these things are really stupid and you think i</td></tr><tr><td>Response_2 0.690</td><td></td><td>was wrong ? &lt;person&gt;,i&#x27;m sure he did.</td></tr><tr><td>Response-3 0.314</td><td></td><td>&lt;person&gt;,i&#x27;m not sure</td></tr><tr><td colspan="3">UDC</td></tr><tr><td>Context_0</td><td>NA</td><td>The netboot one is suppose to download pack-</td></tr><tr><td>Context_1</td><td>NA</td><td>ages from the net. like the ones to be installed? or the installed to be run?</td></tr><tr><td>Response_O 0.993</td><td></td><td>you don ’t need to install the whole system , just install the ubuntu installer</td></tr><tr><td>Response-1 0.952</td><td></td><td>you can install the ubuntu installer from the</td></tr><tr><td>Response_2 0.749</td><td></td><td>ubuntu menu I&#x27;m not sure ,I don ’t know .</td></tr><tr><td>Response_3</td><td>0.184</td><td>you can</td></tr><tr><td>Response_4</td><td>0.003</td><td>youa. 1.</td></tr><tr><td>Context_0</td><td>NA</td><td>DJones: update manager won&#x27;t detect 12.04.1 as a new version if you are already running 12.04, because 12.04.1 = 12.04 + lots of pack-</td></tr><tr><td>Response_0 0.991</td><td></td><td>age updates did you try a clean install of the latest version ?</td></tr><tr><td>Response_1 0.981</td><td></td><td>try installing the latest_UNK and see if it works</td></tr><tr><td>Response_2 0.615</td><td></td><td>I’m not sure you have a problem..</td></tr><tr><td>Response_3 0.191</td><td></td><td>try sudo apt-get remove the package that is not</td></tr><tr><td>Response_4 0.002</td><td></td><td>installed try the-UNK.1.1.1.1.1.-UNK.deb</td></tr></table>
+
+Table 3: Sample responses of HRED, VHRED and hredGAN.   
+
+<table><tr><td>Movie</td><td></td></tr><tr><td>Context_0 HRED VHRED</td><td>perhaps &lt;person&gt; had a word with the man upstairs . i&#x27;m sorry,&lt;person&gt;. &lt;person&lt;&#x27;tdo it. hredGAN_w&lt;person&gt;,i’m not gon na be okay.i just don ’t think it’s a</td></tr><tr><td>Context_1 HRED VHRED</td><td>good idea. hredGAN.u &lt;person&gt;,icause it was allthe way to you. a word ?i&#x27;m sure by now he’s engineered a hostile takeover . i&#x27;m sorry,&lt;person&gt;. &lt;person&gt;&#x27;tdo it.</td></tr><tr><td></td><td>hredGAN_w&lt;person&gt;,i know what you ’re saying，&lt;person&gt;,that’s not whati’m saying. hredGAN_u &lt;person&gt;,i have to tell youi’m not the same.</td></tr><tr><td>Context_0 HRED VHRED</td><td>&lt;person&gt;’s. i&#x27;m sorry,&lt;person&gt;.</td></tr><tr><td></td><td>&lt;person&gt;&#x27;tdo it . hredGAN_w &lt;person&gt;,i’m sure it’s the only thing i ever imagined .</td></tr><tr><td></td><td></td></tr><tr><td></td><td>hredGAN_u &lt;person&gt;,i&#x27;l be right there .</td></tr><tr><td></td><td></td></tr><tr><td>Context_1</td><td></td></tr><tr><td></td><td>can i ask you something about her ?</td></tr><tr><td>HRED</td><td>idon&#x27;tknow .</td></tr><tr><td>VHRED:</td><td>you’re not going to be here .</td></tr><tr><td></td><td>hredGAN_widon’tknow.i thinki’ve heard of it.</td></tr><tr><td></td><td>hredGAN-ui’m sorry,ican &#x27;t.</td></tr><tr><td>Ubuntu</td><td></td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>this is Dacs i am in i used &#x27;sudo statx and it let me in</td></tr><tr><td>HRED</td><td>what&#x27;s the problem ?</td></tr><tr><td>VHRED</td><td>I don&#x27;t know what you want to do .if you want to do it,you need to</td></tr><tr><td></td><td>do it to do it in the terminal ?</td></tr><tr><td></td><td>hredGAN-w you don’t have to do anything，just type in the terminal and it</td></tr><tr><td></td><td>should be to find the right device</td></tr><tr><td></td><td>hredGAN_u you can have a look at the output of the command .</td></tr><tr><td>Context.1</td><td>good deal... cat /etc/X11/default-display-manager</td></tr><tr><td>HRED</td><td>what&#x27;s the problem ?</td></tr><tr><td>VHRED</td><td>do you know what you want to do ?</td></tr><tr><td></td><td>hredGAN_w I’m trying to figure a command that I can find to find out the file</td></tr><tr><td></td><td>that Ican find in the file&quot;</td></tr><tr><td></td><td>hredGAN-u Idon &#x27;t see the point,but I’m not sure how to do that .</td></tr><tr><td>Context_2</td><td>/usr/sbin/lightdmhttp://paste.ubuntu.com/1286224/</td></tr><tr><td></td><td>/etc/X1/xorg.conf</td></tr><tr><td>HRED</td><td>what &#x27;s the problem ?</td></tr><tr><td>VHRED</td><td></td></tr><tr><td></td><td>is there a way to do that in the terminal ?</td></tr><tr><td></td><td>hredGAN_w did you just type\”sudo mount -a\”?</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td>hredGAN-u i have no idea,i just installed ubuntu and i have no idea how to do</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td>that</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr></table>
+
+Qualitative Generator Performance: The results of the human evaluation is reported in the last column of Table 1. The human evaluation agrees largely with the automatic evaluation. The hredGAN w performs best on both datasets although the gap is more on the MTC than on the UTC. This implies that the improvement of HRED with adversarial generation is better than with variational generation (VHRED). In addition, looking at the actual samples from the generator outputs in Table 6 shows that hredGAN especially hredGAN w performs better than (V)HRED. While other models produce short and generic utterances, hredGAN w mostly yields informative responses. For example, in the first dialogue in Table 6, when the speaker is sarcastic about ”the man upstairs”, hredGAN w responds with the most coherent utterance with respect to the dialogue history. We see similar behavior across other samples. We also note that although hredGAN u’s responses are the longest on Ubuntu (in line with the NASL score), the responses are less informative compared to hredGAN w resulting into a lower human evaluation score. We reckon this might be due to a mismatch between utterance-level noise and word-level discrimination or lack of capacity to capture the data distribution using single noise distribution. We hope to investigate this further in the future.
+
+Discriminator Performance: Although only hredGAN uses a discriminator, the observed discriminator behavior is interesting. We observe that the discriminator score is generally reasonable with longer, more informative and more persona-related responses receiving higher scores as shown in Table 2. It worth to note that this behavior, although similar to the behavior of a human judge is learned without supervision. Moreover, the discriminator seems to have learned to assign average score to more frequent or generic responses such as “I don’t know”, “I’m not sure” and so on, and high score to rearer answers. That’s why we sample a modified noise distribution during inference so that the generator can produce rearer utterances that will be scored high by the discriminator.
+
+# 5 CONCLUSION AND FUTURE WORK
+
+In this paper, we have introduced an adversarial learning approach that addresses response diversity and control of generator outputs, using an HRED-derived generator and discriminator. The proposed system outperforms existing state-of-the-art (V)HRED models for generating responses in multiturn dialogue with respect to automatic and human evaluations. The superiority of the adversarial generation (hredGAN) over the variational generation (VHRED) is in line with other generative models employing these approaches. Our analysis also concludes that the word-level noise injection seems to perform better in general.
+
+While this is a good starting point, we recognize the need to explore further improvements to the proposed adversarial framework: In the future, we hope to: explore which noise level works with which discrimination level; consider a multi-resolution discriminator with combined word- and utterancelevel discriminations; and explore further tuning of the generator and discriminator models.
+
+# REFERENCES
+
+D. Bahdanau, K. Cho, and Y. Bengio. Neural machine translation by jointly learning to align and translate. In Proceedings of International Conference of Learning Representation (ICLR 2015), 2015.   
+R. E. Banchs. Movie-dic: A movie dialogue corpus for research and development. In Proceedings of the 50th Annual Meeting of the Association for Computational Linguistics, pp. 203–207, 2012.   
+E. Bruni and R. Fernndez. Adversarial evaluation for open-domain dialogue generation. In Proceedings of the 18th Annual SIGdial Meeting, 2018.   
+T. Che, Y. Li, R. Zhang, R. D. Hjelm, W. Li, Y. Song, and Y. Bengio. Maximum-likelihood augmented discrete generative adversarial networks. In arXiv preprint arXiv:1702.07983, 2017.   
+K. Cho, B. Merrienboer, C. Gulcehre, D. Bahdanau, F. Bougares, H. Schwenk, and Y. Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. In Proceedings of International Conference of Learning Representation (ICLR 2015), pp. 1724– 1734, 2014.   
+X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In International conference on artificial intelligence and statistics, 2010.   
+I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Proceedings of Advances in Neural Information Processing Systems (NIPS 2014), 2014.   
+P. Isola, J. Y. Zhu, T. Zhou, and A. A. Efros. Image-to-image translation with conditional adversarial networks. In Conference on Computer Vision and Pattern Recognition (CVPR, 2017), 2017.   
+S. Jean, K. Cho, R. Memisevic, and Y. Bengio. On using very large target vocabulary for neural machine translation. In arXiv preprint arXiv:1412.2007, 2015.   
+A. Kannan and O. Vinyals. Adversarial evaluation of dialogue models. In arXiv preprint arXiv:1701.08198v1, 2017.   
+A. Lamb, A. Goyah, Y. Zhang, S. Zhang, A. Courville, and Y. Bengio. Professor forcing: A new algorithm for training recurrent networks. In Proceedings of Advances in Neural Information Processing Systems (NIPS 2016), 2016.   
+J. Li, M. Galley, C. Brockett, J. Gao, and B. Dolan. A diversity-promoting objective function for neural conversation models. In Proceedings of NAACL-HLT, 2016a.   
+J. Li, W. Monroe, A. Ritter, M. Galley, J. Gao, and D. Jurafsky. Deep reinforcement learning for dialogue generation. In arXiv preprint arXiv:arXiv:arXiv:1606.01541v4, 2016b.   
+J. Li, W. Monroe, T. Shi, A. Ritter, and D. Jurafsky. Adversarial learning for neural dialogue generation. In arXiv preprint arXiv:1701.06547, 2017.   
+C. Y. Lin. Rouge: a package for automatic evaluation of summaries. In Proceedings of the Workshop on Text Summarization Branches Out, 2014.   
+C. Liu, R. Lowe, I. V. Serban, M. Noseworthy, L. Charlin, and J. Pineau. How not to evaluate your dialogue system: An empirical study of unsupervised evaluation metrics for dialogue response generation. In Proceedings of EMNLP, pp. 2122–2132, 2016.   
+M. T. Luong, I. Sutskever, Q. V. Le, O. Vinyals, and W. Zaremba. Addressing the rare word problem in neural machine translation. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics, 2015.   
+K. Papineni, S. Roukos, T. Ward, and W. Zhu. Bleu: A method for automatic evalution of machine translation. In Proceedings of the 40th Annual Meeting of the Association for Computational Linguistics, pp. 311–318, 2002.   
+I. Serban, A. Sordoni, Y. Bengio, A. Courville, and J. Pineau. Building end-to-end dialogue systems using generative hierarchical neural network models. In Proceedings of The Thirtieth AAAI Conference on Artificial Intelligence (AAAI 2016), pp. 3776–3784, 2016.   
+I. V. Serban, T. Klinger, G. Tesauro, K. Talamadupula, B. Zhou, Y. Bengio, and A. Courville. Multiresolution recurrent neural networks: An application to dialogue response generation. In Proceedings of The Thirty-first AAAI Conference on Artificial Intelligence (AAAI 2017), 2017a.   
+I. V. Serban, A. Sordoni, R. Lowe, L. Charlin, J. Pineau, A. Courville, and Y. Bengio. A hierarchical latent variable encoder-decoder model for generating dialogue. In Proceedings of The Thirty-first AAAI Conference on Artificial Intelligence (AAAI 2017), 2017b.   
+I. Sutskever, O. Vinyals, and Q. Le. Sequence to sequence learning with neural networks. In Proceedings of Advances in Neural Information Processing Systems (NIPS), pp. 3104–3112, 2014.   
+O. Vinyals and Q. Le. A neural conversational model. In Proceedings of ICML Deep Learning Workshop, 2015.   
+R. J. Williams and D. Zipser. A learning algorithm for continually running fully recurrent neural networks. Neural computation, 1(2):270–280, 1989.   
+C. Xing, W. Wu, Y. Wu, M. Zhou, Y. Huang, and W. Ma. Hierarchical recurrent attention network for response generation. In arXiv preprint arXiv:1701.07149, 2017.   
+Z. Xu, B. Liu, B. Wang, S. Chengjie, X. Wang, Z. Wang, and C. Qi. Neural response generation via gan with an approximate embedding layer. In EMNLP, 2017.   
+L. Yu, W. Zhang, J. Wang, and Y. Yu. Seqgan: sequence generative adversarial nets with policy gradient. In Proceedings of The Thirty-first AAAI Conference on Artificial Intelligence (AAAI 2017), 2017.   
+Y. Zhang, Z. Gan, K. Fan, Z. Chen, R. Henao, D. Shen, and L. Carin. Adversarial feature matching for text generation. In arXiv preprint arXiv:1706.03850, 2017.   
+Y. Zhang, M. Galley, J. Gao, Z. Gan, X. Li, C. Brockett, and B. Dolan. Generating informative and diverse conversational responses via adversarial information maximization. In arXiv preprint arXiv:arXiv:1809.05972v5, 2018.
+
+# APPENDIX
+
+# 6 RELATED WORK
+
+Our work is related to end-to-end neural network–based open domain dialogue models. Most neural dialogue models use transduction frameworks adapted from neural machine translations (Sutskever et al., 2014; Bahdanau et al., 2015). These $\mathtt { S e q 2 S e q }$ networks are trained end-to-end with MLE criteria using large corpora of human-to-human conversation data. Others use GAN’s discriminator as a reward function in a reinforcement learning framework (Yu et al., 2017) and in conjunction with MLE (Li et al., 2017; Che et al., 2017). Zhang et al. (2017) explored the idea of GAN with a feature matching criterion. Xu et al. (2017) and Zhang et al. (2018) employed GAN with an approximate embedding layer as well as with adversarial information maximization respectively to improve Seq2Seq’s diversity performance.
+
+Still, $\mathtt { S e q 2 S e q }$ models are limited in their ability to capture long temporal dependencies in multiturn conversation. Although, Li et al. (2016b) attempted to optimize a pair Seq2Seq models for multi-turn dialogue, the multi-turn objective is only applied at inference and not used for actual model training. Hence, the introduction of HRED models (Serban et al., 2016; 2017a;b; Xing et al., 2017) for modeling dialogue response in multi-turn conversations. However, these HRED models suffer from lack of diversity since they are trained with only MLE criteria. On other hand, adversarial system has been used for evaluating open domain dialogue models (Bruni & Fernndez, 2018; Kannan & Vinyals, 2017). Our work, hredGAN is closest to the combination of HRED generation models (Serban et al., 2016) and adversarial evaluation (Kannan & Vinyals, 2017).
+
+Table 4: Generator Performance: HRED vs. HRED $^ +$ Attn   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Teacher Forcing Perplexity</td><td colspan="4">Autoregression</td></tr><tr><td>BLEU-2</td><td>ROUGE-2</td><td>DISTINCT-1/2</td><td>NASL</td></tr><tr><td>MTC HRED</td><td>31.92/36.00</td><td></td><td></td><td></td><td></td></tr><tr><td>HRED+Attn</td><td>26.09/26.41</td><td>0.0474 0.0425</td><td>0.0384</td><td>0.0026/0.0056</td><td>0.535</td></tr><tr><td></td><td></td><td></td><td>0.2239</td><td>0.0397/0.1567</td><td>0.527</td></tr><tr><td>UDC</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>HRED</td><td>69.39/86.40</td><td>0.0177</td><td>0.0483</td><td>0.0203/0.0466</td><td>0.892</td></tr><tr><td>HRED+Attn</td><td>50.82/51.31</td><td>0.0140</td><td>0.0720</td><td>0.0473/0.1262</td><td>0.760</td></tr></table>
+
+# 7 ABLATION EXPERIMENTS
+
+Before proposing the above adversarial learning framework for multi-turn dialogue, we carried out some experiments that are highlighted here.
+
+# 7.1 GENERATOR:
+
+First, we noted that by adding an additional attention memory to the HRED generator, we improved the test set perplexity score by more than 8 and 20 points on the MTC and UDC respectively as shown in Table 4. The addition of attention also shows a strong performance at autoregressive inference across multiple metrics as well as observed improvement in response quality. Hence, the decision for the modified HRED generator.
+
+The adversarial training, however helps to address the lack diversity observed in the generated responses.
+
+# 7.2 DISCRIMINATOR:
+
+Before deciding on the word-level discrimination, we experimented with utterance-level discrimination. The utterance-level discriminator trains very quickly but it leads to mostly generic responses from the generator. We also note that utterance-level discriminator scores are mostly extreme (i.e.,
+
+either low or high). Since we had used convolutional neural network discriminator (Yu et al., 2017) in our experiments, we hope to investigate this further with other architectures.
+
+# 7.3 ADVERSARIAL TRAINING:
+
+Lastly, we also tried a basic policy gradient approach (Li et al., 2017), where word-level discriminator score is used as a reward for each generated word token, but this leads to training instability. This is probably due to the instability of Monte Carlo sampling over large vocabulary size. We believe this might improve with other sampling methods such as importance sampling and hope to investigate further in the future.
+
+# 8 OTHER GENERATED SAMPLES
+
+Table 5: Additional sample responses of HRED, VHRED and hredGAN on Movie.   
+
+<table><tr><td>Movie</td><td></td></tr><tr><td>Context.0 HRED</td><td>&lt;person&gt;i&#x27;ve raised my rate.imight even cut my sessions to forty minutes </td></tr><tr><td>VHRED</td><td>i’m sorry,&lt;person&gt;. &lt;person&gt;,&lt;person&gt;,&lt;person&gt;,&lt;person&gt;</td></tr><tr><td>hredGAN_w</td><td>&lt;person&gt;,i’m sorry,buti’m not sure if you’re really a very good guy</td></tr><tr><td>hredGAN-u</td><td>i&#x27; ll never see them again,&lt;person&gt;.</td></tr><tr><td></td><td>i&#x27;m going to handle this exactly the way your father would have handled this .i’ve got it solved .</td></tr><tr><td>Context_0 Context.1</td><td>you’ve got it solved ?where is she ？</td></tr><tr><td>HRED</td><td>idon&#x27;t know.</td></tr><tr><td>VHRED</td><td>&lt;person&gt;,,i’m sorry.</td></tr><tr><td>hredGAN_w</td><td>to the end of äabeautiful woman who willbe very happy.</td></tr><tr><td>hredGAN_u</td><td>i&#x27;m sorry,ijust didn ’t know-</td></tr><tr><td>Context_0</td><td>ofcoursenot！jperson’slikeadaughtertome.herfatheranditaughtatuniversitytogetheragoodman,butheneverlistened.</td></tr><tr><td>HRED</td><td>i&#x27;m sorry,&lt;person&gt;.</td></tr><tr><td>VHRED hredGAN-w</td><td>&lt;person&gt;,mr.&lt;person&gt;.</td></tr><tr><td>hredGAN-u</td><td>&lt;person&gt;,i know it’s beenallsix years sinceitold himabout you. i&#x27;m sure you didn’t,buti would have donealitle more.</td></tr><tr><td></td><td></td></tr><tr><td>Context_0 Context_1</td><td>ofcourse not！iperson’slikeadaughtertome.erfatheranditaughtatuniversitytogether.agoodman,buthe neverlistened.</td></tr><tr><td>HRED</td><td>neither did i. i&#x27;m sorry，,&lt;person&gt;.</td></tr><tr><td>VHRED</td><td>&lt;person&gt;,you&#x27;rea&lt;unk&gt;.</td></tr><tr><td>hredGAN-w</td><td>&lt;person&gt;,i know you’re think about it. think it&#x27;I be time,right ?</td></tr><tr><td>hredGAN-u</td><td>i&#x27;Ilbe thefirstone.ifitdidyou,you&#x27;lleit.</td></tr><tr><td>Context_0</td><td>come on,&lt;person&gt;,we could have a great week up in vermont .</td></tr><tr><td>Context.1</td><td>i see what you mean.but wednesday we’ve got to be back in new york .</td></tr><tr><td>HRED VHRED</td><td>&lt;person&gt;. &lt;person&gt;,idon&#x27;t know what you’re going to do.</td></tr><tr><td>hredGAN_w</td><td>&lt;person&gt;,iknow .i&#x27;m kind of busy here.</td></tr><tr><td>hredGAN_u</td><td>i&#x27;m sorry,ican &#x27;t.</td></tr><tr><td>Context_0</td><td>isabel ？</td></tr><tr><td>Context_1</td><td>hi.</td></tr><tr><td>HRED</td><td>that’s whati’m talking about .</td></tr><tr><td>VHRED:</td><td>you&#x27;re not going to be a&lt;unk&gt;,&lt;person&gt;.</td></tr><tr><td>hredGAN_w</td><td>&lt;person&gt;？</td></tr><tr><td>hredGAN_u</td><td>what do you want to know ?</td></tr><tr><td>Context.0</td><td>you understand mr.&lt;person&gt; is constantly barraged with nuisance litigation and irs audits </td></tr><tr><td>Context_1</td><td>of course .</td></tr><tr><td>HRED</td><td>that’s right,&lt;person&gt;.</td></tr><tr><td>VHRED:</td><td>&lt;person&gt;,you’re going to bea&lt;unk&gt;of the&lt;unk&gt;.</td></tr><tr><td>hredGAN_w</td><td>&lt;person&gt;,i’msure,but you’re probably stillin to the new&lt;person&gt;’s house,huh ?</td></tr><tr><td>hredGAN_u</td><td>you&#x27;re gon nabe alitle boy,andi’m not gon na get out ！</td></tr><tr><td>Context_0</td><td>&lt;person&gt;&#x27;t go into my room,she’s asleep.</td></tr><tr><td>Context_1</td><td>&lt;person&gt;,but the nanny,mrs.&lt;person&gt;,she wants to see her.</td></tr><tr><td>HRED</td><td>i&#x27;m sorry,&lt;person&gt;.</td></tr><tr><td>VHRED:</td><td>&lt;person&gt;,mr.&lt;person&gt;.</td></tr><tr><td>hredGAN_w</td><td>&lt;person&gt;,i know .but she’s never seen me anyway.</td></tr><tr><td>hredGAN-u</td><td>i&#x27;m sorry ididn&#x27;t know what to say .</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>what was that for ?</td></tr><tr><td>Context_1</td><td>i&#x27;d forgotten how exciting it is working together .</td></tr><tr><td>HRED</td><td>i&#x27;m sorry,&lt;person&gt;.</td></tr><tr><td>VHRED:</td><td>&lt;person&gt;,&lt;person&gt;.idon&#x27;tknow.</td></tr><tr><td>hredGAN_w</td><td>i&#x27;m sorry,&lt;person&gt;.so many people are so interested,but you’re a very nice guy .</td></tr><tr><td>hredGAN_u</td><td>i&#x27;ve always been so sure to&lt;person&gt;</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>a teacher’s.</td></tr><tr><td>Context_1</td><td>oh my god. i&#x27;m sorry,&lt;person&gt;</td></tr><tr><td>HRED VHRED:</td><td>&lt;person&gt;,&lt;person&gt;&#x27;t worry about it.idon’t know what you’re doing.</td></tr><tr><td>hredGAN_w</td><td>i&#x27;msorry.ididn’tmean to.ididn&#x27;t meanto hurt you.ijust wanted you</td></tr><tr><td>hredGAN-u</td><td>&lt;person&gt;,i don &#x27;t want to be your friend .</td></tr><tr><td></td><td></td></tr><tr><td>Context_0 HRED</td><td>this is all we have . &lt;person&gt;,i’m sorry.</td></tr><tr><td>VHRED:</td><td>&lt;person&gt;,idon&#x27;t know what you&#x27;re doing .idon&#x27;t know whati’m going to do.</td></tr><tr><td>hredGAN_w</td><td>i&#x27;m sorry,sir,buti’ma very good man.</td></tr><tr><td>hredGAN-u</td><td>but you’ve been in the apartment .</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>i took the initiative .</td></tr><tr><td>Context_1</td><td>you haven&#x27;tbeen given an assignment in this case.</td></tr><tr><td>HRED</td><td>&lt;person&gt;.</td></tr><tr><td>VHRED:</td><td></td></tr><tr><td></td><td>&lt;person&gt;,&lt;person&gt;,&lt;person&gt;,&lt;person&gt;.i’m not going to get out of the &lt;unk&gt;.</td></tr><tr><td>hredGAN_w</td><td>i&#x27;m not sure.&lt;continued_utterance&gt;i’m not gon na do you this shit anyway,&lt;person&gt;</td></tr><tr><td>hredGAN-u</td><td></td></tr><tr><td></td><td>&lt;person&gt;,i guess i didn &#x27;t.</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>&lt;person&gt;,i was just gon na leave and seeificould pick up their trail .</td></tr><tr><td></td><td></td></tr><tr><td>Context_1</td><td>no,you wait right there for me.&lt;person&gt; beon the piedmontfight tomorrow at seven.meet me at the airport.</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>HRED</td><td>i&#x27;m sorry，,&lt;person&gt;</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>VHRED:</td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>hredGAN_w</td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td>what do youthinki’msaying?idon’tknow whati’m going todo.idon’tknow whati’mgoing todo.</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>hredGAN-u</td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td>i&#x27;m not sure i don &#x27;t.&lt;continued_utterance&gt;do you want to go over to the station ? &lt;person&gt;,i don&#x27;tknowifi&#x27;m not.</td></tr><tr><td></td></table>
+
+Table 6: Additional sample responses of HRED, VHRED and hredGAN on Ubuntu.   
+
+<table><tr><td>Ubuntu</td><td></td></tr><tr><td>Context.0</td><td>what&#x27;s the command you are running to chroot and the error message you get in return?</td></tr><tr><td>Context.1</td><td>i mountded the device sudo mount/dev/sdal/mnt-that works-then sudo chroot/mnt-eroris no such file or command</td></tr><tr><td>HRED</td><td>what &#x27;s the problem ?</td></tr><tr><td>VHRED</td><td>is there a way to do that ? what do you mean ?</td></tr><tr><td>hredGAN_w</td><td>I have no idea,I just did a sudo fdisk and it said it was mounted</td></tr><tr><td>hredGAN_u</td><td>I&#x27;m trying to get the latest version of ubuntu,butI’m getting a lot of problems .</td></tr><tr><td>Context_0</td><td>Hmm,have you checked that ICMP is being allowedallthe way throughand thatthe serverresponds tootherICMPrequests?</td></tr><tr><td>Context_1</td><td>nowicanpingit(iadtenabletlocompressooncienticanoteachthmotesubetaddingaruleihefrewallfoardthelan</td></tr><tr><td></td><td>to vpn</td></tr><tr><td>HRED VHRED</td><td>what &#x27;s the problem ? I don&#x27;t know what you want to do</td></tr><tr><td>hredGAN_w</td><td>I have no idea,I’m just trying to get the ip address from the router to the router&quot;</td></tr><tr><td>hredGAN_u</td><td>I&#x27;m not sure if that’sthe case,butI’m not sure if it’sa good idea to have a look at the output .</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>The netboot one is suppose to download packages from the net.</td></tr><tr><td>HRED</td><td>I don&#x27;t know what you want to do .</td></tr><tr><td>VHRED</td><td>how do I do that ? I&#x27;m not sure of a command to do so Ican just install the ubuntu .iso and burn a new iso</td></tr><tr><td>hredGAN_w hredGAN_u</td><td>you can &#x27;t have a look at the man page ...</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>The netboot one is suppose to download packages from the net.</td></tr><tr><td>Context_1</td><td>like the ones to be installed? or the installed to be run?</td></tr><tr><td>HRED</td><td>I don&#x27;t know what the problem is .</td></tr><tr><td>VHRED</td><td>is there a way to install the package manager ?</td></tr><tr><td>hredGAN_w hredGAN_u</td><td>you don ’t need to install the whole system, just install the ubuntu installer I&#x27;m trying to installa -UNK version of ubuntu,butI&#x27;m trying to install it on my laptop</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>You trying to mount it open with the password?</td></tr><tr><td>HRED</td><td>Ihave to do that,butI have a problem with the same problem. is there a way to do ?</td></tr><tr><td>VHRED</td><td>yes,I&#x27;m not sure if it’s mounted or not</td></tr><tr><td>hredGAN_w</td><td>I&#x27;m trying to install the latest version of Ubuntu,butI&#x27;m running on a -UNK</td></tr><tr><td>hredGAN-u</td><td></td></tr><tr><td>Context_0</td><td>are you using lvm for your root partition?</td></tr><tr><td>HRED</td><td>yes,but I have a problem with a new user,butI don&#x27;t want to do that.</td></tr><tr><td>VHRED</td><td>what is the best way to do that ?what is that ?</td></tr><tr><td>hredGAN_w</td><td>yes,I&#x27;m on alive system,I’m trying to use the partition to boot from windows</td></tr><tr><td>hredGAN_u</td><td>I&#x27;m not sure if it’s a good idea to have a backup of the system..</td></tr><tr><td>Context.0</td><td>are you using lvm for your root partition?</td></tr><tr><td>Context_1</td><td>ihavethesameofgorkigoa04box.Itppearsin2.04lvisonustartandutipathisnotidouselforyootderifty is thereanywaytworkarounditaveyuhardofayonepostingaugabouthistohaveitookedtdar.welliopethycanfiis</td></tr><tr><td></td><td>eventuallyiopetheykeepitrdroundandmoveeverytingtoustartUpstartisoteasytosetupforprogamstatdon’tcomepackaged</td></tr><tr><td></td><td>for upstart. I don&#x27;t know what the problem is,but I don&#x27;t know what the problem is .?</td></tr><tr><td>HRED VHRED</td><td>is there a way to do that ?or **unknown** ？</td></tr><tr><td>hredGAN_w</td><td>you can also try the live cd and see if you can get it back up the live&quot;</td></tr><tr><td>hredGAN-u</td><td>I&#x27;mtryintotywirelessorkingomyapto,ut’mgeingtoheintatcaeabletousteirelescardtogethieless</td></tr><tr><td></td><td>working.</td></tr><tr><td>Context_0</td><td>are you using lvm for your root partition? ihavethesameofgorkingoa0.04box.Itppearsin2.04lisonupstartandultipathisot.idouselforyotfolderifty</td></tr><tr><td>Context.1</td><td>istheranyaytoworkaroundihaveyouhardofanyonepostingabugabouttis tohaveitokedatdar.welliopethyanfiis eventuallyiopetheyepiitrdoudandmoveeverytngtoupstartUpstartisoteasytosetupforprogamstatdon&#x27;tcoepackaged</td></tr><tr><td></td><td>for upstart.</td></tr><tr><td>Context_2 HRED</td><td>yes,becauseicant supply itatboottime,iwantthe truecrypt drive to come up by itself without manual intervention what is the problem ?</td></tr><tr><td>VHRED</td><td>what do you mean ?</td></tr><tr><td>hredGAN_w</td><td>you can also mount a new one and put the mount command to the mount point”</td></tr><tr><td>hredGAN_u</td><td>I&#x27;m trying to get my sound working,butI&#x27;m trying to get my sound working.</td></tr><tr><td></td><td>are you using lvm for your root partition?</td></tr><tr><td>Context_0</td><td></td></tr><tr><td>Context_1</td><td>ihavethesameconfgorkingona4box.Itappearsin04lisonupstartandutipathisnotidouselforootfolderifty isthereanyytworkroudiaveyouheardofanyonepostingugaboutistoveitlokedatdar.welliopeteyafiis</td></tr><tr><td></td><td>eventuallyiopetheykeepitrdroundandmoveeverytingtoustartUpstartisoteasytosetupforprogamstatdon’tcomepackaged</td></tr><tr><td></td><td>for upstart.</td></tr><tr><td>Context_2</td><td>yes,becauseicantsupply itatboottime,i wantthe truecrypt drive to come up by itself without manual intervention</td></tr><tr><td>Context_3</td><td>Kinda defeats the use of it anyone could get in don&#x27;t you think?</td></tr><tr><td>HRED</td><td>what is the problem ?</td></tr><tr><td>VHRED</td><td>is there a way to mount the file ?if you want to do it ?</td></tr><tr><td>hredGAN_w</td><td>I have no idea,I just want to get the data from the other computer</td></tr><tr><td></td><td>I&#x27;m trying to getthe latest driver from the nvidia driver,butI’m trying to get the nvidia driver working</td></tr><tr><td>hredGAN_u</td><td></td></tr><tr><td></td><td></td></tr></table>

parse/train/SJxzPsAqFQ/SJxzPsAqFQ_content_list.json

@@ -0,0 +1,1411 @@
+[
+    {
+        "type": "text",
+        "text": "MULTI-TURN DIALOGUE RESPONSE GENERATION IN AN ADVERSARIAL LEARNING FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose an adversarial learning approach to the generation of multi-turn dialogue responses. Our proposed framework, hredGAN, is based on conditional generative adversarial networks (GANs). The GAN’s generator is a modified hierarchical recurrent encoder-decoder network (HRED) and the discriminator is a word-level bidirectional RNN that shares context and word embedding with the generator. During inference, noise samples conditioned on the dialogue history are used to perturb the generator’s latent space to generate several possible responses. The final response is the one ranked best by the discriminator. The hredGAN shows major advantages over existing methods: (1) it generalizes better than networks trained using only the log-likelihood criterion, and (2) it generates longer, more informative and more diverse responses with high utterance and topic relevance even with limited training data. This superiority is demonstrated on the Movie triples and Ubuntu dialogue datasets with both the automatic and human evaluations. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            489,
+            336,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent advances in deep neural network architectures have enabled tremendous success on a number of difficult machine learning problems. While these results are impressive, producing a deployable neural network–based conversation model that can engage in open domain discussion still remains elusive. A dialogue system needs to be able to generate meaningful and diverse responses that are simultaneously coherent with the input utterance and the overall dialogue topic. Unfortunately, earlier conversation models trained with naturalistic dialogue data suffered greatly from limited contextual information (Sutskever et al., 2014; Vinyals & Le, 2015), and lack diversity (Li et al., 2016a). These problems often leads to generic and safe utterance in response to varieties of input utterance. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            645
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Serban et al. (2016) and Xing et al. (2017) proposed the Hierarchical Recurrent Encoder-Decoder (HRED) network to capture long temporal dependencies in multi-turn conversations to address the limited contextual information but the diversity problem remained. On the other hand, some HRED variants such as variational (Serban et al., 2017b) and multi-resolution (Serban et al., 2017a) HREDs attempt to alleviate the diversity problem by injecting noise at the utterance level and by extracting additional context to condition the generator on. While these approaches achieve certain measures of success over the basic HRED, generated responses are still mostly generic since they do not control the generator’s output as the output conditional distribution is not calibrated. Li et al. (2016a), on the other hand, consider diversity promoting training objective but their model is for single turn conversations, cannot not be trained end-to-end and therefore achieves little. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The generative adversarial network (GAN) (Goodfellow et al., 2014) seems to be an appropriate solution to the diversity problem. GAN matches data from two different distributions by introducing an adversarial game between a generator and a discriminator. We explore hredGAN: conditional GANs for multi-turn dialogue models with HRED generator and discriminator. hredGAN combines both generative and retrieval-based multi-turn dialogue systems to improve their individual performances. This is achieved by sharing the context and word embedding between the generator and the discriminator allowing for joint end-to-end training using back-propagation. To the best of our knowledge, no existing work has applied conditional GANs to multi-turn dialogue models and especially with HRED generators and discriminators. We demonstrate the effectiveness of hredGAN over the VHRED for dialogue modeling with evaluations on the Movie triples and Ubuntu technical support datasets. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 ADVERSARIAL FRAMEWORK FOR MULTI-TURN DIALOGUE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            696,
+            169
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Consider a dialogue consisting of a sequence of $N$ utterances, $\\pmb { X } = \\left( X _ { 1 } , X _ { 2 } , \\cdots , X _ { N } \\right)$ , where each utterance $X _ { i } ~ = ~ \\left( X _ { i } ^ { 1 } , X _ { i } ^ { 2 } , \\cdot \\cdot \\cdot , X _ { i } ^ { M _ { i } } \\right)$ contains a variable-length sequence of $M _ { i }$ word tokens such that $X _ { i } ^ { \\mathcal { j } } ~ \\in ~ V$ for vocabulary $V$ . At any time step $i$ , the dialogue history is given by $\\boldsymbol { X _ { i } } = \\left( X _ { 1 } , X _ { 2 } , \\cdot \\cdot \\cdot , X _ { i } \\right)$ . The dialogue response generation task can be defined as follows: Given a dialogue history $X _ { i }$ , generate a response $Y _ { i } = \\left( Y _ { i } ^ { 1 } , Y _ { i } ^ { 2 } , \\cdots , Y _ { i } ^ { T _ { i } } \\right)$ , where $T _ { i }$ is the number of generated tokens. We also want the distribution of the generated response $P ( Y _ { i } )$ to be indistinguishable from that of the ground truth $P ( X _ { i + 1 } )$ and $T _ { i } = M _ { i + 1 }$ . Conditional GAN learns a mapping from an observed dialogue history, $X _ { i }$ , and a sequence of random noise vectors, $Z _ { i }$ to a sequence of output tokens, $Y _ { i }$ , $G : \\{ X _ { i } , Z _ { i } \\}  Y _ { i }$ . The generator $G$ is trained to produce output sequences that cannot be distinguished from the ground truth sequence by an adversarially trained discriminator $D$ that is trained to do well at detecting generator’s fakes. The distribution of the generator output sequence can be factored by the product rule: ",
+        "bbox": [
+            173,
+            181,
+            825,
+            362
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/08b71c1b25cda1d31aacd47c4fde08b96e086ba059a67623e0a96d1dfc83fdcc.jpg",
+        "text": "$$\n\\begin{array} { r } { P ( Y _ { i } | \\boldsymbol { X _ { i } } ) = P ( Y _ { i } ^ { 1 } ) \\displaystyle \\prod _ { j = 2 } ^ { T _ { i } } P \\big ( Y _ { i } ^ { j } | Y _ { i } ^ { 1 } , \\cdot \\cdot \\cdot , Y _ { i } ^ { j - 1 } , \\pmb { X _ { i } } \\big ) } \\\\ { P \\big ( Y _ { i } ^ { j } | Y _ { i } ^ { 1 } , \\cdot \\cdot \\cdot , Y _ { i } ^ { j - 1 } , \\pmb { X _ { i } } \\big ) = P _ { \\theta _ { G } } \\big ( Y _ { i } ^ { 1 : j - 1 } , \\pmb { X _ { i } } \\big ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            366,
+            669,
+            434
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where Y i:j−1 $\\begin{array} { r c l } { Y _ { i } ^ { i : j - 1 } } & { = } & { ( Y _ { i } ^ { 1 } , \\cdot \\cdot \\cdot , Y _ { i } ^ { j - 1 } ) } \\end{array}$ and $\\theta _ { G }$ are the parameters of the generator model. $P _ { \\theta _ { G } } \\left( Y _ { i } ^ { i : j - 1 } , X _ { i } \\right)$ is an autoregressive generative model where the probability of the current token depends on the past generated sequence. Training the generator $G$ with the log-likelihood criterion is unstable in practice, and therefore the past generated sequence is substituted with the ground truth, a method known as teacher forcing (Williams & Zipser, 1989), i.e., ",
+        "bbox": [
+            174,
+            436,
+            825,
+            512
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6ad1762c4e4c367d6722855a42fabd345eb38135526e7b38c351b05949e184cb.jpg",
+        "text": "$$\nP \\left( Y _ { i } ^ { j } | Y _ { i } ^ { 1 } , \\cdot \\cdot \\cdot , Y _ { i } ^ { j - 1 } , \\pmb { X } _ { i } \\right) \\approx P _ { \\theta _ { G } } \\left( X _ { i + 1 } ^ { 1 : j - 1 } , \\pmb { X } _ { i } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            516,
+            658,
+            536
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Using equation 3 in relation to GAN, we define our fake sample as the teacher forcing output with some input noise $Z _ { i }$ ",
+        "bbox": [
+            178,
+            540,
+            821,
+            568
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b8fb10038eca9e31f4045908e50594d163e4830f34b6acf762643afb66359cf.jpg",
+        "text": "$$\nY _ { i } ^ { j } \\sim P _ { \\theta _ { G } } ( X _ { i + 1 } ^ { 1 : j - 1 } , X _ { i } , Z _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            566,
+            593,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "and the corresponding real sample as ground truth $X _ { i + 1 } ^ { j }$ ",
+        "bbox": [
+            173,
+            590,
+            545,
+            607
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "With the GAN objective, we can match the noise distribution, $P ( Z _ { i } )$ to the distribution of the ground truth response, $P ( X _ { i + 1 } | X _ { i } )$ . Varying the noise input then allows us to generate diverse responses to the same dialogue history. Furthermore, the discriminator, since it is calibrated, is used during inference to rank the generated responses, providing a means of controlling the generator output. ",
+        "bbox": [
+            173,
+            613,
+            825,
+            670
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 OBJECTIVES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            686,
+            302,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The objective of a conditional GAN can be expressed as ",
+        "bbox": [
+            173,
+            712,
+            544,
+            728
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/95dbdfeee25a17194164f3a91bcb5907d38cb00983d527b11c40e5ff11570552.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathcal { L } _ { c G A N } ( G , D ) } & { = \\ \\mathbb { E } _ { X _ { i } , X _ { i + 1 } } [ \\log \\ D ( X _ { i + 1 } , X _ { i } ) ] + \\mathbb { E } _ { X _ { i } , Z _ { i } } [ 1 - \\log D ( G ( X _ { i } , Z _ { i } ) , X _ { i } ) ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            734,
+            789,
+            753
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $G$ tries to minimize this objective against an adversarial $D$ that tries to maximize it: ",
+        "bbox": [
+            173,
+            757,
+            766,
+            772
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee261a0ab6c076afd787efff79546ee9590cbd7957b7f8678383d52c8accc181.jpg",
+        "text": "$$\nG ^ { * } , D ^ { * } = a r g m i n m a x \\mathcal { L } _ { c G A N } ( G , D ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            776,
+            633,
+            799
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Previous approaches have shown that it is beneficial to mix the GAN objective with a more traditional loss such as cross-entropy loss (Lamb et al., 2016; Li et al., 2017). The discriminator’s job remains unchanged, but the generator is tasked not only to fool the discriminator but also to be near the ground truth $X _ { i + 1 }$ in the cross-entropy sense: ",
+        "bbox": [
+            173,
+            803,
+            825,
+            859
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6fbb3555d687afdb5f48aecbcbca050175f55e3c863b7783a93730b77988e3a1.jpg",
+        "text": "$$\n\\mathcal { L } _ { M L E } ( G ) = \\mathbb { E } _ { X _ { i } , X _ { i + 1 } , Z _ { i } } [ - l o g ~ P _ { \\theta _ { G } } \\left( X _ { i + 1 } , X _ { i } , Z _ { i } \\right) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            863,
+            678,
+            882
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our final objective is, ",
+        "bbox": [
+            174,
+            886,
+            318,
+            900
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0da4cbc3c7fecba8ff529614334a46bf088a762e86d386c3469d27d8df224ffa.jpg",
+        "text": "$$\nG ^ { * } , D ^ { * } = a r g m i n m a x \\left( \\lambda _ { G } \\mathcal { L } _ { c G A N } ( G , D ) + \\lambda _ { M } \\mathcal { L } _ { M L E } ( G ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            904,
+            709,
+            928
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/852da0ca9237240374ebfc9d038dc21e91c90ceba20f242e189d501a14252f14.jpg",
+        "image_caption": [
+            "Figure 1: Left: The hredGAN architecture - The generator makes predictions conditioned on the dialogue history, $\\boldsymbol { h } _ { i }$ , attention, $A _ { i } ^ { j }$ , noise sample, $Z _ { i } ^ { j }$ , and ground truth, $X _ { i + 1 } ^ { j - 1 }$ . Right: RNN-based discriminator that discriminates bidirectionally at the word level. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            745,
+            258
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is worth mentioning that, without $Z _ { i }$ , the net could still learn a mapping from $X _ { i }$ to $Y _ { i }$ , but would produce deterministic outputs and fail to match any distribution other than a delta function (Isola et al., 2017). This is one key area where our work is different from Lamb et al.’s and Li et al.’s. The schematic of the proposed hredGAN is depicted at the right hand side of Figure 1. ",
+        "bbox": [
+            173,
+            329,
+            825,
+            386
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 GENERATOR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            404,
+            302,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We adopted an HRED dialogue generator similar to (Serban et al., 2016; 2017a;b; Xing et al., 2017). The HRED contains three recurrent structures, i.e. the encoder $( e R N N )$ , context $( c R N N )$ , and decoder $( d R N N )$ RNN. The conditional probability modeled by the HRED per output word token is given by ",
+        "bbox": [
+            173,
+            429,
+            825,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/db755bb4174dbe4f462013df1638a5965919b6a584ccc356fc2b6dffe2ec20b4.jpg",
+        "text": "$$\nP _ { \\theta _ { G } } \\left( Y _ { i } ^ { j } | X _ { i + 1 } ^ { 1 : j - 1 } , \\pmb { X } _ { i } \\right) = d R N N \\left( E ( X _ { i + 1 } ^ { j - 1 } ) , h _ { i } ^ { j - 1 } , { h _ { i } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            484,
+            681,
+            505
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $E ( . )$ is the embedding lookup, $h _ { i } \\ = \\ c R N N ( e R N N ( E ( X _ { i } ) , h _ { i - 1 } )$ , $e R N N ( . )$ maps a sequence of input symbols into fixed-length vector, and $h$ and $^ { h }$ are the hidden states of the decoder and context RNN, respectively. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            551
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the multi-resolution HRED, (Serban et al., 2017a), high-level tokens are extracted and processed by another RNN to improve performance. We circumvent the need for this extra processing by allowing the decoder to attend to different parts of the input utterance during response generation (Bahdanau et al., 2015; Luong et al., 2015). We introduce a local attention into equation 9 and encode the attention memory differently from the context through an attention encoder RNN $( a R N N )$ , yielding: ",
+        "bbox": [
+            173,
+            558,
+            825,
+            641
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf6d7447481747d6d41b6a3dfa370db1c95c726295e71a74cfb192d1061c6a2b.jpg",
+        "text": "$$\nP _ { \\theta _ { G } } \\left( Y _ { i } ^ { j } | X _ { i + 1 } ^ { 1 : j - 1 } , X _ { i } \\right) = d R N N \\big ( E ( X _ { i + 1 } ^ { j - 1 } ) , h _ { i } ^ { j - 1 } , A _ { i } ^ { j } , h _ { i } \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            640,
+            692,
+            661
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { A _ { i } ^ { j } = \\sum _ { m = 1 } ^ { M _ { i } } \\frac { e x p ( \\alpha _ { m } ) } { \\sum _ { m = 1 } ^ { M _ { i } } e x p ( \\alpha _ { m } ) } h _ { i } ^ { ' m } } \\end{array}$ h 0 m , $h _ { i } ^ { ' m } = a R N N ( E ( X _ { i } ^ { m } ) , h _ { i } ^ { ' m - 1 } ) , h ^ { ' }$ is the hidden state of the attention RNN and $\\alpha _ { k }$ is either a logit projection of $( h _ { i } ^ { j - 1 } , h _ { i } ^ { ' m } )$ in the case of Bahdanau et al. (2015) or $( h _ { i } ^ { j - 1 } ) ^ { T } \\cdot h _ { i } ^ { ' m }$ in the case of Luong et al. (2015). The modified HRED architecture is shown in Figure 2. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            737
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Noise Injection: We inject Gaussian noise at the input of the decoder RNN. Noise samples could be injected at the utterance or word level. With noise injection, the conditional probability of the decoder output becomes ",
+        "bbox": [
+            174,
+            742,
+            825,
+            785
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aa3e461c45d9d62ac102ab5d6546b6bc06c48ad7eca850e537cabb54938d1869.jpg",
+        "text": "$$\nP _ { \\theta _ { G } } \\left( Y _ { i } ^ { j } | X _ { i + 1 } ^ { 1 : j - 1 } , Z _ { i } ^ { j } , \\boldsymbol { X } _ { i } \\right) = d R N N \\left( E ( X _ { i + 1 } ^ { j - 1 } ) , h _ { i } ^ { j - 1 } , A _ { i } ^ { j } , Z _ { i } ^ { j } , h _ { i } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            792,
+            720,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $Z _ { i } ^ { j } \\sim \\mathcal { N } _ { i } ( 0 , I )$ , for utterance-level noise and $Z _ { i } ^ { j } \\sim \\mathcal { N } _ { i } ^ { j } ( 0 , I )$ , for word-level noise. ",
+        "bbox": [
+            169,
+            820,
+            758,
+            839
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 DISCRIMINATOR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            854,
+            330,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The discriminator shares context and word embedding with the generator and can discriminate at the word level (Lamb et al., 2016). The word-level discrimination is achieved through a bidirectional RNN and is able to capture both syntactic and conceptual differences between the generator output ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/0da47b8b0a595d5ad9dff357a0ff6a87f0afab17a3d46c003f6518c7b53b3ae4.jpg",
+        "image_caption": [
+            "Figure 2: The HRED generator with local attention - The attention RNN ensures local relevance while the context RNN ensures global relevance. Their states are combined to initialize the decoder RNN and the discriminator BiRNN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            101,
+            761,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and the ground truth. The aggregate classification of an input sequence, $\\chi$ can be factored over word-level discrimination and expressed as ",
+        "bbox": [
+            173,
+            364,
+            823,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5b0b73a62a3da3b66a99ee6d2e96e9a3f6e66070c3810c96b93bcf3044fe954.jpg",
+        "text": "$$\nD ( X _ { i } , \\chi ) = D ( h _ { i } , \\chi ) = \\bigg [ \\prod _ { j = 1 } ^ { J } D _ { R N N } ( h _ { i } , E ( \\chi ^ { j } ) ) \\bigg ] ^ { \\frac { 1 } { J } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            401,
+            676,
+            446
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $D _ { R N N } ( . )$ is the word discriminator RNN, $\\boldsymbol { h } _ { i }$ is an encoded vector of the dialogue history $X _ { i }$ obtained from the generator’s $c R N N ( . )$ output, and $\\chi ^ { j }$ is the jth word or token of the input sequence $\\chi$ . $\\chi = Y _ { i }$ and $J = T _ { i }$ for the case of generator’s decoder output, $\\chi = X _ { i + 1 }$ and $J = M _ { i + 1 }$ for the case of ground truth. The discriminator architecture is depicted on the left hand side of Figure 1. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            512
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.4 ADVERSARIAL GENERATION OF MULTI-TURN DIALOGUE RESPONSE ",
+        "bbox": [
+            176,
+            530,
+            692,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe the generation process during inference. The generation objective can be mathematically described as ",
+        "bbox": [
+            176,
+            556,
+            821,
+            584
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3aea5a624f30b76309e552a65d2a197033b2f8cde3cb7b8ee2a773925f3d1f90.jpg",
+        "text": "$$\nY _ { i } ^ { * } = a r g m a x \\left\\{ P ( Y _ { i , l } | X _ { i } ) + D ^ { * } ( X _ { i } , Y _ { i , l } ) \\right\\} _ { l = 1 } ^ { L }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            583,
+            665,
+            609
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $Y _ { i , l } = G ^ { * } ( X _ { i } , Z _ { i , l } )$ , $Z _ { i , l }$ is the lth noise samples at dialogue step $i$ , and $L$ is the number of response samples. Equation 13 shows that our inference objective is the same as the training objective (8), combining both the MLE and adversarial criteria. This is in contrast to existing work where the discriminator is usually discarded during inference. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The inference described by equation 13 is intractable due to the enormous search space of $Y _ { i , l }$ . Therefore, we turn to an approximate solution where we use greedy decoding (MLE) on the first part of the objective function to generate $L$ lists of responses based on noise samples $\\{ Z _ { i , l } \\} _ { l = 1 } ^ { L }$ . In order to facilitate the exploration of the generator’s latent space, we sample a modified noise distribution, $Z _ { i , l } ^ { j } \\sim \\mathcal { N } _ { i , l } ( 0 , \\alpha I )$ , or $Z _ { i , l } ^ { j } \\sim \\mathcal { N } _ { i , l } ^ { j } ( 0 , \\alpha I )$ where $\\alpha > 1 . 0$ , is the exploration factor that increases the noise variance. We then rank the $L$ lists using the discriminator score, $\\left\\{ D _ { . } ^ { * } ( X _ { i } , Y _ { i , l } ) \\right\\} _ { l = 1 } ^ { L } .$ . The response with the highest discriminator ranking is the optimum response for the dialogue context. ",
+        "bbox": [
+            173,
+            671,
+            825,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 TRAINING OF HREDGAN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            415,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We trained both the generator and the discriminator simultaneously as highlighted in Algorithm 1 with $\\lambda _ { G } = \\lambda _ { M } = 1$ . GAN training is prone to instability due to competition between the generator and the discriminator. Therefore, parameter updates are conditioned on the discriminator performance (Lamb et al., 2016). ",
+        "bbox": [
+            174,
+            832,
+            823,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The generator consists of four RNNs with different parameters, that is, $a R N N , e R N N , c R N N$ and dRNN. aRNN and eRNN are both bidirectional, while $c R N N$ and dRNN are unidirec",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Adversarial Learning of hredGAN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            488,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Require: A generator $G$ with parameters $\\theta _ { G }$ .   \nRequire: A discriminator $D$ with parameters $\\theta _ { D }$ . for number of training iterations do Initialize $c R N N$ to zero state, $\\scriptstyle h _ { 0 }$ 0Sample a mini-batch of conversations, $\\pmb { X } = \\{ X _ { i } \\} _ { i = 1 } ^ { N }$ , $\\pmb { X _ { i } } = \\left( X _ { 1 } , X _ { 2 } , \\cdot \\cdot \\cdot , X _ { i } \\right)$ with $N$ utterances. Each utterance mini batch $_ i$ contains $M _ { i }$ word tokens. for $i = 1$ to $N - 1$ do Update the context state. $\\begin{array} { r } { \\dot { \\pmb { h _ { i } } } = c R N N ( e R N N ( E ( X _ { i } ) ) , \\pmb { h _ { i - 1 } } ) } \\end{array}$ $P _ { \\theta _ { G } } \\left( Y _ { i } | , Z _ { i } , \\boldsymbol { X } _ { i } \\right) = \\left\\{ P _ { \\theta _ { G } } \\left( Y _ { i } ^ { j } | \\boldsymbol { X } _ { i + 1 } ^ { 1 : j - 1 } , Z _ { i } ^ { j } , \\boldsymbol { X } _ { i } \\right) \\right\\} _ { j = 1 } ^ { M _ { i + 1 } }$ $Y _ { i }$ $Y _ { i } \\stackrel { \\cdot } { \\sim } P _ { \\theta _ { G } } ( Y _ { i } | , Z _ { i } , \\stackrel { \\cdot } { X } _ { i } )$ end forCompute the discriminator accuracy $D _ { a c c }$ over $N - 1$ utterances $\\{ Y _ { i } \\} _ { i = 1 } ^ { N - 1 }$ 1 nd {Xi+1}N−1i=1 a Update $\\theta _ { D }$ with gradient of the discriminator loss. $\\underset { i } { \\overset { \\cdot } { \\sum } } [ \\nabla _ { \\theta _ { D } } \\log \\bar { D ( } h _ { i } , X _ { i + 1 } ) + \\nabla _ { \\theta _ { D } } l o g \\big ( 1 - D ( h _ { i } , Y _ { i } ) \\big ) ]$ end if if $D _ { a c c } < a c c _ { G _ { t h } }$ Update $\\begin{array} { r } { { \\prec } \\ { a c c } _ { G _ { t } } } \\\\ { \\ \\mathrm { e } \\ \\theta _ { G } \\ \\mathrm { w i t } } \\end{array}$ with the generator’s MLE loss only. then $\\underset { i } { \\mathop { \\sum } } [ \\nabla _ { \\theta _ { G } } \\log P _ { \\theta _ { G } } ( Y _ { i } | , Z _ { i } , \\mathbf { X } _ { i } ) ]$ else Update $\\theta _ { G }$ with both adversarial and MLE losses. $\\sum _ { i } [ \\lambda _ { G } \\nabla _ { \\theta _ { G } }$ log $D ( h _ { i } , Y _ { i } ) + \\lambda _ { M } \\nabla _ { \\theta _ { G } }$ l $\\arg P _ { \\theta _ { G } } ( Y _ { i } | , Z _ { i } , X _ { i } ) ]$ end if end for ",
+        "bbox": [
+            173,
+            122,
+            825,
+            421
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "tional. Each RNN has 3 layers, and the hidden state size is 512. The dRNN and $a R N N$ are connected using an additive attention mechanism (Bahdanau et al., 2015). ",
+        "bbox": [
+            176,
+            445,
+            821,
+            474
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The discriminator shares $a R N N , e R N N$ , and $c R N N$ with the generator. $D _ { R N N }$ , is a stacked bidirectional RNN with 3 layers and a hidden state size of 512. The $c R N N$ states are used to initialize the states of $D _ { R N N }$ . The output of both the forward and the backward cells for each word are concatenated and passed to a fully-connected layer with binary output. The output is the probability that the word is from the ground truth given the past and future words of the sequence. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Others: All RNNs used are gated recurrent unit (GRU) cells (Cho et al., 2014). The word embedding size is 512 and shared between the generator and the discriminator. The initial learning rate is 0.5 with decay rate factor of 0.99, applied when the adversarial loss has increased over two iterations. We use a batch size of 64 and clip gradients around 5.0. As in Lamb et al. (2016), we find $a c c _ { D _ { t h } } = 0 . 9 9$ and $a c c _ { G _ { t h } } = 0 . 7 5$ to be good enough. All parameters are initialized with Xavier uniform random initialization (Glorot & Bengio, 2010). The vocabulary size $V$ is 50, 000. Due to the large vocabulary size, we use sampled softmax loss (Jean et al., 2015) for MLE loss to expedite the training process. However, we use full softmax for evaluation. The model is trained end-to-end using the stochastic gradient descent algorithm. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS AND RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            703,
+            447,
+            719
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We consider the task of generating dialogue responses conditioned on the dialogue history and the current input utterance. We compare the proposed hredGAN model against some alternatives on publicly available datasets. ",
+        "bbox": [
+            176,
+            734,
+            825,
+            776
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            287,
+            806
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Movie Triples Corpus, (MTC) dataset (Serban et al., 2016). This dataset was derived from the Movie-DiC dataset by Banchs (2012). Although this dataset spans a wide range of topics with few spelling mistakes, its small size of only about 240,000 dialogue triples makes it difficult to train a dialogue model, as pointed out by Serban et al. (2016). We thought that this scenario would really benefit from the proposed adversarial generation. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Ubuntu Dialogue Corpus, (UDC) dataset (Serban et al., 2017b). This dataset was extracted from the Ubuntu Relay Chat Channel. Although the topics in the dataset are not as diverse as in the MTC, the dataset is very large, containing about 1.85 million conversations with an average of 5 utterances per conversation. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We split both MTC and UDC into training, validation, and test sets, using $90 \\%$ , $5 \\%$ , and $5 \\%$ proportions, respectively. We performed minimal preprocessing of the datasets by replacing all words except the top 50,000 most frequent words by an UNK symbol. ",
+        "bbox": [
+            174,
+            138,
+            821,
+            181
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 EVALUATION METRICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            200,
+            375,
+            214
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Accurate evaluation of dialogue models is still an open challenge. In this paper, we employ both automatic and human evaluations. ",
+        "bbox": [
+            173,
+            227,
+            823,
+            256
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 AUTOMATIC EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            273,
+            408,
+            287
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We employed some of the automatic evaluation metrics that are used in probabilistic language and dialogue models, and statistical machine translation. Although these metrics may not correlate well with human judgment of dialogue responses (Liu et al., 2016), they provide a good baseline for comparing dialogue model performance. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            354
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Perplexity - For a model with parameter $\\theta$ , we define perplexity as: ",
+        "bbox": [
+            173,
+            362,
+            617,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/54820156326709210073969979b319c3ad63ffd9c59086b891f6d942c18900c3.jpg",
+        "text": "$$\ne x p \\bigg [ - \\frac { 1 } { N _ { W } } \\sum _ { k = 1 } ^ { K } l o g P _ { \\theta } ( Y _ { 1 } , Y _ { 2 } , \\ldots , Y _ { N _ { k } - 1 } ) \\bigg ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            376,
+            650,
+            416
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $K$ is the number of conversations in the dataset, $N _ { k }$ is the number of utterances in conversation $k$ , and $N _ { W }$ is the total number of word tokens in the entire dataset. The lower the perplexity, the better. The perplexity measures the likelihood of generating the ground truth given the model parameters. While a generative model can generate a diversity of responses, it should still assign a high probability to the ground truth utterance. ",
+        "bbox": [
+            174,
+            416,
+            823,
+            484
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "BLEU - The BLEU score, (Papineni et al., 2002) provides a measure of overlap between the generated response (candidate) and the ground truth (reference) using a modified n-gram precision. According to Liu et. al. (Liu et al., 2016), BLEU-2 score is fairly correlated with human judgment for non-technical dialogue (such as MTC). ",
+        "bbox": [
+            173,
+            491,
+            825,
+            547
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ROUGE - The ROUGE score, (Lin, 2014) is similar to BLEU but it is recall oriented instead. It is used for automatic evaluation of text summarization and machine translation. To compliment the BLEU score, we use ROUGE-N with $N = 2$ for our evaluation. ",
+        "bbox": [
+            174,
+            554,
+            821,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Distinct n-gram - This is the fraction of unique n-grams in the generated responses. It provides a measure of diversity. Models with higher number of distinct n-grams tend to produce more diverse responses (Li et al., 2016a). For our evaluation, we use 1- and 2- grams. ",
+        "bbox": [
+            174,
+            603,
+            821,
+            646
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Normalized Average Sequence Length (NASL) - This measures the average number of words in model generated responses normalized by the average number of words in the groundtruth. ",
+        "bbox": [
+            171,
+            652,
+            823,
+            681
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2.2 HUMAN EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            698,
+            379,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For human evaluation, we follow a similar setup as Li et al. (2016a), employing crowd-sourced judges to evaluate a random selection of 200 samples. We present both the multi-turn context and the generated responses from the models to 3 judges and asked them to rank the general response quality in terms of relevance and informativeness. For $N$ models, the model with the lowest quality is assigned a score 0 and the highest is assigned a score N-1. Ties are not allowed. The scores are normalized between 0 and 1 and averaged over the total number of samples and judges. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            808
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 BASELINE",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            285,
+            840
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare the performance of our model to (V)HRED (Serban et al., 2016; 2017b), since they are the closest to our approach in implementation and are the current state of the art in open-domain dialogue models. HRED is very similar to our proposed generator, but without the input utterance attention and noise samples. VHRED introduces a latent variable to the HRED between the $c R N N$ and the dRNN and was trained using the variational lower bound on the log-likelihood. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1977ad9741fc8815f6854cbba183d0c1a852f28f1cf4ae5d89f04fab14cef799.jpg",
+        "table_caption": [
+            "Table 1: Generator Performance Evaluation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Teacher Forcing</td><td colspan=\"4\">Autoregression</td><td rowspan=\"2\">Human Evaluation</td></tr><tr><td>Perplexity</td><td>-logD(G(.))</td><td>BLEU-2</td><td>ROUGE-2</td><td>DISTINCT-1/2</td><td>NASL1</td></tr><tr><td>MTC</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>HRED</td><td>31.92/36.00</td><td>NA</td><td>0.0474</td><td>0.0384</td><td>0.0026/0.0056</td><td>0.535</td><td>0.2560</td></tr><tr><td>VHRED</td><td>42.61/44.97</td><td>NA</td><td>0.0606</td><td>0.1181</td><td>0.0048/0.0163</td><td>0.831</td><td>0.3909</td></tr><tr><td>hredGAN_u</td><td>23.57/23.54</td><td>23.57/23.54</td><td>0.0493</td><td>0.2416</td><td>0.0167/0.1306</td><td>0.884</td><td>0.5582</td></tr><tr><td>hredGAN_w</td><td>24.20/24.14</td><td>13.35/13.40</td><td>0.0613</td><td>0.3244</td><td>0.0179/0.1720</td><td>1.540</td><td>0.7869</td></tr><tr><td>UDC</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>HRED</td><td>69.39/86.40</td><td>NA</td><td>0.0177</td><td>0.0483</td><td>0.0203/0.0466</td><td>0.892</td><td>0.3475</td></tr><tr><td>VHRED</td><td>98.50/105.20</td><td>NA</td><td>0.0171</td><td>0.0855</td><td>0.0297/0.0890</td><td>0.873</td><td>0.4046</td></tr><tr><td>hredGAN_u</td><td>56.82/57.32</td><td>10.09/10.08</td><td>0.0137</td><td>0.0716</td><td>0.0260/0.0847</td><td>1.379</td><td>0.6133</td></tr><tr><td>hredGAN_w</td><td>47.73/48.18</td><td>8.37/8.36</td><td>0.0216</td><td>0.1168</td><td>0.0516/0.1821</td><td>1.098</td><td>0.6905</td></tr></table>",
+        "bbox": [
+            176,
+            133,
+            823,
+            308
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The VHRED can generate multiple responses per context like hredGAN, but has no specific criteria for selecting the best response. ",
+        "bbox": [
+            174,
+            327,
+            823,
+            354
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The HRED and VHRED models are both trained using the Theano-based implementation obtained from https://github.com/julianser/hed-dlg-truncated. The training and validation sets used for UDC and MTC dataset were obtained directly from the authors1 of (V)HRED. For model comparison, we use a test set that is disjoint from the training and validation sets. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            417
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            434,
+            279,
+            449
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have two variants of hredGAN based on the noise injection approach, i.e., hredGAN with utterance-level (hredGAN u) and word-level (hredGAN w) noise injections. ",
+        "bbox": [
+            176,
+            460,
+            823,
+            489
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare the performance of these two variants with HRED and VHRED models. ",
+        "bbox": [
+            176,
+            496,
+            730,
+            511
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Perplexity: The average perplexity per word performance of all the four models on MTC and UDC datasets (validation/test) are reported in the first column on Table 1. The table indicates that both variants of the hredGAN model perform better than the HRED and VHRED models in terms of the perplexity measure. However, using the adversarial loss criterion (Eq. equation 8), the hredGAN u model performs better on MTC and worse on UDC. Note that, for this experiment, we run all models in teacher forcing mode. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            601
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Generation Hyperparameter: For adversarial generation, we perform a linear search for $\\alpha$ between 1 and 20 at an increment of 1 using Eq. equation 13, with sample size $L = 6 4$ , on validation sets with models run in autoregression. The optimum values of $\\alpha$ for hredGAN u and hredGAN w for UDC are 7.0 and 9.0 respectively. The values for MTC are not convex, probably due to small size of the dataset, so we use the same $\\alpha$ values as UDC. We however note that for both datasets, any integer value between 3 and 10 (inclusive) works well in practice. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            691
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Quantitative Generator Performance: We run autoregressive inference for all the models (using optimum $\\alpha$ values for hredGAN models and selecting the best of $L = 6 4$ responses using a discriminator) with dialogue contexts from a unique test set. Also, we compute the average BLEU-2, ROUGE-2(f1), Distinct(1/2) and normalized average sequence length (NASL) scores for each model and summarize the results in the middle of Table 1. Distinct(1/2) largely agrees with the perplexity score. Most scores, similar to the perplexity, indicate that hredGAN models perform better than (V)HRED on both datasets. However, on the UDC and MTC, ROUGE and BLUE, respectively scores VHRED slightly better than hredGAN u but still worse than hredGAN w. ",
+        "bbox": [
+            173,
+            698,
+            825,
+            810
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A good dialogue model should find the right balance between precision (BLEU) and diversity. We strongly believe that our adversarial approach is better suited to solving this problem. As hredGAN generators explore diversity, the discriminator ranking gives hredGAN an edge over (V)HRED because it helps detect responses that are out of context and the natural language structure (Table 2). Also, the ROGUE(f1) performance indicates that hredGAN w strikes a better balance between precision (BLEU) and diversity than the rest of the models. This is also obvious from the quality of generated responses. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b325b1fc5f2060d0e03d6a6e12272c3084ab2c59852a18c0f8cad43a3f335b85.jpg",
+        "table_caption": [
+            "Table 2: Example of Discriminator Ranking with hredGAN w "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Item</td><td>D(G(.))</td><td>Utterance</td></tr><tr><td colspan=\"3\">MTC</td></tr><tr><td>Context_0</td><td>NA</td><td>perhaps &lt;person&gt; had a word with the man upstairs.</td></tr><tr><td>Context_1</td><td>NA</td><td>a word ?i’m sure by now he’s engineered a hostile takeover .</td></tr><tr><td>Response_0 0.996</td><td></td><td>&lt;person&gt;,i know what you’re saying， &lt;person&gt;,that’s not whati’m saying.</td></tr><tr><td>Response-1 0.991</td><td></td><td>&lt;person&gt;,i know .i was just about to help</td></tr><tr><td>Response_2 0.315</td><td></td><td>the guy. &lt;person&gt;,i&#x27;m sorry.</td></tr><tr><td>Response_3</td><td>0.203</td><td>&lt;person&gt;,i’ma litle out .</td></tr><tr><td>Context_0</td><td>NA</td><td>says he wanted food.&lt;person&gt;.he wanted the gold .</td></tr><tr><td>Context_1</td><td>NA</td><td>how’s he going to want the gold ? he couldn &#x27; t even know we had it.</td></tr><tr><td>Response_0 0.998</td><td></td><td>&lt;person&gt;,i know .but it’s not him,it’s the only way he’s got it all figured</td></tr><tr><td>Response_1 0.981</td><td></td><td>&lt;person&gt;,i know．but i have to tell you . these things are really stupid and you think i</td></tr><tr><td>Response_2 0.690</td><td></td><td>was wrong ? &lt;person&gt;,i&#x27;m sure he did.</td></tr><tr><td>Response-3 0.314</td><td></td><td>&lt;person&gt;,i&#x27;m not sure</td></tr><tr><td colspan=\"3\">UDC</td></tr><tr><td>Context_0</td><td>NA</td><td>The netboot one is suppose to download pack-</td></tr><tr><td>Context_1</td><td>NA</td><td>ages from the net. like the ones to be installed? or the installed to be run?</td></tr><tr><td>Response_O 0.993</td><td></td><td>you don ’t need to install the whole system , just install the ubuntu installer</td></tr><tr><td>Response-1 0.952</td><td></td><td>you can install the ubuntu installer from the</td></tr><tr><td>Response_2 0.749</td><td></td><td>ubuntu menu I&#x27;m not sure ,I don ’t know .</td></tr><tr><td>Response_3</td><td>0.184</td><td>you can</td></tr><tr><td>Response_4</td><td>0.003</td><td>youa. 1.</td></tr><tr><td>Context_0</td><td>NA</td><td>DJones: update manager won&#x27;t detect 12.04.1 as a new version if you are already running 12.04, because 12.04.1 = 12.04 + lots of pack-</td></tr><tr><td>Response_0 0.991</td><td></td><td>age updates did you try a clean install of the latest version ?</td></tr><tr><td>Response_1 0.981</td><td></td><td>try installing the latest_UNK and see if it works</td></tr><tr><td>Response_2 0.615</td><td></td><td>I’m not sure you have a problem..</td></tr><tr><td>Response_3 0.191</td><td></td><td>try sudo apt-get remove the package that is not</td></tr><tr><td>Response_4 0.002</td><td></td><td>installed try the-UNK.1.1.1.1.1.-UNK.deb</td></tr></table>",
+        "bbox": [
+            174,
+            133,
+            465,
+            565
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6aadbcba8d14f970df698f1258e81af2aee8708359c4e7100a40a8383d0a9fd4.jpg",
+        "table_caption": [
+            "Table 3: Sample responses of HRED, VHRED and hredGAN. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Movie</td><td></td></tr><tr><td>Context_0 HRED VHRED</td><td>perhaps &lt;person&gt; had a word with the man upstairs . i&#x27;m sorry,&lt;person&gt;. &lt;person&lt;&#x27;tdo it. hredGAN_w&lt;person&gt;,i’m not gon na be okay.i just don ’t think it’s a</td></tr><tr><td>Context_1 HRED VHRED</td><td>good idea. hredGAN.u &lt;person&gt;,icause it was allthe way to you. a word ?i&#x27;m sure by now he’s engineered a hostile takeover . i&#x27;m sorry,&lt;person&gt;. &lt;person&gt;&#x27;tdo it.</td></tr><tr><td></td><td>hredGAN_w&lt;person&gt;,i know what you ’re saying，&lt;person&gt;,that’s not whati’m saying. hredGAN_u &lt;person&gt;,i have to tell youi’m not the same.</td></tr><tr><td>Context_0 HRED VHRED</td><td>&lt;person&gt;’s. i&#x27;m sorry,&lt;person&gt;.</td></tr><tr><td></td><td>&lt;person&gt;&#x27;tdo it . hredGAN_w &lt;person&gt;,i’m sure it’s the only thing i ever imagined .</td></tr><tr><td></td><td></td></tr><tr><td></td><td>hredGAN_u &lt;person&gt;,i&#x27;l be right there .</td></tr><tr><td></td><td></td></tr><tr><td>Context_1</td><td></td></tr><tr><td></td><td>can i ask you something about her ?</td></tr><tr><td>HRED</td><td>idon&#x27;tknow .</td></tr><tr><td>VHRED:</td><td>you’re not going to be here .</td></tr><tr><td></td><td>hredGAN_widon’tknow.i thinki’ve heard of it.</td></tr><tr><td></td><td>hredGAN-ui’m sorry,ican &#x27;t.</td></tr><tr><td>Ubuntu</td><td></td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>this is Dacs i am in i used &#x27;sudo statx and it let me in</td></tr><tr><td>HRED</td><td>what&#x27;s the problem ?</td></tr><tr><td>VHRED</td><td>I don&#x27;t know what you want to do .if you want to do it,you need to</td></tr><tr><td></td><td>do it to do it in the terminal ?</td></tr><tr><td></td><td>hredGAN-w you don’t have to do anything，just type in the terminal and it</td></tr><tr><td></td><td>should be to find the right device</td></tr><tr><td></td><td>hredGAN_u you can have a look at the output of the command .</td></tr><tr><td>Context.1</td><td>good deal... cat /etc/X11/default-display-manager</td></tr><tr><td>HRED</td><td>what&#x27;s the problem ?</td></tr><tr><td>VHRED</td><td>do you know what you want to do ?</td></tr><tr><td></td><td>hredGAN_w I’m trying to figure a command that I can find to find out the file</td></tr><tr><td></td><td>that Ican find in the file&quot;</td></tr><tr><td></td><td>hredGAN-u Idon &#x27;t see the point,but I’m not sure how to do that .</td></tr><tr><td>Context_2</td><td>/usr/sbin/lightdmhttp://paste.ubuntu.com/1286224/</td></tr><tr><td></td><td>/etc/X1/xorg.conf</td></tr><tr><td>HRED</td><td>what &#x27;s the problem ?</td></tr><tr><td>VHRED</td><td></td></tr><tr><td></td><td>is there a way to do that in the terminal ?</td></tr><tr><td></td><td>hredGAN_w did you just type\\”sudo mount -a\\”?</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td>hredGAN-u i have no idea,i just installed ubuntu and i have no idea how to do</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td>that</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr></table>",
+        "bbox": [
+            477,
+            135,
+            803,
+            571
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            603,
+            823,
+            632
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Qualitative Generator Performance: The results of the human evaluation is reported in the last column of Table 1. The human evaluation agrees largely with the automatic evaluation. The hredGAN w performs best on both datasets although the gap is more on the MTC than on the UTC. This implies that the improvement of HRED with adversarial generation is better than with variational generation (VHRED). In addition, looking at the actual samples from the generator outputs in Table 6 shows that hredGAN especially hredGAN w performs better than (V)HRED. While other models produce short and generic utterances, hredGAN w mostly yields informative responses. For example, in the first dialogue in Table 6, when the speaker is sarcastic about ”the man upstairs”, hredGAN w responds with the most coherent utterance with respect to the dialogue history. We see similar behavior across other samples. We also note that although hredGAN u’s responses are the longest on Ubuntu (in line with the NASL score), the responses are less informative compared to hredGAN w resulting into a lower human evaluation score. We reckon this might be due to a mismatch between utterance-level noise and word-level discrimination or lack of capacity to capture the data distribution using single noise distribution. We hope to investigate this further in the future. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Discriminator Performance: Although only hredGAN uses a discriminator, the observed discriminator behavior is interesting. We observe that the discriminator score is generally reasonable with longer, more informative and more persona-related responses receiving higher scores as shown in Table 2. It worth to note that this behavior, although similar to the behavior of a human judge is learned without supervision. Moreover, the discriminator seems to have learned to assign average score to more frequent or generic responses such as “I don’t know”, “I’m not sure” and so on, and high score to rearer answers. That’s why we sample a modified noise distribution during inference so that the generator can produce rearer utterances that will be scored high by the discriminator. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            152,
+            493,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have introduced an adversarial learning approach that addresses response diversity and control of generator outputs, using an HRED-derived generator and discriminator. The proposed system outperforms existing state-of-the-art (V)HRED models for generating responses in multiturn dialogue with respect to automatic and human evaluations. The superiority of the adversarial generation (hredGAN) over the variational generation (VHRED) is in line with other generative models employing these approaches. Our analysis also concludes that the word-level noise injection seems to perform better in general. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While this is a good starting point, we recognize the need to explore further improvements to the proposed adversarial framework: In the future, we hope to: explore which noise level works with which discrimination level; consider a multi-resolution discriminator with combined word- and utterancelevel discriminations; and explore further tuning of the generator and discriminator models. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            345
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            368,
+            285,
+            382
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "D. Bahdanau, K. Cho, and Y. Bengio. Neural machine translation by jointly learning to align and translate. In Proceedings of International Conference of Learning Representation (ICLR 2015), 2015.   \nR. E. Banchs. Movie-dic: A movie dialogue corpus for research and development. In Proceedings of the 50th Annual Meeting of the Association for Computational Linguistics, pp. 203–207, 2012.   \nE. Bruni and R. Fernndez. Adversarial evaluation for open-domain dialogue generation. In Proceedings of the 18th Annual SIGdial Meeting, 2018.   \nT. Che, Y. Li, R. Zhang, R. D. Hjelm, W. Li, Y. Song, and Y. Bengio. Maximum-likelihood augmented discrete generative adversarial networks. In arXiv preprint arXiv:1702.07983, 2017.   \nK. Cho, B. Merrienboer, C. Gulcehre, D. Bahdanau, F. Bougares, H. Schwenk, and Y. Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. In Proceedings of International Conference of Learning Representation (ICLR 2015), pp. 1724– 1734, 2014.   \nX. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In International conference on artificial intelligence and statistics, 2010.   \nI. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Proceedings of Advances in Neural Information Processing Systems (NIPS 2014), 2014.   \nP. Isola, J. Y. Zhu, T. Zhou, and A. A. Efros. Image-to-image translation with conditional adversarial networks. In Conference on Computer Vision and Pattern Recognition (CVPR, 2017), 2017.   \nS. Jean, K. Cho, R. Memisevic, and Y. Bengio. On using very large target vocabulary for neural machine translation. In arXiv preprint arXiv:1412.2007, 2015.   \nA. Kannan and O. Vinyals. Adversarial evaluation of dialogue models. In arXiv preprint arXiv:1701.08198v1, 2017.   \nA. Lamb, A. Goyah, Y. Zhang, S. Zhang, A. Courville, and Y. Bengio. Professor forcing: A new algorithm for training recurrent networks. In Proceedings of Advances in Neural Information Processing Systems (NIPS 2016), 2016.   \nJ. Li, M. Galley, C. Brockett, J. Gao, and B. Dolan. A diversity-promoting objective function for neural conversation models. In Proceedings of NAACL-HLT, 2016a.   \nJ. Li, W. Monroe, A. Ritter, M. Galley, J. Gao, and D. Jurafsky. Deep reinforcement learning for dialogue generation. In arXiv preprint arXiv:arXiv:arXiv:1606.01541v4, 2016b.   \nJ. Li, W. Monroe, T. Shi, A. Ritter, and D. Jurafsky. Adversarial learning for neural dialogue generation. In arXiv preprint arXiv:1701.06547, 2017.   \nC. Y. Lin. Rouge: a package for automatic evaluation of summaries. In Proceedings of the Workshop on Text Summarization Branches Out, 2014.   \nC. Liu, R. Lowe, I. V. Serban, M. Noseworthy, L. Charlin, and J. Pineau. How not to evaluate your dialogue system: An empirical study of unsupervised evaluation metrics for dialogue response generation. In Proceedings of EMNLP, pp. 2122–2132, 2016.   \nM. T. Luong, I. Sutskever, Q. V. Le, O. Vinyals, and W. Zaremba. Addressing the rare word problem in neural machine translation. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics, 2015.   \nK. Papineni, S. Roukos, T. Ward, and W. Zhu. Bleu: A method for automatic evalution of machine translation. In Proceedings of the 40th Annual Meeting of the Association for Computational Linguistics, pp. 311–318, 2002.   \nI. Serban, A. Sordoni, Y. Bengio, A. Courville, and J. Pineau. Building end-to-end dialogue systems using generative hierarchical neural network models. In Proceedings of The Thirtieth AAAI Conference on Artificial Intelligence (AAAI 2016), pp. 3776–3784, 2016.   \nI. V. Serban, T. Klinger, G. Tesauro, K. Talamadupula, B. Zhou, Y. Bengio, and A. Courville. Multiresolution recurrent neural networks: An application to dialogue response generation. In Proceedings of The Thirty-first AAAI Conference on Artificial Intelligence (AAAI 2017), 2017a.   \nI. V. Serban, A. Sordoni, R. Lowe, L. Charlin, J. Pineau, A. Courville, and Y. Bengio. A hierarchical latent variable encoder-decoder model for generating dialogue. In Proceedings of The Thirty-first AAAI Conference on Artificial Intelligence (AAAI 2017), 2017b.   \nI. Sutskever, O. Vinyals, and Q. Le. Sequence to sequence learning with neural networks. In Proceedings of Advances in Neural Information Processing Systems (NIPS), pp. 3104–3112, 2014.   \nO. Vinyals and Q. Le. A neural conversational model. In Proceedings of ICML Deep Learning Workshop, 2015.   \nR. J. Williams and D. Zipser. A learning algorithm for continually running fully recurrent neural networks. Neural computation, 1(2):270–280, 1989.   \nC. Xing, W. Wu, Y. Wu, M. Zhou, Y. Huang, and W. Ma. Hierarchical recurrent attention network for response generation. In arXiv preprint arXiv:1701.07149, 2017.   \nZ. Xu, B. Liu, B. Wang, S. Chengjie, X. Wang, Z. Wang, and C. Qi. Neural response generation via gan with an approximate embedding layer. In EMNLP, 2017.   \nL. Yu, W. Zhang, J. Wang, and Y. Yu. Seqgan: sequence generative adversarial nets with policy gradient. In Proceedings of The Thirty-first AAAI Conference on Artificial Intelligence (AAAI 2017), 2017.   \nY. Zhang, Z. Gan, K. Fan, Z. Chen, R. Henao, D. Shen, and L. Carin. Adversarial feature matching for text generation. In arXiv preprint arXiv:1706.03850, 2017.   \nY. Zhang, M. Galley, J. Gao, Z. Gan, X. Li, C. Brockett, and B. Dolan. Generating informative and diverse conversational responses via adversarial information maximization. In arXiv preprint arXiv:arXiv:1809.05972v5, 2018. ",
+        "bbox": [
+            171,
+            385,
+            826,
+            931
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            29,
+            828,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            263,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            344,
+            152
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Our work is related to end-to-end neural network–based open domain dialogue models. Most neural dialogue models use transduction frameworks adapted from neural machine translations (Sutskever et al., 2014; Bahdanau et al., 2015). These $\\mathtt { S e q 2 S e q }$ networks are trained end-to-end with MLE criteria using large corpora of human-to-human conversation data. Others use GAN’s discriminator as a reward function in a reinforcement learning framework (Yu et al., 2017) and in conjunction with MLE (Li et al., 2017; Che et al., 2017). Zhang et al. (2017) explored the idea of GAN with a feature matching criterion. Xu et al. (2017) and Zhang et al. (2018) employed GAN with an approximate embedding layer as well as with adversarial information maximization respectively to improve Seq2Seq’s diversity performance. ",
+        "bbox": [
+            173,
+            170,
+            825,
+            295
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Still, $\\mathtt { S e q 2 S e q }$ models are limited in their ability to capture long temporal dependencies in multiturn conversation. Although, Li et al. (2016b) attempted to optimize a pair Seq2Seq models for multi-turn dialogue, the multi-turn objective is only applied at inference and not used for actual model training. Hence, the introduction of HRED models (Serban et al., 2016; 2017a;b; Xing et al., 2017) for modeling dialogue response in multi-turn conversations. However, these HRED models suffer from lack of diversity since they are trained with only MLE criteria. On other hand, adversarial system has been used for evaluating open domain dialogue models (Bruni & Fernndez, 2018; Kannan & Vinyals, 2017). Our work, hredGAN is closest to the combination of HRED generation models (Serban et al., 2016) and adversarial evaluation (Kannan & Vinyals, 2017). ",
+        "bbox": [
+            174,
+            301,
+            825,
+            428
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/e863aaf8aa53453bb40bb72d911bc9bc9fd40ac3d1a321fd03740e39e9950686.jpg",
+        "table_caption": [
+            "Table 4: Generator Performance: HRED vs. HRED $^ +$ Attn "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Teacher Forcing Perplexity</td><td colspan=\"4\">Autoregression</td></tr><tr><td>BLEU-2</td><td>ROUGE-2</td><td>DISTINCT-1/2</td><td>NASL</td></tr><tr><td>MTC HRED</td><td>31.92/36.00</td><td></td><td></td><td></td><td></td></tr><tr><td>HRED+Attn</td><td>26.09/26.41</td><td>0.0474 0.0425</td><td>0.0384</td><td>0.0026/0.0056</td><td>0.535</td></tr><tr><td></td><td></td><td></td><td>0.2239</td><td>0.0397/0.1567</td><td>0.527</td></tr><tr><td>UDC</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>HRED</td><td>69.39/86.40</td><td>0.0177</td><td>0.0483</td><td>0.0203/0.0466</td><td>0.892</td></tr><tr><td>HRED+Attn</td><td>50.82/51.31</td><td>0.0140</td><td>0.0720</td><td>0.0473/0.1262</td><td>0.760</td></tr></table>",
+        "bbox": [
+            251,
+            476,
+            745,
+            601
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "7 ABLATION EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            622,
+            421,
+            638
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Before proposing the above adversarial learning framework for multi-turn dialogue, we carried out some experiments that are highlighted here. ",
+        "bbox": [
+            171,
+            655,
+            825,
+            684
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "7.1 GENERATOR: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            703,
+            305,
+            717
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "First, we noted that by adding an additional attention memory to the HRED generator, we improved the test set perplexity score by more than 8 and 20 points on the MTC and UDC respectively as shown in Table 4. The addition of attention also shows a strong performance at autoregressive inference across multiple metrics as well as observed improvement in response quality. Hence, the decision for the modified HRED generator. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            800
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The adversarial training, however helps to address the lack diversity observed in the generated responses. ",
+        "bbox": [
+            174,
+            806,
+            821,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "7.2 DISCRIMINATOR: ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            333,
+            869
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Before deciding on the word-level discrimination, we experimented with utterance-level discrimination. The utterance-level discriminator trains very quickly but it leads to mostly generic responses from the generator. We also note that utterance-level discriminator scores are mostly extreme (i.e., ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "either low or high). Since we had used convolutional neural network discriminator (Yu et al., 2017) in our experiments, we hope to investigate this further with other architectures. ",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "7.3 ADVERSARIAL TRAINING: ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            398,
+            162
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we also tried a basic policy gradient approach (Li et al., 2017), where word-level discriminator score is used as a reward for each generated word token, but this leads to training instability. This is probably due to the instability of Monte Carlo sampling over large vocabulary size. We believe this might improve with other sampling methods such as importance sampling and hope to investigate further in the future. ",
+        "bbox": [
+            174,
+            175,
+            825,
+            244
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "8 OTHER GENERATED SAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            457,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/fc1b5a55fd0fdf33f9bf0cf6834527676d7bf8327aaba38c8958dd81a5872c9b.jpg",
+        "table_caption": [
+            "Table 5: Additional sample responses of HRED, VHRED and hredGAN on Movie. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Movie</td><td></td></tr><tr><td>Context.0 HRED</td><td>&lt;person&gt;i&#x27;ve raised my rate.imight even cut my sessions to forty minutes </td></tr><tr><td>VHRED</td><td>i’m sorry,&lt;person&gt;. &lt;person&gt;,&lt;person&gt;,&lt;person&gt;,&lt;person&gt;</td></tr><tr><td>hredGAN_w</td><td>&lt;person&gt;,i’m sorry,buti’m not sure if you’re really a very good guy</td></tr><tr><td>hredGAN-u</td><td>i&#x27; ll never see them again,&lt;person&gt;.</td></tr><tr><td></td><td>i&#x27;m going to handle this exactly the way your father would have handled this .i’ve got it solved .</td></tr><tr><td>Context_0 Context.1</td><td>you’ve got it solved ?where is she ？</td></tr><tr><td>HRED</td><td>idon&#x27;t know.</td></tr><tr><td>VHRED</td><td>&lt;person&gt;,,i’m sorry.</td></tr><tr><td>hredGAN_w</td><td>to the end of äabeautiful woman who willbe very happy.</td></tr><tr><td>hredGAN_u</td><td>i&#x27;m sorry,ijust didn ’t know-</td></tr><tr><td>Context_0</td><td>ofcoursenot！jperson’slikeadaughtertome.herfatheranditaughtatuniversitytogetheragoodman,butheneverlistened.</td></tr><tr><td>HRED</td><td>i&#x27;m sorry,&lt;person&gt;.</td></tr><tr><td>VHRED hredGAN-w</td><td>&lt;person&gt;,mr.&lt;person&gt;.</td></tr><tr><td>hredGAN-u</td><td>&lt;person&gt;,i know it’s beenallsix years sinceitold himabout you. i&#x27;m sure you didn’t,buti would have donealitle more.</td></tr><tr><td></td><td></td></tr><tr><td>Context_0 Context_1</td><td>ofcourse not！iperson’slikeadaughtertome.erfatheranditaughtatuniversitytogether.agoodman,buthe neverlistened.</td></tr><tr><td>HRED</td><td>neither did i. i&#x27;m sorry，,&lt;person&gt;.</td></tr><tr><td>VHRED</td><td>&lt;person&gt;,you&#x27;rea&lt;unk&gt;.</td></tr><tr><td>hredGAN-w</td><td>&lt;person&gt;,i know you’re think about it. think it&#x27;I be time,right ?</td></tr><tr><td>hredGAN-u</td><td>i&#x27;Ilbe thefirstone.ifitdidyou,you&#x27;lleit.</td></tr><tr><td>Context_0</td><td>come on,&lt;person&gt;,we could have a great week up in vermont .</td></tr><tr><td>Context.1</td><td>i see what you mean.but wednesday we’ve got to be back in new york .</td></tr><tr><td>HRED VHRED</td><td>&lt;person&gt;. &lt;person&gt;,idon&#x27;t know what you’re going to do.</td></tr><tr><td>hredGAN_w</td><td>&lt;person&gt;,iknow .i&#x27;m kind of busy here.</td></tr><tr><td>hredGAN_u</td><td>i&#x27;m sorry,ican &#x27;t.</td></tr><tr><td>Context_0</td><td>isabel ？</td></tr><tr><td>Context_1</td><td>hi.</td></tr><tr><td>HRED</td><td>that’s whati’m talking about .</td></tr><tr><td>VHRED:</td><td>you&#x27;re not going to be a&lt;unk&gt;,&lt;person&gt;.</td></tr><tr><td>hredGAN_w</td><td>&lt;person&gt;？</td></tr><tr><td>hredGAN_u</td><td>what do you want to know ?</td></tr><tr><td>Context.0</td><td>you understand mr.&lt;person&gt; is constantly barraged with nuisance litigation and irs audits </td></tr><tr><td>Context_1</td><td>of course .</td></tr><tr><td>HRED</td><td>that’s right,&lt;person&gt;.</td></tr><tr><td>VHRED:</td><td>&lt;person&gt;,you’re going to bea&lt;unk&gt;of the&lt;unk&gt;.</td></tr><tr><td>hredGAN_w</td><td>&lt;person&gt;,i’msure,but you’re probably stillin to the new&lt;person&gt;’s house,huh ?</td></tr><tr><td>hredGAN_u</td><td>you&#x27;re gon nabe alitle boy,andi’m not gon na get out ！</td></tr><tr><td>Context_0</td><td>&lt;person&gt;&#x27;t go into my room,she’s asleep.</td></tr><tr><td>Context_1</td><td>&lt;person&gt;,but the nanny,mrs.&lt;person&gt;,she wants to see her.</td></tr><tr><td>HRED</td><td>i&#x27;m sorry,&lt;person&gt;.</td></tr><tr><td>VHRED:</td><td>&lt;person&gt;,mr.&lt;person&gt;.</td></tr><tr><td>hredGAN_w</td><td>&lt;person&gt;,i know .but she’s never seen me anyway.</td></tr><tr><td>hredGAN-u</td><td>i&#x27;m sorry ididn&#x27;t know what to say .</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>what was that for ?</td></tr><tr><td>Context_1</td><td>i&#x27;d forgotten how exciting it is working together .</td></tr><tr><td>HRED</td><td>i&#x27;m sorry,&lt;person&gt;.</td></tr><tr><td>VHRED:</td><td>&lt;person&gt;,&lt;person&gt;.idon&#x27;tknow.</td></tr><tr><td>hredGAN_w</td><td>i&#x27;m sorry,&lt;person&gt;.so many people are so interested,but you’re a very nice guy .</td></tr><tr><td>hredGAN_u</td><td>i&#x27;ve always been so sure to&lt;person&gt;</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>a teacher’s.</td></tr><tr><td>Context_1</td><td>oh my god. i&#x27;m sorry,&lt;person&gt;</td></tr><tr><td>HRED VHRED:</td><td>&lt;person&gt;,&lt;person&gt;&#x27;t worry about it.idon’t know what you’re doing.</td></tr><tr><td>hredGAN_w</td><td>i&#x27;msorry.ididn’tmean to.ididn&#x27;t meanto hurt you.ijust wanted you</td></tr><tr><td>hredGAN-u</td><td>&lt;person&gt;,i don &#x27;t want to be your friend .</td></tr><tr><td></td><td></td></tr><tr><td>Context_0 HRED</td><td>this is all we have . &lt;person&gt;,i’m sorry.</td></tr><tr><td>VHRED:</td><td>&lt;person&gt;,idon&#x27;t know what you&#x27;re doing .idon&#x27;t know whati’m going to do.</td></tr><tr><td>hredGAN_w</td><td>i&#x27;m sorry,sir,buti’ma very good man.</td></tr><tr><td>hredGAN-u</td><td>but you’ve been in the apartment .</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>i took the initiative .</td></tr><tr><td>Context_1</td><td>you haven&#x27;tbeen given an assignment in this case.</td></tr><tr><td>HRED</td><td>&lt;person&gt;.</td></tr><tr><td>VHRED:</td><td></td></tr><tr><td></td><td>&lt;person&gt;,&lt;person&gt;,&lt;person&gt;,&lt;person&gt;.i’m not going to get out of the &lt;unk&gt;.</td></tr><tr><td>hredGAN_w</td><td>i&#x27;m not sure.&lt;continued_utterance&gt;i’m not gon na do you this shit anyway,&lt;person&gt;</td></tr><tr><td>hredGAN-u</td><td></td></tr><tr><td></td><td>&lt;person&gt;,i guess i didn &#x27;t.</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>&lt;person&gt;,i was just gon na leave and seeificould pick up their trail .</td></tr><tr><td></td><td></td></tr><tr><td>Context_1</td><td>no,you wait right there for me.&lt;person&gt; beon the piedmontfight tomorrow at seven.meet me at the airport.</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>HRED</td><td>i&#x27;m sorry，,&lt;person&gt;</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>VHRED:</td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>hredGAN_w</td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td>what do youthinki’msaying?idon’tknow whati’m going todo.idon’tknow whati’mgoing todo.</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>hredGAN-u</td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td>i&#x27;m not sure i don &#x27;t.&lt;continued_utterance&gt;do you want to go over to the station ? &lt;person&gt;,i don&#x27;tknowifi&#x27;m not.</td></tr><tr><td></td></table>",
+        "bbox": [
+            173,
+            150,
+            825,
+            916
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/9337bb963d046638c69bf8fc56f60a79baf01901e87bc94cbd5c614f92414f2c.jpg",
+        "table_caption": [
+            "Table 6: Additional sample responses of HRED, VHRED and hredGAN on Ubuntu. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Ubuntu</td><td></td></tr><tr><td>Context.0</td><td>what&#x27;s the command you are running to chroot and the error message you get in return?</td></tr><tr><td>Context.1</td><td>i mountded the device sudo mount/dev/sdal/mnt-that works-then sudo chroot/mnt-eroris no such file or command</td></tr><tr><td>HRED</td><td>what &#x27;s the problem ?</td></tr><tr><td>VHRED</td><td>is there a way to do that ? what do you mean ?</td></tr><tr><td>hredGAN_w</td><td>I have no idea,I just did a sudo fdisk and it said it was mounted</td></tr><tr><td>hredGAN_u</td><td>I&#x27;m trying to get the latest version of ubuntu,butI’m getting a lot of problems .</td></tr><tr><td>Context_0</td><td>Hmm,have you checked that ICMP is being allowedallthe way throughand thatthe serverresponds tootherICMPrequests?</td></tr><tr><td>Context_1</td><td>nowicanpingit(iadtenabletlocompressooncienticanoteachthmotesubetaddingaruleihefrewallfoardthelan</td></tr><tr><td></td><td>to vpn</td></tr><tr><td>HRED VHRED</td><td>what &#x27;s the problem ? I don&#x27;t know what you want to do</td></tr><tr><td>hredGAN_w</td><td>I have no idea,I’m just trying to get the ip address from the router to the router&quot;</td></tr><tr><td>hredGAN_u</td><td>I&#x27;m not sure if that’sthe case,butI’m not sure if it’sa good idea to have a look at the output .</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>The netboot one is suppose to download packages from the net.</td></tr><tr><td>HRED</td><td>I don&#x27;t know what you want to do .</td></tr><tr><td>VHRED</td><td>how do I do that ? I&#x27;m not sure of a command to do so Ican just install the ubuntu .iso and burn a new iso</td></tr><tr><td>hredGAN_w hredGAN_u</td><td>you can &#x27;t have a look at the man page ...</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>The netboot one is suppose to download packages from the net.</td></tr><tr><td>Context_1</td><td>like the ones to be installed? or the installed to be run?</td></tr><tr><td>HRED</td><td>I don&#x27;t know what the problem is .</td></tr><tr><td>VHRED</td><td>is there a way to install the package manager ?</td></tr><tr><td>hredGAN_w hredGAN_u</td><td>you don ’t need to install the whole system, just install the ubuntu installer I&#x27;m trying to installa -UNK version of ubuntu,butI&#x27;m trying to install it on my laptop</td></tr><tr><td></td><td></td></tr><tr><td>Context_0</td><td>You trying to mount it open with the password?</td></tr><tr><td>HRED</td><td>Ihave to do that,butI have a problem with the same problem. is there a way to do ?</td></tr><tr><td>VHRED</td><td>yes,I&#x27;m not sure if it’s mounted or not</td></tr><tr><td>hredGAN_w</td><td>I&#x27;m trying to install the latest version of Ubuntu,butI&#x27;m running on a -UNK</td></tr><tr><td>hredGAN-u</td><td></td></tr><tr><td>Context_0</td><td>are you using lvm for your root partition?</td></tr><tr><td>HRED</td><td>yes,but I have a problem with a new user,butI don&#x27;t want to do that.</td></tr><tr><td>VHRED</td><td>what is the best way to do that ?what is that ?</td></tr><tr><td>hredGAN_w</td><td>yes,I&#x27;m on alive system,I’m trying to use the partition to boot from windows</td></tr><tr><td>hredGAN_u</td><td>I&#x27;m not sure if it’s a good idea to have a backup of the system..</td></tr><tr><td>Context.0</td><td>are you using lvm for your root partition?</td></tr><tr><td>Context_1</td><td>ihavethesameofgorkigoa04box.Itppearsin2.04lvisonustartandutipathisnotidouselforyootderifty is thereanywaytworkarounditaveyuhardofayonepostingaugabouthistohaveitookedtdar.welliopethycanfiis</td></tr><tr><td></td><td>eventuallyiopetheykeepitrdroundandmoveeverytingtoustartUpstartisoteasytosetupforprogamstatdon’tcomepackaged</td></tr><tr><td></td><td>for upstart. I don&#x27;t know what the problem is,but I don&#x27;t know what the problem is .?</td></tr><tr><td>HRED VHRED</td><td>is there a way to do that ?or **unknown** ？</td></tr><tr><td>hredGAN_w</td><td>you can also try the live cd and see if you can get it back up the live&quot;</td></tr><tr><td>hredGAN-u</td><td>I&#x27;mtryintotywirelessorkingomyapto,ut’mgeingtoheintatcaeabletousteirelescardtogethieless</td></tr><tr><td></td><td>working.</td></tr><tr><td>Context_0</td><td>are you using lvm for your root partition? ihavethesameofgorkingoa0.04box.Itppearsin2.04lisonupstartandultipathisot.idouselforyotfolderifty</td></tr><tr><td>Context.1</td><td>istheranyaytoworkaroundihaveyouhardofanyonepostingabugabouttis tohaveitokedatdar.welliopethyanfiis eventuallyiopetheyepiitrdoudandmoveeverytngtoupstartUpstartisoteasytosetupforprogamstatdon&#x27;tcoepackaged</td></tr><tr><td></td><td>for upstart.</td></tr><tr><td>Context_2 HRED</td><td>yes,becauseicant supply itatboottime,iwantthe truecrypt drive to come up by itself without manual intervention what is the problem ?</td></tr><tr><td>VHRED</td><td>what do you mean ?</td></tr><tr><td>hredGAN_w</td><td>you can also mount a new one and put the mount command to the mount point”</td></tr><tr><td>hredGAN_u</td><td>I&#x27;m trying to get my sound working,butI&#x27;m trying to get my sound working.</td></tr><tr><td></td><td>are you using lvm for your root partition?</td></tr><tr><td>Context_0</td><td></td></tr><tr><td>Context_1</td><td>ihavethesameconfgorkingona4box.Itappearsin04lisonupstartandutipathisnotidouselforootfolderifty isthereanyytworkroudiaveyouheardofanyonepostingugaboutistoveitlokedatdar.welliopeteyafiis</td></tr><tr><td></td><td>eventuallyiopetheykeepitrdroundandmoveeverytingtoustartUpstartisoteasytosetupforprogamstatdon’tcomepackaged</td></tr><tr><td></td><td>for upstart.</td></tr><tr><td>Context_2</td><td>yes,becauseicantsupply itatboottime,i wantthe truecrypt drive to come up by itself without manual intervention</td></tr><tr><td>Context_3</td><td>Kinda defeats the use of it anyone could get in don&#x27;t you think?</td></tr><tr><td>HRED</td><td>what is the problem ?</td></tr><tr><td>VHRED</td><td>is there a way to mount the file ?if you want to do it ?</td></tr><tr><td>hredGAN_w</td><td>I have no idea,I just want to get the data from the other computer</td></tr><tr><td></td><td>I&#x27;m trying to getthe latest driver from the nvidia driver,butI’m trying to get the nvidia driver working</td></tr><tr><td>hredGAN_u</td><td></td></tr><tr><td></td><td></td></tr></table>",
+        "bbox": [
+            173,
+            121,
+            823,
+            775
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rJo9n9Feg/rJo9n9Feg.md

@@ -0,0 +1,164 @@
+# CHESS GAME CONCEPTS EMERGE UNDER WEAK SUPERVISION: A CASE STUDY OF TIC-TAC-TOE
+
+Hao Zhao∗& Ming Lu   
+Department of Electronic Engineering   
+Tsinghua University   
+Beijing, China   
+{zhao-h13,lu-m13}@mails.tsinghua.edu.cn   
+Anbang Yao & Yurong Chen   
+Cognitive Computing Laboratory   
+Intel Labs China   
+Beijing, China   
+{anbang.yao,yurong.chen}@intel.com   
+Li Zhang   
+Department of Electronic Engineering   
+Tsinghua University   
+Beijing, China   
+{chinazhangli}@mail.tsinghua.edu.cn
+
+# ABSTRACT
+
+This paper explores the possibility of learning chess game concepts under weak supervision with convolutional neural networks, which is a topic that has not been visited to the best of our knowledge. We put this task in three different backgrounds: (1) deep reinforcement learning has shown an amazing capability to learn a mapping from visual inputs to most rewarding actions, without knowing the concepts of a video game. But how could we confirm that the network understands these concepts or it just does not? (2) cross-modal supervision for visual representation learning has drawn much attention recently. Is this methodology still applicable when it comes to the domain of game concepts and actions? (3) class activation mapping is widely recognized as a visualization technique to help us understand what a network has learnt. Is it possible for it to activate at non-salient regions? With the simplest chess game tic-tac-toe, we report interesting results as answers to those three questions mentioned above. All codes, pre-processed datasets and pre-trained models will be released.
+
+# 1 INTRODUCTION
+
+# 1.1 APPLICATION BACKGROUND
+
+Deep reinforcement learning (DRL) has drawn quite much attention since the publication of influential work Mnih et al. (2015). A convolutional neural network (CNN) is used to bridge the gap between video game screen frames and the most rewarding actions. An amazing feature of this kind of systems is that they do not need to know the concepts of these games (e.g. DRL learns to play Breakout without knowing there is a paddle or a ball in Fig 1a). However, how could we confirm that this network really understands these concepts or it just learns a mapping from patterns in the visual inputs to the best actions? This is the first question we are trying to answer here.
+
+Mnih et al. (2015) provides some unsupervised analysis results for visualization, showing that perceptually dissimilar frames may produce close rewards, yet this does not answer the question. We choose another visualization technique called class activation mapping as described in Zhou et al. (2016), which can reveal where the CNN’s attention is. However, directly applying it in tasks like Breakout still cannot answer the question. Imagine one modifies the network described in Mnih et al. (2015) into another version as Zhou et al. (2016) does. The CNN’s attention may be fixed on the ball but it is still not enough to support that the network understands the concept of a ball.
+
+![](images/212e02e9144ac3744d7cce5198efdf27e8ae3f48a5cf3f931abb6df3512a39f3.jpg)  
+Figure 1: We raise three questions from application, methodology and technique perspectives respectively and provide our answers with a case study of the simplest chess game tic-tac-toe.
+
+We propose to use a simple chess game called tic-tac-toe for case study. In order to answer the question, we propose a protocol as this: to place a piece where the CNN’s attention is, and examine whether it is the right move. Of course, the training has to be done under weak supervision, or say, without telling the network what exactly a right move is. We think if this experiment succeeds we can claim that the network figures out the concepts of: (1) a chess board grid; (2) the winning rule; (3) two sides. Detailed analysis about these three concepts are provided later.
+
+# 1.2 METHODOLOGY BACKGROUND
+
+There have been some works about representation learning with cross-modal supervision recently. Owens et al. (2016) clusters sound statistics into several categories, and uses them as labels to learn visual representation from images corresponding to these sounds. It quantitatively shows that visual representation learnt in this way is capable of handling challenging computer vision tasks and qualitatively shows that visual and sound representations are consistent (e.g. babies’ faces correspond to baby cry sound samples). Castrejon et al. (2016) goes even further by learning representations ´ across five modalities: RGB images, clip art pictures, sketches, texts and spatial texts. Gupta et al. (2016) learns depth image representation with mid-level features extracted from RGB images as supervision, and reports improved RGB-D object detection performance.
+
+What is the common point among these works? They generate weak supervision from one modality and use it to learn representation from another (e.g. to learn what a train looks like from what a train sounds like or to learn what a chair looks like in depth images from what a chair looks like in RGB images). During training phase, no concepts about a train or a chair are explicitly modeled. Although there are many other modalities not visited by this methodology, we think the basic ideas behind these works are same: an abstract concept like a train can be observed in different modalities and different representations can be connected.
+
+Here comes the question: is this methodology still applicable when it goes beyond the problem of learning representations from different observations of a same concept? Albanie & Vedaldi (2016) is an example, which tries to relate facial expressions with what happened in a TV show (e.g. if a character earns a lot of money, she will be very happy). Although in Albanie & Vedaldi (2016) what happened is explicitly defined, it still can be regarded as a weak supervision for what this expression is.
+
+Although with the same methodology, the problem studied in this paper addresses even higher semantics: to learn what to do under the weak supervision of what will happen (Fig 1b). This is substantially different from cross-modal supervision works mentioned above because there is no longer a certain abstract concept of object or attribute observed in different modalities. Instead, figuring out the relationship between what to do and what will happen needs a higher level of intelligence.
+
+# 1.3 TECHNIQUE BACKGROUND
+
+The core technique used in this paper is class activation mapping (CAM) as described in Zhou et al. (2016). So leaving out all the backgrounds about playing a chess game or cross-modal supervision, what do our experiments say more than its inventors’? We think we show that CAM can also activate at non-salient regions. CAM helps us to understand where contributes the most to a classification result. As Fig 1c shows, the heatmap reveals that the face contributes the most to the result that the network claims it as a person.
+
+As has already been shown by Krizhevsky et al. (2012), kernels of lower layers of a CNN capture gradients in an image. Existing CAM experiments tend to activate at salient regions, and this is very reasonable because there are more gradients and therefore more information (e.g. the face in Fig 1c). Here comes the question: could CAM activate at non-salient regions like the empty spaces on a chess board? Our answer is positive as the results (Fig 1d) show that in order to predict what will happen in the future, the CNN’s attention is fixed upon texture-free regions.
+
+Since we render chessboards as visual inputs without adding noise, those empty spaces are completely empty meaning that: (1) if we take out the activated patch in Fig 1d, all pixels in this patch have exactly the same value. (2) If we evaluate this patch with quantitative information metric like entropy, there is no information here. Thus the only reason why these regions are activated is that the network collects enough information from these regions’ receptive fields. We argue that this experiment (CAM can activate at non-salient regions) testifies (again) CNN’s ability to hierarchically collect information from visual inputs.
+
+# 1.4 WHAT THIS PAPER IS ABOUT
+
+After introducing those three backgrounds, we describe our work briefly as: to classify rendered tic-tac-toe chessboards with weak labels and to visualize that the CNN’s attention automatically reveals where the next piece should be placed. Learnt representation shows that: (1) the network knows some concepts of the game that it is not told of; (2) this level of supervision for representation learning is possible; (3) the technique of class activation mapping can activate at non-salient regions.
+
+# 2 RELATED WORKS
+
+# 2.1 CONCEPT LEARNING
+
+Concept learning has different meanings in different contexts, and how to confirm a concept is learnt remains an open question. In Jia et al. (2013), a concept is learnt if a generative model is learnt from a small number of positive samples. In Lake et al. (2015), a concept is learnt if a model learnt from only one instance can generalize to various tasks. Higgins et al. (2016) claims a concept is learnt when a model can predict unseen objects’ sizes and positions. To summarize, they evaluate whether a concept is learnt through a model’s generalization ability. In even earlier works like Zhu et al. (2010);Yang et al. (2010), concept learning means a object/attribute classification task dealing with appearance variations, in which a concept is actually already pre-defined.
+
+Unlike these works, we investigate the concepts of game rules instead of object/attribute. Unlike Jia et al. (2013);Lake et al. (2015);Higgins et al. (2016), we claim a concept is learnt through a novel testing protocol instead of generalization ability. Why generalization ability could show a concept is learnt? We think the reason is that a model understands a concept if it can use it in more cases. To this end, we argue that our protocol could also show a concept is learnt because the learnt representations in our experiments can be used to decide what to do though no rule about what need to be done is provided.
+
+# 2.2 CROSS-MODAL SUPERVISION
+
+The literature of cross-model supervision and the differences between this paper and existing ones are already covered in last section. Here we re-claim it briefly: Owens et al. (2016);Castrejon et al. ´ (2016);Gupta et al. (2016) learn representations across modalities because actually they are different observations of a same (object or attribute) concept. Whether this methodology is applicable for higher-level concepts like game rules remains an open question and we provide positive answers to this question.
+
+![](images/8892a56ef87396c0bedee70e871be9fad495f0c0c15b30f3151d2d2719a136dd.jpg)  
+Figure 2: 18 different types of chessboard states and corresponding labels.
+
+# 2.3 CLASS ACTIVATION MAPPING
+
+Before the technique of class activation mapping is introduced by Zhou et al. (2016), pioneering works like Simonyan et al. (2014);Zhou et al. (2015) have already shown CNN’s ability to localize objects with image-level labels. Although with different techniques, Simonyan et al. (2014);Zhou et al. (2015)’s activation visualization results also focus on salient regions. Unlike these works, we show that class activation mapping can activate at non-salient regions, or say more specifically, completely texture-free regions. Since the activated patch itself provides no information, all discriminative information comes from its context. This is another strong evidence to prove CNN’s capability to collect information from receptive fields, as a hierarchical visual model.
+
+# 3 EXPERIMENT I: GAME ENDS IN NEXT MOVE
+
+A tic-tac-toe chessboard is a $3 \times 3$ grid, and there are two players (black and white in our case). Due to duality, we generate all training samples assuming the black side takes the first move. The state space of tic-tac-toe is small consisting of totally $3 ^ { 9 } = 1 9 6 8 3$ combinations. Among them, many combinations are illegal such as the one in which all 9 pieces are black. We exhaustively search over the space according to a recursive simulation algorithm, in which: (1) the chessboard state is denoted by an integer smaller than 19683. (2) every state corresponds to a 9-d vector, with each element can take a value from this set $\{ 0$ -illegal, 1-black win, 2-white win, 4-tie, 5-uncertain}. We call this 9-d vector a state transfer vector, denoting what will happen if the next legal piece placement happens at according location. (3) generated transfer vectors can predict the existence of a critical move that will finish the game in advance. We will release this simulation code.
+
+After pruning out illegal states, we collect 4486 possible states in total. Among these samples, we further take out 1029 states that a certain side is going to win in the next move. We then transform these chessboard states into visual representations (gray-scale images at resolution (180, 180)). Each of these 1029 samples is assigned a label according to the state transfer vectors. There are totally 18 different labels illustrating 2 (sides) $\times 9$ (locations). As demonstrated by Fig 2, we randomly pick a sample for each label. As mentioned before black side takes the first move, thus if the numbers of black and white pieces are equal the next move will be black side’s and if there are one more black piece the next move will be white side’s.
+
+![](images/8f8d60a34b686f41449c3251b6fd487b761cb5d326e1b51c7d782dde4f49e98b.jpg)  
+Figure 3: Class activation mapping results on our dataset.
+
+Although the concepts of two sides and nine locations are coded into the labels, this kind of supervision is still weak supervision. Because what we are showing to the algorithm is just 18 abstract categories as Fig 2 shows. Could an algorithm figure out what it needs to do by observing these visual inputs? We think even for a human baby it is difficult because no concepts like this is a game or you need to find out how to win are provided. In the setting of deep reinforcement learning there is at least an objective of getting higher score to pursue.
+
+As mentioned before, the method we exploit is to train a classification network on this rendered dataset (Fig 2) and analyze learnt representations with the technique of class activation mapping. As Zhou et al. (2016) suggests, we add one global average pooling layer after the last convolutional layer of a pre-trained AlexNet model. All fully connected layers of the AlexNet model are discarded, and a new fully connected layer is added after the global average pooling layer. After the new classification network is fine-tuned on our dataset, a CAM visualization is generated by weighting the outputs of the last convolutional layer with parameters from the added fully connected layer. Our CAM implementation is built upon Marvin and it will be released.
+
+Due to the simplicity of this classification task, the top one classification accuracy is $100 \%$ (not surprisingly). Class activation mapping results are provided in Fig 3 and here we present the reasons why we claim concepts are learnt: (1) We provide 18 abstract categories, but in order to classify visual inputs into these 18 categories the network’s attention is roughly fixed upon chessboard grids.
+
+![](images/226e2c831d860a179e42335e7f0432775ef17d4bdb8ac894947b5e24c52ec26f.jpg)  
+Figure 4: Class activation mapping results after grid lines are added.
+
+This means the concept of grid emerges in the learnt representation. (2) If we place a piece at the most activated location in Fig 3, that will be the right (and legal) move to finish the game. On one hand, this means the concept of winning rule emerges in the learnt representation. On the other hand, this means this learnt concept can be used to deal with un-taught task (analogous to Jia et al. (2013);Lake et al. (2015);Higgins et al. (2016) who use generalization ability to illustrate that concepts are learnt). (3) As Fig 3cehijnpq show, both sides can win in the next move if we violate the take-turns rule. However, the network pays attention to the right location that is consistent to the rule. For example, in Fig 3j, it seems that placing a black piece at the left-top location will also end the game. However, this move will violate the rule because there are already more black pieces than white pieces meaning that this is the white side’s turn. This means that the concept of two sides emerges in learnt representation.
+
+Except for learnt concepts, we analyze what this experiment provides for the remaining two questions. To the second question: results in Fig 3 show that the methodology of generating labels from one modality (state transfer vectors in our case) to supervise another modality is still applicable. More importantly, we use images as inputs yet the learnt visual representations contain not only visual saliency information but also untold chess game concepts. To the third question: as Fig 3 shows, most activated regions are empty spaces on the chessboard.
+
+# 4 EXPERIMENT II: ADDING GRID LINES
+
+Since we claim complicated concepts emerge in learnt visual representations, a natural question will be: if the chessboard’s and pieces’ appearances are changed does this experiment still work? Thus we design this experiment by adding grid lines to the chessboards when rendering synthetic data (Fig 4). The intentions behind this design is three-folded: (1) in this case, the chessboard’s appearance is changed. (2) after these lines are added, the concept that there is a chessboard grid is actually implied. Still, we do not think these lines directly provide the concept of chessboard grid thus we use the word imply. Whether the network can figure out what these lines mean still remain uncertain. (3) those locations that are completely empty in Experiment I are no longer empty from the perspective of information (still empty from the perspective of game rule).
+
+![](images/5238a69f19c05ea5229faba22dda67bc64c677462955158ffe8170e6749eebed.jpg)  
+Figure 5: Class activation mapping results after piece appearance is changed.
+
+We train the same network on the newly rendered dataset with grid lines and calculate CAM results in the same way. The results are demonstrated by Fig 4. Generally speaking, the grid lines allow the network to better activate at the location of right move, making them stands out more on the heatmap. What does this mean to the three intentions mentioned in last paragraph? (1) Firstly, it shows that our experiment is robust to chess board appearance variance. (2) Secondly, after implying the concept that there is a chessboard grid, the network performs better at paying attention to the location of right move. Again we compare this phenomenon against how a human baby learns. Although not supported by phycological experiment, we think with a chessboard grid a human baby is more easy to figure out the game rule than without. (3) Thirdly, heatmap changes in Fig 4 is not surprising, because after adding those lines, the empty (from the perspective of game rule) regions contain more gradients for lower layers of a CNN to collect. However, again it supports that activating at non-salient regions is NOT trivial.
+
+# 5 EXPERIMENT III: PIECE APPEARANCE CHANGE
+
+In this experiment we change the appearance of the piece by: (1) replacing black boxes with white circles; (2) replacing white boxes with black crosses. Note that in this case the white side moves first. Again we train the same network and visualize with CAM. The results comparison is provided in Fig 6. Further we add grid lines to the cross/circle chessboard.
+
+# 6 EXPERIMENT IV: MODEL BEHAVIOR OVER TIME
+
+In order to further demonstrate the non-triviality of the model behaviors, we design this experiment. We train on the dataset in Experiment I with 1000 iterations and snap-shotted the parameters at 500th iteration. The classification accuracy is $100 \%$ at 1000th iteration and $5 3 . 1 3 \%$ at $5 0 0 \mathrm { { t h } }$ iteration. The
+
+![](images/a8f8adc772c519b2e57b717c8754a2ce124e23d0e0deb48f45376d388ad84535.jpg)  
+Figure 6: Class activation mapping results on true positive samples at 500 iterations (left, $5 3 . 1 3 \%$ accuracy) and 1000 iterations (right, $100 \%$ accuracy).
+
+![](images/01b182b4efe7c03df5fc6c15a4502eb08266f0fecea19c4505bd2b42f31fed7e.jpg)  
+Figure 7: We propose two quantitative evaluation protocols: (a) by selecting the most activated patch, we calculate how frequent the representation fire at the correct location; (b) we correlate the representation with an ideal activation map.
+
+CAM results are shown by Fig 5 in which all samples are true positives. We think it shows that there are two ways to achieve this classification task: (1) by paying attention to the visual patterns formed by the existing pieces; (2) by paying attention to where the next piece should be placed. This experiment shows that at an earlier stage of learning the model’s behavior is consistent to the first hypothesis and after the training is completely done the network can finally fire at correct location.
+
+# 7 QUANTITATIVE EVALUATION
+
+We propose two different quantitative evaluation protocols. The first one is representation accuracy (RAC), for which we select the most activated patch and examine whether it is the correct location to end the game. The second one is representation consistency (RCO), which correlates the normalized representation and a normalized ideal activation map. The quantitative comparisons are shown in Table 1, in which NAC stands for network classification accuracy. These results quantitatively support that: (1) learnt representation can be used to predict the right move at an over $70 \%$ accuracy. (2) adding grid lines (implying the concept of a chessboard) dramatically improves localization.
+
+# 8 CONCLUSION
+
+The core experiment in this paper is to train a classification CNN on rendered chessboard images under weak labels. After class activation mapping visualization, we analyse and interpret the results in three different backgrounds. Although simple, we argue that our results are enough to show that: (1) a CNN can automatically figure out complicated game rule concepts in this case. (2) cross-modal supervision for representation learning is still applicable in this case of higher-level semantics. (3) the technique of CAM can activate at non-salient regions, testifying CNN’s capability to collect information from context in an extreme case (only context has information).
+
+Table 1: Quantitative results.   
+
+<table><tr><td>Experiment</td><td>I original</td><td>II grid</td><td>Ⅲ piece</td><td>ⅢI piece+grid</td><td>IV 500th</td></tr><tr><td>NAC (%)</td><td>100.00</td><td>100.00</td><td>100.00</td><td>100.00</td><td>53.13</td></tr><tr><td>RAC (%)</td><td>71.82</td><td>97.25</td><td>83.77</td><td>99.00</td><td>27.87</td></tr><tr><td>RCO (103)</td><td>-8.096</td><td>-5.115</td><td>-7.751</td><td>-4.9321</td><td>-10.610</td></tr></table>
+
+# REFERENCES
+
+Samuel Albanie and Andrea Vedaldi. Learning grimaces by watching tv. In BMVC, 2016.
+
+Lluıs Castrejon, Yusuf Aytar, Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Learning ´ aligned cross-modal representations from weakly aligned data. In CVPR, 2016.
+
+Saurabh Gupta, Judy Hoffman, and Jitendra Malik. Cross modal distillation for supervision transfer. In CVPR, 2016.
+
+Irina Higgins, Loic Matthey, Xavier Glorot, Arka Pal, Benigno Uria, Charles Blundell, Shakir Mohamed, and Alexander Lerchner. Early visual concept learning with unsupervised deep learning. arXiv:1606.05579, 2016.
+
+Yangqing Jia, Joshua T Abbott, Joseph Austerweil, Thomas Griffiths, and Trevor Darrell. Visual concept learning: Combining machine vision and bayesian generalization on concept hierarchies. In NIPS, 2013.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012.
+
+Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. In Science, 2015.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. In Nature, 2015.
+
+Andrew Owens, Jiajun Wu, Josh H McDermott, William T Freeman, and Antonio Torralba. Ambient sound provides supervision for visual learning. In ECCV, 2016.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. 2014.
+
+Jingjing Yang, Yuanning Li, Yonghong Tian, Ling-Yu Duan, and Wen Gao. Per-sample multiple kernel approach for visual concept learning. In Journal on Image and Video Processing, 2010.
+
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Object detectors emerge in deep scene cnns. In ICLR, 2015.
+
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In CVPR, 2016.
+
+Shiai Zhu, Gang Wang, Chong-Wah Ngo, and Yu-Gang Jiang. On the sampling of web images for learning visual concept classifiers. In Proceedings of the ACM International Conference on Image and Video Retrieval, 2010.

parse/train/rJo9n9Feg/rJo9n9Feg_content_list.json

@@ -0,0 +1,900 @@
+[
+    {
+        "type": "text",
+        "text": "CHESS GAME CONCEPTS EMERGE UNDER WEAK SUPERVISION: A CASE STUDY OF TIC-TAC-TOE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hao Zhao∗& Ming Lu   \nDepartment of Electronic Engineering   \nTsinghua University   \nBeijing, China   \n{zhao-h13,lu-m13}@mails.tsinghua.edu.cn   \nAnbang Yao & Yurong Chen   \nCognitive Computing Laboratory   \nIntel Labs China   \nBeijing, China   \n{anbang.yao,yurong.chen}@intel.com   \nLi Zhang   \nDepartment of Electronic Engineering   \nTsinghua University   \nBeijing, China   \n{chinazhangli}@mail.tsinghua.edu.cn ",
+        "bbox": [
+            184,
+            170,
+            562,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            580,
+            170,
+            913,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            261,
+            524,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            367,
+            544,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper explores the possibility of learning chess game concepts under weak supervision with convolutional neural networks, which is a topic that has not been visited to the best of our knowledge. We put this task in three different backgrounds: (1) deep reinforcement learning has shown an amazing capability to learn a mapping from visual inputs to most rewarding actions, without knowing the concepts of a video game. But how could we confirm that the network understands these concepts or it just does not? (2) cross-modal supervision for visual representation learning has drawn much attention recently. Is this methodology still applicable when it comes to the domain of game concepts and actions? (3) class activation mapping is widely recognized as a visualization technique to help us understand what a network has learnt. Is it possible for it to activate at non-salient regions? With the simplest chess game tic-tac-toe, we report interesting results as answers to those three questions mentioned above. All codes, pre-processed datasets and pre-trained models will be released. ",
+        "bbox": [
+            233,
+            400,
+            764,
+            594
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            625,
+            334,
+            640
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1.1 APPLICATION BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            656,
+            415,
+            671
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep reinforcement learning (DRL) has drawn quite much attention since the publication of influential work Mnih et al. (2015). A convolutional neural network (CNN) is used to bridge the gap between video game screen frames and the most rewarding actions. An amazing feature of this kind of systems is that they do not need to know the concepts of these games (e.g. DRL learns to play Breakout without knowing there is a paddle or a ball in Fig 1a). However, how could we confirm that this network really understands these concepts or it just learns a mapping from patterns in the visual inputs to the best actions? This is the first question we are trying to answer here. ",
+        "bbox": [
+            174,
+            684,
+            823,
+            781
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mnih et al. (2015) provides some unsupervised analysis results for visualization, showing that perceptually dissimilar frames may produce close rewards, yet this does not answer the question. We choose another visualization technique called class activation mapping as described in Zhou et al. (2016), which can reveal where the CNN’s attention is. However, directly applying it in tasks like Breakout still cannot answer the question. Imagine one modifies the network described in Mnih et al. (2015) into another version as Zhou et al. (2016) does. The CNN’s attention may be fixed on the ball but it is still not enough to support that the network understands the concept of a ball. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            885
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/212e02e9144ac3744d7cce5198efdf27e8ae3f48a5cf3f931abb6df3512a39f3.jpg",
+        "image_caption": [
+            "Figure 1: We raise three questions from application, methodology and technique perspectives respectively and provide our answers with a case study of the simplest chess game tic-tac-toe. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            825,
+            255
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose to use a simple chess game called tic-tac-toe for case study. In order to answer the question, we propose a protocol as this: to place a piece where the CNN’s attention is, and examine whether it is the right move. Of course, the training has to be done under weak supervision, or say, without telling the network what exactly a right move is. We think if this experiment succeeds we can claim that the network figures out the concepts of: (1) a chess board grid; (2) the winning rule; (3) two sides. Detailed analysis about these three concepts are provided later. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            446
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.2 METHODOLOGY BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            431,
+            505
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There have been some works about representation learning with cross-modal supervision recently. Owens et al. (2016) clusters sound statistics into several categories, and uses them as labels to learn visual representation from images corresponding to these sounds. It quantitatively shows that visual representation learnt in this way is capable of handling challenging computer vision tasks and qualitatively shows that visual and sound representations are consistent (e.g. babies’ faces correspond to baby cry sound samples). Castrejon et al. (2016) goes even further by learning representations ´ across five modalities: RGB images, clip art pictures, sketches, texts and spatial texts. Gupta et al. (2016) learns depth image representation with mid-level features extracted from RGB images as supervision, and reports improved RGB-D object detection performance. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            652
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "What is the common point among these works? They generate weak supervision from one modality and use it to learn representation from another (e.g. to learn what a train looks like from what a train sounds like or to learn what a chair looks like in depth images from what a chair looks like in RGB images). During training phase, no concepts about a train or a chair are explicitly modeled. Although there are many other modalities not visited by this methodology, we think the basic ideas behind these works are same: an abstract concept like a train can be observed in different modalities and different representations can be connected. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here comes the question: is this methodology still applicable when it goes beyond the problem of learning representations from different observations of a same concept? Albanie & Vedaldi (2016) is an example, which tries to relate facial expressions with what happened in a TV show (e.g. if a character earns a lot of money, she will be very happy). Although in Albanie & Vedaldi (2016) what happened is explicitly defined, it still can be regarded as a weak supervision for what this expression is. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Although with the same methodology, the problem studied in this paper addresses even higher semantics: to learn what to do under the weak supervision of what will happen (Fig 1b). This is substantially different from cross-modal supervision works mentioned above because there is no longer a certain abstract concept of object or attribute observed in different modalities. Instead, figuring out the relationship between what to do and what will happen needs a higher level of intelligence. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.3 TECHNIQUE BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            401,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The core technique used in this paper is class activation mapping (CAM) as described in Zhou et al. (2016). So leaving out all the backgrounds about playing a chess game or cross-modal supervision, what do our experiments say more than its inventors’? We think we show that CAM can also activate at non-salient regions. CAM helps us to understand where contributes the most to a classification result. As Fig 1c shows, the heatmap reveals that the face contributes the most to the result that the network claims it as a person. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            213
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As has already been shown by Krizhevsky et al. (2012), kernels of lower layers of a CNN capture gradients in an image. Existing CAM experiments tend to activate at salient regions, and this is very reasonable because there are more gradients and therefore more information (e.g. the face in Fig 1c). Here comes the question: could CAM activate at non-salient regions like the empty spaces on a chess board? Our answer is positive as the results (Fig 1d) show that in order to predict what will happen in the future, the CNN’s attention is fixed upon texture-free regions. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since we render chessboards as visual inputs without adding noise, those empty spaces are completely empty meaning that: (1) if we take out the activated patch in Fig 1d, all pixels in this patch have exactly the same value. (2) If we evaluate this patch with quantitative information metric like entropy, there is no information here. Thus the only reason why these regions are activated is that the network collects enough information from these regions’ receptive fields. We argue that this experiment (CAM can activate at non-salient regions) testifies (again) CNN’s ability to hierarchically collect information from visual inputs. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.4 WHAT THIS PAPER IS ABOUT ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            428,
+            418,
+            443
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After introducing those three backgrounds, we describe our work briefly as: to classify rendered tic-tac-toe chessboards with weak labels and to visualize that the CNN’s attention automatically reveals where the next piece should be placed. Learnt representation shows that: (1) the network knows some concepts of the game that it is not told of; (2) this level of supervision for representation learning is possible; (3) the technique of class activation mapping can activate at non-salient regions. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            525
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            354,
+            563
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 CONCEPT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            579,
+            361,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Concept learning has different meanings in different contexts, and how to confirm a concept is learnt remains an open question. In Jia et al. (2013), a concept is learnt if a generative model is learnt from a small number of positive samples. In Lake et al. (2015), a concept is learnt if a model learnt from only one instance can generalize to various tasks. Higgins et al. (2016) claims a concept is learnt when a model can predict unseen objects’ sizes and positions. To summarize, they evaluate whether a concept is learnt through a model’s generalization ability. In even earlier works like Zhu et al. (2010);Yang et al. (2010), concept learning means a object/attribute classification task dealing with appearance variations, in which a concept is actually already pre-defined. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unlike these works, we investigate the concepts of game rules instead of object/attribute. Unlike Jia et al. (2013);Lake et al. (2015);Higgins et al. (2016), we claim a concept is learnt through a novel testing protocol instead of generalization ability. Why generalization ability could show a concept is learnt? We think the reason is that a model understands a concept if it can use it in more cases. To this end, we argue that our protocol could also show a concept is learnt because the learnt representations in our experiments can be used to decide what to do though no rule about what need to be done is provided. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 CROSS-MODAL SUPERVISION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            416,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The literature of cross-model supervision and the differences between this paper and existing ones are already covered in last section. Here we re-claim it briefly: Owens et al. (2016);Castrejon et al. ´ (2016);Gupta et al. (2016) learn representations across modalities because actually they are different observations of a same (object or attribute) concept. Whether this methodology is applicable for higher-level concepts like game rules remains an open question and we provide positive answers to this question. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/8892a56ef87396c0bedee70e871be9fad495f0c0c15b30f3151d2d2719a136dd.jpg",
+        "image_caption": [
+            "Figure 2: 18 different types of chessboard states and corresponding labels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            98,
+            826,
+            385
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            452,
+            825,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 CLASS ACTIVATION MAPPING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            423,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Before the technique of class activation mapping is introduced by Zhou et al. (2016), pioneering works like Simonyan et al. (2014);Zhou et al. (2015) have already shown CNN’s ability to localize objects with image-level labels. Although with different techniques, Simonyan et al. (2014);Zhou et al. (2015)’s activation visualization results also focus on salient regions. Unlike these works, we show that class activation mapping can activate at non-salient regions, or say more specifically, completely texture-free regions. Since the activated patch itself provides no information, all discriminative information comes from its context. This is another strong evidence to prove CNN’s capability to collect information from receptive fields, as a hierarchical visual model. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENT I: GAME ENDS IN NEXT MOVE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            660,
+            580,
+            678
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A tic-tac-toe chessboard is a $3 \\times 3$ grid, and there are two players (black and white in our case). Due to duality, we generate all training samples assuming the black side takes the first move. The state space of tic-tac-toe is small consisting of totally $3 ^ { 9 } = 1 9 6 8 3$ combinations. Among them, many combinations are illegal such as the one in which all 9 pieces are black. We exhaustively search over the space according to a recursive simulation algorithm, in which: (1) the chessboard state is denoted by an integer smaller than 19683. (2) every state corresponds to a 9-d vector, with each element can take a value from this set $\\{ 0$ -illegal, 1-black win, 2-white win, 4-tie, 5-uncertain}. We call this 9-d vector a state transfer vector, denoting what will happen if the next legal piece placement happens at according location. (3) generated transfer vectors can predict the existence of a critical move that will finish the game in advance. We will release this simulation code. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After pruning out illegal states, we collect 4486 possible states in total. Among these samples, we further take out 1029 states that a certain side is going to win in the next move. We then transform these chessboard states into visual representations (gray-scale images at resolution (180, 180)). Each of these 1029 samples is assigned a label according to the state transfer vectors. There are totally 18 different labels illustrating 2 (sides) $\\times 9$ (locations). As demonstrated by Fig 2, we randomly pick a sample for each label. As mentioned before black side takes the first move, thus if the numbers of black and white pieces are equal the next move will be black side’s and if there are one more black piece the next move will be white side’s. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/8f8d60a34b686f41449c3251b6fd487b761cb5d326e1b51c7d782dde4f49e98b.jpg",
+        "image_caption": [
+            "Figure 3: Class activation mapping results on our dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            98,
+            825,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            623,
+            823,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although the concepts of two sides and nine locations are coded into the labels, this kind of supervision is still weak supervision. Because what we are showing to the algorithm is just 18 abstract categories as Fig 2 shows. Could an algorithm figure out what it needs to do by observing these visual inputs? We think even for a human baby it is difficult because no concepts like this is a game or you need to find out how to win are provided. In the setting of deep reinforcement learning there is at least an objective of getting higher score to pursue. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As mentioned before, the method we exploit is to train a classification network on this rendered dataset (Fig 2) and analyze learnt representations with the technique of class activation mapping. As Zhou et al. (2016) suggests, we add one global average pooling layer after the last convolutional layer of a pre-trained AlexNet model. All fully connected layers of the AlexNet model are discarded, and a new fully connected layer is added after the global average pooling layer. After the new classification network is fine-tuned on our dataset, a CAM visualization is generated by weighting the outputs of the last convolutional layer with parameters from the added fully connected layer. Our CAM implementation is built upon Marvin and it will be released. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Due to the simplicity of this classification task, the top one classification accuracy is $100 \\%$ (not surprisingly). Class activation mapping results are provided in Fig 3 and here we present the reasons why we claim concepts are learnt: (1) We provide 18 abstract categories, but in order to classify visual inputs into these 18 categories the network’s attention is roughly fixed upon chessboard grids. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/226e2c831d860a179e42335e7f0432775ef17d4bdb8ac894947b5e24c52ec26f.jpg",
+        "image_caption": [
+            "Figure 4: Class activation mapping results after grid lines are added. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            101,
+            825,
+            452
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This means the concept of grid emerges in the learnt representation. (2) If we place a piece at the most activated location in Fig 3, that will be the right (and legal) move to finish the game. On one hand, this means the concept of winning rule emerges in the learnt representation. On the other hand, this means this learnt concept can be used to deal with un-taught task (analogous to Jia et al. (2013);Lake et al. (2015);Higgins et al. (2016) who use generalization ability to illustrate that concepts are learnt). (3) As Fig 3cehijnpq show, both sides can win in the next move if we violate the take-turns rule. However, the network pays attention to the right location that is consistent to the rule. For example, in Fig 3j, it seems that placing a black piece at the left-top location will also end the game. However, this move will violate the rule because there are already more black pieces than white pieces meaning that this is the white side’s turn. This means that the concept of two sides emerges in learnt representation. ",
+        "bbox": [
+            174,
+            521,
+            825,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Except for learnt concepts, we analyze what this experiment provides for the remaining two questions. To the second question: results in Fig 3 show that the methodology of generating labels from one modality (state transfer vectors in our case) to supervise another modality is still applicable. More importantly, we use images as inputs yet the learnt visual representations contain not only visual saliency information but also untold chess game concepts. To the third question: as Fig 3 shows, most activated regions are empty spaces on the chessboard. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            765
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENT II: ADDING GRID LINES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            524,
+            808
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since we claim complicated concepts emerge in learnt visual representations, a natural question will be: if the chessboard’s and pieces’ appearances are changed does this experiment still work? Thus we design this experiment by adding grid lines to the chessboards when rendering synthetic data (Fig 4). The intentions behind this design is three-folded: (1) in this case, the chessboard’s appearance is changed. (2) after these lines are added, the concept that there is a chessboard grid is actually implied. Still, we do not think these lines directly provide the concept of chessboard grid thus we use the word imply. Whether the network can figure out what these lines mean still remain uncertain. (3) those locations that are completely empty in Experiment I are no longer empty from the perspective of information (still empty from the perspective of game rule). ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5238a69f19c05ea5229faba22dda67bc64c677462955158ffe8170e6749eebed.jpg",
+        "image_caption": [
+            "Figure 5: Class activation mapping results after piece appearance is changed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            103,
+            825,
+            454
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            518,
+            823,
+            547
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We train the same network on the newly rendered dataset with grid lines and calculate CAM results in the same way. The results are demonstrated by Fig 4. Generally speaking, the grid lines allow the network to better activate at the location of right move, making them stands out more on the heatmap. What does this mean to the three intentions mentioned in last paragraph? (1) Firstly, it shows that our experiment is robust to chess board appearance variance. (2) Secondly, after implying the concept that there is a chessboard grid, the network performs better at paying attention to the location of right move. Again we compare this phenomenon against how a human baby learns. Although not supported by phycological experiment, we think with a chessboard grid a human baby is more easy to figure out the game rule than without. (3) Thirdly, heatmap changes in Fig 4 is not surprising, because after adding those lines, the empty (from the perspective of game rule) regions contain more gradients for lower layers of a CNN to collect. However, again it supports that activating at non-salient regions is NOT trivial. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            720
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENT III: PIECE APPEARANCE CHANGE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            741,
+            604,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment we change the appearance of the piece by: (1) replacing black boxes with white circles; (2) replacing white boxes with black crosses. Note that in this case the white side moves first. Again we train the same network and visualize with CAM. The results comparison is provided in Fig 6. Further we add grid lines to the cross/circle chessboard. ",
+        "bbox": [
+            174,
+            773,
+            825,
+            829
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENT IV: MODEL BEHAVIOR OVER TIME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            614,
+            866
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to further demonstrate the non-triviality of the model behaviors, we design this experiment. We train on the dataset in Experiment I with 1000 iterations and snap-shotted the parameters at 500th iteration. The classification accuracy is $100 \\%$ at 1000th iteration and $5 3 . 1 3 \\%$ at $5 0 0 \\mathrm { { t h } }$ iteration. The ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a8f8adc772c519b2e57b717c8754a2ce124e23d0e0deb48f45376d388ad84535.jpg",
+        "image_caption": [
+            "Figure 6: Class activation mapping results on true positive samples at 500 iterations (left, $5 3 . 1 3 \\%$ accuracy) and 1000 iterations (right, $100 \\%$ accuracy). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            826,
+            291
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/01b182b4efe7c03df5fc6c15a4502eb08266f0fecea19c4505bd2b42f31fed7e.jpg",
+        "image_caption": [
+            "Figure 7: We propose two quantitative evaluation protocols: (a) by selecting the most activated patch, we calculate how frequent the representation fire at the correct location; (b) we correlate the representation with an ideal activation map. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            357,
+            813,
+            525
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "CAM results are shown by Fig 5 in which all samples are true positives. We think it shows that there are two ways to achieve this classification task: (1) by paying attention to the visual patterns formed by the existing pieces; (2) by paying attention to where the next piece should be placed. This experiment shows that at an earlier stage of learning the model’s behavior is consistent to the first hypothesis and after the training is completely done the network can finally fire at correct location. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            689
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 QUANTITATIVE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            446,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We propose two different quantitative evaluation protocols. The first one is representation accuracy (RAC), for which we select the most activated patch and examine whether it is the correct location to end the game. The second one is representation consistency (RCO), which correlates the normalized representation and a normalized ideal activation map. The quantitative comparisons are shown in Table 1, in which NAC stands for network classification accuracy. These results quantitatively support that: (1) learnt representation can be used to predict the right move at an over $70 \\%$ accuracy. (2) adding grid lines (implying the concept of a chessboard) dramatically improves localization. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            842
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            863,
+            318,
+            878
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The core experiment in this paper is to train a classification CNN on rendered chessboard images under weak labels. After class activation mapping visualization, we analyse and interpret the results in three different backgrounds. Although simple, we argue that our results are enough to show that: (1) a CNN can automatically figure out complicated game rule concepts in this case. (2) cross-modal supervision for representation learning is still applicable in this case of higher-level semantics. (3) the technique of CAM can activate at non-salient regions, testifying CNN’s capability to collect information from context in an extreme case (only context has information). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/382a7fcea6ebda5cb37874260165473416ddb9a6888e51f6246b7efa2d7a595f.jpg",
+        "table_caption": [
+            "Table 1: Quantitative results. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Experiment</td><td>I original</td><td>II grid</td><td>Ⅲ piece</td><td>ⅢI piece+grid</td><td>IV 500th</td></tr><tr><td>NAC (%)</td><td>100.00</td><td>100.00</td><td>100.00</td><td>100.00</td><td>53.13</td></tr><tr><td>RAC (%)</td><td>71.82</td><td>97.25</td><td>83.77</td><td>99.00</td><td>27.87</td></tr><tr><td>RCO (103)</td><td>-8.096</td><td>-5.115</td><td>-7.751</td><td>-4.9321</td><td>-10.610</td></tr></table>",
+        "bbox": [
+            223,
+            98,
+            776,
+            190
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            246,
+            825,
+            315
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            285,
+            352
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Samuel Albanie and Andrea Vedaldi. Learning grimaces by watching tv. In BMVC, 2016. ",
+        "bbox": [
+            171,
+            359,
+            761,
+            376
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lluıs Castrejon, Yusuf Aytar, Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Learning ´ aligned cross-modal representations from weakly aligned data. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            383,
+            821,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Saurabh Gupta, Judy Hoffman, and Jitendra Malik. Cross modal distillation for supervision transfer. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            421,
+            820,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Loic Matthey, Xavier Glorot, Arka Pal, Benigno Uria, Charles Blundell, Shakir Mohamed, and Alexander Lerchner. Early visual concept learning with unsupervised deep learning. arXiv:1606.05579, 2016. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            502
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yangqing Jia, Joshua T Abbott, Joseph Austerweil, Thomas Griffiths, and Trevor Darrell. Visual concept learning: Combining machine vision and bayesian generalization on concept hierarchies. In NIPS, 2013. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            554
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012. ",
+        "bbox": [
+            173,
+            563,
+            821,
+            592
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. In Science, 2015. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            630
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. In Nature, 2015. ",
+        "bbox": [
+            176,
+            637,
+            823,
+            681
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew Owens, Jiajun Wu, Josh H McDermott, William T Freeman, and Antonio Torralba. Ambient sound provides supervision for visual learning. In ECCV, 2016. ",
+        "bbox": [
+            171,
+            689,
+            823,
+            719
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. 2014. ",
+        "bbox": [
+            171,
+            727,
+            821,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jingjing Yang, Yuanning Li, Yonghong Tian, Ling-Yu Duan, and Wen Gao. Per-sample multiple kernel approach for visual concept learning. In Journal on Image and Video Processing, 2010. ",
+        "bbox": [
+            171,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Object detectors emerge in deep scene cnns. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            803,
+            823,
+            832
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In CVPR, 2016. ",
+        "bbox": [
+            169,
+            840,
+            823,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shiai Zhu, Gang Wang, Chong-Wah Ngo, and Yu-Gang Jiang. On the sampling of web images for learning visual concept classifiers. In Proceedings of the ACM International Conference on Image and Video Retrieval, 2010. ",
+        "bbox": [
+            176,
+            878,
+            823,
+            921
+        ],
+        "page_idx": 8
+    }
+]