Add files using upload-large-folder tool

parse/train/1toB0Fo9CZy/1toB0Fo9CZy.md

@@ -0,0 +1,450 @@
+# NEURAL ARCHITECTURE SEARCH OF SPD MANIFOLD NETWORKS
+
+Anonymous authors
+
+# ABSTRACT
+
+In this paper, we propose a new neural architecture search (NAS) problem of Symmetric Positive Definite (SPD) manifold networks. Unlike the conventional NAS problem, our problem requires to search for a unique computational cell called the SPD cell. This SPD cell serves as a basic building block of SPD neural architectures. An efficient solution to our problem is important to minimize the extraneous manual effort in the SPD neural architecture design. To accomplish this goal, we first introduce a geometrically rich and diverse SPD neural architecture search space for an efficient SPD cell design. Further, we model our new NAS problem using the supernet strategy, which models the architecture search problem as a one-shot training process of a single supernet. Based on the supernet modeling, we exploit a differentiable NAS algorithm on our relaxed continuous search space for SPD neural architecture search. Statistical evaluation of our method on drone, action, and emotion recognition tasks mostly provides better results than the stateof-the-art SPD networks and NAS algorithms. Empirical results show that our algorithm excels in discovering better SPD network design and providing models that are more than 3 times lighter than searched by state-of-the-art NAS algorithms.
+
+# 1 INTRODUCTION
+
+Designing a favorable neural network architecture for a given application requires a lot of time, effort, and domain expertise. To mitigate this issue, researchers in the recent years have started developing algorithms to automate the design process of neural network architectures (Zoph & Le, 2016; Zoph et al., 2018; Liu et al., 2017; 2018a; Real et al., 2019; Liu et al., 2018b; Tian et al., 2020). Although these neural architecture search (NAS) algorithms have shown great potential to provide an optimal architecture for a given application, it is limited to handle architectures with Euclidean operations and representation. To deal with non-euclidean data representation and corresponding set of operations, researchers have barely proposed any NAS algorithms —to the best of our knowledge.
+
+It is well-known that manifold-valued data representation such as symmetric positive definite (SPD) matrices have shown overwhelming accomplishments in many real-world applications such as pedestrian detection (Tuzel et al., 2006; 2008), magnetic resonance imaging analysis (Pennec et al., 2006), action recognition (Harandi et al., 2014), face recognition (Huang et al., 2014; 2015), braincomputer interfaces (Barachant et al., 2011), structure from motion (Kumar et al., 2018; Kumar, 2019), etc. Also, in applications like diffusion tensor imaging of the brain, drone imaging, samples are collected directly as SPD’s. As a result, neural network usage based on Euclidean data representation becomes inefficient for those applications. Consequently, this has led to the development of the SPD neural network (SPDNet) architectures for further improvements in these areas of research (Huang & Van Gool, 2017; Brooks et al., 2019). However, these architectures are handcrafted, so the operations or the parameters defined for these networks generally change as per the application. This motivated us to propose a new NAS problem of SPD manifold networks. A solution to this problem can reduce unwanted efforts in SPDNet design. Compared to the traditional NAS problem, our NAS problem requires a new definition of computation cell and proposal for diverse SPD candidate operation set. In particular, we model the basic architecture cell with a specific directed acyclic graph (DAG), where each node is a latent SPD representation, and each edge corresponds to a SPD candidate operation. Here, the intermediate transformations between nodes respect the geometry of the SPD manifolds.
+
+For solving the suggested NAS problem, we exploit a supernet search strategy which models the architecture search problem as a one-shot training process of a supernet that comprises of a mixture of SPD neural architectures. The supernet modeling enables us to perform a differential architecture search on a continuous relaxation of SPD neural architecture search space, and therefore, can be solved using a gradient descent approach. Our evaluation validates that the proposed method can build a reliable SPD network from scratch. We show the results of our method on benchmark datasets that clearly show results better than handcrafted SPDNet. Our work makes the following contributions:
+
+• We introduce a NAS problem of SPD manifold networks that opens up a new direction of research in automated machine learning and SPD manifold learning. Based on a supernet modeling, we propose a novel differentiable NAS algorithm for SPD neural architecture search. Concretely, we exploit a sparsemax-based Frechet mixture of SPD operations to introduce sparsity that is essential ´ for an effective diffentiable search, and bi-level optimization with manifold-based update and convexity-based update to jointly optimize architecture parameters and network kernel weights. Besides well-studied operations from exiting SPDNets (Huang & Van Gool, 2017; Brooks et al., 2019; Chakraborty et al., 2020), we follow Liu et al. (2018b) to further introduce some new SPD layers, i.e., skip connection, none operation, max pooling and averaging pooling. Our introduced additional set of SPD operations make the search space more diverse for the neural architecture search algorithm to obtain more generalized SPD neural network architectures. Evaluation on three benchmark datasets shows that our searched SPD neural architectures can outperform the existing handcrafted SPDNets (Huang & Van Gool, 2017; Brooks et al., 2019; Chakraborty et al., 2020) and the state-of-the-art NAS methods (Liu et al., 2018b; Chu et al., 2020). Notably, our searched architecture is more than 3 times lighter than those searched by the traditional NAS algorithms.
+
+# 2 BACKGROUND
+
+In recent years, plenty of research work has been published in the area of NAS (Gong et al., 2019; Liu et al., 2019; Nayman et al., 2019; Guo et al., 2020). This is probably due to the success of deep learning for several applications which has eventually led to the automation of neural architecture design. Also, improvements in the processing capabilities of machines has influenced the researchers to work out this computationally expensive yet an important problem. Computational cost for some of the well-known NAS algorithms is in thousands of GPU days which has resulted in the development of several computationally efficient methods (Zoph et al., 2018; Real et al., 2019; Liu et al., 2018a; 2017; Baker et al., 2017; Brock et al., 2017; Bender, 2019; Elsken et al., 2017; Cai et al., 2018; Pham et al., 2018; Negrinho & Gordon, 2017; Kandasamy et al., 2018; Chu et al., 2020). In this work, we propose a new NAS problem of SPD networks. We solve this problem using a supernet modeling methodology with a one-shot differentiable training process of an overparameterized supernet. Our modeling is driven by the recent progress in supernet methodology. Supernet methodology has shown a great potential than other NAS methodologies in terms of search efficiency. Since our work is directed towards solving a new NAS problem, we confine our discussion to the work that have greatly influenced our method i.e., one-shot NAS methods and SPD networks.
+
+To the best of our knowledge, there are mainly two types of one-shot NAS methods based on the architecture modeling (Elsken et al., 2018) (a) parameterized architecture (Liu et al., 2018b; Zheng et al., 2019; Wu et al., 2019; Chu et al., 2020), and (b) sampled architecture (Deb et al., 2002; Chu et al., 2019). In this paper, we adhere to the parametric modeling due to its promising results on conventional neural architectures. A majority of the previous work on NAS with continuous search space fine-tunes the explicit feature of specific architectures (Saxena & Verbeek, 2016; Veniat & Denoyer, 2018; Ahmed & Torresani, 2017; Shin et al., 2018). On the contrary, Liu et al. (2018b); Liang et al. (2019); Zhou et al. (2019); Zhang et al. (2020); Wu et al. (2020); Chu et al. (2020) provides architectural diversity for NAS with highly competitive performances. The other part of our work focuses on SPD network architectures. There exist algorithms to develop handcrafted SPDNet (Huang & Van Gool, 2017; Brooks et al., 2019; Chakraborty et al., 2020). To automate the process of SPD network design, in this work, we choose the most promising approaches from these fields (NAS (Liu et al., 2018b), SPD networks (Huang & Van Gool, 2017)) and propose a NAS algorithm for SPD inputs. Next, we summarize the essential notions of Riemannian geometry of SPD manifolds, followed by an introduction of some basic SPDNet operations and layers. As some of the introduced operations and layers have been well-studied by the existing literature, we applied them directly to define our SPD neural architectures’ search space.
+
+Representation and Operation: We denote $n \times n$ real SPD as $\pmb { X } \in \mathcal { S } _ { + + } ^ { n }$ . A real SPD matrix $\pmb { X } \in \mathcal { S } _ { + + } ^ { n }$ satisfies the property that for any non-zero $z \in \mathbb { R } ^ { n }$ , $z ^ { T } X z > 0$ (Harandi et al., 2017). We denote $\overrightharpoon { \tau } _ { X } \mathcal { M }$ as the tangent space of the manifold $\mathcal { M }$ at $\pmb { X } \in \mathcal { S } _ { + + } ^ { n }$ and log corresponds to matrix logarithm. Let $X _ { 1 } , X _ { 2 }$ be any two points on the SPD manifold then the distance between them is given by
+
+$$
+\delta _ { \mathcal { M } } ( X _ { 1 } , X _ { 2 } ) = 0 . 5 \| \log ( X _ { 1 } ^ { - \frac { 1 } { 2 } } X _ { 2 } X _ { 1 } ^ { - \frac { 1 } { 2 } } ) \| _ { F }
+$$
+
+There are other efficient methods to compute distance between two points on the SPD manifold (Gao et al., 2019; Dong et al., 2017b), however, their discussion is beyond the scope of our work. Other property of the Riemannian manifold of our interest is local diffeomorphism of geodesics which is a one-to-one mapping from the point on the tangent space of the manifold to the manifold (Pennec, 2020; Lackenby, 2020). To define such notions, let $\pmb { X } \in \mathcal { S } _ { + + } ^ { n }$ be the base point and, $Y \in \mathcal { T } _ { \mathbf { X } } \mathcal { S } _ { + + } ^ { n }$ , then Eq:(2) associates $Y \in \mathcal { T } _ { X } { S } _ { + + } ^ { n }$ to a point on the manifold (Pennec, 2020).
+
+$$
+\exp _ { X } ( Y ) = X ^ { \frac { 1 } { 2 } } \exp ( X ^ { - \frac { 1 } { 2 } } Y X ^ { - \frac { 1 } { 2 } } ) X ^ { \frac { 1 } { 2 } } \in { \mathcal { S } } _ { + + } ^ { n } , \ \forall Y \in { \mathcal { T } } _ { X }
+$$
+
+Similarly, an inverse map is defined as $\log _ { X } ( Z ) = X ^ { \frac { 1 } { 2 } } \log ( X ^ { - \frac { 1 } { 2 } } Z X ^ { - \frac { 1 } { 2 } } ) X ^ { \frac { 1 } { 2 } } \in { \mathcal { T } } _ { X } , \forall Z \in S _ { + + } ^ { n } .$
+
+1) Basic operations of SPD Network: It is well-known that operations such as mean centralization, normalization, and adding bias to a batch of data are inherent performance booster for most neural networks. In the same spirit, existing works like Brooks et al. (2019); Chakraborty (2020) use the notion of these operations for the SPD or general manifold data to define analogous operations on manifolds. Below we introduce them following the work of Brooks et al. (2019).
+
+• Batch mean, centering and bias: Given a batch of $N$ SPD matrices $\{ X _ { i } \} _ { i = 1 } ^ { N }$ , we can compute its Riemannian barycenter $( { \mathcal { B } } )$ as ${ \mathcal { B } } = \underset { X _ { \mu } \in S _ { + + } ^ { n } } { \mathrm { a r g m i n } } ~ \sum _ { i = 1 } ^ { N } \delta _ { { \mathcal { M } } } ^ { 2 } ( X _ { i } , X _ { \mu } )$ . It is sometimes referred as Frechet mean ( ´ Moakher, 2005; Bhatia $\&$ Holbrook, 2006). This definition can be extended to compute the weighted Riemannian Barycenter 1 also known as weighted Frechet Mean (wFM) . ´
+
+$$
+\mathcal { B } = \mathop { \mathrm { \underset { \boldsymbol { x } } { \mathrm { r g m i n } } } } _ { \boldsymbol { x } _ { \mu } \in S _ { + + } ^ { n } } \sum _ { i = 1 } ^ { N } w _ { i } \delta _ { \mathcal { M } } ^ { 2 } ( \boldsymbol { X } _ { i } , \boldsymbol { X } _ { \mu } ) ; \mathrm { \boldsymbol { s . t . } } w _ { i } \geq 0 \mathrm { \ a n d \ } \sum _ { i = 1 } ^ { N } w _ { i } = 1
+$$
+
+Eq:(3) can be approximated using Karcher flow (Karcher, 1977; Bonnabel, 2013; Brooks et al., 2019) or recursive geodesic mean (Cheng et al., 2016; Chakraborty et al., 2020).
+
+2) Basic layers of SPD Network: Analogous to standard CNN, methods like Huang & Van Gool (2017); Brooks et al. (2019); Chakraborty et al. (2020) designed SPD layers to perform operations that respect SPD manifold constraints. Assuming $\pmb { X } _ { k - 1 } \in \mathcal { S } _ { + + } ^ { n }$ be the input SPD matix to the $k ^ { t h }$ layer, the SPD network layers are defined as follows:
+
+• BiMap layer: This layer corresponds to a dense layer for SPD data. The BiMap layer reduces the dimension of a input SPD matrix via a transformation matrix $W _ { k }$ as $\pmb { X } _ { k } = \bar { \pmb { W } } _ { k } \mathbf { \bar { X } } _ { k - 1 } \pmb { W } _ { k } ^ { T }$ . To ensure the matrix $X _ { k }$ to be an SPD matrix, the $W _ { k }$ matrix must be of full row-rank.
+
+• Batch normalization layer: To perform batch normalization after each BiMap layer, we first compute the Riemannian barycenter of the batch of SPD matrices followed by a running mean update step, which is Riemannian weighted average between the batch mean and the current running mean, with the weights $( 1 - \theta )$ and $( \theta )$ respectively. Once mean is calculated, we centralize and add bias to each SPD sample of the batch using Eq:(4) (Brooks et al., 2019), where $\mathcal { P }$ is the notation used for parallel transport :
+
+Batch centering : Centering th $\begin{array} { r l } & { \textup { \bf e } \mathcal { B } : { \bf X } _ { i } ^ { c } = \mathcal { P } _ { \mathcal { B }  I } ( { \bf X } _ { i } ) = \mathcal { B } ^ { - \frac { 1 } { 2 } } { \bf X } _ { i } \mathcal { B } ^ { - \frac { 1 } { 2 } } , I \mathrm { ~ i s ~ t h e ~ i d e n t i t y ~ m a t r i x } } \\ & { { \bf \mathfrak { I } } : { \bf X } _ { i } ^ { b } = \mathcal { P } _ { I  G } ( { \bf X } _ { i } ^ { c } ) = G ^ { \frac { 1 } { 2 } } { \bf X } _ { i } ^ { c } G ^ { \frac { 1 } { 2 } } , I \mathrm { ~ i s ~ t h e ~ i d e n t i t y ~ m a t r i x } } \end{array}$ Bias the batch $:$ Bias towards
+
+• ReEig layer: The ReEig layer is analogous to ReLU like layers present in the classical ConvNets. It aims to introduce non-linearity to SPD network. The ReEig for the $k ^ { t h }$ layer is defined as: $\boldsymbol { X _ { k } } = \boldsymbol { U _ { k - 1 } } \operatorname* { m a x } ( \epsilon \boldsymbol { I } , \boldsymbol { \Sigma _ { k - 1 } } ) \boldsymbol { U } _ { k - 1 } ^ { T }$ where, $X _ { k - 1 } = { U _ { k - 1 } } { \Sigma _ { k - 1 } } { \bar { U } _ { k - 1 } } ^ { T }$ , $\pmb { I }$ is the identity matrix, and $\epsilon > 0$ is a rectification threshold value. $U _ { k - 1 } , \Sigma _ { k - 1 }$ are the orthonormal matrix and singular-value matrix respectively which are obtained via matrix factorization of $X _ { k - 1 }$ .
+
+![](images/057e5525c0758c45be6d58436ee9d1b918873874614670b2febe60bfed508908.jpg)  
+Figure 1: (a) A SPD cell structure composed of 4 SPD nodes, 2 input node and 1 output node. Initially the edges are unknown (b) Mixture of candidate SPD operations between nodes (c) Optimal cell architecture obtained after solving the relaxed continuous search space under a bi-level optimization formulation.
+
+• LogEig layer: To map the manifold representation of SPD to flat space so that a Euclidean operation can be performed, LogEig layer is introduced. The LogEig layer is defined as: $X _ { k } =$ $\begin{array} { r } { \dot { U } _ { k - 1 } \log ( \Sigma _ { k - 1 } ) \dot { U } _ { k - 1 } ^ { T } } \end{array}$ where, $\begin{array} { r } { \bar { X _ { k - 1 } } = \bar { U _ { k - 1 } } \Sigma _ { k - 1 } U _ { k - 1 } ^ { T } } \end{array}$ . The LogEig layer is used with fully connected layers to solve tasks with SPD representation.
+
+• ExpEig layer: This layer maps tmanifold space. It is defined as $\begin{array} { r } { \pmb { X } _ { k } = \pmb { \dot { U _ { k - 1 } } } \mathrm { e x p } \big ( \pmb { \Sigma } _ { k - 1 } \big ) \mathbf { \dot { U } } _ { k - 1 } ^ { T } } \end{array}$ ntation where, $\begin{array} { r } { \pmb { X } _ { k - 1 } = \mathbf { \dot { U } } _ { k - 1 } \pmb { \Sigma } _ { k - 1 } \pmb { U } _ { k - 1 } ^ { T } } \end{array}$ • Weighted Riemannian pooling layer: It uses wFM definition to compute the output of the layer. Recent method use recursive geodesic mean algorithm to calculate the mean (Chakraborty et al., 2020), in contrast, we use Karcher flow algorithm to compute it (Karcher, 1977) as it is simple and widely used in practice.
+
+# 3 NEURAL ARCHITECTURE SEARCH OF SPD MANIFOLD NETWORK
+
+As alluded before, to solve the suggested problem, there are a few key changes that must be introduced. Firstly, a new definition of the computation cell is required. In contrast to the computational cells designed by regular NAS algorithms like Liu et al. (2018b); Chu et al. (2020), our computational cell —which we call as SPD cell, additionally incorporate the notion of SPD manifold geometry so that SPD representations can be treated properly. On the other hand, like the regular NAS cell design, our SPD cell can either be a normal cell that returns SPD feature maps of the same width and height or, a reduction cell in which the SPD feature maps are reduced by a certain factor in width and height. Secondly, to solve our new NAS problem will require an appropriate and diverse SPD search space that can help NAS method to optimize for an effective SPD cell, which can then be stacked and trained to build an efficient SPD neural network architecture.
+
+Concretely, a SPD cell is modeled by a directed asyclic graph (DAG) which is composed of nodes and edges. In our DAG each node is an latent representation of the SPD manifold valued data i.e. an intermediate SPD feature map and, each edge corresponds to a valid candidate operation on SPD manifold (see Fig.1(a)). Each edge of a SPD cell is associated with a set of candidate SPD manifold operations $( \mathcal { O } _ { \mathcal { M } } )$ that transforms the SPD valued latent representation from the source node (say $\bar { X } _ { \mathcal { M } } ^ { ( i ) } )$ to the target node (say $\pmb { X } _ { \mathcal { M } } ^ { ( j ) }$ ). We define the intermediate transformation between the nodes in our SPD cell as: $\begin{array} { r } { \pmb { X } _ { \mathcal { M } } ^ { ( j ) } = \underset { \pmb { X } _ { \mathcal { M } } ^ { ( j ) } } { \mathrm { a r g m i n } } \sum _ { i < j } \delta _ { \mathcal { M } } ^ { 2 } \Big ( \mathcal { O } _ { \mathcal { M } } ^ { ( i , j ) } \big ( \pmb { X } _ { \mathcal { M } } ^ { ( i ) } \big ) , \pmb { X } _ { \mathcal { M } } ^ { ( j ) } \Big ) , } \end{array}$ , where $\delta _ { \mathcal { M } }$ denotes the geodesic distance Eq:(1). Generally, this transformation result corresponds to the unweighted Frechet mean ´ of the operations based on the predecessors, such that the mixture of all operations still reside on SPD manifolds. Note that our definition of SPD cell ensures that each computational graph preserves the appropriate geometric structure of the SPD manifold. Equipped with the notion of SPD cell and its intermediate transformation, we are prepared to propose our search space (§3.1) followed by the solution to our SPDNet NAS problem (§3.2) and its results (§4).
+
+# 3.1 SEARCH SPACE
+
+Our search space consists of a set of valid SPD network operations which is defined for the supernet search. First of all, the search space includes some existing SPD operations2, e.g., BiMap, batch normalization, ReEig, LogEig, ExpEig and weighted Riemannian pooling layers, all of which are introduced in Sec.2. Though those individual operations (e.g., BiMap, LogEig, ExpEig) have been explored well by existing works, different aggregations on them are still understudied, which are essential to enrich our search space. To be specific to enrich the search space, following Liu et al. (2018b); Gong et al. (2019) traditional NAS methods, we apply the SPD batch normalization to every SPD convolution operation (i.e., BiMap), and design three variants of convolution blocks including the one without activation (i.e., ReEig), the one using post-activation and the one using pre-activation (see Table 1). In addition, we introduce five new operations analogous to DARTS (Liu et al., 2018b) to enrich the search space in the context of SPD networks. These are skip normal, none normal, average pooling, max pooling and skip reduced. The effect of such diverse operation choices have not been fully explored for SPD networks. All the candidate operations are illustrated in Table (1), and the definitions of the new operations are detailed as follows:
+
+Table 1: Search space for the proposed SPD architecture search method.   
+
+<table><tr><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=2>Definition</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>Definition</td></tr><tr><td rowspan=1 colspan=1>BiMap_0</td><td rowspan=1 colspan=2>{BiMap,BatchNormalization}</td><td rowspan=1 colspan=1>WeightedReimannPooling_normal</td><td rowspan=1 colspan=1>{wFM on SPD multiple times}</td></tr><tr><td rowspan=1 colspan=1>BiMap_1</td><td rowspan=1 colspan=2>{BiMap,Batch Normalization,ReEig}</td><td rowspan=1 colspan=1>AveragePooling_reduced</td><td rowspan=1 colspan=1>{LogEig,AveragePooling,ExpEig}</td></tr><tr><td rowspan=1 colspan=1>BiMap_2</td><td rowspan=1 colspan=2>{ReEig,BiMap,BatchNormalization}</td><td rowspan=1 colspan=1>MaxPooling_reduced</td><td rowspan=1 colspan=1>{LogEig,MaxPooling,ExpEig}</td></tr><tr><td rowspan=1 colspan=1>Skip_normal</td><td rowspan=1 colspan=1>{Output same as input}</td><td rowspan=1 colspan=1></td><td rowspan=2 colspan=2>Skip_reduced={Cin =BiMap(Xin),[Uin,Din,~]=svd(Cin);in=1,2},Cout=UbDbU,where,Ub=diag(U1,U2)and Db=diag(D1,D2)</td></tr><tr><td rowspan=1 colspan=1>None_normal</td><td rowspan=1 colspan=1>{Return identitymatrix}</td><td rowspan=1 colspan=1></td></tr></table>
+
+(a) Skip normal: It preserves the input representation and is similar to skip connection. (b) None normal: It corresponds to the operation that returns identity as the output i.e, the notion of zero in the SPD space. (c) Max pooling: Given a set of SPD matrices, max pooling operation first projects these samples to a flat space via a LogEig operation, where a standard max pooling operation is performed. Finally, an ExpEig operation is used to map the sample back to the SPD manifold. (d) Average pooling: Similar to Max pooling, the average pooling operation first projects the samples to the flat space using a LogEig operation, where a standard average pooling is employed. To map the sample back to SPD manifold, an ExpEig operation is used. (e) Skip reduced: It is similar to ‘skip normal’ but in contrast, it decomposes the input into small matrices to reduces the inter-dependency between channels. Our definition of reduce operation is in line with the work of Liu et al. (2018b).
+
+The newly introduced operations allow us to generate a more diverse discrete search space. As presented in Table 2, the randomly selected architecture (generally consisting of the newly introduced SPD operations) shows some improvement over SPDNet and SPDNetBN, both of which only contain conventional SPD operations. This establishes the effectiveness of the introduced rich search space.
+
+# 3.2 SUPERNET SEARCH
+
+To solve the suggested new NAS problem, one of the most promising NAS methodologies is supernet modeling. While we can resort to some other NAS methods to solve the problem like reinforcement learning based method (Zoph & Le, 2016) or evolution based algorithm (Real et al., 2019), in general, the supernet method models the architecture search problem as a one-shot training process of a single supernet that consists of all architectures. Based on the supernet modeling, we can search for the optimal SPD neural architecture either using parameterization of architectures or sampling of single-path architectures. In this paper, we focus on the parameterization approach that is based on the continuous relaxation of the SPD neural architecture representation. Such an approach allows for an efficient search of architecture using the gradient descent approach. Next, we introduce our supernet search method, followed by a solution to our proposed bi-level optimization problem. Fig.1(b) and Fig.1(c) illustrates an overview of our proposed method.
+
+To search for an optimal SPD architecture $( \alpha )$ , we optimize the over parameterized supernet. In essence, it stacks the basic computation cells with the parameterized candidate operations from our search space in a one-shot search manner. The contribution of specific subnets to the supernet helps in deriving the optimal architecture from the supernet. Since the proposed operation search space is discrete in nature, we relax the explicit choice of an operation to make the search space continuous. To do so, we use wFM over all possible candidate operations. Mathematically,
+
+$$
+\bar { \mathcal { O } } _ { \mathcal { M } } ( X _ { \mathcal { M } } ) = \underset { X _ { \mathcal { M } } ^ { \mu } } { \mathrm { a r g m i n } } \sum _ { k = 1 } ^ { N _ { e } } \tilde { \alpha } ^ { k } \delta _ { \mathcal { M } } ^ { 2 } \left( \mathcal { O } _ { \mathcal { M } } ^ { ( k ) } \left( X _ { \mathcal { M } } \right) , X _ { \mathcal { M } } ^ { \mu } \right) ; \mathrm { ~ s u b j e c t ~ t o : ~ \mathbf { 1 } ~ } ^ { T } \tilde { \alpha } = 1 , \ 0 \leq \tilde { \alpha } \leq 1
+$$
+
+# Algorithm 1: The proposed Neural Architecture Search of SPD Manifold Nets (SPDNetNAS)
+
+Require: Mixed Operation $\bar { \mathcal { O } } _ { \mathcal { M } }$ which is parameterized by $\alpha ^ { k }$ for each edge $k \in N _ { e }$ ; while not converged do
+
+Step1: Update $\alpha$ (architecture) using Eq:(8) solution by satisfying an additional strict convex constraint. Note that updates on $w$ and $\tilde { w }$ (Eq:(9), Eq:(10)) should follow the gradient descent on SPD manifold; Step2: Update $w$ by solving $\nabla _ { w } E _ { t r a i n } ( w , \alpha )$ ; Ensure SPD manifold gradient to update $w$ (Absil et al., 2009; Huang & Van Gool, 2017; Brooks et al., 2019);
+
+end
+
+Ensure: Final architecture based on $\alpha$ . Decide the operation at an edge $k$ using argmax $\{ \alpha _ { o } ^ { k } \}$ where, $\mathcal { O } _ { \mathcal { M } } ^ { k }$ is the $k ^ { t h }$ candidate operation between nodes, $X _ { \mu }$ is the intermediate SPD manifold mean (Eq.3) and, $N _ { e }$ denotes number of edges. We can compute wFM solution either using Karcher flow (Karcher, 1977) or recursive geodesic mean (Chakraborty et al., 2020) algorithm. Nonetheless, we adhere to Karcher flow algorithm as it is widely used to calculate $\mathrm { w F M } ^ { 3 }$ . To impose the explicit convex constraint on $\tilde { \alpha }$ , we project the solution onto the probability simplex as
+
+$$
+\begin{array} { r } { \underset { \alpha } { \mathrm { m i n i m i z e } } ~ \| \alpha - \tilde { \alpha } \| _ { 2 } ^ { 2 } ; ~ \mathrm { s u b j e c t t o : } ~ \mathbf { 1 } ^ { T } \alpha = 1 , ~ 0 \leq \alpha \leq 1 } \end{array}
+$$
+
+Eq:(6) enforces the explicit constraint on the weights to supply $\alpha$ for our task and can easily be added as a convex layer in the framework (Agrawal et al., 2019). This projection is likely to reach the boundary of the simplex, in which case $\alpha$ becomes sparse (Martins $\&$ Astudillo, 2016). Optionally, softmax, sigmoid and other regularization methods can be employed to satisfy the convex constraint. However, Chu et al. (2020) has observed that the use of softmax can cause performance collapse and may lead to aggregation of skip connections. While Chu et al. (2020) suggested sigmoid can overcome the unfairness problem with softmax, it may output smoothly changed values which is hard to threshold for dropping redundant operations with non-marginal contributions to the supernet. Also, FairDARTS (Chu et al., 2020) regularization, may not preserve the summation equal to 1 constraint. Besides, Chakraborty et al. (2020) proposes recursive statistical approach to solve wFM with convex constraint, however, the definition proposed do not explicitly preserve the equality constraint and it requires re-normalization of the solution. In contrast, our approach composes of the sparsemax transformation for convex Frechet mixture of SPD operations with the following two advantages: 1) ´ It can preserve most of the important properties of softmax such as, it is simple to evaluate, cheaper to differentiate (Martins & Astudillo, 2016). 2) It is able to produce sparse distributions such that the best operation associated with each edge is more likely to make more dominant contributions to the supernet, and thus more optimal architecture can be derived (refer Figure 2(a),2(b) and §4).
+
+From Eq:(5–6), the mixing of operations between nodes is determined by the weighted combination of alpha’s $( \alpha ^ { k } )$ and the set of operations. This relaxation makes the search space continuous and therefore, architecture search can be achieved by learning a set of alpha $( \alpha = \dot { \{ \alpha ^ { k } , \forall k \in N _ { e } \} } )$ . To achieve our goal, we must simultaneously learn the contribution of several possible operation within all the mixed operations $( w )$ and the corresponding architecture $\alpha$ . Consequently, for a given $w$ , we can find $\alpha$ and vice-versa resulting in the following bi-level optimization problem.
+
+$$
+\operatorname* { m i n i m i z e } _ { \alpha } E _ { v a l } ^ { U } \big ( w ^ { o p t } ( \alpha ) , \alpha \big ) ; \mathrm { ~ s u b j e c t ~ t o : ~ } w ^ { o p t } ( \alpha ) = \operatorname* { a r g m i n } _ { w } E _ { t r a i n } ^ { L } ( w , \alpha )
+$$
+
+The lower-level optimization $E _ { t r a i n } ^ { L }$ corresponds to the optimal weight variable learned for a given $\alpha$ i.e., $w ^ { o p t } ( \alpha )$ using a training loss. The upper-level optimization $E _ { v a l } ^ { U }$ solves for the variable $\alpha$ given the optimal $w$ using a validation loss. This bi-level search method gives optimal mixture of multiple small architectures. To derive each node in the discrete architecture, we maintain top- $k$ operations i.e, with the $k ^ { \mathrm { { t h } } }$ highest weight among all the candidate operations associated with all the previous nodes.
+
+Bi-level Optimization: The bi-level optimization problem proposed in Eq:(7) is difficult to solve. Following Liu et al. (2018b) work, we approximate $w ^ { o p t } ( \alpha )$ in the upper- optimization problem to skip inner-optimization as follows:
+
+$$
+\nabla _ { \alpha } \mathbf { E } _ { v a l } ^ { U } \big ( w ^ { o p t } ( \alpha ) , \alpha \big ) \approx \nabla _ { \alpha } \mathbf { E } _ { v a l } ^ { U } \big ( w - \eta \nabla _ { w } \mathbf { E } _ { t r a i n } ^ { L } ( w , \alpha ) , \alpha \big )
+$$
+
+![](images/172a103b42feef5e86181503a0e76a8d2471907461a55f04848574c84c51be5b.jpg)  
+(a) Distribution of edge weights for operation selection   
+  
+Figure 2: (a) Distribution of edge weights for operation selection using softmax, sigmoid, and sparsemax on Frechet mixture of SPD operations. (b) Derived sparsemax architecture by the proposed SPDNetNAS. Better ´ sparsity leads to less skips and poolings compared to those of other NAS solutions shown in Appendix Fig.5.
+
+Here, $\eta$ is the learning rate and $\nabla$ is the gradient operator. Note that the gradient based optimization for $w$ must follow the geometry of SPD manifold to update the structured connection weight, and its corresponding SPD matrix data. Applying the chain rule to Eq:(8) gives
+
+$$
+\overbrace { \nabla _ { \alpha } { \pmb { E } } _ { v a l } ^ { U } \big ( \tilde { w } , \alpha \big ) } ^ { \mathrm { f i r s t ~ t e r m } } - \overbrace { \eta \nabla _ { \alpha , w } ^ { 2 } { \pmb { E } } _ { t r a i n } ^ { L } ( w , \alpha ) \nabla _ { \tilde { w } } { \pmb { E } } _ { v a l } ^ { U } ( \tilde { w } , \alpha ) } ^ { \mathrm { s e c o n d t e r m } }
+$$
+
+where, $\tilde { w } = \Psi _ { \bf r } \big ( w - \eta \tilde { \nabla } _ { w } E _ { t r a i n } ^ { L } ( w , \alpha ) \big )$ denotes the weight update on the SPD manifold for the forward model. $\tilde { \nabla } _ { w }$ , $\Psi _ { \mathbf { r } }$ symbolizes the Riemannian gradient and the retraction operator respectively. The second term in the Eq:(9) involves second order differentials with very high computational complexity, hence, using the finite approximation method the second term of Eq:(9) reduces to:
+
+$$
+\nabla _ { \alpha , w } ^ { 2 } E _ { t r a i n } ^ { L } ( w , \alpha ) \nabla _ { \bar { w } } E _ { v a l } ^ { U } ( \tilde { w } , \alpha ) = \left( \nabla _ { \alpha } E _ { t r a i n } ^ { L } ( w ^ { + } , \alpha ) - \nabla _ { \alpha } E _ { t r a i n } ^ { L } ( w ^ { - } , \alpha ) \right) / 2 \delta
+$$
+
+where, $w ^ { \pm } = \Psi _ { \mathbf { r } } ( w \pm \delta \tilde { \nabla } _ { \tilde { w } } E _ { v a l } ^ { U } ( \tilde { w } , \alpha ) )$ and $\delta$ is a small number set to $0 . 0 1 / \| \nabla _ { \tilde { w } } E _ { v a l } ^ { U } ( \tilde { w } , \alpha ) \| _ { 2 }$ Though the structure of bi-level optimization the same as the DARTS Liu et al. (2018b), there are some key differences. Firstly, the updates on the manifold-valued kernel weights are constrained on manifolds, which ensures that the feature maps at every intermediate layer are SPDs. For concrete derivations on back-propagation for SPD network layers, refer to Huang & Van Gool (2017) work. Secondly, the update on the aggregation weights of the involved SPD operations needs to satisfy an additional strict convex constraint, which is enforced as part of the optimization problem. The pseudo code of our method is outlined in Algorithm $^ { ( 1 ) }$ .
+
+# 4 EXPERIMENTS AND RESULTS
+
+To keep the experimental evaluation consistent with the previously proposed SPD networks (Huang & Van Gool, 2017; Brooks et al., 2019), we used RADAR (Chen et al., 2006), HDM05 (Muller et al. ¨ , 2007), and AFEW (Dhall et al., 2014) datasets. For SPDNetNAS, we first optimize the supernet on the training/validation sets, and then prune it with the best operation for each edge. Finally, we train the optimized architecture from scratch to document the results. For both these stages, we consider the same normal and reduction cells. A cell receives preprocessed inputs which is performed using fixed BiMap 2 to make the input of same initial dimension. All architectures are trained with a batch size of 30. Learning rate $( \eta )$ for RADAR, HDM05, and AFEW dataset is set to 0.025, 0.025 and 0.05 respectively. Besides, we conducted experiments where we select architecture using a random search path (SPDNetNAS (R)), to justify whether our search space with the introduced SPD operations can derive meaningful architectures. We refer to SPDNet (Huang & Van Gool, 2017), SPDNetBN (Brooks et al., 2019), and ManifoldNet (Chakraborty et al., 2020) for comparison against handcrafted SPD networks. SPDNet and SPDNetBN are evaluated using their original implementations. We follow the video classification setup of (Chakraborty et al., 2020) to evaluate ManifoldNet on AFEW. It is non-trivial to adapt ManifoldNet to RADAR and HDM05, as ManifoldNet requires SPD features with multiple channels and both of the two datasets can hardly obtain them. For comparing against Euclidean NAS methods, we used DARTS (Liu et al., 2018b) and FairDARTS (Chu et al., 2020) by treating SPD’s logarithm maps as Euclidean data in their official implementation with default setup. We observed that using raw SPD’s as input to Euclidean NAS algorithms degrades its performance.
+
+a) Drone Recognition: For this task, we used the RADAR dataset from (Chen et al., 2006). The synthetic setting for this dataset is composed of radar signals, where each signal is split into windows of length 20 resulting in a $2 0 \mathbf { x } 2 0$ covariance matrix for each window (one radar data point). The synthesized dataset consists of 1000 data points per class. Given $2 0 \times 2 0$ input covariance matrices, our reduction cell reduces them to $1 0 \times 1 0$ matrices followed by normal cell to provide complexity to our network. Following Brooks et al. (2019), we assign $50 \%$ , $2 5 \%$ , and $2 5 \%$ of the dataset for training, validation, and test set respectively. The Euclidean NAS algorithms are evaluated on the euclidean map of the input. For direct SPD input the performance of darts $( 9 5 . 8 6 \% )$ and fairdarts $( 9 2 . 2 6 \% )$ are worse as expected. For this dataset, our algorithm takes 1 CPU day of search time to provide the SPD architecture. Training and validation take 9 CPU hours for 200 epochs4. Test results on this dataset are provided in Table (2) which clearly shows the benefit of our method. Statistical performance show that our NAS algorithm provides an efficient architecture with much fewer parameters (more than 140 times) than state-of-the-art Euclidean NAS on the SPD manifold valued data. The normal and reduction cells obtained on this dataset are shown in Fig. 2(b).
+
+b) Action Recognition: For this task, we used the HDM05 dataset (Muller et al.¨ , 2007) which contains 130 action classes, yet, for consistency with previous work (Brooks et al., 2019), we used 117 class for performance comparison. This dataset has 3D coordinates of 31 joints per frame. Following the previous works (Harandi et al., 2017; Huang & Van Gool, 2017), we model an action for a sequence using $9 3 \times 9 3$ joint covariance matrix. The dataset has 2083 SPD matrices distributed among all 117 classes. Similar to the previous task, we split the dataset into $50 \%$ , $2 5 \%$ , and $2 5 \%$ for training, validation, and testing. Here, our reduction cell is designed to reduce the matrices dimensions from 93 to 30 for legitimate comparison against Brooks et al. (2019). To search for the best architecture, we ran our algorithm for 50 epoch (3 CPU days). Figure 2(b) show the final cell architecture that got selected based on the validation performance. The optimal architecture is trained from scratch for 100 epochs which took approximately 16 CPU hours. The test accuracy achieved on this dataset is provided in Table (2). Statistics clearly show that our models despite being lighter performs better than the NAS models and the handcrafted SPDNets. The NAS models’ inferior results show that the use of SPD layers for respecting SPD geometries is crucial for SPD data analysis.
+
+Table 2: Performance comparison of our method against existing SPDNets and TraditionalNAS on drone and action recognition. SPDNetNAS (R): randomly select architecure from our search space, DARTS/FairDARTS: accepts logarithm forms of SPDs. The search time of our method on RADAR and HDM05 is noted to be 1 CPU days and 3 CPU days respectively. And the search cost of DARTS and FairDARTS on RADAR and HDM05 are about 8 GPU hours. #RADAR and #HDM05 show model parameter comparison on the respective dataset.   
+
+<table><tr><td>Dataset</td><td>DARTS</td><td>FairDARTS</td><td>SPDNet</td><td>SPDNetBN</td><td>SPDNetNAS (R)</td><td>SPDNetNAS</td></tr><tr><td>RADAR</td><td>98.21%± 0.23</td><td>98.51%±0.09</td><td>93.21%±0.39</td><td>92.13%±0.77</td><td>95.49% ±0.08</td><td>97.75%±0.30</td></tr><tr><td>#RADAR</td><td>2.6383MB</td><td>2.6614MB</td><td>0.0014MB</td><td>0.0018MB</td><td>0.0185MB</td><td>0.0184MB</td></tr><tr><td>HDM05</td><td>53.93% ± 1.42</td><td>47.71% ± 1.46</td><td>61.60% ± 1.35</td><td>65.20% ± 1.15</td><td>66.92% ± 0.72</td><td>69.87% ±0.31</td></tr><tr><td>#HDM05</td><td>3.6800MB</td><td>5.1353MB</td><td>0.1082MB</td><td>0.1091MB</td><td>1.0557MB</td><td>1.064MBMB</td></tr></table>
+
+c) Emotion Recognition: We used AFEW dataset (Dhall et al., 2014) to evaluate the transferability of our searched architecture for emotion recognition. This dataset has 1345 videos of facial expressions classified into 7 distinct classes. To train on the video frames directly, we stack all the handcrafted SPDNets and our searched SPDNet on top of a covolutional network Meng et al. (2019) with its official implementation. For ManifoldNet, we compute a $6 4 \times 6 4$ spatial covariance matrix for each frame on the intermediate CNN features of $6 4 \times 5 6 \times 5 6$ (channels, height, width). We follow the reported setup of Chakraborty et al. (2020) to first apply a single wFM layer with kernel size 5, stride 3 and 8 channels, followed by three temporal wFM layers of kernel size 3 and stride 2, with the channels being 1, 4, 8 respectively. We closely follow the official implementation of ManifoldNet 5 for the wFM layers and adapt the code to our specific task. Since SPDNet, SPDNetBN and our SPDNetNAS require a single channel SPD matrix as input, we use the final 512 dimensional vector extracted from the covolutional network, project it using a dense layer to a 100 dimensional feature vector and compute a $1 0 0 \times 1 0 0$ temporal covariance matrix. To study the transferability of our algorithm, we evaluate its searched architecture on RADAR and HDM05. In addition, we evaluate DARTS and FairDARTS directly on the video frames of AFEW. Table (3) reports the evaluations results. As we can observe, the transferred architectures can handle the new dataset quite convincingly, and their test accuracies are better than those of the existing SPDNets and the Euclidean NAS algorithms. In Appendix, we present results of competing methods and our searched models on the raw SPD features of AFEW.
+
+Table 3: Performance comparison of our transferred architectures on AFEW against handcrafted SPDNets and Euclidean NAS. SPDNetNAS(RADAR/HDM05): architectures searched on RADAR and HDM05 respectively.   
+
+<table><tr><td>DARTS</td><td>FairDARTS</td><td>ManifoldNet</td><td>SPDNet</td><td>SPDNetBN</td><td>SPDNetNAS (RADAR)</td><td>SPDNetNAS (HDM05)</td></tr><tr><td>26.88%</td><td>22.31%</td><td>28.84%</td><td>34.06%</td><td>37.80%</td><td>40.80%</td><td>40.64%</td></tr></table>
+
+# d) Ablation study:
+
+Lastly, we conducted some ablation study to realize the effect of probability simplex constraint (sparsemax) on our suggested Frechet ´ mixture of SPD operations. Although in Fig. 2(a) we show better probability weight distribution with sparsemax, Table(4) shows that
+
+Table 4: Ablations study on different solutions to our suggested Frechet mixture of SPD operations. ´   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>softmax</td><td rowspan=1 colspan=1>sigmoid</td><td rowspan=1 colspan=1>sparsemax</td></tr><tr><td rowspan=1 colspan=1>RADAR</td><td rowspan=1 colspan=1>96.47%± 0.10</td><td rowspan=1 colspan=1>97.70%± 0.23</td><td rowspan=1 colspan=1>97.75% ± 0.30</td></tr><tr><td rowspan=1 colspan=1>HDM05</td><td rowspan=1 colspan=1>68.74%± 0.93</td><td rowspan=1 colspan=1>68.64% ±0.09</td><td rowspan=1 colspan=1>69.87% ± 0.31</td></tr></table>
+
+it performs better empirically as well on both RADAR and HDM05 compared to the softmax and sigmoid cases. Therefore, SPD architectures derived using the sparsemax is observed to be better.
+
+e) Statistical comparison under same model complexity: We compare the statistical performance of our method against the other competing methods under similar model sizes. Table 5 show the results obtained on the RADAR dataset. One key point to note here is that when we increase the number of parameters in SPDNet and SPDNetBN, we observe a very severe degradation in the performance accuracy —mainly because the network starts overfitting rapidly. The performance degradation is far more severe for the HDM05 dataset with SPDNet (1.047MB) performing $0 . 7 6 1 9 \%$ and SPDNetBN (1.082MB) performing $1 . 4 5 \%$ and hence, is not reported in the table below. That further indicates the ability of SPDNetNAS to generalize better and avoid overfitting despite the larger model size.
+
+Similarly, we experimented on the AFEW dataset. To have a fair comparison against the related method like ManifoldNet, whose model size is about (76MB), we must reduce the model size accordingly. ManifoldNet model size is large mainly due to multiple final dense fully connected layers. Hence, to reduce the model size, we decreased the number of FC layers. The performance result with comparable model sizes on the AFEW dataset is shown in Table 5. Again, we can infer that our SPDNetNAS achieves a significant performance improvement over the others.
+
+Table 5: Performance of our model against ManifoldNet, SPDNet and SPDNetBN with comparable model sizes on the RADAR and AFEW datasets.   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>Manifoldnet</td><td rowspan=1 colspan=1>SPDNet</td><td rowspan=1 colspan=1>SPDNetBN</td><td rowspan=1 colspan=1>SPDNetNAS</td></tr><tr><td rowspan=1 colspan=1>RADAR</td><td rowspan=1 colspan=1>NA</td><td rowspan=1 colspan=1>73.066%</td><td rowspan=1 colspan=1>87.866%</td><td rowspan=1 colspan=1>97.75%</td></tr><tr><td rowspan=1 colspan=1>#RADAR</td><td rowspan=1 colspan=1>NA</td><td rowspan=1 colspan=1>0.01838MB</td><td rowspan=1 colspan=1>0.01838MB</td><td rowspan=1 colspan=1>0.01840MB</td></tr><tr><td rowspan=1 colspan=1>AFEW</td><td rowspan=1 colspan=1>25.8%</td><td rowspan=1 colspan=1>34.06%</td><td rowspan=1 colspan=1>37.80%</td><td rowspan=1 colspan=1>40.64%</td></tr><tr><td rowspan=1 colspan=1>#AFEW</td><td rowspan=1 colspan=1>11.6476MB</td><td rowspan=1 colspan=1>11.2626MB</td><td rowspan=1 colspan=1>11.2651MB</td><td rowspan=1 colspan=1>11.7601MB</td></tr></table>
+
+# 5 CONCLUSION AND FUTURE DIRECTION
+
+In this work, we present a neural architecture search problem of SPD manifold networks. To solve it, a SPD cell representation and corresponding candidate operation search space is introduced. A parameterized supernet search method is employed to explore the relaxed continuous SPD search space following a bi-level optimization problem with probability simplex constraint for effective SPD network design. The solution to our proposed problem using back-propagation is carefully crafted, so that, the weight updates follow the geometry of the SPD manifold. Quantitative results on the benchmark dataset show a commendable performance gain over handcrafted SPD networks and Euclidean NAS algorithms. Additionally, we demonstrate that the learned SPD architecture is much lighter than other NAS based architecture and, it is transferable to other datasets as well.
+
+Our work provides an architecture search methodology for the scenarios where the acquired input data are SPD’s, for example, diffusion tensor imaging for medical applications, drone recognition, etc. In addition, our method offers a paradigm to automate the neural architecture design for the scenarios that require the second-order representations/poolings for robust visual recognition (e.g., Wang et al. (2017); Engin et al. (2018); Wang et al. (2019)). Accordingly, we encourage more future works to pursue these two directions. Also, it is fairly interesting to extend our proposed method to sequential manifold valued data (Zhen et al., 2019; Chakraborty et al., 2018).
+
+# REFERENCES
+
+P-A Absil, Robert Mahony, and Rodolphe Sepulchre. Optimization algorithms on matrix manifolds. Princeton University Press, 2009.
+
+Akshay Agrawal, Brandon Amos, Shane Barratt, Stephen Boyd, Steven Diamond, and J Zico Kolter. Differentiable convex optimization layers. In Advances in neural information processing systems, pp. 9562–9574, 2019.
+
+Karim Ahmed and Lorenzo Torresani. Connectivity learning in multi-branch networks. arXiv preprint arXiv:1709.09582, 2017.
+
+Bowen Baker, Otkrist Gupta, Ramesh Raskar, and Nikhil Naik. Accelerating neural architecture search using performance prediction. arXiv preprint arXiv:1705.10823, 2017.
+
+Alexandre Barachant, Stephane Bonnet, Marco Congedo, and Christian Jutten. Multiclass brain– ´ computer interface classification by riemannian geometry. IEEE Transactions on Biomedical Engineering, 59(4):920–928, 2011.
+
+Gabriel Bender. Understanding and simplifying one-shot architecture search. 2019.
+
+Rajendra Bhatia and John Holbrook. Riemannian geometry and matrix geometric means. Linear algebra and its applications, 413(2-3):594–618, 2006.
+
+Silvere Bonnabel. Stochastic gradient descent on riemannian manifolds. IEEE Transactions on Automatic Control, 58(9):2217–2229, 2013.
+
+Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. Smash: one-shot model architecture search through hypernetworks. arXiv preprint arXiv:1708.05344, 2017.
+
+Daniel Brooks, Olivier Schwander, Fred´ eric Barbaresco, Jean-Yves Schneider, and Matthieu Cord. ´ Riemannian batch normalization for spd neural networks. In Advances in Neural Information Processing Systems, pp. 15463–15474, 2019.
+
+Han Cai, Tianyao Chen, Weinan Zhang, Yong Yu, and Jun Wang. Efficient architecture search by network transformation. In Thirty-Second AAAI conference on artificial intelligence, 2018.
+
+Rudrasis Chakraborty. Manifoldnorm: Extending normalizations on riemannian manifolds. arXiv preprint arXiv:2003.13869, 2020.
+
+Rudrasis Chakraborty, Chun-Hao Yang, Xingjian Zhen, Monami Banerjee, Derek Archer, David Vaillancourt, Vikas Singh, and Baba Vemuri. A statistical recurrent model on the manifold of symmetric positive definite matrices. In Advances in Neural Information Processing Systems, pp. 8883–8894, 2018.
+
+Rudrasis Chakraborty, Jose Bouza, Jonathan Manton, and Baba C Vemuri. Manifoldnet: A deep neural network for manifold-valued data with applications. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020.
+
+Victor C Chen, Fayin Li, S-S Ho, and Harry Wechsler. Micro-doppler effect in radar: phenomenon, model, and simulation study. IEEE Transactions on Aerospace and electronic systems, 42(1):2–21, 2006.
+
+Guang Cheng, Jeffrey Ho, Hesamoddin Salehian, and Baba C Vemuri. Recursive computation of the frechet mean on non-positively curved riemannian manifolds with applications. In ´ Riemannian Computing in Computer Vision, pp. 21–43. Springer, 2016.
+
+Xiangxiang Chu, Bo Zhang, Jixiang Li, Qingyuan Li, and Ruijun Xu. Scarletnas: Bridging the gap between scalability and fairness in neural architecture search. arXiv preprint arXiv:1908.06022, 2019.
+
+Xiangxiang Chu, Tianbao Zhou, Bo Zhang, and Jixiang Li. Fair DARTS: Eliminating Unfair Advantages in Differentiable Architecture Search. In 16th Europoean Conference On Computer Vision, 2020. URL https://arxiv.org/abs/1911.12126.pdf.
+
+Kalyanmoy Deb, Amrit Pratap, Sameer Agarwal, and TAMT Meyarivan. A fast and elitist multiobjective genetic algorithm: Nsga-ii. IEEE transactions on evolutionary computation, 6(2):182–197, 2002.
+
+Abhinav Dhall, Roland Goecke, Jyoti Joshi, Karan Sikka, and Tom Gedeon. Emotion recognition in the wild challenge 2014: Baseline, data and protocol. In Proceedings of the 16th international conference on multimodal interaction, pp. 461–466, 2014.
+
+Tingxing Dong, Azzam Haidar, Stanimire Tomov, and Jack J Dongarra. Optimizing the svd bidiagonalization process for a batch of small matrices. In ICCS, pp. 1008–1018, 2017a.
+
+Zhen Dong, Su Jia, Chi Zhang, Mingtao Pei, and Yuwei Wu. Deep manifold learning of symmetric positive definite matrices with application to face recognition. In Thirty-First AAAI Conference on Artificial Intelligence, 2017b.
+
+Thomas Elsken, Jan-Hendrik Metzen, and Frank Hutter. Simple and efficient architecture search for convolutional neural networks. arXiv preprint arXiv:1711.04528, 2017.
+
+Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Neural architecture search: A survey. arXiv preprint arXiv:1808.05377, 2018.
+
+Melih Engin, Lei Wang, Luping Zhou, and Xinwang Liu. Deepkspd: Learning kernel-matrix-based spd representation for fine-grained image recognition. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 612–627, 2018.
+
+Zhi Gao, Yuwei Wu, Mehrtash Harandi, and Yunde Jia. A robust distance measure for similarity-based classification on the spd manifold. IEEE Transactions on Neural Networks and Learning Systems, 2019.
+
+Mark Gates, Stanimire Tomov, and Jack Dongarra. Accelerating the svd two stage bidiagonal reduction and divide and conquer using gpus. Parallel Computing, 74:3–18, 2018.
+
+Xinyu Gong, Shiyu Chang, Yifan Jiang, and Zhangyang Wang. Autogan: Neural architecture search for generative adversarial networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3224–3234, 2019.
+
+Zichao Guo, Xiangyu Zhang, Haoyuan Mu, Wen Heng, Zechun Liu, Yichen Wei, and Jian Sun. Single path one-shot neural architecture search with uniform sampling. In European Conference on Computer Vision, pp. 544–560. Springer, 2020.
+
+Mehrtash Harandi, Mathieu Salzmann, and Richard Hartley. Dimensionality reduction on spd manifolds: The emergence of geometry-aware methods. IEEE transactions on pattern analysis and machine intelligence, 40(1):48–62, 2017.
+
+Mehrtash T Harandi, Mathieu Salzmann, and Richard Hartley. From manifold to manifold: Geometryaware dimensionality reduction for spd matrices. In European conference on computer vision, pp. 17–32. Springer, 2014.
+
+Zhiwu Huang and Luc Van Gool. A riemannian network for spd matrix learning. In Thirty-First AAAI Conference on Artificial Intelligence, 2017.
+
+Zhiwu Huang, Ruiping Wang, Shiguang Shan, and Xilin Chen. Learning euclidean-to-riemannian metric for point-to-set classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1677–1684, 2014.
+
+Zhiwu Huang, Ruiping Wang, Shiguang Shan, Xianqiu Li, and Xilin Chen. Log-euclidean metric learning on symmetric positive definite manifold with application to image set classification. In International conference on machine learning, pp. 720–729, 2015.
+
+Kirthevasan Kandasamy, Willie Neiswanger, Jeff Schneider, Barnabas Poczos, and Eric P Xing. Neural architecture search with bayesian optimisation and optimal transport. In Advances in Neural Information Processing Systems, pp. 2016–2025, 2018.
+
+Hermann Karcher. Riemannian center of mass and mollifier smoothing. Communications on pure and applied mathematics, 30(5):509–541, 1977.
+
+Suryansh Kumar. Jumping manifolds: Geometry aware dense non-rigid structure from motion. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5346–5355, 2019.
+
+Suryansh Kumar, Anoop Cherian, Yuchao Dai, and Hongdong Li. Scalable dense non-rigid structurefrom-motion: A grassmannian perspective. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 254–263, 2018.
+
+Marc Lackenby. Introductory chapter on riemannian manifolds. Notes, 2020.
+
+Hanwen Liang, Shifeng Zhang, Jiacheng Sun, Xingqiu He, Weiran Huang, Kechen Zhuang, and Zhenguo Li. Darts+: Improved differentiable architecture search with early stopping. arXiv preprint arXiv:1909.06035, 2019.
+
+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 Proceedings of the European Conference on Computer Vision (ECCV), pp. 19–34, 2018a.
+
+Chenxi Liu, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, Wei Hua, Alan L Yuille, and Li FeiFei. Auto-deeplab: Hierarchical neural architecture search for semantic image segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 82–92, 2019.
+
+Hanxiao Liu, Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, and Koray Kavukcuoglu. Hierarchical representations for efficient architecture search. arXiv preprint arXiv:1711.00436, 2017.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018b.
+
+Andre Martins and Ramon Astudillo. From softmax to sparsemax: A sparse model of attention and multi-label classification. In International Conference on Machine Learning, pp. 1614–1623, 2016.
+
+Debin Meng, Xiaojiang Peng, Kai Wang, and Yu Qiao. Frame attention networks for facial expression recognition in videos. In 2019 IEEE International Conference on Image Processing (ICIP), pp. 3866–3870. IEEE, 2019.
+
+Maher Moakher. A differential geometric approach to the geometric mean of symmetric positivedefinite matrices. SIAM Journal on Matrix Analysis and Applications, 26(3):735–747, 2005.
+
+Meinard Muller, Tido R ¨ oder, Michael Clausen, Bernhard Eberhardt, Bj ¨ orn Kr ¨ uger, and Andreas ¨ Weber. Documentation mocap database hdm05. 2007.
+
+Niv Nayman, Asaf Noy, Tal Ridnik, Itamar Friedman, Rong Jin, and Lihi Zelnik. Xnas: Neural architecture search with expert advice. In Advances in Neural Information Processing Systems, pp. 1977–1987, 2019.
+
+Renato Negrinho and Geoff Gordon. Deeparchitect: Automatically designing and training deep architectures. arXiv preprint arXiv:1704.08792, 2017.
+
+Xavier Pennec. Manifold-valued image processing with spd matrices. In Riemannian Geometric Statistics in Medical Image Analysis, pp. 75–134. Elsevier, 2020.
+
+Xavier Pennec, Pierre Fillard, and Nicholas Ayache. A riemannian framework for tensor computing. International Journal of computer vision, 66(1):41–66, 2006.
+
+Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. arXiv preprint arXiv:1802.03268, 2018.
+
+Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. In Proceedings of the aaai conference on artificial intelligence, volume 33, pp. 4780–4789, 2019.
+
+Shreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. In Advances in Neural Information Processing Systems, pp. 4053–4061, 2016.
+
+Richard Shin, Charles Packer, and Dawn Song. Differentiable neural network architecture search. 2018.
+
+Yuan Tian, Qin Wang, Zhiwu Huang, Wen Li, Dengxin Dai, Minghao Yang, Jun Wang, and Olga Fink. Off-policy reinforcement learning for efficient and effective gan architecture search. In Proceedings of the European Conference on Computer Vision, 2020.
+
+Oncel Tuzel, Fatih Porikli, and Peter Meer. Region covariance: A fast descriptor for detection and classification. In European conference on computer vision, pp. 589–600. Springer, 2006.
+
+Oncel Tuzel, Fatih Porikli, and Peter Meer. Pedestrian detection via classification on riemannian manifolds. IEEE transactions on pattern analysis and machine intelligence, 30(10):1713–1727, 2008.
+
+Tom Veniat and Ludovic Denoyer. Learning time/memory-efficient deep architectures with budgeted super networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3492–3500, 2018.
+
+Qilong Wang, Peihua Li, and Lei Zhang. G2denet: Global gaussian distribution embedding network and its application to visual recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2730–2739, 2017.
+
+Qilong Wang, Jiangtao Xie, Wangmeng Zuo, Lei Zhang, and Peihua Li. Deep cnns meet global covariance pooling: Better representation and generalization. arXiv preprint arXiv:1904.06836, 2019.
+
+Ruiping Wang, Huimin Guo, Larry S Davis, and Qionghai Dai. Covariance discriminative learning: A natural and efficient approach to image set classification. In 2012 IEEE Conference on Computer Vision and Pattern Recognition, pp. 2496–2503. IEEE, 2012.
+
+Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer. Fbnet: Hardware-aware efficient convnet design via differentiable neural architecture search. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 10734–10742, 2019.
+
+Yan Wu, Aoming Liu, Zhiwu Huang, Siwei Zhang, and Luc Van Gool. Neural architecture search as sparse supernet. arXiv preprint arXiv:2007.16112, 2020.
+
+X. Zhang, Z. Huang, N. Wang, S. XIANG, and C. Pan. You only search once: Single shot neural architecture search via direct sparse optimization. IEEE Transactions on Pattern Analysis and Machine Intelligence, pp. 1–1, 2020.
+
+Xingjian Zhen, Rudrasis Chakraborty, Nicholas Vogt, Barbara B Bendlin, and Vikas Singh. Dilated convolutional neural networks for sequential manifold-valued data. In Proceedings of the IEEE International Conference on Computer Vision, pp. 10621–10631, 2019.
+
+Xiawu Zheng, Rongrong Ji, Lang Tang, Baochang Zhang, Jianzhuang Liu, and Qi Tian. Multinomial distribution learning for effective neural architecture search. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1304–1313, 2019.
+
+H Zhou, M Yang, J Wang, and W Pan. Bayesnas: A bayesian approach for neural architecture search. In 36th International Conference on Machine Learning, ICML 2019, volume 97, pp. 7603–7613. Proceedings of Machine Learning Research (PMLR), 2019.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 8697–8710, 2018.
+
+# A ADDITIONAL EXPERIMENTAL ANALYSIS
+
+# A.1 EFFECT OF MODIFYING PREPROCESSING LAYERS FOR MULTIPLE DIMENSIONALITY REDUCTION
+
+Unlike Huang & Van Gool (2017) work on the SPD network, where multiple transformation matrices are applied at multiple layers to reduce the dimension of the input data, our reduction cell presented in the main paper is one step. For example: For HDM05 dataset (Muller et al. ¨ , 2007), the author’s of SPDNet (Huang & Van Gool, 2017) apply $9 3 \times 7 0$ , $7 0 \times 5 0$ , $5 0 \times 3 0$ , transformation matrices to reduce the dimension of the input matrix, on the contrary, we reduce the dimension in one step from 93 to 30 which is inline with Brooks et al. (2019) work.
+
+To study the behaviour of our method under multiple dimesionality reduction pipeline on HDM05, we use the preprocessing layers to perform dimensionality reduction. To be precise, we consider a preprocessing step to reduce the dimension from 93 to 70 to 50 and then, a reduction cell that reduced the dimension from 50 to 24. This modification has the advantage that it reduces the search time from 3 CPU days to 2.5 CPU days, and in addition, provides a performance gain (see Table (6)). The normal and the reduction cells for the multiple dimension reduction are shown in Figure (3).
+
+![](images/c11333de9aa741bd78a8501d2e77f2b62355899cb1c3e95dee57af3c470a29f1.jpg)  
+Figure 3: (a)-(b) Normal cell and Reduction cell for multiple dimensionality reduction respectively
+
+A.2 EFFECT OF ADDING NODES TO THE CELL
+
+Experiments presented in the main paper consists of $N = 5$ nodes per cell which includes two input nodes, one output node, and two intermediate nodes. To do further analysis of our design choice, we added nodes to the cell. Such analysis can help us study the critical behaviour of our cell design i.e, whether adding an intermediate nodes can improve the performance or not?, and how it affects the computational complexity of our algorithm? To perform this experimental analysis, we used HDM05 dataset (Muller et al. ¨ , 2007). We added one extra intermediate node $N = 6$ ) to the cell design. We observe that we converge towards an architecture design that is very much similar in terms of operations (see Figure 4). The evaluation results shown in Table (7) help us to deduce that adding more intermediate nodes increases the number of channels for output node, subsequently leading to increased complexity and almost double the computation time.
+
+Table 6: Results of modifying preprocessing layers for multiple dimentionality reduction on HDM05   
+Table 7: Results for multi-node experiments on HDM05   
+
+<table><tr><td>Numberof nodes</td><td>SPDNetNAS</td><td>Search time</td></tr><tr><td>5</td><td>68.74% ±0.93</td><td>3 CPU days</td></tr><tr><td>6</td><td>67.96% ± 0.67</td><td>6 CPU days</td></tr></table>
+
+# A.3 EFFECT OF ADDING MULTIPLE CELLS
+
+In our paper we stack 1 normal cell over 1 reduction cell for all the experiments. For more extensive analysis of the proposed method, we conducted training experiments by stacking multiple cells which is in-line with the experiments conducted by Liu et al. (2018b). We then transfer the optimized architectures from the singe cell search directly to the multi-cell architectures for training. Hence, the search time for all our experiments is same as for a single cell search i.e. 3 CPU days. Results for this experiment are provided in Table 8. The first row in the table shows the performance for single cell model, while the second and third rows show the performance with multi-cell stacking. Remarkably, by stacking multiple cells our proposed SPDNetNAS outperforms SPDNetBN Brooks et al. (2019) by a large margin (about $8 \%$ , i.e., about $12 \%$ for the relative improvement).
+
+![](images/541d0888a69dfbf707011f85a069e45b500386a941c2586325443f996faba58a.jpg)  
+Figure 4: (a)-(b) Optimal Normal cell and Reduction cell with 6 nodes on the HDM05 dataset
+
+Table 8: Results for multiple cell search and training experiments on HDM05: reduction corresponds to reduction cell and normal corresponds to the normal cell.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Dim reduction in cells</td><td rowspan=1 colspan=1>Cell type sequence</td><td rowspan=1 colspan=1>SPDNetNAS</td><td rowspan=1 colspan=1>Search Time</td></tr><tr><td rowspan=1 colspan=1>single cell</td><td rowspan=1 colspan=1>93→46</td><td rowspan=1 colspan=1>reduction-normal</td><td rowspan=1 colspan=1>68.74%± 0.93</td><td rowspan=1 colspan=1>3 CPU days</td></tr><tr><td rowspan=1 colspan=1>multi-cell</td><td rowspan=1 colspan=1>93→46</td><td rowspan=1 colspan=1>normal-reduction-normal</td><td rowspan=1 colspan=1>71.48%± 0.42</td><td rowspan=1 colspan=1>3CPU days</td></tr><tr><td rowspan=1 colspan=1>multi-cell</td><td rowspan=1 colspan=1>93→46→22</td><td rowspan=1 colspan=1>reduction-normal-reduction-normal</td><td rowspan=1 colspan=1>73.59 %± 0.33</td><td rowspan=1 colspan=1>3 CPU days</td></tr></table>
+
+# A.4 AFEW PERFORMANCE COMPARISON ON RAW SPD FEATURES
+
+In addition to the evaluation on CNN features in the major paper, we also use the raw SPD features (extracted from gray video frames) from Huang & Van Gool (2017); Brooks et al. (2019) to compare the competing methods. To be specific, each frame is normalized to $2 0 \times 2 0$ and then represent each video using a $4 0 0 \times 4 0 0$ covariance matrix (Wang et al., 2012; Huang & Van Gool, 2017). Table 9 summarizes the results. As we can see, the transferred architecture can handle the new dataset quite convincingly. The test accuracy is comparable to the best SPD network method for RADAR model transfer. For HDM05 model transfer, the test accuracy is much better than the existing SPD networks.
+
+Table 9: Performance of transferred SPDNetNAS Network architecture in comparison to existing SPD Networks on the AFEW dataset Dhall et al. (2014). RAND symbolizes random architecture from our search space. DARTS/FairDARTS: accepts the logarithms of raw SPDs, and the other competing methods receive the SPD features.   
+
+<table><tr><td>DARTS</td><td>FairDARTS</td><td>ManifoldNet</td><td>SPDNet</td><td>SPDNetBN</td><td>Ours(R)</td><td>Ours(RADAR)</td><td>Ours (HDM05)</td></tr><tr><td>25.87 %</td><td>25.34%</td><td>23.98%</td><td>33.17%</td><td>35.22%</td><td>32.88%</td><td>35.31 %</td><td>38.01%</td></tr></table>
+
+# A.5 DERIVED CELL ARCHITECTURE USING SIGMOID ON FRECHET MIXTURE OF ´ SPDOPERATION
+
+Figure 5(a) and Figure 5(b) show the cell architecture obtained using the softmax and sigmoid respectively on the Frechet mixture of SPD operation. It can be observed that it has relatively more ´ skip and pooling operation than sparsemax ((see Figure 2(b))). In contrast to softmax and sigmoid, the SPD cell obtained using sparsemax is composed of more convolution type operation in the architecture, which in fact is important for better representation of the data.
+
+![](images/9a77339e53ae081023d645770643a279522daa427038d1c7dcb84e2328c43f99.jpg)  
+Figure 5: (a), (b) Derived architecture by using softmax and sigmoid on the Frechet mixture of SPD operations. ´ These are the normal cell and reduced cell obtained on RADAR and HDM05 dataset.
+
+A.6 COMPARISON BETWEEN KARCHER FLOW AND RECURSIVE APPORACH FOR WEIGHTEDFRECHET MEAN
+
+The proposed NAS algorithm is based on Frechet Mean computations. From the weighted mixture ´ of operations between nodes to the derivation of intermediate nodes, both compute the Frechet ´ mean of a set of points on the SPD manifold. It is well known that there is no closed form solution when the number of input samples is bigger than 2 (Brooks et al., 2019). We can only compute an approximation using the famous Karcher flow algorithm (Brooks et al., 2019) or recursive geodesic mean (Chakraborty et al., 2020). For comparison, we replace our used Karcher flow algorithm with the recursive approach under our SPDNetNAS framework. Table 10 sumarizes the comparison between these two algorithms. We observe considerable decrease in accuracy for both the training and test set when using the recursive methods, showing that the Karcher flow algorithm favors our proposed algorithm more.
+
+Table 10: Test performance of the proposed SPDNetNAS using the Karcher flow algorithm and the recursive algorithm to compute Frechet means. ´   
+
+<table><tr><td>Dataset/Method</td><td>Karcher flow</td><td>Recursivealgorithm</td></tr><tr><td>RADAR</td><td>96.47% ±0.08</td><td>68.13% ±0.64</td></tr><tr><td>HDM05</td><td>68.74%± 0.93</td><td>56.85%± 0.17</td></tr></table>
+
+# A.7 CONVERGENCE CURVE ANALYSIS
+
+Figure 6(a) shows the validation curve which almost saturates at 200 epoch demonstrating the stability of our training process. First column bar of Figure (6(b)) show the test accuracy comparison when only $10 \%$ of the data is used for training our architecture which demonstrate the effectiveness of our algorithm. Further, we study this for our SPDNetNAS architecture by taking $10 \%$ , $33 \%$ , $80 \%$ of the data for training. Figure 6(b)) clealy show our superiority of SPDNetNAS algorithm than handcrafted SPD networks.
+
+Figure (7(a)) and Figure (7(b)) show the convergence curve of our loss function on the RADAR and HDM05 datasets respectively. For the RADAR dataset the validation and training losses follow a similar trend and converges at 200 epochs. For the HDM05 dataset, we observe the training curve plateaus after 60 epochs, where as the validation curve takes 100 epochs to provide a stable performance. Additionally, we noticed a reasonable gap between the training loss and validation loss for the HDM05 dataset (Muller et al. ¨ , 2007). A similar pattern of convergence gap between validation loss and training loss has been observed by Huang & Van Gool (2017) work.
+
+# A.8 WHY WE PREFERRED TO SIMULATE OUR EXPERIMENTS ON CPU RATHER THAN GPU?
+
+When dealing with SPD matrices, we need to carry out complex computations. These computations are performed to make sure that our transformed representation and corresponding operations respect the underlying manifold structure. In our study, we analyzed SPD matrices with the Affine Invariant
+
+![](images/99576f072e6d74b43ecdbfdb0b1d5fed8ea2da83bc1744271e6787f59d53b1c9.jpg)  
+Figure 6: (a) Validation accuracy of our method in comparison to the SPDNet and SPDNetBN on RADAR dataset. Clearly, our SPDNetNAS algorithm show a steeper validation accuracy curve. (b) Test accuracy on $10 \%$ , $33 \%$ , $80 \%$ , $100 \%$ of the total data sample. It can be observed that our method exhibit superior performance.
+
+![](images/c888e6fb925a59516206b83f7c09d6dadc9920ddd674c3438c8592ea5a0e7f18.jpg)  
+Figure 7: (a) Loss function curve showing the values over 200 epochs for the RADAR dataset (b) Loss function curve showing the values over 100 epochs on the HDM05 dataset.
+
+Riemannian Metric (AIRM), this induces operations heavily dependent on singular value decomposition (SVD) or eigendecomposition (EIG). Both decompositions suffer from weak support on GPU platforms. Hence, our training did not benefit from GPU acceleration and we decided to train on CPU. As a future work, we aim to speedup our implementation on GPU by optimizing the SVD Householder bi-diagonalization process as studied in some existing works like Dong et al. (2017a); Gates et al. (2018).
+
+# B DETAILED DESCRIPTION OF OUR PROPOSED OPERATIONS
+
+In this section, we describe some of the major operations defined in the main paper from an intuitive point of view. We particularly focus on some of the new operations that are defined for the input SPDs, i.e., the Weighted Riemannian Pooling, the Average/Max Pooling, the Skip Reduced operation and the Mixture of Operations.
+
+# B.1 WEIGHTED RIEMANNIAN POOLING
+
+Figure 8 provides an intuition behind the Weighted Riemannian Pooling operation. Here, w 11, w 21, etc., corresponds to the set of normalized weights for each channel (shown as two blue channels). The next channel —shown in orange, is then computed as weighted Frechet mean over these two ´ input channels. This procedure is repeated to achieve the desired number of output channels (here two), and finally all the output channels are concatenated. The weights are learnt as a part of the optimization procedure ensuring the explicit convex constraint is imposed.
+
+![](images/494514445164eab2facd773c6a0087968954008e0505773803e8ddbdde24017e.jpg)  
+Figure 8: Weighted Riemannian Pooling: Performs multiple weighted Frechet means on the channels of the ´ input SPD
+
+# B.2 AVERAGE AND MAX POOLING
+
+In Figure 9 we show our average and max pooling operations. We first perform a LogEig map on the SPD matrices to project them to the Euclidean space. Next, we perform average and max pooling on these Euclidean matrices similar to classical convolutional neural networks. We further perform an ExpEig map to project the Euclidean matrices back on the SPD manifold. The diagram shown in Figure 9 is inspired by Huang & Van Gool (2017) work. The kernel size of AveragePooling reduced and MaxPooling reduced is set to 2 or 4 for all experiments according to the specific dimensionality reduction factors.
+
+![](images/c89ea03a243fcccc6e758e8b9fe66ec8085e7d076dab0340ee451b2687d2ccb9.jpg)  
+Figure 9: Avg/Max Pooling: Maps the SPD matrix to Euclidean space using LogEig mapping, does avg/max pooling followed by ExpEig map
+
+# B.3 SKIP REDUCED
+
+Following Liu et al. (2018b), we defined an analogous of Skip operation on a single channel for the reduced cell (Figure 10). We start by using a BiMap layer —equivalent to Conv in Liu et al. (2018b), to map the input channel to an SPD whose space dimension is half of the input dimension. We further perform an SVD decomposition on the two SPDs followed by concatenating the Us, Vs and Ds obtained from SVD to block diagonal matrices. Finally, we compute the output by multiplying the block diagonal U, V and D computed before.
+
+![](images/a1a38275f50ee883993c704d50ce8643e5b8a29fd4f58ca528a7595bb19558e7.jpg)  
+Figure 10: Skip Reduced:Maps input to two smaller matrices using BiMaps, followed by SVD decomposition on them and then computes the output using a block diagonal form of U’s D’s and V’s
+
+# B.4 MIXED OPERATION ON SPDS
+
+In Figure 11 we provide an intuition of the mixed operation we have proposed in the main paper. We consider a very simple base case of three nodes, two input nodes (1 and 2) and one output node (node 3). The goal is to compute the output node 3 from input nodes 1 and 2. We perform a candidate set of operations on the input node, which correspond to edges between the nodes (here two for simplicity). Each operation has a weight $\alpha _ { i _ { - } j }$ where i corresponds to the node index and j is the candidate operation identifier. In Figure 11 below i and $\mathrm { j } \in \{ \bar { 1 } , 2 \}$ and $\pmb { \alpha _ { 1 } } = \{ \alpha _ { 1 . 1 } , \alpha _ { 1 . 2 } \}$ , ${ \pmb { \alpha _ { 2 } } } = \{ { \alpha _ { 2 . 1 } , \alpha _ { 2 . 2 } } \}$ . $\alpha$ ’s are optimized as a part of the bi-level optimization procedure proposed in the main paper. Using these alpha’s, we perform a channel-wise weighted Frechet mean (wFM) as ´ depicted in the figure below. This effectively corresponds to a mixture of the candidate operations. Note that the alpha’s corresponding to all channels of a single operation are assumed to be the same. Once the weighted Frechet means have been computed for nodes 1 and 2, we perform a channel-wise ´ concatenation on the outputs of the two nodes, effectively doubling the number of channels in node 3.
+
+![](images/059a21dbab02ce1e7ad7325e141e7fb3f25b1c39f58f3c412f3f165c188d2801.jpg)  
+Figure 11: Detailed overview of mixed operations. We simplify the example by taking 3 nodes (two input nodes and one output node) and two candidate operations. Input nodes have two channels (SPD matrices), we perform channelwise weighted Frechet mean between the result of each operation (edge) where weights ´ $\alpha$ ’s are optimized during bi-level architecture search optimization. Output node 3 is formed by concatenating both mixed operation outputs, resulting in a four channel node.   
+Listing 1: Function to solve the sparsemax constraint optimization
+
+# C DIFFERENTIABLE CONVEX LAYER FOR SPARSEMAX OPTIMIZATION
+
+1 import cvxpy as cp   
+2 from cvxpylayers.torch import CvxpyLayer   
+3   
+4 def sparsemax_convex_layer(x, n):   
+5 $\begin{array} { r l } { \mathbf { \tilde { w } _ { - } } } & { { } = } \end{array}$ cp.Variable(n)   
+6 $\begin{array} { r l } { \mathrm { x } \_ } & { { } = } \end{array}$ cp.Parameter(n)   
+7   
+8 # define the objective and constraint   
+9 objective $=$ cp.Minimize(cp.sum(cp.multiply $( \ w _ { \mathbb { W } _ { - } } , \mathrm { ~ \\v ~ { ~ x ~ } _ { - } ) ~ } )$ ))   
+10 constraint $=$ [cp.sum(w_) == 1.0, $0 . 0 < = \mathrm { \Delta } \mathsf { w } _ { - }$ , w_<=1.0]   
+11   
+12 opt_problem $=$ cp.Problem(objective, constraint)   
+13 layer $=$ CvxpyLayer(opt_problem, parameter $\mathbf { S } = \left[ \mathbf { X } _ { - } \right]$ , variable $\mathrm { s } = \left[ \mathrm { w } _ { - } \right]$ )   
+14 $\begin{array} { r } { \begin{array} { c c l } { \mathtt { w } , } & { = } & { \mathtt { l a y e r } \left( \mathtt { x } \right) } \end{array} } \end{array}$   
+15 return w

parse/train/BJlS634tPr/BJlS634tPr_content_list.json

@@ -0,0 +1,1444 @@
+[
+    {
+        "type": "text",
+        "text": "PC-DARTS: PARTIAL CHANNEL CONNECTIONS FOR MEMORY-EFFICIENT ARCHITECTURE SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yuhui $\\mathbf { X } \\mathbf { u } ^ { 1 * }$ Lingxi Xie2 Xiaopeng Zhang2 Xin Chen3   \nGuo- $\\mathbf { J u n 0 \\dot { i } ^ { 4 } }$ Qi Tian2(\u0000) Hongkai Xiong1   \n1Shanghai Jiao Tong University 2Huawei Noah’s Ark Lab   \n3Tongji University 4Futurewei Technologies   \nyuhuixu@sjtu.edu.cn {198808xc,zxphistory}@gmail.com 1410452@tongji.edu.cn   \nguojunq@gmail.com tian.qi1@huawei.com xionghongkai@sjtu.edu.cn ",
+        "bbox": [
+            183,
+            169,
+            836,
+            257
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            294,
+            544,
+            309
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Differentiable architecture search (DARTS) provided a fast solution in finding effective network architectures, but suffered from large memory and computing overheads in jointly training a super-network and searching for an optimal architecture. In this paper, we present a novel approach, namely, Partially-Connected DARTS, by sampling a small part of super-network to reduce the redundancy in exploring the network space, thereby performing a more efficient search without comprising the performance. In particular, we perform operation search in a subset of channels while bypassing the held out part in a shortcut. This strategy may suffer from an undesired inconsistency on selecting the edges of super-net caused by sampling different channels. We alleviate it using edge normalization, which adds a new set of edge-level parameters to reduce uncertainty in search. Thanks to the reduced memory cost, PC-DARTS can be trained with a larger batch size and, consequently, enjoys both faster speed and higher training stability. Experimental results demonstrate the effectiveness of the proposed method. Specifically, we achieve an error rate of $2 . 5 7 \\%$ on CIFAR10 with merely 0.1 GPU-days for architecture search, and a state-of-the-art top-1 error rate of $\\dot { 2 } 4 . 2 \\%$ on ImageNet (under the mobile setting) using 3.8 GPU-days for search. Our code has been made available at https://github.com/yuhuixu1993/PC-DARTS. ",
+        "bbox": [
+            233,
+            338,
+            764,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            612,
+            336,
+            628
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural architecture search (NAS) emerged as an important branch of automatic machine learning (AutoML), and has been attracting increasing attentions from both academia and industry. The key methodology of NAS is to build a large space of network architectures, develop an efficient algorithm to explore the space, and discover the optimal structure under a combination of training data and constraints (e.g., network size and latency). Different from early approaches that often incur large computation overheads (Zoph & Le, 2017; Zoph et al., 2018; Real et al., 2019), recent oneshot approaches (Pham et al., 2018; Liu et al., 2019) have reduced the search costs by orders of magnitudes, which advances its applications to many real-world problems. In particular, DARTS (Liu et al., 2019) converts the operation selection into weighting a fixed set of operations. This makes the entire framework differentiable to architecture hyper-parameters and thus the network search can be efficiently accomplished in an end-to-end fashion. Despite its sophisticated design, DARTS is still subject to a large yet redundant space of network architectures and thus suffers from heavy memory and computation overheads. This prevents the search process from using larger batch sizes for either speedup or higher stability. Prior work (Chen et al., 2019) proposed to reduce the search space, which leads to an approximation that may sacrifice the optimality of the discovered architecture. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            852
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a simple yet effective approach named Partially-Connected DARTS (PCDARTS) to reduce the burdens of memory and computation. The core idea is intuitive: instead of sending all channels into the block of operation selection, we randomly sample a subset of them in each step, while bypassing the rest directly in a shortcut. We assume the computation on this subset is a surrogate approximating that on all the channels. Besides the tremendous reduction in memory and computation costs, channel sampling brings another benefit – operation search is regularized and less likely to fall into local optima. However, PC-DARTS incurs a side effect, where the selection of channel connectivity would become unstable as different subsets of channels are sampled across iterations. Thus, we introduce edge normalization to stabilize the search for network connectivity by explicitly learning an extra set of edge-selection hyper-parameters. By sharing these hyper-parameters throughout the training process, the sought network architecture is insensitive to the sampled channels across iterations and thus is more stable. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Benefiting from the partial connection strategy, we are able to greatly increase the batch size. Specifically, as only $1 / K$ of channels are randomly sampled for an operation selection, it reduces the memory burden by almost $K$ times. This allows us to use a $K$ times larger batch size during search, which not only accelerates the network search but also stabilizes the process particularly for largescale datasets. Experiments on benchmark datasets demonstrate the effectiveness of PC-DARTS. Specifically, we achieve an error rate of $2 . 5 7 \\%$ in less than 0.1 GPU-days (around 1.5 hours) on a single Tesla V100 GPU, surpassing the result of $2 . 7 6 \\%$ reported by DARTS that required 1.0 GPUday. Furthermore, PC-DARTS allows a direct search on ImageNet (while DARTS failed due to low stability), and sets the state-of-the-art record with a top-1 error of $2 4 . 2 \\%$ (under the mobile setting) in only 3.8 GPU-days (11.5 hours on eight Tesla V100 GPUs). ",
+        "bbox": [
+            174,
+            277,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            443,
+            343,
+            459
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Thanks to the rapid development of deep learning, significant gain in performance has been brought to a wide range of computer vision problems, most of which owed to manually desgined network architectures (Krizhevsky et al., 2012; Simonyan & Zisserman, 2015; He et al., 2016; Huang et al., 2017). Recently, a new research field named neural architecture search (NAS) has been attracting increasing attentions. The goal is to find automatic ways of designing neural architectures to replace conventional handcrafted ones. According to the heuristics to explore the large architecture space, existing NAS approaches can be roughly divided into three categories, namely, evolution-based approaches, reinforcement-learning-based approaches and one-shot approaches. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            590
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The first type of architecture search methods (Liu et al., 2018b; Xie & Yuille, 2017; Real et al., 2017; Elsken et al., 2019; Real et al., 2019; Miikkulainen et al., 2019) adopted evolutionary algorithms, which assumed the possibility of applying genetic operations to force a single architecture or a family evolve towards better performance. Among them, Liu et al. (Liu et al., 2018b) introduced a hierarchical representation for describing a network architecture, and Xie et al. (Xie & Yuille, 2017) decomposed each architecture into a representation of ‘genes’. Real et al. (Real et al., 2019) proposed aging evolution which improved upon standard tournament selection, and surpassed the best manually designed architecture since then. Another line of heuristics turns to reinforcement learning (RL) (Zoph & Le, 2017; Baker et al., 2017; Zoph et al., 2018; Zhong et al., 2018; Liu et al., 2018a), which trained a meta-controller to guide the search process. Zoph et al. (Zoph & Le, 2017) first proposed using a controller-based recurrent neural network to generate hyper-parameters of neural networks. To reduce the computation cost, researchers started to search for blocks or cells (Zhong et al., 2018; Zoph et al., 2018) instead of the entire network, and consequently, managed to reduce the overall computational costs by a factor of 7. Other kinds of approximation, such as greedy search (Liu et al., 2018a), were also applied to further accelerate search. Nevertheless, the computation costs of these approaches, based on either evolution or RL, are still beyond acceptance. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to accomplish architecture search within a short period of time, researchers considered to reduce the costs of evaluating each searched candidate. Early efforts include sharing weights between searched and newly generated networks (Cai et al., 2018), and later these methods were generalized into a more elegant framework named one-shot architecture search (Brock et al., 2018; Cai et al., 2019; Liu et al., 2019; Pham et al., 2018; Xie et al., 2019), in which an over-parameterized network or super-network covering all candidate operations was trained only once, from which exponentially many sub-networks can be sampled. As typical examples, SMASH (Brock et al., ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/673989415b90d9a279095d73eddf41f256434aba92fe94afee85cf045494360f.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the proposed approach (best viewed in color), partially-connected DARTS (PC-DARTS). As an example, we investigate how information is propagated to node $\\# 3$ , i.e., $j = 3$ . There are two sets of hyper-parameters during search, namely, $\\{ \\stackrel { \\cdot } { \\alpha } _ { i , j } ^ { o } \\}$ and $\\{ \\beta _ { i , j } \\}$ , where $0 \\leqslant i < j$ and $o \\in \\mathcal { O }$ . To determine $\\left\\{ \\alpha _ { i , j } ^ { o } \\right\\}$ , we only sample a subset, $1 / K$ , of channels and connect them to the next stage, so that the memory consumption is reduced by $K$ times. To minimize the uncertainty incurred by sampling, we add $\\{ \\beta _ { i , j } \\}$ as extra edge-level parameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            108,
+            794,
+            369
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2018) trained the over-parameterized network by a HyperNet (Ha et al., 2017), and ENAS (Pham et al., 2018) shared parameters among child models to avoid retraining each candidate from scratch. ",
+        "bbox": [
+            174,
+            500,
+            823,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This paper is based on DARTS (Liu et al., 2018b), which introduced a differentiable framework for architecture search, and thus combine the search and evaluation stages into one. A super-network is optimized during the search stage, after which the strongest sub-network is preserved and then retrained. Despite its simplicity, researchers detected some of its drawbacks, such as instability (Li & Talwalkar, 2019; Sciuto et al., 2019), which led to a few improved approaches beyond DARTS (Cai et al., 2019; Chen et al., 2019; Mei et al., 2020). In particular, ProxylessNAS (Cai et al., 2019) was the first method that searched directly on ImageNet, and P-DARTS (Chen et al., 2019) designed a progressive search stage to bridge the depth gap between the super-network and the sub-network. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE PROPOSED APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            667,
+            431,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PRELIMINARIES: DIFFERENTIABLE ARCHITECTURE SEARCH (DARTS) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            700,
+            705,
+            714
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first review the baseline DARTS (Liu et al., 2019), and define the notations for the discussion later. Mathematically, DARTS decomposes the searched network into a number $( L )$ of cells. Each cell is represented as a directed acyclic graph (DAG) with $N$ nodes, where each node defines a network layer. There is a pre-defined space of operations denoted by $\\mathcal { O }$ , in which each element, $o ( \\cdot )$ , is a fixed operation (e.g., identity connection, and $3 \\times 3$ convolution) performed at a network layer. Within a cell, the goal is to choose one operation from $\\mathcal { O }$ to connect each pair of nodes. Let a pair of nodes be $( i , j )$ , where $0 \\leqslant i < j \\leqslant N - 1$ , the core idea of DARTS is to formulate the information propagated from $i$ to $j$ as a weighted sum over $| \\mathcal { O } |$ operations, namely, $\\begin{array} { r } { f _ { i , j } ( \\mathbf { x } _ { i } ) = \\sum _ { o \\in \\mathcal { O } } \\frac { \\exp \\left\\{ \\alpha _ { i , j } ^ { o } \\right\\} } { \\sum _ { o ^ { \\prime } \\in \\mathcal { O } } \\exp \\left\\{ \\alpha _ { i , j } ^ { o ^ { \\prime } } \\right\\} } \\cdot o ( \\mathbf { x } _ { i } ) } \\end{array}$ , where $\\mathbf { x } _ { i }$ is the output of the $i$ -th node, and $\\alpha _ { i , j } ^ { o }$ is a hyper-parameter for weighting operation $o \\big ( \\mathbf { x } _ { i } \\big )$ . The output of a node is the sum of all input flows, i.e., $\\begin{array} { r } { \\mathbf { x } _ { j } ^ { - } = \\sum _ { i < j } f _ { i , j } ( \\mathbf { x } _ { i } ) } \\end{array}$ , and the output of the entire cell is formed by concatenating the output of nodes ${ \\bf x } _ { 2 } - { \\bf x } _ { N - 1 }$ , i.e., $\\mathrm { c o n c a t } ( \\mathbf { x } _ { 2 } , \\mathbf { x } _ { 3 } , \\dots , \\mathbf { x } _ { N - 1 } )$ . Note that the first two nodes, $\\mathbf { x } _ { \\mathrm { 0 } }$ and $\\mathbf { x } _ { 1 }$ , are input nodes to a cell, which are fixed during architecture search. ",
+        "bbox": [
+            173,
+            727,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This design makes the entire framework differentiable to both layer weights and hyper-parameters $\\alpha _ { i , j } ^ { o }$ , so that it is possible to perform architecture search in an end-to-end fashion. After the search process is finished, on each edge $( i , j )$ , the operation $o$ with the largest $\\alpha _ { i , j } ^ { o }$ value is preserved, and each node $j$ is connected to two precedents $i < j$ with the largest $\\alpha _ { i , j } ^ { o }$ preserved. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            162
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 PARTIAL CHANNEL CONNECTIONS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            178,
+            455,
+            193
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A drawback of DARTS lies in memory inefficiency. In the main part of the searched architecture, $| \\mathcal { O } |$ operations and the corresponding outputs need to be stored at each node (i.e., each network layer), leading to $| { \\mathcal { O } } | \\times$ memory to use. To fit into a GPU, one must reduce the batch size during search, which inevitably slows down search speed, and may deteriorate search stability and accuracy. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            261
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An alternative solution to memory efficiency is the partial channel connection as depicted in Figure 1. Take the connection from $\\mathbf { x } _ { i }$ to $\\mathbf { x } _ { j }$ for example. This involves defining a channel sampling mask $\\mathbf { S } _ { i , j }$ , which assigns 1 to selected channels and 0 to masked ones. The selected channels are sent into mixed computation of $| \\mathcal { O } |$ operations, while the masked ones bypass these operations, i.e., they are directly copied to the output, ",
+        "bbox": [
+            174,
+            267,
+            825,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/877bf145a0b12cada335e6eb4d5aa7ca5b931e22cf7500c4f02520496388c4e2.jpg",
+        "text": "$$\nf _ { i , j } ^ { \\mathrm { P C } } ( \\mathbf { x } _ { i } ; \\mathbf { S } _ { i , j } ) = \\sum _ { o \\in \\mathcal { O } } \\frac { \\exp \\left\\{ \\alpha _ { i , j } ^ { o } \\right\\} } { \\sum _ { o ^ { \\prime } \\in \\mathcal { O } } \\exp \\left\\{ \\alpha _ { i , j } ^ { o ^ { \\prime } } \\right\\} } \\cdot o ( \\mathbf { S } _ { i , j } * \\mathbf { x } _ { i } ) + ( 1 - \\mathbf { S } _ { i , j } ) * \\mathbf { x } _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            343,
+            738,
+            385
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where, $\\mathbf { S } _ { i , j } * \\mathbf { x } _ { i }$ and $( 1 - \\mathbf { S } _ { i , j } ) * \\mathbf { x } _ { i }$ denote the selected and masked channels, respectively. In practice, we set the proportion of selected channels to $1 / K$ by regarding $K$ as a hyper-parameter. By varying $K$ , we could trade off between architecture search accuracy (smaller $K$ ) and efficiency (larger $K$ ) to strike a balance (See Section 4.4.1 for more details). ",
+        "bbox": [
+            174,
+            390,
+            825,
+            446
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A direct benefit brought by the partial channel connection is that the memory overhead of computing $f _ { i , j } ^ { \\mathrm { P C } } ( \\mathbf { x } _ { i } ; \\mathbf { S } _ { i , j } )$ is reduced by $K$ times. This allows us to use a larger batch size for architecture search. There are twofold benefits. First, the computing cost could be reduced by $K$ times during the architecture search. Moreover, the larger batch size implies the possibility of sampling more training data during each iteration. This is particularly important for the stability of architecture search. In most cases, the advantage of one operation over another is not significant, unless more training data are involved in a mini-batch to reduce the uncertainty in updating the parameters of network weights and architectures. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 EDGE NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            582,
+            380,
+            595
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let us look into the impact of sampling channels on neural architecture search. There are both positive and negative effects. On the upside, by feeding a small subset of channels for operation mixture while bypassing the remainder, we make it less biased in selecting operations. In other words, for edge $( i , { \\bar { j } } )$ , given an input $\\mathbf { x } _ { i }$ , the difference from using two sets of hyper-parameters $\\left\\{ \\alpha _ { i , j } ^ { o } \\right\\}$ and $\\left\\{ \\alpha _ { i , j } ^ { \\prime o } \\right\\}$ is largely reduced, because only a small part $( 1 / K )$ of input channels would go through the operation mixture while the remaining channels are left intact. This regularizes the preference of a weight-free operation (e.g., skip-connect, max-pooling, etc.) over a weight-equipped one (e.g., various kinds of convolution) in $\\mathcal { O }$ . In the early stage, the search algorithm often prefers weight-free operations, because they do not have weights to train and thus produce more consistent outputs, i.e., $o \\big ( \\mathbf { x } _ { i } \\big )$ . In contrast, the weight-equipped ones, before their weights are well optimized, would propagate inconsistent information across iterations. Consequently, weight-free operations often accumulate larger weights (namely $\\alpha _ { i , j } ^ { o }$ ) at the beginning, and this makes it difficult for the weightequipped operations to beat them even after they have been well trained thereafter. This phenomenon is especially significant when the proxy dataset (on which architecture search is performed) is difficult, and this could prevent DARTS from performing satisfactory architecture search on ImageNet. In experiments, we will show that PC-DARTS, with partial channel connections, produces more stable and superior performance on ImageNet. ",
+        "bbox": [
+            173,
+            608,
+            825,
+            847
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "On the downside, in a cell, each output node $\\mathbf { x } _ { j }$ needs to pick up two input nodes from its precedents $\\left\\{ \\mathbf { x } _ { 0 } , \\mathbf { x } _ { 1 } , \\dotsc , \\mathbf { x } _ { j - 1 } \\right\\}$ , which are weighted by $\\operatorname* { m a x } _ { o } \\alpha _ { 0 , j } ^ { o }$ , maxo $\\alpha _ { 1 , j } ^ { o } , \\dots , \\operatorname* { m a x } _ { o } \\alpha _ { j - 1 , j } ^ { o }$ , respectively, following the original DARTS. However, these architecture parameters are optimized by randomly sampled channels across iterations, and thus the optimal connectivity determined by them could be unstable as the sampled channels change over time. This could cause undesired fluctuation in the resultant network architecture. To mitigate this problem, we introduce edge normalization that weighs on each edge $( i , j )$ explicitly, denoted by $\\beta _ { i , j }$ , so that the computation of $\\mathbf { x } _ { j }$ becomes: ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d05d2e7ac3df144b04c0ff6cfd2eaf11dd55f7e24e47f424a4be65bd0a1f10de.jpg",
+        "text": "$$\n\\mathbf { x } _ { j } ^ { \\mathrm { P C } } = \\sum _ { i < j } \\frac { \\exp \\left\\{ \\beta _ { i , j } \\right\\} } { \\sum _ { i ^ { \\prime } < j } \\exp \\left\\{ \\beta _ { i ^ { \\prime } , j } \\right\\} } \\cdot f _ { i , j } ( \\mathbf { x } _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            137,
+            633,
+            178
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Specifically, after the architecture search is done, the connectivity of edge $( i , j )$ is determined by both $\\left\\{ \\alpha _ { i , j } ^ { o } \\right\\}$ and $\\beta _ { i , j }$ , for which we multiply the normalized coefficients together, i.e., multiplying $\\overline { { \\sum _ { i ^ { \\prime } < j } \\exp \\left\\{ \\beta _ { i ^ { \\prime } , j } \\right\\} } }$ $\\exp \\{ \\beta _ { i , j } \\}$ by $\\frac { \\exp \\left\\{ \\alpha _ { i , j } ^ { o } \\right\\} } { \\sum _ { o ^ { \\prime } \\in \\mathcal { O } } \\exp \\left\\{ \\alpha _ { i , j } ^ { o ^ { \\prime } } \\right\\} }$ Then the edges are selected by finding the large edge weights as in DARTS. Since $\\beta _ { i , j }$ are shared through the training process, the learned network architecture is insensitive to the sampled channels across iterations, making the architecture search more stable. In Section 4.4.2, we will show that edge normalization is also effective over the original DARTS. Finally, the extra computation overhead required for edge normalization is negligible. ",
+        "bbox": [
+            173,
+            189,
+            825,
+            304
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 DISCUSSIONS AND RELATIONSHIP TO PRIOR WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            320,
+            573,
+            334
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First of all, there are two major contributions of our approach, namely, channel sampling and edge normalization. Channel sampling, as the key technique in this work, has not been studied in NAS for reducing computational overhead (other regularization methods like Dropout (Srivastava et al., 2014) and DropPath (Larsson et al., 2017) cannot achieve the same efficiency, in both time and memory, as channel sampling). It accelerates and regularizes search and, with the help of edge normalization, improves search stability. Note that both search speed and stability are very important for a search algorithm. Combining channel sampling and edge normalization, we obtain the best accuracy on ImageNet (based on the DARTS search space), and the direct search cost on ImageNet (3.8 GPU-days) is the lowest known. Moreover, these two components are easily transplanted to other search algorithms to improve search accuracy and speed, e.g., edge normalization boosts the accuracy and speed of the original DARTS methods. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            500
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Other researchers also tried to alleviate the large memory consumption of DARTS. Among prior efforts, ProxylessNAS (Cai et al., 2019) binarized the multinomial distribution $\\alpha _ { i , j } ^ { o }$ and samples two paths at each time, which significantly reduced memory cost and enabled direct search on ImageNet. PARSEC (Casale et al., 2019) also proposed a sampling-based optimization method to learn a probability distribution. Our solution, by preserving all operations for architecture search, achieves a higher accuracy in particular on challenging datasets like ImageNet $( + 0 . 7 \\%$ over ProxylessNAS and $+ 1 . 8 \\%$ over PARSEC). Another practical method towards memory efficiency is ProgressiveDARTS (Chen et al., 2019), which eliminated a subset of operators in order to provide sufficient memory for deeper architecture search. In comparison, our approach preserves all operators and instead performs sub-sampling on the channel dimension. This strategy works better in particular on large-scale datasets like ImageNet. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            679,
+            326,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS AND IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            709,
+            516,
+            723
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We perform experiments on CIFAR10 and ImageNet, two most popular datasets for evaluating neural architecture search. CIFAR10 (Krizhevsky & Hinton, 2009) consists of 60K images, all of which are of a spatial resolution of $3 2 \\times 3 2$ . These images are equally distributed over 10 classes, with 50K training and 10K testing images. ImageNet (Deng et al., 2009) contains 1,000 object categories, and $1 . 3 \\mathrm { M }$ training images and 50K validation images, all of which are high-resolution and roughly equally distributed over all classes. Following the conventions (Zoph et al., 2018; Liu et al., 2019), we apply the mobile setting where the input image size is fixed to be $2 2 4 \\times 2 2 4$ and the number of multi-add operations does not exceed 600M in the testing stage. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Following DARTS (Liu et al., 2019) as well as conventional architecture search approaches, we use an individual stage for architecture search, and after the optimal architecture is obtained, we conduct another training process from scratch. In the search stage, the goal is to determine the best sets of hyper-parameters, namely $\\{ \\alpha _ { i , j } ^ { o } \\}$ and $\\{ \\beta _ { i , j } \\}$ for each edge $( i , j )$ . To this end, the trainnig set is partitioned into two parts, with the first part used for optimizing network parameters, e.g., convolutional weights, and the second part used for optimizing hyper-parameters. The entire search stage is accomplished in an end-to-end manner. For fair comparison, the operation space $\\mathcal { O }$ remains the same as the convention, which contains 8 choices, i.e., $3 \\times 3$ and $5 \\times 5$ separable convolution, $3 \\times 3$ and $5 \\times 5$ dilated separable convolution, $3 \\times 3$ max-pooling, $3 \\times 3$ average-pooling, skip-connect (a.k.a., identity), and zero (a.k.a., none). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/b1923efc986150dd80d579bcb3f6e84b45fa65153518d2f60d02fb164be42bf3.jpg",
+        "table_caption": [
+            "Table 1: Comparison with state-of-the-art network architectures on CIFAR10. "
+        ],
+        "table_footnote": [
+            "† Recorded on a single GTX 1080Ti. It can be shortened into 0.06 GPU-days if Tesla V100 is used. ‡ We ran PC-DARTS 5 times and used standalone validation to pick the best from the 5 runs. This process was done by using 45K out of 50K training images for training, and the remaining 5K images for validation. The best one in validation was used for testing, which reported a test error of $2 . 5 7 \\%$ . "
+        ],
+        "table_body": "<table><tr><td>Architecture</td><td>Test Err. (%)</td><td>Params (M)</td><td>Search Cost (GPU-days)</td><td>Search Method</td></tr><tr><td>DenseNet-BC (Huang et al., 2017)</td><td>3.46</td><td>25.6</td><td>1</td><td>manual</td></tr><tr><td>NASNet-A + cutout (Zoph et al., 2018)</td><td>2.65</td><td>3.3</td><td>1800</td><td>RL</td></tr><tr><td>AmoebaNet-B + cutout (Real et al., 2019)</td><td>2.55±0.05</td><td>2.8</td><td>3150</td><td>evolution</td></tr><tr><td>Hireachical Evolution (Liu et al.,2018b)</td><td>3.75±0.12</td><td>15.7</td><td>300</td><td>evolution</td></tr><tr><td>PNAS (Liu et al., 2018a)</td><td>3.41±0.09</td><td>3.2</td><td>225</td><td>SMBO</td></tr><tr><td>ENAS + cutout (Pham et al., 2018)</td><td>2.89</td><td>4.6</td><td>0.5</td><td>RL</td></tr><tr><td>NAONet-WS (Luo et al., 2018)</td><td>3.53</td><td>3.1</td><td>0.4</td><td>NAO</td></tr><tr><td>DARTS (lst order) + cutout (Liu et al., 2019)</td><td>3.00±0.14</td><td>3.3</td><td>0.4</td><td>gradient-based</td></tr><tr><td>DARTS (2nd order) + cutout (Liu et al.,2019)</td><td>2.76±0.09</td><td>3.3</td><td>1</td><td>gradient-based</td></tr><tr><td>SNAS (moderate) + cutout (Xie et al., 2019)</td><td>2.85±0.02</td><td>2.8</td><td>1.5</td><td>gradient-based</td></tr><tr><td>ProxylessNAS + cutout (Cai et al., 2019)</td><td>2.08</td><td>-</td><td>4.0</td><td>gradient-based</td></tr><tr><td>P-DARTS + cutout (Chen et al., 2019)</td><td>2.50</td><td>3.4</td><td>0.3</td><td>gradient-based</td></tr><tr><td>BayesNAS + cutout (Zhou et al.,2019)</td><td>2.81±0.04</td><td>3.4</td><td>0.2</td><td>gradient-based</td></tr><tr><td>PC-DARTS +cutout</td><td>2.57±0.07‡</td><td>3.6</td><td>0.1†</td><td>gradient-based</td></tr></table>",
+        "bbox": [
+            176,
+            127,
+            826,
+            361
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            448,
+            825,
+            518
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We propose an alternative and more efficient implementation for partial channel connections. For edge $( i , j )$ , we do not perform channel sampling at each time of computing $o \\big ( \\mathbf { x } _ { i } \\big )$ , but instead choose the first $1 / K$ channels of $\\mathbf { x } _ { i }$ for operation mixture directly. To compensate, after $\\mathbf { x } _ { j }$ is obtained, we shuffle its channels before using it for further computations. This is the same implementation used in ShuffleNet (Zhang et al., 2018), which is more GPU-friendly and thus runs faster. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS ON CIFAR10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            375,
+            628
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the search scenario, the over-parameterized network is constructed by stacking 8 cells (6 normal cells and 2 reduction cells), and each cell consists of $N = 6$ nodes. We train the network for 50 epochs, with the initial number of channels being 16. The 50K training set of CIFAR10 is split into two subsets with equal size, with one subset used for training network weights and the other used for architecture hyper-parameters. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We set $K = 4$ for CIFAR10, i.e., only $1 / 4$ features are sampled on each edge, so that the batch size during search is increased from 64 to 256. Besides, following (Chen et al., 2019), we freeze the hyper-parameters, $\\left\\{ \\alpha _ { i , j } ^ { o } \\right\\}$ and $\\{ \\beta _ { i , j } \\}$ , and only allow the network parameters to be tuned in the first 15 epochs. This process, called warm-up, is to alleviate the drawback of the parameterized operations. The total memory cost is less than 12GB so that we can train it on most modern GPUs. The network weights are optimized by momentum SGD, with an initial learning rate of 0.1 (annealed down to zero following a cosine schedule without restart), a momentum of 0.9, and a weight decay of $3 \\times 1 0 ^ { - 4 }$ . We use an Adam optimizer (Kingma & Ba, 2015) for $\\left\\{ \\alpha _ { i , j } ^ { o } \\right\\}$ and $\\{ \\beta _ { i , j } \\}$ , with a fixed learning rate of $6 \\times 1 0 ^ { - 4 }$ , a momentum of (0.5, 0.999) and a weight decay of $1 0 ^ { - 3 }$ . Owing to the increased batch size, the entire search process only requires 3 hours on a GTX 1080Ti GPU, or 1.5 hours on a Tesla V100 GPU, which is almost $4 \\times$ faster than the original first-order DARTS. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The evaluation stage simply follows that of DARTS. The network is composed of 20 cells (18 normal cells and 2 reduction cells), and each type of cells share the same architecture. The initial number of channels is 36. The entire 50K training set is used, and the network is trained from scratch for ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b6df549661eba198cfa204b40257d214e1e6f0f2fa4ecbf2b21cf63acff3e2e5.jpg",
+        "image_caption": [
+            "Figure 2: Cells found on CIFAR10 and ImageNet. Searching on ImageNet makes the normal cell more complex (deeper), although the reduction cell is very similar to that found on CIFAR10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            106,
+            818,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "600 epochs using a batch size of 128. We use the SGD optimizer with an initial learning rate of 0.025 (annealed down to zero following a cosine schedule without restart), a momentum of 0.9, a weight decay of $3 \\times 1 0 ^ { - 4 }$ and a norm gradient clipping at 5. Drop-path with a rate of 0.3 as well as cutout (DeVries & Taylor, 2017) is also used for regularization. We visualize the searched normal and reduction cells in the left-hand side of Figure 2. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            483
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results and comparison to recent approaches are summarized in Table 1. In merely 0.1 GPU-days, PC-DARTS achieve an error rate of $2 . 5 7 \\%$ , with both search time and accuracy surpassing the baseline, DARTS, significantly. To the best of our knowledge, our approach is the fastest one that achieves an error rate of less than $3 \\%$ . Our number ranks among the top of recent architecture search results. ProxylessNAS used a different protocol to achieve an error rate of $2 . 0 8 \\%$ , and also reported a much longer time for architecture search. P-DARTS (Chen et al., 2019) slightly outperforms our approach by searching over a deeper architecture, which we can integrate our approach into P-DARTS to accelerate it as well as improve its performance (consistent accuracy gain is obtained). ",
+        "bbox": [
+            174,
+            491,
+            825,
+            602
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 RESULTS ON IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            619,
+            383,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We slightly modify the network architecture used on CIFAR10 to fit ImageNet. The overparameterized network starts with three convolution layers of stride 2 to reduce the input image resolution from $2 2 4 \\times 2 2 4$ to $2 8 \\times 2 8$ . 8 cells (6 normal cells and 2 reduction cells) are stacked beyond this point, and each cell consists of $N = 6$ nodes. To reduce search time, we randomly sample two subsets from the 1.3M training set of ImageNet, with $1 0 \\%$ and $2 . 5 \\%$ images, respectively. The former one is used for training network weights and the latter for updating hyper-parameters. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ImageNet is much more difficult than CIFAR10. To preserve more information, we use a subsampling rate of $1 / 2$ , which doubles that used in CIFAR10. Still, a total of 50 epochs are trained and architecture hyper-parameters are frozen during the first 35 epochs. For network weights, we use a momentum SGD with an initial learning rate of 0.5 (annealed down to zero following a cosine schedule without restart), a momentum of 0.9, and a weight decay of $3 \\times 1 0 ^ { - 5 }$ . For hyper-parameters, we use the Adam optimizer (Kingma & Ba, 2015) with a fixed learning rate of $6 \\times \\bar { 1 0 } ^ { - 3 }$ , a momentum (0.5, 0.999) and a weight decay of $1 0 ^ { - 3 }$ . We use eight Tesla V100 GPUs for search, and the total batch size is 1,024. The entire search process takes around 11.5 hours. We visualize the searched normal and reduction cells in the right-hand side of Figure 2. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The evaluation stage follows that of DARTS, which also starts with three convolution layers with a stride of 2 that reduce the input image resolution from $2 2 4 \\times 2 2 4$ to $2 8 \\times 2 8$ . 14 cells (12 normal cells and 2 reduction cells) are stacked beyond this point, with the initial channel number being 48. The network is trained from scratch for 250 epochs using a batch size of 1,024. We use the SGD optimizer with a momentum of 0.9, an initial learning rate of 0.5 (decayed down to zero linearly), and a weight decay of $3 \\times 1 0 ^ { - 5 }$ . Additional enhancements are adopted including label smoothing and an auxiliary loss tower during training. Learning rate warm-up is applied for the first 5 epochs. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/24f035fe245e68e378a4f6185b7bd5d44d956910ff5c0c75c561363e2996b72e.jpg",
+        "table_caption": [
+            "Table 2: Comparison with state-of-the-art architectures on ImageNet (mobile setting). "
+        ],
+        "table_footnote": [
+            "‡ This architecture was searched on ImageNet directly, otherwise it was searched on CIFAR10 or CIFAR100. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Architecture</td><td colspan=\"2\">Test Err. (%)</td><td rowspan=\"2\">Params (M)</td><td rowspan=\"2\">×+ (M)</td><td rowspan=\"2\">Search Cost (GPU-days)</td><td rowspan=\"2\">Search Method</td></tr><tr><td>top-1</td><td>top-5</td></tr><tr><td>Inception-vl (Szegedy et al., 2015)</td><td>30.2</td><td>10.1</td><td>6.6</td><td>1448</td><td>=</td><td>manual</td></tr><tr><td>MobileNet (Howard et al., 2017)</td><td>29.4</td><td>10.5</td><td>4.2</td><td>569</td><td></td><td>manual</td></tr><tr><td>ShuffleNet 2× (v1) (Zhang et al.,2018)</td><td>26.4</td><td>10.2</td><td>~5</td><td>524</td><td>=</td><td>manual</td></tr><tr><td>ShuffleNet 2× (v2) (Ma et al., 2018)</td><td>25.1</td><td>1</td><td>~5</td><td>591</td><td>=</td><td>manual</td></tr><tr><td>NASNet-A (Zoph et al., 2018)</td><td>26.0</td><td>8.4</td><td>5.3</td><td>564</td><td>1800</td><td>RL</td></tr><tr><td>AmoebaNet-C (Real et al., 2019)</td><td>24.3</td><td>7.6</td><td>6.4</td><td>570</td><td>3150</td><td>evolution</td></tr><tr><td>PNAS (Liu et al., 2018a)</td><td>25.8</td><td>8.1</td><td>5.1</td><td>588</td><td>225</td><td>SMBO</td></tr><tr><td>MnasNet-92 (Tan et al., 2019)</td><td>25.2</td><td>8.0</td><td>4.4</td><td>388</td><td>-</td><td>RL</td></tr><tr><td>DARTS (2nd order) (Liu et al., 2019)</td><td>26.7</td><td>8.7</td><td>4.7</td><td>574</td><td>4.0</td><td>gradient-based</td></tr><tr><td>SNAS (mild) (Xie et al., 2019)</td><td>27.3</td><td>9.2</td><td>4.3</td><td>522</td><td>1.5</td><td>gradient-based</td></tr><tr><td>ProxylessNAS (GPU)‡ (Cai et al.,2019)</td><td>24.9</td><td>7.5</td><td>7.1</td><td>465</td><td>8.3</td><td>gradient-based</td></tr><tr><td>P-DARTS (CIFAR10) (Chen et al.,2019)</td><td>24.4</td><td>7.4</td><td>4.9</td><td>557</td><td>0.3</td><td>gradient-based</td></tr><tr><td>P-DARTS (CIFAR10O) (Chen et al., 2019)</td><td>24.7</td><td>7.5</td><td>5.1</td><td>577</td><td>0.3</td><td>gradient-based</td></tr><tr><td>BayesNAS (Zhou et al., 2019)</td><td>26.5</td><td>8.9</td><td>3.9</td><td>：</td><td>0.2</td><td>gradient-based</td></tr><tr><td>PC-DARTS (CIFAR10)</td><td>25.1</td><td>7.8</td><td>5.3</td><td>586</td><td>0.1</td><td>gradient-based</td></tr><tr><td>PC-DARTS (ImageNet)‡</td><td>24.2</td><td>7.3</td><td>5.3</td><td>597</td><td>3.8</td><td>gradient-based</td></tr></table>",
+        "bbox": [
+            176,
+            127,
+            826,
+            381
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            422,
+            825,
+            464
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results are summarized in Table 2. Note that the architectures searched on CIFAR10 and ImageNet itself are both evaluated. For the former, it reports a top-1/5 error of $2 5 . 1 \\% / 7 . 8 \\%$ , which significantly outperforms $2 6 . 7 \\% / 8 . 7 \\%$ reported by DARTS. This is impressive given that our search time is much shorter. For the latter, we achieve a top-1/5 error of $2 4 . \\bar { 2 } \\% / 7 . 3 \\%$ , which is the best known performance to date. In comparison, ProxylessNAS (Cai et al., 2019), another approach that directly searched on ImageNet, used almost doubled time to produce $2 4 . 9 \\% / 7 . 5 \\%$ , which verifies that our strategy of reducing memory consumption is more efficient yet effective. ",
+        "bbox": [
+            173,
+            470,
+            825,
+            569
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/55a490e1e876e6cdd7e670c74058843a9941e6b930f30b096130ce48be899a08.jpg",
+        "image_caption": [
+            "Figure 3: Search cost and accuracy comparison between our approach with different sampling rates, namely, $1 / 1 , 1 / 2 , 1 / 4$ and $1 / 8$ , among which $1 / 4$ makes a nice tradeoff between accuracy and efficiency. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            589,
+            490,
+            739
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c2a5ba04ce4299c4751ae85cf0095eed1dc9ef907bcfdd7bababab01681e7ca7.jpg",
+        "table_caption": [
+            "Table 3: Ablation study on CIFAR10 and ImageNet. PC and EN denote partial channel connections and edge normalization, respectively. All architectures on ImageNet are re-trained by 100 epochs (the $2 5 . 8 \\%$ error corresponds to the best entry, $2 4 . 2 \\%$ , reported in Table 2 (250 epochs). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">CIFAR10 Search Cost</td></tr><tr><td>PC</td><td>EN</td><td>Test Error</td></tr><tr><td></td><td>X</td><td>3.00±0.14% 0.4 GPU-days</td></tr><tr><td>X</td><td>√</td><td>2.82±0.05% 0.4 GPU-days</td></tr><tr><td>√</td><td>X</td><td>2.67±0.11% 0.1 GPU-days 0.1 GPU-days</td></tr><tr><td>&lt;</td><td>一</td><td>2.57±0.07%</td></tr><tr><td></td><td></td><td>ImageNet (ILSVRC2012) Search Cost</td></tr><tr><td>PC</td><td>EN</td><td>Test Error</td></tr><tr><td>X</td><td>X</td><td>26.8±0.1% 7.7 GPU-days</td></tr><tr><td>X</td><td>√</td><td>26.3±0.1% 7.7 GPU-days</td></tr><tr><td>√</td><td></td><td>3.8 GPU-days</td></tr><tr><td>【</td><td>X 1</td><td>26.2±0.1% 25.8±0.1% 3.8 GPU-days</td></tr></table>",
+        "bbox": [
+            519,
+            575,
+            802,
+            734
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            845,
+            341,
+            859
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4.1 EFFECTIVENESS OF CHANNEL PROPORTION $1 / K$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            871,
+            566,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first evaluate $K$ , the hyper-parameter that controls the sampling rate of channels. Note that a tradeoff exists: increasing the sampling rate (i.e., using a smaller $K$ ) allows more accurate information to be propagated, while sampling a smaller portion of channels casts heavier regularization and may alleviate over-fitting. To study its impacts, we evaluate the performance produced by four sampling rates, namely $1 / 1 , 1 / 2 , 1 / 4$ and $1 / 8$ , on CIFAR10, and plot the results into a diagram of search time and accuracy in Figure 3. One can observe that a sampling rate of $1 / 4$ yields superior performance over $1 / 2$ and $1 / 1$ in terms of both time and accruacy. Using $1 / 8$ , while being able to further reduce search time, causes a dramatic accuracy drop. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/279113ff4c14886c1bbb26ace2dfaf78b89b2de7e1d50043f047720039d43e6f.jpg",
+        "table_caption": [
+            "Table 4: Experiments on stability of DARTS and PC-DARTS. Left: Evaluations of searched architectures in five independent search runs. Middle: architectures searched with different numbers of epochs. Right: runs on architectures searched with different numbers of nodes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Methods</td><td colspan=\"5\">Runs</td><td colspan=\"4\">Epochs</td><td colspan=\"3\">Nodes</td></tr><tr><td>#1</td><td>#2</td><td>#3</td><td>#4</td><td>#5</td><td>50</td><td>75</td><td>100</td><td>125</td><td>5</td><td>6</td><td>7</td></tr><tr><td>DARTS-v1(%)</td><td>2.89</td><td>3.15</td><td>2.99</td><td>3.07</td><td>3.27</td><td>2.98</td><td>2.87</td><td>3.32</td><td>3.08</td><td>3.03</td><td>2.98</td><td>2.89</td></tr><tr><td>DARTS-v2(%)</td><td>3.11</td><td>2.68</td><td>2.77</td><td>3.14</td><td>3.06</td><td>2.76</td><td>2.93</td><td>3.51</td><td>3.18</td><td>2.82</td><td>2.76</td><td>3.02</td></tr><tr><td>PC-DARTS(%)</td><td>2.72</td><td>2.67</td><td>2.57</td><td>2.75</td><td>2.64</td><td>2.57</td><td>2.67</td><td>2.69</td><td>2.75</td><td>2.63</td><td>2.57</td><td>2.64</td></tr></table>",
+        "bbox": [
+            176,
+            155,
+            825,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            258,
+            825,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "These experiments not only justify the tradeoff between accuracy and efficiency of architecture search, but also reveal the redundancy of super-network optimization in the context of NAS. More essentially, this reflects the gap between search and evaluation, i.e., a better optimized super-network does not guarantee a better searched architecture – in other words, differentiable NAS approaches are easily to over-fit on the super-network. From this viewpoint, channel sampling plays the role of regularization, which shrinks the gap between search and evaluation. ",
+        "bbox": [
+            174,
+            349,
+            825,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4.2 CONTRIBUTIONS OF DIFFERENT COMPONENTS OF PC-DARTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            448,
+            665,
+            462
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Next, we evaluate the contributions made by two components of PC-DARTS, namely, partial channel connections and edge normalization. The results are summarized in Table 3. It is clear that edge normalization brings the effect of regularization even when the channels are fully-connected. Being a component with very few extra costs, it can be freely applied to a wide range of approaches involving edge selection. In addition, edge normalization cooperates well with partial channel connections to provide further improvement. Without edge normalization, our approach can suffer low stability in both the number of network parameters and accuracy. On CIFAR10, we run search without edge normalization for several times, and the testing error ranges from $2 . 5 4 \\%$ to $3 . 0 1 \\%$ . On the other hand, with edge normalization, the maximal difference among five runs does not exceed $0 . 1 5 \\%$ . Therefore, we justify our motivation in designing edge normalization (see Section 3.3), i.e., it can be a standalone method for stabilizing architecture search, yet it works particularly well under partial channel connection, since the latter introduces randomness and stabilization indeed helps. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            638
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4.3 STABILITY OF OUR APPROACH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            442,
+            669
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this part, we demonstrate the stability of our approach from three different perspectives. Results are summarized in Table 4, with detailed analysis below. ",
+        "bbox": [
+            173,
+            679,
+            823,
+            707
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "First, we evaluate the stability of different approaches by conducting 5 independent search runs. We re-implement DARTS-v1 and DARTS-v2 with the proposed code, as well as that of our approach, and perform five individual search processes with the same hyper-parameters but different random seeds $( 0 , 1 , 2 , 3 , 4 )$ . The architectures found by DARTS in different runs, either v1 or v2, suffer much higher standard deviations than that of our approach (DARTS-v1: $\\pm 0 . 1 5 \\%$ , DARTS-v2: $\\pm 0 . 2 1 \\%$ , PC-DARTS: $\\pm 0 . 0 7 \\%$ ). ",
+        "bbox": [
+            174,
+            713,
+            825,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Second, we study how the search algorithm is robust to hyper-parameters, e.g., the length of the search stage. We try different numbers of epochs, from 50 to 125, and observe how it impacts the performance of searched architectures. Again, we find that both DARTS-v1 and DARTS-v2 are less robust to this change. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            861
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Third, we go one step further by enlarging the search space, allowing a larger number of nodes to appear in each cell – the original DARTS-based space has 6 nodes, and here we allow 5, 6 and 7 nodes. From 5 to 6 nodes, the performance of all three algorithms goes up, while from 6 to 7 nodes, DARTS-v2 suffers a significant accuracy drop, while PC-DARTS mostly preserves it performance. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/1ee59b3575386c5a655954d95c275ce96a65b3e7265ceda979d0b5546c43a314.jpg",
+        "table_caption": [
+            "Table 5: Detection results, in terms of average precisions, on the MS-COCO dataset (test-dev 2015). "
+        ],
+        "table_footnote": [
+            "‡ The backbone architecture of PC-DARTS was searched on ImageNet (with a $2 4 . 2 \\%$ top-1 error). "
+        ],
+        "table_body": "<table><tr><td>Network</td><td>Input Size</td><td>Backbone</td><td>×+</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td>SSD300 (Liu et al., 2016)</td><td>300×300</td><td>VGG-16</td><td>35.2B</td><td>23.2</td><td>41.2</td><td>23.4</td><td>5.3</td><td>23.2</td><td>39.6</td></tr><tr><td>SSD512 (Liu et al., 2016)</td><td>512×512</td><td>VGG-16</td><td>99.5B</td><td>26.8</td><td>46.5</td><td>27.8</td><td>9.0</td><td>28.9</td><td>41.9</td></tr><tr><td>YOLOV2 (Redmon &amp; Farhadi,2017)</td><td>416×416</td><td>Darknet-19</td><td>17.5B</td><td>21.6</td><td>44.0</td><td>19.2</td><td>5.0</td><td>22.4</td><td>35.5</td></tr><tr><td>Pelee (Wang et al., 2018)</td><td>304×304</td><td>PeleeNet</td><td>1.3B</td><td>22.4</td><td>38.3</td><td>22.9</td><td>1</td><td>-</td><td>1</td></tr><tr><td>SSDLiteV1 (Howard et al.,2017)</td><td>320×320</td><td>MobileNetV1</td><td>1.3B</td><td>22.2</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>SSDLiteV2 (Sandler et al., 2018)</td><td>320×320</td><td>MobileNetV2</td><td>0.8B</td><td>22.1</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>SSDLiteV3 (Tan et al., 2019)</td><td>320×320</td><td>MnasNet-A1</td><td>0.8B</td><td>23.0</td><td>-</td><td>-</td><td>3.8</td><td>21.7</td><td>42.0</td></tr><tr><td>PC-DARTS with SSD</td><td>320×320</td><td>PC-DARTSt</td><td>1.2B</td><td>28.9</td><td>46.9</td><td>30.0</td><td>7.9</td><td>32.0</td><td>48.3</td></tr></table>",
+        "bbox": [
+            176,
+            126,
+            825,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As a side note, all these algorithms fail to gain accuracy in enlarged search spaces, because CIFAR10 is relatively simple and the performance of searched architectures seems to saturate. ",
+        "bbox": [
+            173,
+            289,
+            821,
+            316
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "With all the above experiments, we can conclude that PC-DARTS is indeed more robust than DARTS in different scenarios of evaluation. This largely owes to the regularization mechanism introduced by PC-DARTS, which (i) forces it to adjust to dynamic architectures, and (ii) avoids the large pruning gap after search, brought by the none operator. ",
+        "bbox": [
+            174,
+            324,
+            825,
+            380
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.5 TRANSFERRING TO OBJECT DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            397,
+            493,
+            412
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To further validate the performance of the architecture found by PC-DARTS, we use it as the backbone for object detection. We plug the architecture found on ImageNet, as shown in Figure 2, into a popular object detection framework named Single-Shot Detectors (SSD) (Liu et al., 2016). We train the entire model on the MS-COCO (Lin et al., 2014) trainval dataset, which is obtained by a standard pipeline that excludes 5K images from the val set, merges the rest data into the 80K train set and evaluates it on the test-dev 2015 set. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            507
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Results are summarized in Table 5. Results for SSD, YOLO and MobileNets are from (Tan et al., 2019). With the backbone searched by PC-DARTS, we need only 1.2B FLOPs to achieve an AP of $2 8 . 9 \\%$ , which is $5 . 7 \\%$ higher than SSD300 (but with $2 9 \\times$ fewer FLOPs), or $2 . 1 \\%$ higher than SSD512 (but with $8 3 \\times$ fewer FLOPs). Compared to the ‘Lite’ versions of SSD, our result enjoys significant advantages in AP, surpassing the most powerful one (SSDLiteV3) by an AP of $6 . { \\dot { 9 } } \\%$ . All these results suggest that the advantages obtained by PC-DARTS on image classification can transfer well to object detection, a more challenging task, and we believe these architectures would benefit even more application scenarios. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            328,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we proposed a simple and effective approach named partially-connected differentiable architecture search (PC-DARTS). The core idea is to randomly sample a proportion of channels for operation search, so that the framework is more memory efficient and, consequently, a larger batch size can be used for higher stability. Additional contribution to search stability is made by edge normalization, a light-weighted module that requires merely no extra computation. Our approach can accomplish a complete search within 0.1 GPU-days on CIFAR10, or 3.8 GPU-days on ImageNet, and report state-of-the-art classification accuracy in particular on ImageNet. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            777
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research delivers two important messages that are important for future research. First, differentiable architecture search seems to suffer even more significant instability compared to conventional neural network training, and so it can largely benefit from both (i) regularization and (ii) a larger batch size. This work shows an efficient way to incorporate these two factors in a single pipeline, yet we believe there exist other (possibly more essential) solutions for this purpose. Second, going one step further, our work reveals the redundancy of super-network optimization in NAS, and experiments reveal a gap between improving super-network optimization and finding a better architecture, and regularization plays an efficient role in shrinking the gap. We believe these insights can inspire researchers in this field, and we will also follow this path towards designing stabilized yet efficient algorithms for differentiable architecture search. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "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 ICLR, 2018. ",
+        "bbox": [
+            174,
+            162,
+            823,
+            193
+        ],
+        "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, 2018. ",
+        "bbox": [
+            173,
+            200,
+            823,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Han Cai, Ligeng Zhu, and Song Han. ProxylessNAS: Direct neural architecture search on target task and hardware. In ICLR, 2019. ",
+        "bbox": [
+            171,
+            238,
+            825,
+            268
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francesco Paolo Casale, Jonathan Gordon, and Nicolo Fusi. Probabilistic neural architecture search. arXiv preprint arXiv:1902.05116, 2019. ",
+        "bbox": [
+            171,
+            276,
+            823,
+            305
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xin Chen, Lingxi Xie, Jun Wu, and Qi Tian. Progressive differentiable architecture search: Bridging the depth gap between search and evaluation. In ICCV, 2019. ",
+        "bbox": [
+            171,
+            314,
+            823,
+            343
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009. ",
+        "bbox": [
+            171,
+            352,
+            825,
+            381
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017. ",
+        "bbox": [
+            173,
+            390,
+            823,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Efficient multi-objective neural architecture search via lamarckian evolution. In ICLR, 2019. ",
+        "bbox": [
+            173,
+            428,
+            823,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Ha, Andrew Dai, and Quoc V Le. Hypernetworks. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            464,
+            653,
+            481
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            489,
+            821,
+            518
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. MobileNets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017. ",
+        "bbox": [
+            176,
+            526,
+            823,
+            570
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            579,
+            823,
+            608
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015. ",
+        "bbox": [
+            171,
+            616,
+            812,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. ",
+        "bbox": [
+            169,
+            640,
+            821,
+            670
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In NIPS, 2012. ",
+        "bbox": [
+            171,
+            678,
+            823,
+            708
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gustav Larsson, Michael Maire, and Gregory Shakhnarovich. FractalNet: Ultra-deep neural networks without residuals. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            715,
+            823,
+            746
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. In UAI, 2019. ",
+        "bbox": [
+            169,
+            753,
+            823,
+            784
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge J. Belongie, Lubomir D. Bourdev, Ross B. Girshick, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C. Lawrence Zitnick. Microsoft COCO: ´ Common objects in context. In ECCV, 2014. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            835
+        ],
+        "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 ECCV, 2018a. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, and Koray Kavukcuoglu. Hierarchical representations for efficient architecture search. In ICLR, 2018b. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture search. In ICLR, 2019. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Weiwei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott E. Reed, Cheng-Yang Fu, and Alexander C. Berg. Ssd: Single shot multibox detector. In ECCV, 2016. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Renqian Luo, Fei Tian, Tao Qin, Enhong Chen, and Tie-Yan Liu. Neural architecture optimization. In NeurIPS, 2018. ",
+        "bbox": [
+            173,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, and Jian Sun. ShuffleNet V2: Practical guidelines for efficient cnn architecture design. In ECCV, 2018. ",
+        "bbox": [
+            171,
+            217,
+            823,
+            247
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jieru Mei, Xiaochen Lian, Xiaojie Jin, Linjie Yang, Yingwei Li, Alan Yuille, and Jianchao Yang. AtomNAS: Fine-grained end-to-end neural architecture search. In ICLR, 2020. ",
+        "bbox": [
+            171,
+            256,
+            823,
+            285
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Risto Miikkulainen, Jason Liang, Elliot Meyerson, Aditya Rawal, Daniel Fink, Olivier Francon, Bala Raju, Hormoz Shahrzad, Arshak Navruzyan, Nigel Duffy, et al. Evolving deep neural networks. In Artificial Intelligence in the Age of Neural Networks and Brain Computing, pp. 293–312. Elsevier, 2019. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            351
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. In ICML, 2018. ",
+        "bbox": [
+            173,
+            359,
+            823,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Jie Tan, Quoc V Le, and Alexey Kurakin. Large-scale evolution of image classifiers. In ICML, 2017. ",
+        "bbox": [
+            174,
+            397,
+            823,
+            428
+        ],
+        "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, 2019. ",
+        "bbox": [
+            171,
+            436,
+            823,
+            465
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Joseph Redmon and Ali Farhadi. Yolo9000: Better, faster, stronger. CVPR, 2017. ",
+        "bbox": [
+            171,
+            474,
+            709,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mark Sandler, Andrew G. Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. CVPR, 2018. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            529
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Sciuto, Kaicheng Yu, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. ArXiv, abs/1902.08142, 2019. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            566
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            575,
+            823,
+            604
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            176,
+            613,
+            825,
+            656
+        ],
+        "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 CVPR, 2015. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            708
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mingxing Tan, Bo Chen, Ruoming Pang, Vijay Vasudevan, and Quoc V Le. MnasNet: Platformaware neural architecture search for mobile. CVPR, 2019. ",
+        "bbox": [
+            169,
+            717,
+            823,
+            747
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Robert J. Wang, Xiang Li, Shuang Ao, and Charles X. Ling. Pelee: A real-time object detection system on mobile devices. In NeurIPS, 2018. ",
+        "bbox": [
+            173,
+            756,
+            823,
+            785
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lingxi Xie and Alan Yuille. Genetic CNN. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            794,
+            562,
+            809
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sirui Xie, Hehui Zheng, Chunxiao Liu, and Liang Lin. SNAS: Stochastic neural architecture search. In ICLR, 2019. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. ShuffleNet: An extremely efficient convolutional neural network for mobile devices. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhao Zhong, Junjie Yan, Wei Wu, Jing Shao, and Cheng-Lin Liu. Practical block-wise neural network architecture generation. In CVPR, 2018. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongpeng Zhou, Minghao Yang, Jun Wang, and Wei Pan. BayesNAS: A Bayesian approach for neural architecture search. In ICML, 2019. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            141,
+            825,
+            156
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In CVPR, 2018. ",
+        "bbox": [
+            174,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HJzgZ3JCW/HJzgZ3JCW.md

@@ -0,0 +1,222 @@
+# EFFICIENT SPARSE-WINOGRAD CONVOLUTIONAL NEURAL NETWORKS
+
+Xingyu Liu∗, Jeff Pool†, Song $\mathbf { H a n } ^ { \ddag \mathsection }$ , William J. Dally∗†   
+∗ Stanford University, † NVIDIA, ‡ Massachusetts Institute of Technology, § Google Brain   
+{xyl, dally}@stanford.edu
+
+# ABSTRACT
+
+Convolutional Neural Networks (CNNs) are computationally intensive, which limits their application on mobile devices. Their energy is dominated by the number of multiplies needed to perform the convolutions. Winograd’s minimal filtering algorithm (Lavin, 2015) and network pruning (Han et al., 2015) can reduce the operation count, but these two methods cannot be directly combined – applying the Winograd transform fills in the sparsity in both the weights and the activations. We propose two modifications to Winograd-based CNNs to enable these methods to exploit sparsity. First, we move the ReLU operation into the Winograd domain to increase the sparsity of the transformed activations. Second, we prune the weights in the Winograd domain to exploit static weight sparsity. For models on CIFAR-10, CIFAR-100 and ImageNet datasets, our method reduces the number of multiplications by $1 0 . 4 \times$ , $6 . 8 \times$ and $1 0 . 8 \times$ respectively with loss of accuracy less than $0 . 1 \%$ , outperforming previous baselines by $2 . 0 { \times } { - } 3 . 0 { \times }$ . We also show that moving ReLU to the Winograd domain allows more aggressive pruning.
+
+# 1 INTRODUCTION
+
+Deep Convolutional Neural Networks (CNNs) have shown significant improvement in many machine learning applications. However, CNNs are compute-limited. Their performance is dominated by the number of multiplies needed to perform the convolutions. Moreover, the computational workload of CNNs continues to grow over time. LeCun et al. (1998) proposed a CNN model with less than $2 . 3 \times 1 0 ^ { 7 }$ multiplies for handwritten digit classification. Later, Krizhevsky et al. (2012) developed AlexNet, an ImageNet-winning CNN with more than $1 . 1 \times 1 0 ^ { 9 }$ multiplies. In 2014, ImageNetwinning and runner up CNNs increased the number of multiplies to $1 . 4 \times 1 0 ^ { 9 }$ (Szegedy et al., 2015) and $1 . \check { 6 } \times 1 0 ^ { 1 0 }$ (Simonyan & Zisserman, 2015) respectively. Despite the powerful representational ability of large scale CNNs, their computational workload prohibits deployment on mobile devices.
+
+Two research directions have been explored to address the problem. Lavin (2015) proposed using Winograd’s minimal filtering algorithm (Winograd, 1980) to reduce the number of multiplies needed to perform $3 \times 3$ kernel convolutions. On the other end, pruning the model (Han et al., 2015; 2016b) and exploiting the dynamic sparsity of activations due to ReLU also reduces the required multiplies.
+
+Unfortunately, the above two directions are not compatible: the Winograd transformation fills in the zeros in both the weights and the activations (Figure 1(a)) – eliminating the gain from exploiting sparsity. Thus, for a pruned network, Winograd’s algorithm actually increases the number of multiplies; the loss of sparsity more than offsets the reduced operation count.
+
+In this paper, we introduce two modifications to the original Winograd-based convolution algorithm to eliminate this problem. First, we move the ReLU operation to be after the Winograd transform to also make the activations sparse at the point where the multiplies are performed. Second, we prune the weights after (rather than before) they are transformed. Thus, the weights are sparse when the elementwise multiply is performed — reducing the operation count. Together, these two modifications enable the gains of Winograd’s algorithm and of exploiting sparsity to be combined. We open-source our code and models at https://github.com/xingyul/Sparse-Winograd-CNN.
+
+![](images/5d31248203791cc829c4714ffc9261eddfcb11f30161ef59302401d8d87056d8.jpg)  
+Figure 1: Combining Winograd convolution with sparse weights and activations. (a) Conventional Winograd-based convolution fills in the zeros in both the weights and activations. (b) Pruning the $4 \times 4$ transformed kernel restores sparsity to the weights. (c) Our proposed Winograd-ReLU CNN. Moving the ReLU layer after Winograd transformation also restores sparsity to the activations.
+
+# 2 RELATED WORK
+
+Linear Algebra property in Convolution: Previous research proposes using the linear algebra property of convolution to reduce the number of multiplies by trading additions for multiplies. Cong & Xiao (2014) convert convolution into matrix multiplies and utilize the linear algebra property at the sub-matrix block level. This approach achieves a $47 \%$ saving in multiplies. Lavin (2015) exploits the element-level linear algebra property of convolution, i.e. Winograd’s minimal filtering algorithm (Winograd, 1980). This approach reduces the number of multiplies by $2 . 2 5 \times$ to $4 \times$ , depending on the image patch size used in the algorithm. Winograd’s algorithm is also used in a state-of-the-art deep learning library, cuDNN (Chetlur et al., 2014), to improve computation efficiency.
+
+Model Compression: Model compression reduces the number of multiplies of CNNs by pruning network parameters (LeCun et al., 1990; Hassibi et al., 1993) and exploiting weight sparsity. Han et al. (2015; 2016b) proposed learning the sparsity pattern of network weights by eliminating weights whose absolute value is less than an empirical threshold. This approach can prune the convolutional layers of the model to only $3 0 \% - 5 0 \%$ of the original size and reduce the number of multiplies required. Liu et al. (2017) first proposed pruning and re-training the weights in Winograd domain for conventional Winograd convolution. Li et al. (2017) later showed promising results on large datasets and reported $9 0 \%$ sparsity in the Winograd parameters of AlexNet with less than $0 . 1 \%$ accuracy loss.
+
+Dynamic Activation Sparsity: The ReLU non-linearity sets activations whose values are negative to zero, causing dynamic sparsity in activations. Model compression can work in tandem with dynamic activation sparsity and reduce multiplication workload. Han et al. (2015) showed that exploiting sparsity of both weights and activations can reduce the number of multiplies by $4 - 1 1 \times$ . Huan et al. (2016) further proposed to manually set a small positive ReLU threshold at test time to exploit greater sparsity in activation without losing testing accuracy. Research in novel architectures also led to optimizations for deep learning accelerators to exploit the sparsity in activations. Han et al. (2016a) proposed using a Leading Non-zero Detection unit (LNZD) for their fully-connected layer accelerator to efficiently skip zeros in input activations. Albericio et al. (2016) proposed a similar mechanism for a convolution layer accelerator.
+
+# 3 SPARSE WINOGRAD CONVOLUTION
+
+We first introduce the conventional Winograd convolution and show how sparsity of weights or activations is lost during the dataflow of the algorithm. We then present the novel Winograd-ReLU CNN architecture. It preserves sparsity in both weights and activations before multiplies are performed and significantly reduces the computational workload.
+
+# 3.1 SPARSITY IN CONVENTIONAL SPATIAL AND WINOGRAD CNN
+
+The basic block of the conventional Winograd convolution algorithm works on an $p \times p$ patch (denoted by $d$ ) extracted with stride of $( p - 2 ) \times ( p - 2 )$ from an $H \times W$ input feature map. With “valid” padding, the $p \times p$ patch is convolved with a $3 \times 3$ kernel (denoted by $g$ ) to produce an $\bar { ( \boldsymbol { p } - 2 ) } \times ( \boldsymbol { p } - 2 )$ output patch (denoted by $S$ ). The output patches are assembled into an output feature map.
+
+Input activation patch $d$ and kernel $g$ (spatial-domain activation and weights) are transformed using matrices $B$ and $G$ to be $B ^ { T } d B$ and $G g G ^ { T }$ (Winograd-domain activation and weights) respectively, both with shape $p \times p$ . After element-wise product in Winograd-domain, the output activation $S$ is obtained using matrix $A$ (equation (1)). Matrices $B$ , $G$ and $A$ are $p$ -specific. When $p = 4$ , $B$ and $A$ consists of 1, $- 1$ and 0, so the multiplication with $B$ and $A$ only requires addition. It reduces the number of multiplies from $9 ( p - 2 ) ^ { 2 }$ to $p ^ { 2 }$ . Lavin (2015) gives details of the algorithm.
+
+$$
+S = A ^ { T } [ [ G g G ^ { T } ] \odot [ B ^ { T } d B ] ] A
+$$
+
+Spatial Baseline Network: When using a “vanilla” pruned network, as introduced by Han et al. (2015), a ReLU non-linear operation is performed by the previous layer on spatial-domain input $d$ and spatial-domain weight $g$ is pruned. The output activation patch $S$ is obtained from equation (2). This is illustrated in Figure 1(a) for $p = 4$ . Though $g$ and $d$ may both be sparse due to pruning and ReLU respectively, the element-wise multiply is dense due to $\dot { G } ( \cdot ) G ^ { T }$ and $\mathsf { \bar { B } } ( \cdot ) B ^ { T }$ transformations filling the spatial-domain zeros. Sparsity does not reduce the number of multiplies in Winograd’s algorithm.
+
+$$
+S = A ^ { T } [ [ G \mathrm { P r u n e } ( g ) G ^ { T } ] \odot [ B ^ { T } \mathrm { R e L U } ( d ) B ] ] A
+$$
+
+Winograd Native Pruned Network: When using the Winograd-domain pruned network introduced by Liu et al. (2017) and Li et al. (2017), the spatial-domain input $d$ is ReLU-ed by the previous layer while the Winograd-domain weight $G g G ^ { T }$ is pruned. The output activation patch $S$ is obtained from equation (3). The algorithm when $p = 4$ is also illustrated in Figure 1(b). Though Winograd-domain weights are sparse due to pruning, Winograd-domain activations are still dense due to $B ( \cdot ) B ^ { T }$ transforms. The sparsity in spatial activations due to ReLU does not reduce the number of multiplies.
+
+$$
+S = A ^ { T } [ [ \mathrm { P r u n e } ( G g G ^ { T } ) ] \odot [ B ^ { T } \mathrm { R e L U } ( d ) B ] ] A
+$$
+
+# 3.2 WINOGRAD-RELU CNN
+
+To address the above problems, we introduce the Winograd-ReLU Network. Instead of applying ReLU to the activations in the spatial domain, we apply ReLU to the activations in the Winograd domain, as in equation (4) and Figure 1(c). The ReLU operation zeros all negative transformed activations, reducing the number of multiplies in the Winograd domain.
+
+$$
+S = A ^ { T } [ [ \mathrm { P r u n e } ( G g G ^ { T } ) ] \odot [ \mathrm { R e L U } ( B ^ { T } d B ) ] ] A
+$$
+
+In the Winograd-ReLU CNN, we eliminate the spatial-domain kernel entirely. Because this ReLU is really associated with the previous layer, we perform this transformed ReLU starting with the second layer. We point out that the proposed new CNN architecture is not mathematically equivalent to the vanilla CNN nor the conventional Winograd CNN. Due to the change of network architecture, the training and pruning should also be changed. Our method operates in three phases: dense training, pruning, and retraining.
+
+Dense training: we train a dense $p \times p$ kernel directly in the transform domain. The transformed kernel is initialized and trained directly by back-propagation through the inverse transform — eliminating the need to maintain a kernel in the spatial domain or to transform a spatial kernel.
+
+Pruning: we prune the transformed kernel by computing the threshold $t$ required to achieve a desired pruning rate $r$ and setting all weights whose absolute value less than $t$ to zero. In our experiments, we used the same $r$ for all Winograd-ReLU layers. Because sensitivity varies from layer to layer, we expect that better performance could be achieved by varying the pruning rate $r _ { i }$ for each layer $i$ .
+
+Re-training: we re-train the model using a “sparsity mask” to force the weights that were pruned to remain zero. The sparsity mask is computed during the pruning step and is kept constant during re-training. The gradient of the network’s loss, $L$ , with respect to the input activation and Winograd weights can be derived using the chain rule. Equation (5) shows the calculation of input activation gradient $\nabla _ { d } L$ and Winograd weight gradient $\nabla _ { G g G ^ { T } } L$ using the loss gradient passed from upstream layers $\nabla _ { S } L$ .
+
+$$
+\begin{array} { r l } & { \nabla _ { G g G ^ { T } } L = ( A \nabla _ { S } L A ^ { T } ) \odot ( B ^ { T } d B ) \odot m a s k } \\ & { \nabla _ { d } L = B [ ( A \nabla _ { S } L A ^ { T } ) \odot ( G g G ^ { T } ) \odot m a s k ] B ^ { T } } \end{array}
+$$
+
+# 4 EXPERIMENTS
+
+We applied the methodology described above to several different CNNs on different datasets. The original network models are chosen such that the majority of the convolution layers have $3 \times 3$ kernels. This ensures the largest portion of layers can be converted to Winograd convolution layers and ReLU be put in Winograd domain. We used image classification datasets of different scales: CIFAR-10, CIFAR-100 (Krizhevsky & Hinton, 2009) and ImageNet 2012 (Russakovsky et al., 2015). For network architectures, we chose VGG-nagadomi (Nagadomi, 2014), ConvPool-CNN-C model (Springenberg et al., 2015) and a variation of ResNet-18 (He et al., 2016a) respectively on three datasets. Using the Tensorflow (Abadi et al., 2016) framework, we trained the spatial baseline CNN, corresponding conventional Winograd CNN, and Winograd-ReLU CNN models from scratch. Then the three models are iteratively pruned and re-trained. For a specific dataset, we used the same data augmentation for the training of all models on the dataset.
+
+# 4.1 CIFAR-10
+
+We used VGG-nagadomi (Nagadomi, 2014) on the CIFAR-10 dataset. VGG-nagadomi is a lightweight version of VGGNet (Simonyan & Zisserman, 2015). It contains 8 convolution layers with $3 \times 3$ kernels. The best reported validation set accuracy it achieves on CIFAR-10 is $9 3 . 3 1 \%$ (Nagadomi, 2014). We trained three models from scratch. The corresponding conventional Winograd CNN model and Winograd-ReLU CNN model can achieve validation set accuracy of $9 3 . 3 0 \%$ and $9 3 . 4 3 \%$ respectively. The first convolution layer is most sensitive to pruning and we set its density to a constant of $8 0 \%$ . We iteratively pruned and re-trained other convolution layers with density from $8 0 \%$ down to $2 0 \%$ .
+
+![](images/fb3a21d02a88528097fbdb90725d1ce6938144edeab9e66abd322edd1ec20c0a.jpg)  
+Figure 2: Test accuracy vs density for the three models in Figure 1 on VGG-nagadomi.
+
+Figure 2 shows test accuracy as a function of weight density for the three models. The two baseline models can only be pruned to $6 0 \%$ density before accuracy falls significantly $( > ~ 0 . 1 \% )$ . Our Winograd-ReLU CNN model can be pruned to $4 0 \%$ density before falling to the same accuracy.
+
+Table 1 shows the input activation density and compares the workloads for each pruned convolution layer in three models. Pruning two baseline models reduces the convolution layer workload by $5 . 1 \times$ and $3 . 7 \times \mathbf { \Omega } ^ { 1 }$ respectively. Pruning the Winograd-ReLU model reduces the convolution layer workload by $1 3 . 3 \times$ , a $2 . 6 \times$ and $3 . 6 \times$ improvement respectively over the two baselines. The improvement of overall network workload reduction is $2 . 2 \times$ and $3 . 0 \times$ respectively over two baselines.
+
+Table 1: VGG-nagadomi weight and activation density on CIFAR-10.   
+
+<table><tr><td rowspan=3 colspan=1>Layer</td><td rowspan=1 colspan=3>Spatial Baseline CNNPruning (Han et al., 2015)</td><td rowspan=1 colspan=3>Winograd CNNNativePruning (Li et al., 2017)</td><td rowspan=1 colspan=3>Winograd-ReLU CNNPruning (ours)</td></tr><tr><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=1>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=1>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=1>Workload</td></tr><tr><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td></tr><tr><td rowspan=1 colspan=1>convo</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>80%</td></tr><tr><td rowspan=1 colspan=1>conv1</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>30%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>46%</td><td rowspan=1 colspan=1>8%</td></tr><tr><td rowspan=1 colspan=1>conv2</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>12%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>39%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>conv3</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>37%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>conv4</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>18%</td><td rowspan=1 colspan=1>11%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>conv5</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>26%</td><td rowspan=1 colspan=1>15%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>38%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>conv6</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>24%</td><td rowspan=1 colspan=1>14%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>6%</td></tr><tr><td rowspan=1 colspan=1>conv7</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>21%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>36%</td><td rowspan=1 colspan=1>6%</td></tr><tr><td rowspan=1 colspan=1>conv total</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>20%(5.1x)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>27%(3.7x)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>8%(13.3x)</td></tr><tr><td rowspan=1 colspan=1>overall</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>21%(4.7x)</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>29%(3.5x)</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>10%(10.4x)</td></tr></table>
+
+# 4.2 CIFAR-100
+
+We used the ConvPool-CNN-C (Springenberg et al., 2015) model on on the CIFAR-100 dataset. ConvPool-CNN-C contains 9 convolution layers, out of which 7 have $3 \times 3$ kernels. We trained three models from scratch. The spatial baseline CNN model and conventional Winograd CNN model can achieve single model validation accuracy of $6 9 . 3 4 \%$ and $6 9 . 3 2 \%$ respectively. The corresponding Winograd-ReLU network model can achieve validation set accuracy of $6 9 . 7 5 \%$ . We pruned the first convolution layer to a constant density of $8 0 \%$ . We iteratively pruned and re-trained the other layers to densities from $8 0 \%$ down to $2 0 \%$ .
+
+![](images/9b55c6044b978fdfbdadf97113336e994041038c9766619715b294e088ca5169.jpg)  
+Figure 3: Test accuracy vs density for the three models in Figure 1 on ConvPool-CNN-C.
+
+Figure 3 shows the accuracy as a function of density for spatial baseline and Winograd-ReLU models. The spatial-baseline and Winograd-ReLU models can be pruned to $6 0 \%$ density without significant $( > 0 . 1 \% )$ loss of accuracy. In contrast, the conventional Winograd CNN model can only be pruned to $7 0 \%$ density. At a given density, the Winograd-ReLU model has the highest accuracy.
+
+Table 2: ConvPool-CNN-C weight and activation density on CIFAR-100.   
+
+<table><tr><td rowspan=3 colspan=1>Layer</td><td rowspan=1 colspan=4>Spatial Baseline CNNPruning (Han et al.,2015)</td><td rowspan=1 colspan=3>Winograd CNNNativePruning (Li et al., 2017)</td><td rowspan=1 colspan=4>Winograd-ReLU CNNPruning (ours)</td></tr><tr><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=2>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=1>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=2>Workload</td></tr><tr><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td></tr><tr><td rowspan=1 colspan=1>conv0</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=2>80%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=2>80%</td></tr><tr><td rowspan=1 colspan=1>conv1</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>53%</td><td rowspan=1 colspan=2>33%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>54%</td><td rowspan=1 colspan=2>14%</td></tr><tr><td rowspan=1 colspan=1>conv2</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>52%</td><td rowspan=1 colspan=2>32%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>53%</td><td rowspan=1 colspan=2>14%</td></tr><tr><td rowspan=1 colspan=1>conv3</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>77%</td><td rowspan=1 colspan=2>46%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>54%</td><td rowspan=1 colspan=2>14%</td></tr><tr><td rowspan=1 colspan=1>conv4</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=2>21%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>54%</td><td rowspan=1 colspan=2>14%</td></tr><tr><td rowspan=1 colspan=1>conv5</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>32%</td><td rowspan=1 colspan=2>19%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>42%</td><td rowspan=1 colspan=2>11%</td></tr><tr><td rowspan=1 colspan=1>conv6</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>56%</td><td rowspan=1 colspan=2>33%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>43%</td><td rowspan=1 colspan=2>11%</td></tr><tr><td rowspan=1 colspan=1>conv total</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>29%(3.5x)</td><td></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>31%(3.2x)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>14%(7.1x)</td><td></td></tr><tr><td rowspan=1 colspan=1>overall</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>30%(3.4x)</td><td></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>32%(3.1x)</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>15%(6.8x)</td><td rowspan=1 colspan=1></td></tr></table>
+
+Table 2 shows the input activation density and compares the workloads for each pruned convolution layer in three models. Pruning two baseline models reduces the convolution layer workload by $3 . 5 \times$ and $3 . 2 \times$ respectively. Pruning the Winograd-ReLU model reduces the workload by $7 . 1 \times$ , a $2 . 1 \times$ and $2 . 2 \times$ improvement respectively over the two baselines. The improvement of overall network workload reduction is $2 . 0 \times$ and $2 . 2 \times$ respectively over two baselines.
+
+# 4.3 IMAGENET
+
+We used a variation of the full pre-activation version (He et al., 2016b) of ResNet-18 (He et al., 2016a) on the ImageNet 2012 dataset. We used this version because it performs the best among various ResNet versions and its structure suits our Winograd-ReLU approach – its ReLU units are located before convolutions in the residual modules. The variation is different from original ResNet-18 by replacing all $2 \times 2$ -stride $3 \times 3$ convolution layers with a $2 \times 2$ max-pooling layer followed by a $1 \times 1$ -stride $3 \times 3$ convolution layer. Such difference ensure most of convolution layers can be converted to Winograd convolution layer. Another difference is that it doesn’t have the last max pooling layer so the last group of residual modules has spatial size of $1 4 \times 1 4$ , in order to keep the spatial size even instead of odd. This setting suits Winograd convolution with $p = 4$ best in that even spatial size is required for even $p$ values.
+
+We trained three models from scratch. For single model and single central $2 2 4 \times 2 2 4$ cropping, the spatial baseline CNN model and conventional Winograd CNN model can achieve single model top1/top-5 validation accuracy of $6 6 . 6 7 \% / 8 7 . 4 2 \%$ and $6 6 . 8 4 \% / 8 7 . 4 7 \%$ . The corresponding WinogradReLU CNN model can achieve validation top-1/top-5 accuracy of $6 6 . 7 8 \% / 8 7 . 4 3 \%$ . We kept the first convolution layer intact. We iteratively pruned other convolution layers with density rate from $8 0 \%$ down to $1 0 \%$ .
+
+![](images/66d0fc58a4fe5bacbc490133481a6e6715ed83b330deb9a49fd96bb340c1ba7e.jpg)  
+Figure 4: Top-1 and top-5 validation accuracy vs density for three models on a variation of ResNet-18.
+
+Figure 4 shows the accuracy as a function of density for three models. The spatial baseline CNN model and conventional Winograd CNN model can be pruned to $6 0 \%$ and $5 0 \%$ respectively without significant $( > 0 . 1 \% )$ loss of top-1 or top-5 accuracy. The Winograd-ReLU model can be pruned much further, to $3 0 \% / 3 5 \%$ density without significant $( > 0 . 1 \% )$ ) loss of top-1/top-5 accuracy. At these densities, top-1 accuracies are $6 6 . 5 3 \%$ , $6 6 . 4 5 \%$ and $6 6 . 6 1 \%$ for three models respectively, with a dense spatial baseline of $6 6 . 6 7 \%$ ; top-5 accuracies are $8 7 . 2 9 \%$ , $8 7 . 3 0 \%$ and $8 7 . 3 5 \%$ for three models respectively, with a dense spatial baseline of $8 7 . 4 2 \%$ .
+
+Table 3 shows the input activation density and compares the workloads for each pruned convolution layer in three models. Pruning the two baseline models reduces the convolution layer workload by $5 . 1 \times$ and $4 . 5 \times$ respectively. Pruning the Winograd-ReLU model reduces the workload by $1 3 . 2 \times$ a $2 . 6 \times$ and $2 . 9 \times$ improvement respectively over the two baselines. The improvement of overall network workload reduction is $2 . 3 \times$ and $2 . 6 \times$ respectively over two baselines.
+
+# 5 DISCUSSION
+
+In this section, we summarize the experiment results and compare the three models in terms of a) weight and activation dimensions and b) the dynamic density of activations. We then visualize the kernels to illustrate the pattern of the proposed Winograd-ReLU model kernel.
+
+Table 3: ResNet-18 variation weight and activation density on ImageNet.   
+
+<table><tr><td rowspan=3 colspan=1>Layer</td><td rowspan=1 colspan=4>Spatial Baseline CNNPruning (Han et al., 2015)</td><td rowspan=1 colspan=3>Winograd CNNNativePruning (Li et al.,2017)</td><td rowspan=1 colspan=4>Winograd-ReLU CNNPruning (ours)</td></tr><tr><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=2>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=1>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=2>Workload</td></tr><tr><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td></tr><tr><td rowspan=1 colspan=1>res2a_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>90%</td><td rowspan=1 colspan=2>54%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>48%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res2a_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>64%</td><td rowspan=1 colspan=2>39%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res2b_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>71%</td><td rowspan=1 colspan=2>43%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res2b_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>53%</td><td rowspan=1 colspan=2>32%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res3a_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>94%</td><td rowspan=1 colspan=2>56%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res3a_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=2>21%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res3b_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>47%</td><td rowspan=1 colspan=2>28%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res3b_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>29%</td><td rowspan=1 colspan=2>17%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res4a_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>88%</td><td rowspan=1 colspan=2>53%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res4a_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>23%</td><td rowspan=1 colspan=2>14%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res4b_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>36%</td><td rowspan=1 colspan=2>22%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res4b_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>21%</td><td rowspan=1 colspan=2>13%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res5a_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>45%</td><td rowspan=1 colspan=2>27%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res5a_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>14%</td><td rowspan=1 colspan=2>9%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>48%</td><td rowspan=1 colspan=2>7%</td></tr><tr><td rowspan=1 colspan=1>res5b_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>16%</td><td rowspan=1 colspan=2>10%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>48%</td><td rowspan=1 colspan=2>7%</td></tr><tr><td rowspan=1 colspan=1>res5b_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>12%</td><td rowspan=1 colspan=2>7%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>conv total</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>20%(5.1x)</td><td></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>22%(4.5x)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>8%(13.2x)</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>overall</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>21%(4.7x)</td><td></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>24%(4.2x)</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>9%(10.8x)</td><td rowspan=1 colspan=1></td></tr></table>
+
+# 5.1 WEIGHT AND ACTIVATION DIMENSION
+
+In a convolutional neural network, a convolution-ReLU pair acts as a classifier on a spatial patch of an input feature. The dimension of the space being classified is the total number of elements passing through the ReLU layer. The decision boundaries of the classifier are determined by the weights. Insufficient non-zero weights or insufficient activations results in too simple a decision boundary and causes accuracy loss.
+
+Experimental results have shown that Winograd-ReLU CNN can reach the same accuracy as both vanilla spatial baseline CNN and conventional Winograd CNN without pruning, and that WinogradReLU CNN is more robust to aggressive pruning. In this subsection we provide an explanation for the latter observation from the aspect of activation and weight dimensions. We provide a summary on dimensions in Table 4.
+
+Table 4: Comparison of ReLU dimension and weight dimension in three types of networks. Assume the convolution-ReLU pair operates on input activation of spatial size of $H \times W$ and the number of input and output channels are $C$ and $K$ respectively.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>SpatialBaselineCNN (Han et al., 2015)</td><td rowspan=1 colspan=1>Winograd nativeprunedCNN (Li et al., 2017)</td><td rowspan=1 colspan=1>Winograd-ReLUCNN (ours)</td></tr><tr><td rowspan=1 colspan=1>Weightdimension</td><td rowspan=1 colspan=1>KxC×3×3</td><td rowspan=1 colspan=1>KxCxpxp</td><td rowspan=1 colspan=1>KxCxpxp</td></tr><tr><td rowspan=1 colspan=1>ReLUdimension</td><td rowspan=1 colspan=1>HxW×K</td><td rowspan=1 colspan=1>HxW×K</td><td rowspan=1 colspan=1>WxKp-2</td></tr></table>
+
+Weight Dimension Increase: Compared to a vanilla $3 \times 3$ CNN, a conventional Winograd CNN uses $( p \times p )$ -dimension Winograd kernels. Training a Winograd CNN from scratch allows higher dimension $( p \times p )$ for Winograd kernels, and a Winograd-ReLU CNN shares these characteristics.
+
+ReLU Dimension Increase: A major difference between our Winograd-ReLU CNN and conventional Winograd CNN is that the ReLU layers in Winograd-ReLU CNN have higher dimension. The dimension increase comes from the Winograd transformation extracting $p \times p$ feature patches with $( p - 2 ) \times ( p - 2 )$ strides from $H \times W$ activations. The total number of extracted Winograd-domain activations is $\textstyle { \frac { p } { p - 2 } } H \times { \frac { p } { p - 2 } } W$ , an increase from the spatial domain’s $H \times W$ .
+
+We can see that our Winograd-ReLU architecture has an advantage on the dimensions of weights and activations over other two models. This means Winograd-ReLU CNNs classify on a higher dimension with more complex decision boundaries, which forms a stronger representational ability in high dimensional image feature space.
+
+# 5.2 DYNAMIC ACTIVATION DENSITY
+
+As is shown in the ImageNet results in the previous section, dynamic activation density of spatial baseline CNN model varies significantly among layers. Layers at earlier stages typically have higher density in activation than later stages. In Winograd-ReLU CNN model, the dynamic activation densities vary little among layers and are all close to $5 0 \%$ .
+
+An explanation is that the nature of image convolution ensures activations $d$ to be spatially smooth. Thus, due to the structure of matrix $B$ (Lavin, 2015), 15 of 16 elements in the $4 \times 4$ matrix of Winograd-domain activation patch $B ^ { T } \cdot d \cdot B$ have a mean close to zero. This benefits classification within a patch since ReLU layer is most powerful when half of activations are positive.
+
+# 5.3 KERNEL VISUALIZATION
+
+We visualize the kernels of the proposed Winograd-ReLU model. We selected the first 6 input and output channels of layer res2a_2a of ResNet-18 at three different pruning densities. Unlike spatial domain kernels, Winograd-ReLU kernels do not show clear physical meanings such as edge or corner detectors. However, we observe that values of the $( 2 , 2 )$ elements (from top-left, 1-based indices) in each kernel are typically distinct in a kernel and are most likely kept during aggressive pruning. A possible reason for this is that the $( 2 , 2 )$ elements of Winograd-domain activation in a $4 \times 4$ patch are special: interested readers can calculate $B ^ { T } \cdot d \cdot B$ symbolically and will realize that $( 2 , 2 )$ elements are the only elements that are transformed with a linear combination of only adding and no subtraction. In a spatially smooth activation patch, this means the $( 2 , 2 )$ elements are the ones and the only ones with a non-zero mean.
+
+![](images/fd33a2d5e5795c4f4f5b91a08e71770af5c29ae4ab59f59354e5c6021572949a.jpg)  
+Figure 5: Kernels of ResNet-18 Winograd-ReLU model res2a_2a layer with density of $1 0 0 \%$ (left, $8 7 . 4 3 \%$ top-5 accuracy), $3 5 \%$ (middle, $8 7 . 3 6 \%$ top-5 accuracy) and $1 5 \%$ (right, $8 6 . 5 7 \%$ top-5 accuracy). Positive, negative and pruned weights are in red, blue and black respectively.
+
+# 6 CONCLUSION AND FUTURE WORK
+
+We have shown that we can combine the computational savings of sparse weights and activations with the savings of the Winograd transform by making two modifcations to conventional CNNs. To make the weights sparse at the point of multiplication, we train and prune the weights in the transform domain. This simple approach does not reduce the workload with respect to spatial pruning, though, so we move the ReLU non-linear operation after the Winograd transform to make the activations sparse at the point of multiplication. Moving ReLU to the Winograd domain also allows the weights to be more aggressively pruned without losing accuracy. With a $2 \times 2$ output patch $( p = 4 )$ ), the net result is a reduction of $1 0 . 4 \times$ , $6 . 8 \times$ and $1 0 . 8 \times$ in computation on three datasets: CIFAR-10, CIFAR-100 and ImageNet.
+
+We plan to extend this work in the following directions. First, we expect that even greater savings on computation can be realized by using larger patch sizes (e.g., $p = 6$ ), and there may be benefit in exploring different Winograd transformation matrices ( $^ { \prime } B , G$ and $A$ ). Second, we expect that using different pruning rates $r _ { i }$ for each network layer will help maintain accuracy and improve overall workload reduction. Finally, we expect that combining our Winograd-ReLU network with other network simplification techniques, e.g. quantization of weights and/or activations (Courbariaux et al., 2015; Lin et al., 2016; Rastegari et al., 2016), will reduce the energy of computation even further.
+
+# REFERENCES
+
+Martín Abadi et al. Tensorflow: A system for large-scale machine learning. In Proceedings of the 12th USENIX Conference on Operating Systems Design and Implementation (OSDI), 2016.
+
+Jorge Albericio, Patrick Judd, Tayler Hetherington, Tor Aamodt, Natalie Enright Jerger, and Andreas Moshovos. Cnvlutin: Ineffectual-neuron-free Deep Neural Network Computing. In Proceedings of the 43rd International Symposium on Computer Architecture (ISCA), 2016.
+
+Sharan Chetlur, Cliff Woolley, Philippe Vandermersch, Jonathan Cohen, John Tran, Bryan Catanzaro, and Evan Shelhamer. cuDNN: Efficient primitives for deep learning. CoRR, abs/1410.0759, 2014. URL http://arxiv.org/abs/1410.0759.
+
+Jason Cong and Bingjun Xiao. Minimizing computation in convolutional neural networks. In International Conference on Artificial Neural Networks (ICANN), pp. 281–290. Springer, 2014.
+
+Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In Advances in neural information processing systems (NIPS), 2015.
+
+Song Han, Jeff Pool, John Tran, and William J. Dally. Learning both weights and connections for efficient neural networks. In Advances in neural information processing systems (NIPS), 2015.
+
+Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A. Horowitz, and William J. Dally. EIE: Efficient inference engine on compressed deep neural network. In Proceedings of the 43rd International Symposium on Computer Architecture (ISCA), 2016a.
+
+Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In International Conference on Learning Representations (ICLR), 2016b.
+
+Babak Hassibi, David G Stork, et al. Second order derivatives for network pruning: Optimal brain surgeon. Advances in Neural Information Processing Systems (NIPS), pp. 164–164, 1993.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016a.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision (ECCV), pp. 630–645. Springer, 2016b.
+
+Yuxiang Huan, Yifan Qin, Yantian You, Lirong Zheng, and Zhuo Zou. A multiplication reduction technique with near-zero approximation for embedded learning in IoT devices. In System-on-Chip Conference (SOCC), 29th IEEE International, pp. 102–107. IEEE, 2016.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems (NIPS), 2012.
+
+Andrew Lavin. Fast algorithms for convolutional neural networks. CoRR, abs/1509.09308, 2015. URL http://arxiv.org/abs/1509.09308.
+
+Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems (NIPS), pp. 598–605, 1990.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Sheng R. Li, Jongsoo Park, and Ping Tak Peter Tang. Enabling sparse Winograd convolution by native pruning. CoRR, abs/1702.08597, 2017. URL http://arxiv.org/abs/1702.08597.
+
+Zhouhan Lin, Matthieu Courbariaux, Roland Memisevic, and Yoshua Bengio. Neural networks with few multiplications. In Proceedings of International Conference on Learning Representations (ICLR), 2016.
+
+Xingyu Liu, Song Han, Huizi Mao, and William J. Dally. Efficient sparse-winograd convolutional neural networks. International Conference on Learning Representations (ICLR) Workshop, 2017.
+
+Nagadomi. Code for kaggle-cifar10 competition. 5th place. https://github.com/ nagadomi/kaggle-cifar10-torch7, 2014.
+
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. XNOR-Net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision (ECCV), 2016.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 2015.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In Proceedings of International Conference on Learning Representations (ICLR), 2015.
+
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. International Conference on Learning Representations (ICLR) Workshop, 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 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1–9, June 2015.
+
+Shmuel Winograd. Arithmetic complexity of computations, volume 33. Siam, 1980.

parse/train/HJzgZ3JCW/HJzgZ3JCW_content_list.json

@@ -0,0 +1,1158 @@
+[
+    {
+        "type": "text",
+        "text": "EFFICIENT SPARSE-WINOGRAD CONVOLUTIONAL NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            648,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xingyu Liu∗, Jeff Pool†, Song $\\mathbf { H a n } ^ { \\ddag \\mathsection }$ , William J. Dally∗†   \n∗ Stanford University, † NVIDIA, ‡ Massachusetts Institute of Technology, § Google Brain   \n{xyl, dally}@stanford.edu ",
+        "bbox": [
+            184,
+            167,
+            764,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional Neural Networks (CNNs) are computationally intensive, which limits their application on mobile devices. Their energy is dominated by the number of multiplies needed to perform the convolutions. Winograd’s minimal filtering algorithm (Lavin, 2015) and network pruning (Han et al., 2015) can reduce the operation count, but these two methods cannot be directly combined – applying the Winograd transform fills in the sparsity in both the weights and the activations. We propose two modifications to Winograd-based CNNs to enable these methods to exploit sparsity. First, we move the ReLU operation into the Winograd domain to increase the sparsity of the transformed activations. Second, we prune the weights in the Winograd domain to exploit static weight sparsity. For models on CIFAR-10, CIFAR-100 and ImageNet datasets, our method reduces the number of multiplications by $1 0 . 4 \\times$ , $6 . 8 \\times$ and $1 0 . 8 \\times$ respectively with loss of accuracy less than $0 . 1 \\%$ , outperforming previous baselines by $2 . 0 { \\times } { - } 3 . 0 { \\times }$ . We also show that moving ReLU to the Winograd domain allows more aggressive pruning. ",
+        "bbox": [
+            233,
+            290,
+            766,
+            482
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            532,
+            336,
+            547
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep Convolutional Neural Networks (CNNs) have shown significant improvement in many machine learning applications. However, CNNs are compute-limited. Their performance is dominated by the number of multiplies needed to perform the convolutions. Moreover, the computational workload of CNNs continues to grow over time. LeCun et al. (1998) proposed a CNN model with less than $2 . 3 \\times 1 0 ^ { 7 }$ multiplies for handwritten digit classification. Later, Krizhevsky et al. (2012) developed AlexNet, an ImageNet-winning CNN with more than $1 . 1 \\times 1 0 ^ { 9 }$ multiplies. In 2014, ImageNetwinning and runner up CNNs increased the number of multiplies to $1 . 4 \\times 1 0 ^ { 9 }$ (Szegedy et al., 2015) and $1 . \\check { 6 } \\times 1 0 ^ { 1 0 }$ (Simonyan & Zisserman, 2015) respectively. Despite the powerful representational ability of large scale CNNs, their computational workload prohibits deployment on mobile devices. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            695
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Two research directions have been explored to address the problem. Lavin (2015) proposed using Winograd’s minimal filtering algorithm (Winograd, 1980) to reduce the number of multiplies needed to perform $3 \\times 3$ kernel convolutions. On the other end, pruning the model (Han et al., 2015; 2016b) and exploiting the dynamic sparsity of activations due to ReLU also reduces the required multiplies. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            758
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, the above two directions are not compatible: the Winograd transformation fills in the zeros in both the weights and the activations (Figure 1(a)) – eliminating the gain from exploiting sparsity. Thus, for a pruned network, Winograd’s algorithm actually increases the number of multiplies; the loss of sparsity more than offsets the reduced operation count. ",
+        "bbox": [
+            176,
+            765,
+            825,
+            820
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce two modifications to the original Winograd-based convolution algorithm to eliminate this problem. First, we move the ReLU operation to be after the Winograd transform to also make the activations sparse at the point where the multiplies are performed. Second, we prune the weights after (rather than before) they are transformed. Thus, the weights are sparse when the elementwise multiply is performed — reducing the operation count. Together, these two modifications enable the gains of Winograd’s algorithm and of exploiting sparsity to be combined. We open-source our code and models at https://github.com/xingyul/Sparse-Winograd-CNN. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/5d31248203791cc829c4714ffc9261eddfcb11f30161ef59302401d8d87056d8.jpg",
+        "image_caption": [
+            "Figure 1: Combining Winograd convolution with sparse weights and activations. (a) Conventional Winograd-based convolution fills in the zeros in both the weights and activations. (b) Pruning the $4 \\times 4$ transformed kernel restores sparsity to the weights. (c) Our proposed Winograd-ReLU CNN. Moving the ReLU layer after Winograd transformation also restores sparsity to the activations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            71,
+            815,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            343,
+            523
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Linear Algebra property in Convolution: Previous research proposes using the linear algebra property of convolution to reduce the number of multiplies by trading additions for multiplies. Cong & Xiao (2014) convert convolution into matrix multiplies and utilize the linear algebra property at the sub-matrix block level. This approach achieves a $47 \\%$ saving in multiplies. Lavin (2015) exploits the element-level linear algebra property of convolution, i.e. Winograd’s minimal filtering algorithm (Winograd, 1980). This approach reduces the number of multiplies by $2 . 2 5 \\times$ to $4 \\times$ , depending on the image patch size used in the algorithm. Winograd’s algorithm is also used in a state-of-the-art deep learning library, cuDNN (Chetlur et al., 2014), to improve computation efficiency. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            662
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Model Compression: Model compression reduces the number of multiplies of CNNs by pruning network parameters (LeCun et al., 1990; Hassibi et al., 1993) and exploiting weight sparsity. Han et al. (2015; 2016b) proposed learning the sparsity pattern of network weights by eliminating weights whose absolute value is less than an empirical threshold. This approach can prune the convolutional layers of the model to only $3 0 \\% - 5 0 \\%$ of the original size and reduce the number of multiplies required. Liu et al. (2017) first proposed pruning and re-training the weights in Winograd domain for conventional Winograd convolution. Li et al. (2017) later showed promising results on large datasets and reported $9 0 \\%$ sparsity in the Winograd parameters of AlexNet with less than $0 . 1 \\%$ accuracy loss. ",
+        "bbox": [
+            173,
+            669,
+            825,
+            780
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Dynamic Activation Sparsity: The ReLU non-linearity sets activations whose values are negative to zero, causing dynamic sparsity in activations. Model compression can work in tandem with dynamic activation sparsity and reduce multiplication workload. Han et al. (2015) showed that exploiting sparsity of both weights and activations can reduce the number of multiplies by $4 - 1 1 \\times$ . Huan et al. (2016) further proposed to manually set a small positive ReLU threshold at test time to exploit greater sparsity in activation without losing testing accuracy. Research in novel architectures also led to optimizations for deep learning accelerators to exploit the sparsity in activations. Han et al. (2016a) proposed using a Leading Non-zero Detection unit (LNZD) for their fully-connected layer accelerator to efficiently skip zeros in input activations. Albericio et al. (2016) proposed a similar mechanism for a convolution layer accelerator. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 SPARSE WINOGRAD CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            504,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first introduce the conventional Winograd convolution and show how sparsity of weights or activations is lost during the dataflow of the algorithm. We then present the novel Winograd-ReLU CNN architecture. It preserves sparsity in both weights and activations before multiplies are performed and significantly reduces the computational workload. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            189
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 SPARSITY IN CONVENTIONAL SPATIAL AND WINOGRAD CNN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            207,
+            645,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The basic block of the conventional Winograd convolution algorithm works on an $p \\times p$ patch (denoted by $d$ ) extracted with stride of $( p - 2 ) \\times ( p - 2 )$ from an $H \\times W$ input feature map. With “valid” padding, the $p \\times p$ patch is convolved with a $3 \\times 3$ kernel (denoted by $g$ ) to produce an $\\bar { ( \\boldsymbol { p } - 2 ) } \\times ( \\boldsymbol { p } - 2 )$ output patch (denoted by $S$ ). The output patches are assembled into an output feature map. ",
+        "bbox": [
+            174,
+            233,
+            826,
+            289
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Input activation patch $d$ and kernel $g$ (spatial-domain activation and weights) are transformed using matrices $B$ and $G$ to be $B ^ { T } d B$ and $G g G ^ { T }$ (Winograd-domain activation and weights) respectively, both with shape $p \\times p$ . After element-wise product in Winograd-domain, the output activation $S$ is obtained using matrix $A$ (equation (1)). Matrices $B$ , $G$ and $A$ are $p$ -specific. When $p = 4$ , $B$ and $A$ consists of 1, $- 1$ and 0, so the multiplication with $B$ and $A$ only requires addition. It reduces the number of multiplies from $9 ( p - 2 ) ^ { 2 }$ to $p ^ { 2 }$ . Lavin (2015) gives details of the algorithm. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            378
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4f8c201320f8ec1f92552d204e5fd4405a058e91a80a911750074483da56c3b2.jpg",
+        "text": "$$\nS = A ^ { T } [ [ G g G ^ { T } ] \\odot [ B ^ { T } d B ] ] A\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            386,
+            602,
+            405
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Spatial Baseline Network: When using a “vanilla” pruned network, as introduced by Han et al. (2015), a ReLU non-linear operation is performed by the previous layer on spatial-domain input $d$ and spatial-domain weight $g$ is pruned. The output activation patch $S$ is obtained from equation (2). This is illustrated in Figure 1(a) for $p = 4$ . Though $g$ and $d$ may both be sparse due to pruning and ReLU respectively, the element-wise multiply is dense due to $\\dot { G } ( \\cdot ) G ^ { T }$ and $\\mathsf { \\bar { B } } ( \\cdot ) B ^ { T }$ transformations filling the spatial-domain zeros. Sparsity does not reduce the number of multiplies in Winograd’s algorithm. ",
+        "bbox": [
+            173,
+            419,
+            826,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb8b4d2e84b0f4604eeda8e96330880b0b74b23568a2e7390bff100840dd077e.jpg",
+        "text": "$$\nS = A ^ { T } [ [ G \\mathrm { P r u n e } ( g ) G ^ { T } ] \\odot [ B ^ { T } \\mathrm { R e L U } ( d ) B ] ] A\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            513,
+            658,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Winograd Native Pruned Network: When using the Winograd-domain pruned network introduced by Liu et al. (2017) and Li et al. (2017), the spatial-domain input $d$ is ReLU-ed by the previous layer while the Winograd-domain weight $G g G ^ { T }$ is pruned. The output activation patch $S$ is obtained from equation (3). The algorithm when $p = 4$ is also illustrated in Figure 1(b). Though Winograd-domain weights are sparse due to pruning, Winograd-domain activations are still dense due to $B ( \\cdot ) B ^ { T }$ transforms. The sparsity in spatial activations due to ReLU does not reduce the number of multiplies. ",
+        "bbox": [
+            173,
+            544,
+            825,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/545219d17e7c6851f9239c1c4567f5966651b45a0a5c9280cbc4aa7bf1ee272b.jpg",
+        "text": "$$\nS = A ^ { T } [ [ \\mathrm { P r u n e } ( G g G ^ { T } ) ] \\odot [ B ^ { T } \\mathrm { R e L U } ( d ) B ] ] A\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            635,
+            658,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 WINOGRAD-RELU CNN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            670,
+            388,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To address the above problems, we introduce the Winograd-ReLU Network. Instead of applying ReLU to the activations in the spatial domain, we apply ReLU to the activations in the Winograd domain, as in equation (4) and Figure 1(c). The ReLU operation zeros all negative transformed activations, reducing the number of multiplies in the Winograd domain. ",
+        "bbox": [
+            173,
+            695,
+            825,
+            751
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a0c870d7f35831c36554279005c7e54668ac048ff0d5ecf74a4ad73fda3e36c5.jpg",
+        "text": "$$\nS = A ^ { T } [ [ \\mathrm { P r u n e } ( G g G ^ { T } ) ] \\odot [ \\mathrm { R e L U } ( B ^ { T } d B ) ] ] A\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            758,
+            658,
+            777
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the Winograd-ReLU CNN, we eliminate the spatial-domain kernel entirely. Because this ReLU is really associated with the previous layer, we perform this transformed ReLU starting with the second layer. We point out that the proposed new CNN architecture is not mathematically equivalent to the vanilla CNN nor the conventional Winograd CNN. Due to the change of network architecture, the training and pruning should also be changed. Our method operates in three phases: dense training, pruning, and retraining. ",
+        "bbox": [
+            173,
+            791,
+            825,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dense training: we train a dense $p \\times p$ kernel directly in the transform domain. The transformed kernel is initialized and trained directly by back-propagation through the inverse transform — eliminating the need to maintain a kernel in the spatial domain or to transform a spatial kernel. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pruning: we prune the transformed kernel by computing the threshold $t$ required to achieve a desired pruning rate $r$ and setting all weights whose absolute value less than $t$ to zero. In our experiments, we used the same $r$ for all Winograd-ReLU layers. Because sensitivity varies from layer to layer, we expect that better performance could be achieved by varying the pruning rate $r _ { i }$ for each layer $i$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Re-training: we re-train the model using a “sparsity mask” to force the weights that were pruned to remain zero. The sparsity mask is computed during the pruning step and is kept constant during re-training. The gradient of the network’s loss, $L$ , with respect to the input activation and Winograd weights can be derived using the chain rule. Equation (5) shows the calculation of input activation gradient $\\nabla _ { d } L$ and Winograd weight gradient $\\nabla _ { G g G ^ { T } } L$ using the loss gradient passed from upstream layers $\\nabla _ { S } L$ . ",
+        "bbox": [
+            173,
+            165,
+            825,
+            248
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a889a32a46d96d744f60d07854a71e6b58dcc59d7872b9aa49093e38dcd8372b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla _ { G g G ^ { T } } L = ( A \\nabla _ { S } L A ^ { T } ) \\odot ( B ^ { T } d B ) \\odot m a s k } \\\\ & { \\nabla _ { d } L = B [ ( A \\nabla _ { S } L A ^ { T } ) \\odot ( G g G ^ { T } ) \\odot m a s k ] B ^ { T } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            247,
+            660,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            296,
+            326,
+            313
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We applied the methodology described above to several different CNNs on different datasets. The original network models are chosen such that the majority of the convolution layers have $3 \\times 3$ kernels. This ensures the largest portion of layers can be converted to Winograd convolution layers and ReLU be put in Winograd domain. We used image classification datasets of different scales: CIFAR-10, CIFAR-100 (Krizhevsky & Hinton, 2009) and ImageNet 2012 (Russakovsky et al., 2015). For network architectures, we chose VGG-nagadomi (Nagadomi, 2014), ConvPool-CNN-C model (Springenberg et al., 2015) and a variation of ResNet-18 (He et al., 2016a) respectively on three datasets. Using the Tensorflow (Abadi et al., 2016) framework, we trained the spatial baseline CNN, corresponding conventional Winograd CNN, and Winograd-ReLU CNN models from scratch. Then the three models are iteratively pruned and re-trained. For a specific dataset, we used the same data augmentation for the training of all models on the dataset. ",
+        "bbox": [
+            173,
+            328,
+            826,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            497,
+            290,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We used VGG-nagadomi (Nagadomi, 2014) on the CIFAR-10 dataset. VGG-nagadomi is a lightweight version of VGGNet (Simonyan & Zisserman, 2015). It contains 8 convolution layers with $3 \\times 3$ kernels. The best reported validation set accuracy it achieves on CIFAR-10 is $9 3 . 3 1 \\%$ (Nagadomi, 2014). We trained three models from scratch. The corresponding conventional Winograd CNN model and Winograd-ReLU CNN model can achieve validation set accuracy of $9 3 . 3 0 \\%$ and $9 3 . 4 3 \\%$ respectively. The first convolution layer is most sensitive to pruning and we set its density to a constant of $8 0 \\%$ . We iteratively pruned and re-trained other convolution layers with density from $8 0 \\%$ down to $2 0 \\%$ . ",
+        "bbox": [
+            173,
+            522,
+            826,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb3a21d02a88528097fbdb90725d1ce6938144edeab9e66abd322edd1ec20c0a.jpg",
+        "image_caption": [
+            "Figure 2: Test accuracy vs density for the three models in Figure 1 on VGG-nagadomi. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            643,
+            761,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows test accuracy as a function of weight density for the three models. The two baseline models can only be pruned to $6 0 \\%$ density before accuracy falls significantly $( > ~ 0 . 1 \\% )$ . Our Winograd-ReLU CNN model can be pruned to $4 0 \\%$ density before falling to the same accuracy. ",
+        "bbox": [
+            173,
+            781,
+            825,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the input activation density and compares the workloads for each pruned convolution layer in three models. Pruning two baseline models reduces the convolution layer workload by $5 . 1 \\times$ and $3 . 7 \\times \\mathbf { \\Omega } ^ { 1 }$ respectively. Pruning the Winograd-ReLU model reduces the convolution layer workload by $1 3 . 3 \\times$ , a $2 . 6 \\times$ and $3 . 6 \\times$ improvement respectively over the two baselines. The improvement of overall network workload reduction is $2 . 2 \\times$ and $3 . 0 \\times$ respectively over two baselines. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/cd54f2b6be8fc3123d70ec33d1a6f0db2a885a1358db6b643dc7ca54466705a2.jpg",
+        "table_caption": [
+            "Table 1: VGG-nagadomi weight and activation density on CIFAR-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=3 colspan=1>Layer</td><td rowspan=1 colspan=3>Spatial Baseline CNNPruning (Han et al., 2015)</td><td rowspan=1 colspan=3>Winograd CNNNativePruning (Li et al., 2017)</td><td rowspan=1 colspan=3>Winograd-ReLU CNNPruning (ours)</td></tr><tr><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=1>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=1>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=1>Workload</td></tr><tr><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td></tr><tr><td rowspan=1 colspan=1>convo</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>80%</td></tr><tr><td rowspan=1 colspan=1>conv1</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>30%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>46%</td><td rowspan=1 colspan=1>8%</td></tr><tr><td rowspan=1 colspan=1>conv2</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>12%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>39%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>conv3</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>37%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>conv4</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>18%</td><td rowspan=1 colspan=1>11%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>conv5</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>26%</td><td rowspan=1 colspan=1>15%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>38%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>conv6</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>24%</td><td rowspan=1 colspan=1>14%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>6%</td></tr><tr><td rowspan=1 colspan=1>conv7</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>21%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>27%</td><td rowspan=1 colspan=1>40%</td><td rowspan=1 colspan=1>36%</td><td rowspan=1 colspan=1>6%</td></tr><tr><td rowspan=1 colspan=1>conv total</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>20%(5.1x)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>27%(3.7x)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>8%(13.3x)</td></tr><tr><td rowspan=1 colspan=1>overall</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>21%(4.7x)</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>29%(3.5x)</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>10%(10.4x)</td></tr></table>",
+        "bbox": [
+            174,
+            92,
+            823,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 CIFAR-100 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            303,
+            299,
+            316
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We used the ConvPool-CNN-C (Springenberg et al., 2015) model on on the CIFAR-100 dataset. ConvPool-CNN-C contains 9 convolution layers, out of which 7 have $3 \\times 3$ kernels. We trained three models from scratch. The spatial baseline CNN model and conventional Winograd CNN model can achieve single model validation accuracy of $6 9 . 3 4 \\%$ and $6 9 . 3 2 \\%$ respectively. The corresponding Winograd-ReLU network model can achieve validation set accuracy of $6 9 . 7 5 \\%$ . We pruned the first convolution layer to a constant density of $8 0 \\%$ . We iteratively pruned and re-trained the other layers to densities from $8 0 \\%$ down to $2 0 \\%$ . ",
+        "bbox": [
+            173,
+            329,
+            826,
+            426
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9b55c6044b978fdfbdadf97113336e994041038c9766619715b294e088ca5169.jpg",
+        "image_caption": [
+            "Figure 3: Test accuracy vs density for the three models in Figure 1 on ConvPool-CNN-C. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            443,
+            767,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the accuracy as a function of density for spatial baseline and Winograd-ReLU models. The spatial-baseline and Winograd-ReLU models can be pruned to $6 0 \\%$ density without significant $( > 0 . 1 \\% )$ loss of accuracy. In contrast, the conventional Winograd CNN model can only be pruned to $7 0 \\%$ density. At a given density, the Winograd-ReLU model has the highest accuracy. ",
+        "bbox": [
+            173,
+            579,
+            826,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/941cd87a1914bafd8a9ebbfb064aa2fd28dfa7d8b2af7bb978a1a1c8d6488481.jpg",
+        "table_caption": [
+            "Table 2: ConvPool-CNN-C weight and activation density on CIFAR-100. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=3 colspan=1>Layer</td><td rowspan=1 colspan=4>Spatial Baseline CNNPruning (Han et al.,2015)</td><td rowspan=1 colspan=3>Winograd CNNNativePruning (Li et al., 2017)</td><td rowspan=1 colspan=4>Winograd-ReLU CNNPruning (ours)</td></tr><tr><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=2>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=1>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=2>Workload</td></tr><tr><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td></tr><tr><td rowspan=1 colspan=1>conv0</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=2>80%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=2>80%</td></tr><tr><td rowspan=1 colspan=1>conv1</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>53%</td><td rowspan=1 colspan=2>33%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>54%</td><td rowspan=1 colspan=2>14%</td></tr><tr><td rowspan=1 colspan=1>conv2</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>52%</td><td rowspan=1 colspan=2>32%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>53%</td><td rowspan=1 colspan=2>14%</td></tr><tr><td rowspan=1 colspan=1>conv3</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>77%</td><td rowspan=1 colspan=2>46%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>54%</td><td rowspan=1 colspan=2>14%</td></tr><tr><td rowspan=1 colspan=1>conv4</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=2>21%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>54%</td><td rowspan=1 colspan=2>14%</td></tr><tr><td rowspan=1 colspan=1>conv5</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>32%</td><td rowspan=1 colspan=2>19%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>42%</td><td rowspan=1 colspan=2>11%</td></tr><tr><td rowspan=1 colspan=1>conv6</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>56%</td><td rowspan=1 colspan=2>33%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>31%</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>43%</td><td rowspan=1 colspan=2>11%</td></tr><tr><td rowspan=1 colspan=1>conv total</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>29%(3.5x)</td><td></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>31%(3.2x)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>14%(7.1x)</td><td></td></tr><tr><td rowspan=1 colspan=1>overall</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>30%(3.4x)</td><td></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>32%(3.1x)</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>15%(6.8x)</td><td rowspan=1 colspan=1></td></tr></table>",
+        "bbox": [
+            179,
+            667,
+            820,
+            838
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows the input activation density and compares the workloads for each pruned convolution layer in three models. Pruning two baseline models reduces the convolution layer workload by $3 . 5 \\times$ and $3 . 2 \\times$ respectively. Pruning the Winograd-ReLU model reduces the workload by $7 . 1 \\times$ , a $2 . 1 \\times$ and $2 . 2 \\times$ improvement respectively over the two baselines. The improvement of overall network workload reduction is $2 . 0 \\times$ and $2 . 2 \\times$ respectively over two baselines. ",
+        "bbox": [
+            173,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            292,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We used a variation of the full pre-activation version (He et al., 2016b) of ResNet-18 (He et al., 2016a) on the ImageNet 2012 dataset. We used this version because it performs the best among various ResNet versions and its structure suits our Winograd-ReLU approach – its ReLU units are located before convolutions in the residual modules. The variation is different from original ResNet-18 by replacing all $2 \\times 2$ -stride $3 \\times 3$ convolution layers with a $2 \\times 2$ max-pooling layer followed by a $1 \\times 1$ -stride $3 \\times 3$ convolution layer. Such difference ensure most of convolution layers can be converted to Winograd convolution layer. Another difference is that it doesn’t have the last max pooling layer so the last group of residual modules has spatial size of $1 4 \\times 1 4$ , in order to keep the spatial size even instead of odd. This setting suits Winograd convolution with $p = 4$ best in that even spatial size is required for even $p$ values. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            272
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We trained three models from scratch. For single model and single central $2 2 4 \\times 2 2 4$ cropping, the spatial baseline CNN model and conventional Winograd CNN model can achieve single model top1/top-5 validation accuracy of $6 6 . 6 7 \\% / 8 7 . 4 2 \\%$ and $6 6 . 8 4 \\% / 8 7 . 4 7 \\%$ . The corresponding WinogradReLU CNN model can achieve validation top-1/top-5 accuracy of $6 6 . 7 8 \\% / 8 7 . 4 3 \\%$ . We kept the first convolution layer intact. We iteratively pruned other convolution layers with density rate from $8 0 \\%$ down to $1 0 \\%$ . ",
+        "bbox": [
+            174,
+            279,
+            826,
+            362
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/66d0fc58a4fe5bacbc490133481a6e6715ed83b330deb9a49fd96bb340c1ba7e.jpg",
+        "image_caption": [
+            "Figure 4: Top-1 and top-5 validation accuracy vs density for three models on a variation of ResNet-18. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            386,
+            771,
+            574
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the accuracy as a function of density for three models. The spatial baseline CNN model and conventional Winograd CNN model can be pruned to $6 0 \\%$ and $5 0 \\%$ respectively without significant $( > 0 . 1 \\% )$ loss of top-1 or top-5 accuracy. The Winograd-ReLU model can be pruned much further, to $3 0 \\% / 3 5 \\%$ density without significant $( > 0 . 1 \\% )$ ) loss of top-1/top-5 accuracy. At these densities, top-1 accuracies are $6 6 . 5 3 \\%$ , $6 6 . 4 5 \\%$ and $6 6 . 6 1 \\%$ for three models respectively, with a dense spatial baseline of $6 6 . 6 7 \\%$ ; top-5 accuracies are $8 7 . 2 9 \\%$ , $8 7 . 3 0 \\%$ and $8 7 . 3 5 \\%$ for three models respectively, with a dense spatial baseline of $8 7 . 4 2 \\%$ . ",
+        "bbox": [
+            173,
+            637,
+            825,
+            733
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows the input activation density and compares the workloads for each pruned convolution layer in three models. Pruning the two baseline models reduces the convolution layer workload by $5 . 1 \\times$ and $4 . 5 \\times$ respectively. Pruning the Winograd-ReLU model reduces the workload by $1 3 . 2 \\times$ a $2 . 6 \\times$ and $2 . 9 \\times$ improvement respectively over the two baselines. The improvement of overall network workload reduction is $2 . 3 \\times$ and $2 . 6 \\times$ respectively over two baselines. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            843,
+            310,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we summarize the experiment results and compare the three models in terms of a) weight and activation dimensions and b) the dynamic density of activations. We then visualize the kernels to illustrate the pattern of the proposed Winograd-ReLU model kernel. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/b9e6626bf01e5ac7bdc6aaf2ff563240ec5d752683b89ded893b939be3e4d334.jpg",
+        "table_caption": [
+            "Table 3: ResNet-18 variation weight and activation density on ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=3 colspan=1>Layer</td><td rowspan=1 colspan=4>Spatial Baseline CNNPruning (Han et al., 2015)</td><td rowspan=1 colspan=3>Winograd CNNNativePruning (Li et al.,2017)</td><td rowspan=1 colspan=4>Winograd-ReLU CNNPruning (ours)</td></tr><tr><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=2>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=1>Workload</td><td rowspan=1 colspan=2>Density</td><td rowspan=2 colspan=2>Workload</td></tr><tr><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td><td rowspan=1 colspan=1>Weight</td><td rowspan=1 colspan=1>Act</td></tr><tr><td rowspan=1 colspan=1>res2a_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>90%</td><td rowspan=1 colspan=2>54%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>48%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res2a_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>64%</td><td rowspan=1 colspan=2>39%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res2b_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>71%</td><td rowspan=1 colspan=2>43%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res2b_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>53%</td><td rowspan=1 colspan=2>32%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res3a_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>94%</td><td rowspan=1 colspan=2>56%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res3a_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=2>21%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res3b_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>47%</td><td rowspan=1 colspan=2>28%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res3b_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>29%</td><td rowspan=1 colspan=2>17%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res4a_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>88%</td><td rowspan=1 colspan=2>53%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res4a_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>23%</td><td rowspan=1 colspan=2>14%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res4b_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>36%</td><td rowspan=1 colspan=2>22%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res4b_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>21%</td><td rowspan=1 colspan=2>13%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res5a_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>45%</td><td rowspan=1 colspan=2>27%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>res5a_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>14%</td><td rowspan=1 colspan=2>9%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>48%</td><td rowspan=1 colspan=2>7%</td></tr><tr><td rowspan=1 colspan=1>res5b_2a</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>16%</td><td rowspan=1 colspan=2>10%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>48%</td><td rowspan=1 colspan=2>7%</td></tr><tr><td rowspan=1 colspan=1>res5b_2b</td><td rowspan=1 colspan=1>60%</td><td rowspan=1 colspan=1>12%</td><td rowspan=1 colspan=2>7%</td><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>35%</td><td rowspan=1 colspan=1>49%</td><td rowspan=1 colspan=2>8%</td></tr><tr><td rowspan=1 colspan=1>conv total</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>20%(5.1x)</td><td></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>22%(4.5x)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>8%(13.2x)</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>overall</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>21%(4.7x)</td><td></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>24%(4.2x)</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>9%(10.8x)</td><td rowspan=1 colspan=1></td></tr></table>",
+        "bbox": [
+            178,
+            117,
+            820,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 WEIGHT AND ACTIVATION DIMENSION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            486,
+            446
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In a convolutional neural network, a convolution-ReLU pair acts as a classifier on a spatial patch of an input feature. The dimension of the space being classified is the total number of elements passing through the ReLU layer. The decision boundaries of the classifier are determined by the weights. Insufficient non-zero weights or insufficient activations results in too simple a decision boundary and causes accuracy loss. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            529
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Experimental results have shown that Winograd-ReLU CNN can reach the same accuracy as both vanilla spatial baseline CNN and conventional Winograd CNN without pruning, and that WinogradReLU CNN is more robust to aggressive pruning. In this subsection we provide an explanation for the latter observation from the aspect of activation and weight dimensions. We provide a summary on dimensions in Table 4. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/29782db119dca3c4f6d92f9518fc4447f25ba2884e58007c9c123d51c7d9ecaa.jpg",
+        "table_caption": [
+            "Table 4: Comparison of ReLU dimension and weight dimension in three types of networks. Assume the convolution-ReLU pair operates on input activation of spatial size of $H \\times W$ and the number of input and output channels are $C$ and $K$ respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>SpatialBaselineCNN (Han et al., 2015)</td><td rowspan=1 colspan=1>Winograd nativeprunedCNN (Li et al., 2017)</td><td rowspan=1 colspan=1>Winograd-ReLUCNN (ours)</td></tr><tr><td rowspan=1 colspan=1>Weightdimension</td><td rowspan=1 colspan=1>KxC×3×3</td><td rowspan=1 colspan=1>KxCxpxp</td><td rowspan=1 colspan=1>KxCxpxp</td></tr><tr><td rowspan=1 colspan=1>ReLUdimension</td><td rowspan=1 colspan=1>HxW×K</td><td rowspan=1 colspan=1>HxW×K</td><td rowspan=1 colspan=1>WxKp-2</td></tr></table>",
+        "bbox": [
+            178,
+            661,
+            820,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Weight Dimension Increase: Compared to a vanilla $3 \\times 3$ CNN, a conventional Winograd CNN uses $( p \\times p )$ -dimension Winograd kernels. Training a Winograd CNN from scratch allows higher dimension $( p \\times p )$ for Winograd kernels, and a Winograd-ReLU CNN shares these characteristics. ",
+        "bbox": [
+            174,
+            741,
+            823,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ReLU Dimension Increase: A major difference between our Winograd-ReLU CNN and conventional Winograd CNN is that the ReLU layers in Winograd-ReLU CNN have higher dimension. The dimension increase comes from the Winograd transformation extracting $p \\times p$ feature patches with $( p - 2 ) \\times ( p - 2 )$ strides from $H \\times W$ activations. The total number of extracted Winograd-domain activations is $\\textstyle { \\frac { p } { p - 2 } } H \\times { \\frac { p } { p - 2 } } W$ , an increase from the spatial domain’s $H \\times W$ . ",
+        "bbox": [
+            173,
+            790,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We can see that our Winograd-ReLU architecture has an advantage on the dimensions of weights and activations over other two models. This means Winograd-ReLU CNNs classify on a higher dimension with more complex decision boundaries, which forms a stronger representational ability in high dimensional image feature space. ",
+        "bbox": [
+            174,
+            868,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 DYNAMIC ACTIVATION DENSITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            442,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As is shown in the ImageNet results in the previous section, dynamic activation density of spatial baseline CNN model varies significantly among layers. Layers at earlier stages typically have higher density in activation than later stages. In Winograd-ReLU CNN model, the dynamic activation densities vary little among layers and are all close to $5 0 \\%$ . ",
+        "bbox": [
+            174,
+            130,
+            825,
+            184
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "An explanation is that the nature of image convolution ensures activations $d$ to be spatially smooth. Thus, due to the structure of matrix $B$ (Lavin, 2015), 15 of 16 elements in the $4 \\times 4$ matrix of Winograd-domain activation patch $B ^ { T } \\cdot d \\cdot B$ have a mean close to zero. This benefits classification within a patch since ReLU layer is most powerful when half of activations are positive. ",
+        "bbox": [
+            174,
+            191,
+            825,
+            247
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 KERNEL VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            263,
+            388,
+            277
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We visualize the kernels of the proposed Winograd-ReLU model. We selected the first 6 input and output channels of layer res2a_2a of ResNet-18 at three different pruning densities. Unlike spatial domain kernels, Winograd-ReLU kernels do not show clear physical meanings such as edge or corner detectors. However, we observe that values of the $( 2 , 2 )$ elements (from top-left, 1-based indices) in each kernel are typically distinct in a kernel and are most likely kept during aggressive pruning. A possible reason for this is that the $( 2 , 2 )$ elements of Winograd-domain activation in a $4 \\times 4$ patch are special: interested readers can calculate $B ^ { T } \\cdot d \\cdot B$ symbolically and will realize that $( 2 , 2 )$ elements are the only elements that are transformed with a linear combination of only adding and no subtraction. In a spatially smooth activation patch, this means the $( 2 , 2 )$ elements are the ones and the only ones with a non-zero mean. ",
+        "bbox": [
+            173,
+            289,
+            825,
+            428
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/fd33a2d5e5795c4f4f5b91a08e71770af5c29ae4ab59f59354e5c6021572949a.jpg",
+        "image_caption": [
+            "Figure 5: Kernels of ResNet-18 Winograd-ReLU model res2a_2a layer with density of $1 0 0 \\%$ (left, $8 7 . 4 3 \\%$ top-5 accuracy), $3 5 \\%$ (middle, $8 7 . 3 6 \\%$ top-5 accuracy) and $1 5 \\%$ (right, $8 6 . 5 7 \\%$ top-5 accuracy). Positive, negative and pruned weights are in red, blue and black respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            439,
+            825,
+            588
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            665,
+            493,
+            681
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have shown that we can combine the computational savings of sparse weights and activations with the savings of the Winograd transform by making two modifcations to conventional CNNs. To make the weights sparse at the point of multiplication, we train and prune the weights in the transform domain. This simple approach does not reduce the workload with respect to spatial pruning, though, so we move the ReLU non-linear operation after the Winograd transform to make the activations sparse at the point of multiplication. Moving ReLU to the Winograd domain also allows the weights to be more aggressively pruned without losing accuracy. With a $2 \\times 2$ output patch $( p = 4 )$ ), the net result is a reduction of $1 0 . 4 \\times$ , $6 . 8 \\times$ and $1 0 . 8 \\times$ in computation on three datasets: CIFAR-10, CIFAR-100 and ImageNet. ",
+        "bbox": [
+            173,
+            695,
+            825,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We plan to extend this work in the following directions. First, we expect that even greater savings on computation can be realized by using larger patch sizes (e.g., $p = 6$ ), and there may be benefit in exploring different Winograd transformation matrices ( $^ { \\prime } B , G$ and $A$ ). Second, we expect that using different pruning rates $r _ { i }$ for each network layer will help maintain accuracy and improve overall workload reduction. Finally, we expect that combining our Winograd-ReLU network with other network simplification techniques, e.g. quantization of weights and/or activations (Courbariaux et al., 2015; Lin et al., 2016; Rastegari et al., 2016), will reduce the energy of computation even further. ",
+        "bbox": [
+            173,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martín Abadi et al. Tensorflow: A system for large-scale machine learning. In Proceedings of the 12th USENIX Conference on Operating Systems Design and Implementation (OSDI), 2016. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jorge Albericio, Patrick Judd, Tayler Hetherington, Tor Aamodt, Natalie Enright Jerger, and Andreas Moshovos. Cnvlutin: Ineffectual-neuron-free Deep Neural Network Computing. In Proceedings of the 43rd International Symposium on Computer Architecture (ISCA), 2016. ",
+        "bbox": [
+            174,
+            162,
+            823,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sharan Chetlur, Cliff Woolley, Philippe Vandermersch, Jonathan Cohen, John Tran, Bryan Catanzaro, and Evan Shelhamer. cuDNN: Efficient primitives for deep learning. CoRR, abs/1410.0759, 2014. URL http://arxiv.org/abs/1410.0759. ",
+        "bbox": [
+            176,
+            215,
+            825,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jason Cong and Bingjun Xiao. Minimizing computation in convolutional neural networks. In International Conference on Artificial Neural Networks (ICANN), pp. 281–290. Springer, 2014. ",
+        "bbox": [
+            169,
+            267,
+            823,
+            296
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In Advances in neural information processing systems (NIPS), 2015. ",
+        "bbox": [
+            173,
+            305,
+            823,
+            348
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William J. Dally. Learning both weights and connections for efficient neural networks. In Advances in neural information processing systems (NIPS), 2015. ",
+        "bbox": [
+            173,
+            357,
+            821,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A. Horowitz, and William J. Dally. EIE: Efficient inference engine on compressed deep neural network. In Proceedings of the 43rd International Symposium on Computer Architecture (ISCA), 2016a. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            439
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In International Conference on Learning Representations (ICLR), 2016b. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            489
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Babak Hassibi, David G Stork, et al. Second order derivatives for network pruning: Optimal brain surgeon. Advances in Neural Information Processing Systems (NIPS), pp. 164–164, 1993. ",
+        "bbox": [
+            174,
+            500,
+            821,
+            529
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016a. ",
+        "bbox": [
+            176,
+            537,
+            825,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision (ECCV), pp. 630–645. Springer, 2016b. ",
+        "bbox": [
+            173,
+            575,
+            823,
+            606
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yuxiang Huan, Yifan Qin, Yantian You, Lirong Zheng, and Zhuo Zou. A multiplication reduction technique with near-zero approximation for embedded learning in IoT devices. In System-on-Chip Conference (SOCC), 29th IEEE International, pp. 102–107. IEEE, 2016. ",
+        "bbox": [
+            176,
+            613,
+            825,
+            657
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            683
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems (NIPS), 2012. ",
+        "bbox": [
+            173,
+            690,
+            825,
+            719
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew Lavin. Fast algorithms for convolutional neural networks. CoRR, abs/1509.09308, 2015. URL http://arxiv.org/abs/1509.09308. ",
+        "bbox": [
+            173,
+            728,
+            825,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems (NIPS), pp. 598–605, 1990. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            834
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sheng R. Li, Jongsoo Park, and Ping Tak Peter Tang. Enabling sparse Winograd convolution by native pruning. CoRR, abs/1702.08597, 2017. URL http://arxiv.org/abs/1702.08597. ",
+        "bbox": [
+            173,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhouhan Lin, Matthieu Courbariaux, Roland Memisevic, and Yoshua Bengio. Neural networks with few multiplications. In Proceedings of International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xingyu Liu, Song Han, Huizi Mao, and William J. Dally. Efficient sparse-winograd convolutional neural networks. International Conference on Learning Representations (ICLR) Workshop, 2017. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nagadomi. Code for kaggle-cifar10 competition. 5th place. https://github.com/ nagadomi/kaggle-cifar10-torch7, 2014. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. XNOR-Net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision (ECCV), 2016. ",
+        "bbox": [
+            174,
+            178,
+            823,
+            220
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 2015. ",
+        "bbox": [
+            173,
+            228,
+            826,
+            285
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In Proceedings of International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            174,
+            294,
+            826,
+            335
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. International Conference on Learning Representations (ICLR) Workshop, 2015. ",
+        "bbox": [
+            173,
+            344,
+            825,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1–9, June 2015. ",
+        "bbox": [
+            174,
+            396,
+            826,
+            439
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shmuel Winograd. Arithmetic complexity of computations, volume 33. Siam, 1980. ",
+        "bbox": [
+            174,
+            448,
+            722,
+            463
+        ],
+        "page_idx": 9
+    }
+]

parse/train/enoVQWLsfyL/enoVQWLsfyL.md

@@ -0,0 +1,319 @@
+# VIEWMAKER NETWORKS: LEARNING VIEWS FOR UNSUPERVISED REPRESENTATION LEARNING
+
+Alex Tamkin, Mike Wu, Noah Goodman   
+Department of Computer Science   
+Stanford University   
+Stanford, CA 94305, USA   
+{atamkin, wumike, ngoodman}@stanford.edu
+
+# ABSTRACT
+
+Many recent methods for unsupervised representation learning train models to be invariant to different “views,” or distorted versions of an input. However, designing these views requires considerable trial and error by human experts, hindering widespread adoption of unsupervised representation learning methods across domains and modalities. To address this, we propose viewmaker networks: generative models that learn to produce useful views from a given input. Viewmakers are stochastic bounded adversaries: they produce views by generating and then adding an $\ell _ { p }$ -bounded perturbation to the input, and are trained adversarially with respect to the main encoder network. Remarkably, when pretraining on CIFAR-10, our learned views enable comparable transfer accuracy to the welltuned SimCLR augmentations—despite not including transformations like cropping or color jitter. Furthermore, our learned views significantly outperform baseline augmentations on speech recordings $^ { + 9 }$ points on average) and wearable sensor data $+ 1 7$ points on average). Viewmaker views can also be combined with handcrafted views: they improve robustness to common image corruptions and can increase transfer performance in cases where handcrafted views are less explored. These results suggest that viewmakers may provide a path towards more general representation learning algorithms—reducing the domain expertise and effort needed to pretrain on a much wider set of domains. Code is available at https://github.com/alextamkin/viewmaker.
+
+![](images/f0ad74b113dfb1890cf9bad006c8d5ce9860843ba7f9fbb220c81b43547e6f72.jpg)  
+Figure 1: Viewmaker networks generate complex and diverse input-dependent views for unsupervised learning. Examples shown are for CIFAR-10. Original image in center with pink border.
+
+# 1 INTRODUCTION
+
+Unsupervised representation learning has made significant recent strides, including in computer vision, where view-based methods have enabled strong performance on benchmark tasks (Wu et al., 2018; Oord et al., 2018; Bachman et al., 2019; Zhuang et al., 2019; Misra & Maaten, 2020; He et al., 2020; Chen et al., 2020a). Views here refer to human-defined data transformations, which target capabilities or invariances thought to be useful for transfer tasks. In particular, in contrastive learning of visual representations, models are trained to maximize the mutual information between different views of an image, including crops, blurs, noise, and changes to color and contrast (Bachman et al.,
+
+2019; Chen et al., 2020a). Much work has investigated the space of possible image views (and their compositions) and understanding their effects on transfer learning (Chen et al., 2020a; Wu et al., 2020; Tian et al., 2019; Purushwalkam & Gupta, 2020)
+
+The fact that views must be hand designed is a significant limitation. While views for image classification have been refined over many years, new views must be developed from scratch for new modalities. Making matters worse, even within a modality, different domains may have different optimal views (Purushwalkam & Gupta, $\textcircled { 2 0 2 0 }$ . Previous studies have investigated the properties of good views through the lens of mutual information (Tian et al., 2020; Wu et al., 2020), but a broadly-applicable approach for learning views remains unstudied.
+
+In this work, we present a general method for learning diverse and useful views for contrastive learning. Rather than searching through possible compositions of existing view functions $\mathbb { ( C u b u k ) }$ et al., 2018; Lim et al., 2019), which may not be available for many modalities, our approach produces views with a generative model, called the viewmaker network, trained jointly with the encoder network. This flexibility enables learning a broad set of possible view functions, including input-dependent views, without resorting to hand-crafting or expert domain knowledge. The viewmaker network is trained adversarially to create views which increase the contrastive loss of the encoder network. Rather than directly outputting views for an image, the viewmaker instead outputs a stochastic perturbation that is added to the input. This perturbation is projected onto an $\ell _ { p }$ sphere, controlling the effective strength of the view, similar to methods in adversarial robustness. This constrained adversarial training method enables the model to reduce the mutual information between different views while preserving useful input features for the encoder to learn from.
+
+In summary, we contribute:
+
+1. Viewmaker networks: to our knowledge the first modality-agnostic method to learn views for unsupervised representation learning   
+2. On image data, where expert-designed views have been extensively optimized, our viewmaker-models achieve comparable transfer performance to state of the art contrastive methods while being more robust to common corruptions.   
+3. On speech data, our method significantly outperforms existing human-defined views on a range of speech recognition transfer tasks.   
+4. On time-series data from wearable sensors, our model significantly outperforms baseline views on the task of human activity recognition (e.g., cycling, running, jumping rope).
+
+# 2 RELATED WORK
+
+Unsupervised representation learning Learning useful representations from unlabeled data is a fundamental problem in machine learning (Pan & Yang, 2009; Bengio et al., 2013). A recently successful framework for unsupervised representation learning for images involves training a model to be invariant to various data transformations (Bachman et al., 2019; Misra & Maaten, 2020), although the idea has much earlier roots (Becker & Hinton, 1992; Hadsell et al., 2006; Dosovitskiy et al., 2014). This idea has been expanded by a number of contrastive learning approaches which push embeddings of different views, or transformed inputs, closer together, while pushing other pairs apart (Tian et al., 2019; He et al., 2020; Chen et al., $\boxed { 2 0 2 0 \mathrm { a } } \boxed { \mathrm { b } } \boxed { \mathrm { c } }$ , as well as non-contrastive approaches which do not explicitly push apart unmatched views (Grill et al., 2020; Caron et al., 2020) Related but more limited setups have been explored for speech, where data augmentation strategies are less explored (Oord et al., 2018; Kharitonov et al., 2020).
+
+Understanding and designing views Several works have studied the role of views in contrastive learning, including from a mutual-information perspective $\mathrm { ( W u ~ e t ~ a l . } , \mathbb { Z } 0 2 0 )$ , in relation to specific transfer tasks $( \overbrace { [ 1 \mathrm { a n ~ e t ~ a l . } ] } ^ { \sim } , \overbrace { 2 0 1 9 } )$ , with respect to different kinds of invariances $( \mathbf { \mathbb { P u r u s h w a l k a m \& } } ]$ $\overline { { \mathrm { G u p t a } } } , \overline { { \vert 2 0 2 0 \vert } }$ , or via careful empirical studies $\mathrm { ( } \mathrm { C h e n \ e t \ a l . } \mathrm { , } \mathrm { 2 0 2 0 a } \mathrm { ) }$ . Outside of a contrastive learning framework, Gontijo-Lopes et al. $\underline { { ( 2 0 2 0 ) } }$ study how data augmentation aids generalization in vision models. Much work has explored different handcrafted data augmentation methods for supervised learning of images (Hendrycks et al., 2020; Lopes et al., 2019; Perez & Wang, 2017; Yun et al., 2019; Zhang et al., 2017), speech (Park et al., 2019; Kovacs et al., 2017; T ´ oth et al., 2018; Kharitonov et al., ´ 2020), or in feature space (DeVries & Taylor, 2017).
+
+![](images/ae184fa82ff4181505f881e74ed5776fe0a9ac2a0be921111a116fa38e2f1f19.jpg)  
+Figure 2: Diagram of our method. The viewmaker network is trained to produce stochastic adversarial views restricted to an $\ell _ { 1 }$ sphere around the input.
+
+Adversarial methods Our work is related to and inspired by work on adversarial methods, including the $\ell _ { p }$ balls studied in adversarial robustness (Szegedy et al., 2013; Madry et al., 2017; Raghunathan et al., 2018) and training networks with adversarial objectives (Goodfellow et al., 2014; Xiao et al., $\overline { { \boxed { 2 0 1 8 } } }$ . Our work is also connected to the vicinal risk minimization principle (Chapelle et al., 2001) and can be interpreted as producing amortized virtual adversarial examples (Miyato et al., $\boxed { 2 0 1 8 }$ . Previous adversarial view-based pretraining methods add adversarial noise on top of existing handcrafted views $\mathrm { ( K i m ~ e t ~ a l . ) } \mathrm { [ 2 0 2 0 ] } $ or require access to specific transfer tasks during pretraining (Tian et al., 2020). In contrast, our method is more general: it is neither specialized to a particular downstream task, nor requires neither human-defined view families. Outside of multi-view learning paradigms, adversarial methods have also seen use for representation learning in GANs (Donahue et al., 2016; Donahue & Simonyan, 2019) or in choosing harder negative samples $\mathrm { \textregistered B o s e ~ e t ~ a l . } \mathrm { \textnot { B } } ^ { \mathrm { \scriptsize { B } } \mathrm { { o } } 1 8 \mathrm { \textmu } }$ as well as for data augmentation (Antoniou et al., 2017; Volpi et al., 2018; Bowles et al., 2018). Adversarial networks that perturb inputs have also been investigated to improve GAN training (Sajjadi et al., 2018) and to remove “shortcut” features (e.g., watermarks) for self-supervised pretext tasks (Minderer et al., 2020).
+
+Learning views Outside of adversarial approaches, our work is related to other studies that seek to learn data augmentation strategies by composing existing human-designed augmentations (Ratner et al., 2017; Cubuk et al., 2018; Zhang et al., 2019; Ho et al., 2019; Lim et al., 2019; Cubuk et al., 2020) or by modeling variations specific to the data distribution (Tran et al., 2017; Wong & Kolter, 2020). By contrast, our method requires no human-defined view functions, does not require first pretraining a generative model, and can generate perturbations beyond naturally-occurring variation observed in the training data (e.g. brightness or contrast), potentially conferring robustness benefits, as we explore in Section 4.3.
+
+# 3 METHOD
+
+In contrastive learning, the objective is to push embeddings of positive views (derived from the same input) close together, while pushing away embeddings of negative views (derived from different inputs). We focus mainly on the simple, yet performant, SimCLR contrastive learning algorithm $\mathbb { C } \mathrm { h e n }$ $\boxed { \mathrm { e t ~ a l . } } \boxed { 2 0 2 0 \mathrm { a } }$ , but we also consider a memory bank-based algorithm $\mathtt { ( W u ~ e t ~ a l . } ] \mathtt { \tilde { 2 } O l 8 } $ in Section 4. As our method is agnostic to the specific pretraining loss used, it is naturally compatible with other view-based algorithms such as MoCo $\pmb { \mathrm { ( f l e ~ e t ~ a l . ) } } \widetilde { \pmb { 2 0 2 0 } } \}$ , BYOL $\mathrm { ( } \overline { { \mathrm { G r i l l ~ e t ~ a l . } } } \mathrm { , } \overline { { 2 0 2 0 } } \mathrm { ) }$ , and SwAV (Caron et al., 2020) by similarly substituting the data transformation pipeline with a viewmaker network.
+
+Formally, given a batch of $N$ pairs of positive views $( i , j )$ the SimCLR loss is
+
+$$
+{ \mathcal { L } } = { \frac { 1 } { 2 N } } \sum _ { k = 1 } ^ { N } [ \ell ( 2 k - 1 , 2 k ) + \ell ( 2 k , 2 k - 1 ) ] { \mathrm { ~ w h e r e ~ } } \ell ( i , j ) = - \log { \frac { \exp ( s _ { i , j } / \tau ) } { \sum _ { k = 1 } ^ { 2 N } { \mathbb { 1 } } _ { [ k \neq i ] } \exp ( s _ { i , k } / \tau ) } }
+$$
+
+and $s _ { a , b }$ is the cosine similarity of the embeddings of views $a$ and $b$ .
+
+We generate views by perturbing examples with a viewmaker network $V$ , trained jointly with the main encoder network $M$ . There are three attributes desirable for useful perturbations, each of which motivates an aspect of our method:
+
+1. Challenging: The perturbations should be complex and strong enough that an encoder must develop useful representations to perform the self-supervised task. We accomplish this by generating perturbations with a neural network that is trained adversarially to increase the loss of the encoder network. Specifically, we use a neural network that ingests the input $X$ and outputs a view $X + V ( X )$ .
+
+2. Faithful: The perturbations must not make the encoder task impossible, being so strong that they destroy all features of the input. For example, perturbations should not be able to zero out the input, making learning impossible. We accomplish this by constraining the perturbations to an $\ell _ { p }$ sphere around the original input. $\ell _ { p }$ constraints are common in the adversarial robustness literature where perturbations are expected to be indistinguishable. In our experiments, we find the best results are achieved with an $\ell _ { 1 }$ sphere, which grants the viewmaker a distortion budget that it can spend on a small perturbation for a large part of the input or a more extreme perturbation for a smaller portion.
+
+3. Stochastic: The method should be able to generate a variety of perturbations for a single input, as the encoder objective requires contrasting two different views of an input against each other. To do this, we inject random noise into the viewmaker, such that the model can learn a stochastic function that produces a different perturbed input each forward pass.
+
+Figure $\bigstar$ summarizes our method. The encoder and viewmaker are optimized in alternating steps to minimize and maximize $\mathcal { L }$ , respectively. We use an image-to-image neural network as our viewmaker network, with an architecture adapted from work on style transfer $\left( \mathrm { J o h n s o n e t a l . } \right) \left[ \mathrm { 2 0 1 6 } \right)$ See the Appendix for more details. This network ingests the input image and outputs a perturbation that is constrained to an $\ell _ { 1 }$ sphere. The sphere’s radius is determined by the volume of the input tensor times a hyperparameter $\epsilon$ , the distortion budget, which determines the strength of the applied perturbation. This perturbation is added to the input image and optionally clamped in the case of images to ensure all pixels are in $[ 0 , 1 ]$ . Algorithm 1 describes this process precisely.
+
+Input: Viewmaker network $V$ , $C \times W \times H$ image X, $\ell _ { 1 }$ distortion budget ✏, noise    
+Output: Perturbed $C \times W \times H$ image $X$   
+$P  V ( X , \delta ) \ / ,$ / generate perturbation   
+$\begin{array} { r } { P \gets \frac { \epsilon C W H } { | P | _ { 1 } } P \gets | / \langle } \end{array}$ project to $\ell _ { 1 }$ sphere   
+$X  X + P / /$ apply perturbation   
+$X \gets \mathrm { c l a m p } ( X , 0 , 1 ) / /$ clamp (images only)
+
+# 4 IMAGES
+
+We begin by applying the viewmaker to contrastive learning for images. In addition to SimCLR (Chen et al., 2020a), we also consider a memory bank-based instance discrimination framework (Wu et al., 2018, henceforth InstDisc).
+
+We pretrain ResNet-18 $\mathbb { ( H e \ e t \ a l . ) } \mathbb { 2 0 1 5 } )$ models on CIFAR-10 (Krizhevsky, 2009) for 200 epochs with a batch size of 256. We train a viewmaker-encoder system with a distortion budget of $\epsilon = 0 . 0 5$ . We tried distortion budgets $\epsilon \in \lbrace 0 . 1 , 0 . 0 5 , 0 . 0 2 \rbrace$ and found 0.05 to work best; however, we anticipate that further tuning would yield additional gains. As we can see in Figure $^ { 1 , }$ the learned views are diverse, consisting of qualitatively different kinds of perturbations and affecting different parts of the input. We compare the resulting encoder representations with a model trained with the expert views used for SimCLR, comprised of many human-defined transformations targeting different kinds of invariances useful for image classification: cropping-and-resizing, blurring, horizontal flipping, color dropping, and shifts in brightness, contrast, saturation, and hue (Chen et al., 2020a).
+
+# 4.1 TRANSFER RESULTS ON IMAGE CLASSIFICATION TASKS
+
+We evaluate our models on CIFAR-10, as well as eleven transfer tasks including MetaDataset $\underline { { ( \Pi \dot { } \mathbf { i } ) } }$ antafillou et al., 2019), MSCOCO (Lin et al., 2014), MNIST (LeCun et al., 1998), and FashionMNIST (Xiao et al., 2017). We use the standard linear evaluation protocol, which trains a logistic regression on top of representations from a frozen model. We apply the same views as in pretraining, freezing the final viewmaker when using learned views; we apply no views during validation. Table $\bigtriangledown$ shows our results, indicating comparable overall performance with SimCLR and InstDisc, all without the use of human-crafted view functions. This performance is noteworthy as our $\ell _ { 1 }$ views cannot implement cropping-and-rescaling, which was shown to be the most important view function in Chen et al. $\textcircled { 1 2 0 2 0 2 }$ . We speculate that the ability of the viewmaker to implement partial masking of an image may enable a similar kind of spatial information ablation as cropping.
+
+Table 1: Our learned views (Ours) enable comparable transfer performance to expert views (Expt) on CIFAR-10. Suite of transfer tasks using pretrained representations from CIFAR-10 for both the SimCLR and InstDisc pretraining setups. Numbers are percent accuracy with the exception of CelebA which is F1. FaMNIST stands for FashionMNIST.   
+
+<table><tr><td></td><td colspan="2">SimCLR</td><td colspan="2">InstDisc</td><td></td><td colspan="2">SimCLR</td><td colspan="2">InstDisc</td></tr><tr><td>Dataset</td><td>Expt</td><td>Ours</td><td>Expt</td><td>Ours</td><td>Dataset</td><td>Expt</td><td>Ours</td><td>Expt</td><td>Ours</td></tr><tr><td>CIFAR-10</td><td>86.2</td><td>84.5</td><td>82.4</td><td>80.1</td><td>MNIST</td><td>97.1</td><td>98.7</td><td>98.7</td><td>98.9</td></tr><tr><td>MSCOCO</td><td>49.9</td><td>50.4</td><td>48.6</td><td>50.2</td><td>FaMNIST</td><td>88.3</td><td>91.5</td><td>89.2</td><td>91.4</td></tr><tr><td>CelebA (F1)</td><td>51.0</td><td>51.8</td><td>57.0</td><td>53.7</td><td>CUBirds</td><td>11.2</td><td>8.7</td><td>13.7</td><td>9.4</td></tr><tr><td>LSUN</td><td>56.2</td><td>55.0</td><td>56.0</td><td>55.6</td><td>VGGFlower</td><td>53.3</td><td>53.6</td><td>61.5</td><td>54.8</td></tr><tr><td>Aircraft</td><td>32.5</td><td>31.7</td><td>37.7</td><td>33.5</td><td>TrafficSign</td><td>96.6</td><td>94.9</td><td>98.9</td><td>94.3</td></tr><tr><td>DTD</td><td>30.4</td><td>28.8</td><td>29.8</td><td>29.8</td><td>Fungi</td><td>2.2</td><td>2.0</td><td>2.6</td><td>2.1</td></tr></table>
+
+# 4.1.1 COMPARISON TO RANDOM $\ell _ { 1 }$ NOISE
+
+Is random noise sufficient to produce domain-agnostic views? To assess how important adversarial training is to the quality of the learned representations, we perform an ablation where we generate views by adding Gaussian noise normalized to the same $\epsilon = 0 . 0 5$ budget as used in the previous section. Transfer accuracy on CIFAR-10 is significantly hurt by this ablation, reaching $5 2 . 0 1 \%$ for a SimCLR model trained with random noise views compared to $\mathbf { 8 4 . 5 0 \% }$ for our method, demonstrating the importance of adversarial training to our method.
+
+# 4.1.2 THE IMPORTANCE OF INTER-PATCH MUTUAL INFORMATION AND CROPPING VIEWS
+
+Cropping-and-resizing has been identified as a crucial view function when pretraining on ImageNet (Chen et al., 2020a). However, what properties of a pretraining dataset make cropping useful? We hypothesize that such a dataset must have images whose patches have high mutual information. In other words, there must be some way for the model to identify that different patches of the same image come from the same image. While this may be true for many object or scene recognition datasets, it may be false for other important pretraining datasets, including medical or satellite imagery, where features of interest are isolated to particular parts of the image.
+
+To investigate this hypothesis, we modify the CIFAR-10 dataset to reduce the inter-patch mutual information by replacing each 16x16 corner of the image with the corner from another image in the training dataset (see Figure $\perp$ for an example). Thus, random crops on this dataset, which we call CIFAR-10-Corners, will often contain completely unrelated information. When pretrained on CIFAR-10-Corners, expert views achieve $6 3 . 3 \%$ linear evaluation accuracy on the original CIFAR10 dataset, while viewmaker views achieve $6 8 . 8 \%$ . This gap suggests that viewmaker views are less reliant on inter-patch mutual information than the expert views.
+
+# 4.2 COMBINING VIEWMAKER AND HANDCRAFTED VIEWS
+
+Can viewmakers improve performance in cases where some useful handcrafted views have already been identified? $\boxed { \mathrm { C h e n ~ e t ~ a l . } } \textcircled { 2 0 2 0 a } )$ show that views produced through cropping are significantly improved by a suite of color-based augmentations, which they argue prevents the network from relying solely on color statistics to perform the contrastive task. Here, we show that viewmaker networks also enable strong gains when added on top of cropping and horizontal flipping views when pretraining on CIFAR-10—without any domain-specific knowledge. Alone, this subset of
+
+![](images/cd65f0b26e7ed3d0124667590f6c3e4dacc67ceb47f41bcbf95794567d036736.jpg)  
+Figure 3: Our learned views are still able to yield useful information even when the inter-patch mutual information in a dataset is low, as in Figure 3b.
+
+<table><tr><td>Views</td><td>Clean</td><td>Corrupted</td><td>Diff</td></tr><tr><td>Ours</td><td>84.5</td><td>71.4</td><td>-13.1</td></tr><tr><td>SimCLR*</td><td>86.2</td><td>77.1</td><td>-9.1</td></tr><tr><td>Combined*</td><td>86.3</td><td>79.8</td><td>-6.5</td></tr></table>
+
+(a) Accuracy on CIFAR-10 and CIFAR-10-C. ⇤Overlap with CIFAR-10-C corruptions.
+
+![](images/7256165d389e3e07b022a12e6ea06b8a2ae93227c6369be26f829c35cf64be0b.jpg)  
+(b) Accuracy gain on CIFAR-10-C by from adding our learned views atop expert views.
+
+Figure 4: Performance of different views on CIFAR-10-C corruptions. Our learned views enable solid performance in the face of unseen corruptions despite not explicitly including any blurring, contrast, or brightness transformations during training, unlike the expert views. Adding our learned views on top of SimCLR yields additional gains in robust accuracy, especially on different kinds of noise corruptions and glass blurring.
+
+handcrafted augmentations achieves $7 3 . 2 \%$ linear evaluation accuracy on CIFAR-10. Combining these views with learned viewmaker perturbations $\epsilon = 0 . 0 5$ ) achieves $8 3 . 1 \% \big \Updownarrow$ This suggests that viewmakers can significantly improve representation learning even in cases where some domainspecific views have already been developed.
+
+# 4.3 ROBUSTNESS TO COMMON CORRUPTIONS
+
+Image classification systems should behave robustly even when the data distribution is slightly different from that seen during training. Does using a viewmaker improve robustness against common types of corruptions not experienced at train time? To answer this, we evaluate both learned views, expert views, and their composition on the CIFAR-10-C dataset (Hendrycks & Dietterich, 2019) which assesses robustness to corruptions like snow, pixelation, and blurring. In this setting, corruptions are applied only at test time, evaluating whether the classification system is robust to some types of corruptions to which humans are robust.
+
+When considering methods in isolation, SimCLR augmentations result in less of an accuracy drop from clean to corrupted data compared to our learned views, as shown in Table $4 \mathrm { a } .$ This gap is expected, as the expert views overlap significantly with the CIFAR-10-C corruptions: both include blurring, brightness, and contrast transformations. Interestingly, however, when we train a viewmaker network while also applying expert augmentations (“Combined,” Table $\mathrm { 4 a ) }$ , we can further improve the robust accuracy, with notable gains on noise and glass blur corruptions (Figure $\textcircled { 4 6 }$ This is noteworthy, as our learned views have no explicit overlap with the CIFAR-10-C corruptions, unlike the expert augmentations $\cdot ^ { 2 }$ In the Combined setting, we use a distortion budget of $\epsilon = 0 . 0 1$ , which we find works better than $\epsilon = 0 . 0 5$ , likely because combining the two augmentations at their full strength would make the learning task too difficult.
+
+Table 2: Our learned views significantly outperform existing views for speech transfer tasks. Linear evaluation accuracy for SimCLR models trained on LibriSpeech. Left: ResNet- $1 8 +$ Librispeech 100 hour, Right: ResNet- $5 0 +$ Librispeech $9 6 0 \mathrm { { h r } }$ . “Time” refers to view functions applied in the time domain (Kharitonov et al., $\boxed { 2 0 2 0 }$ , while “Spec.” refers to view functions applied directly to the spectrogram (Park et al., 2019). 0.05 and 0.1 denote viewmaker distortion bounds $\epsilon$ .   
+
+<table><tr><td rowspan="2">ResNet-18,100hr</td><td colspan="2">Expert</td><td colspan="2">Ours (ε)</td></tr><tr><td>Time</td><td>Spec.</td><td>0.05</td><td>0.1</td></tr><tr><td>LibriSpeech Sp. ID</td><td>97.1</td><td>91.6</td><td>88.3</td><td>84.0</td></tr><tr><td>VoxCeleb1 Sp. ID</td><td>5.7</td><td>7.8</td><td>12.1</td><td>9.1</td></tr><tr><td>AudioMNIST</td><td>31.7</td><td>63.9</td><td>93.3</td><td>87.9</td></tr><tr><td>Google Commands</td><td>27.1</td><td>31.9</td><td>47.4</td><td>41.6</td></tr><tr><td>Fluent Actions</td><td>29.4</td><td>32.0</td><td>41.6</td><td>37.9</td></tr><tr><td>Fluent Objects</td><td>37.1</td><td>40.3</td><td>47.6</td><td>47.6</td></tr><tr><td>Fluent Locations</td><td>59.7</td><td>63.3</td><td>66.5</td><td>68.3</td></tr></table>
+
+<table><tr><td>ResNet-50,960hr</td><td>Spec.</td><td>0.05</td></tr><tr><td>LibriSpeech Sp. ID</td><td>95.9</td><td>90.0</td></tr><tr><td>VoxCeleb1 Sp.ID AudioMNIST</td><td>8.6</td><td>10.7</td></tr><tr><td></td><td>80.2</td><td>88.0</td></tr><tr><td>Google Commands</td><td>28.3</td><td>32.6</td></tr><tr><td>Fluent Actions</td><td>30.5</td><td>42.5</td></tr><tr><td>Fluent Objects</td><td>36.2</td><td>50.8</td></tr><tr><td>Fluent Locations</td><td>62.0</td><td>68.9</td></tr></table>
+
+These results suggest that learned views are a promising avenue for improving robustness in selfsupervised learning models.
+
+# 5 SPEECH
+
+Representation learning on speech data is an emerging and important research area, given the large amount of available unlabeled data and the increasing prevalence of speech-based human-computer interaction (Latif et al., 2020). However, compared to images, there is considerably less work on self-supervised learning and data augmentations for speech data. Thus, it is a compelling setting to investigate whether viewmaker augmentations are broadly applicable across modalities.
+
+# 5.1 SELF-SUPERVISED LEARNING SETUP
+
+We adapt the contrastive learning setup from SimCLR (Chen et al., 2020a). Training proceeds largely the same as for images, but the inputs are 2D log mel spectrograms. We consider both view functions applied in the time-domain before the STFT, including noise, reverb, pitch shifts, and changes in loudness (Kharitonov et al., $\boxed { 2 0 2 0 }$ , as well as spectral views, which involve masking or noising different parts of the spectrogram (Park et al., 2019). To generate learned views, we pass the spectrogram as input to the viewmaker. We normalize the spectrogram to mean zero and variance one before passing it through the viewmaker, and do not clamp the resulting perturbed spectrogram. See the Appendix for more details. We train on the Librispeech dataset (Panayotov et al., 2015) for 200 epochs, and display some examples of learned views in the Appendix.
+
+# 5.2 SPEECH CLASSIFICATION RESULTS
+
+We evaluate on three speech classification datasets: Fluent Speech Commands (Lugosch et al., $\bigstar$ Google Speech Commands $\left( \mathrm { W a r d e n } \right) , \left[ 2 0 1 8 \right)$ , and spoken digit classification (Becker et al., 2018), as well as speaker classification on VoxCeleb $( \mathrm { I N a g r a n i e t a l . } \mathrm { \bar { 2 0 1 7 } } )$ and Librispeech (Panayotov et al., $\boxed { 2 0 1 5 }$ , all using the linear evaluation protocol for 100 epochs. In Table $\bigtriangledown$ we report results with both the same distortion budget $\epsilon = 0 . 0 5$ as in the image domain, as well as a larger $\epsilon = 0 . 1$ , for comparison. Both versions significantly outperform the preexisting waveform and spectral augmentations, with a $+ 9$ percentage point improvement on average for the ResNet-18 $\acute { \epsilon } = 0 . 0 5 )$ ) viewmaker model over the best expert views. The gains for real-world tasks such as command identification are compelling. One notable exception is the task of LibriSpeech speaker identification. Since LibriSpeech is the same dataset the model was pretrained on, and this effect is not replicated on VoxCeleb1, the other speaker classification dataset, we suspect the model may be picking up on dataset-specific artifacts (e.g. background noise, microphone type) which may make the speaker
+
+Table 3: Our learned views significantly outperform existing views for activity recognition on wearable sensor data. Our method learns superior representations across a large range of distortion budgets $\epsilon$ , although budgets that are too strong prevent learning. Linear evaluation accuracy for ResNet18 models trained on Pamap2 with SimCLR. “Spectral” refers to view functions applied directly to the spectrogram (Park et al., 2019).   
+
+<table><tr><td></td><td colspan="2">Spectral</td><td colspan="5">Ours (e)</td></tr><tr><td>Dataset</td><td>With Noise</td><td>Without Noise</td><td>0.02</td><td>0.05</td><td>0.2</td><td>0.5</td><td>2.0</td></tr><tr><td>Pamap2</td><td>71.0</td><td>74.6</td><td>83.0</td><td>87.4</td><td>88.6</td><td>91.3</td><td>9.1</td></tr></table>
+
+ID task artificially easier. An interesting possibility is that the worse performance of viewmaker views may result from the model being able to identify and ablate such spurious correlations in the spectrograms.
+
+# 6 WEARABLE SENSOR DATA
+
+To further validate that our method for learning views is useful across different modalities, we consider time-series data from wearable sensors. Wearable sensor data has a broad range of applications, including health care, entertainment, and education (Lara & Labrador, 2012). We specifically consider whether viewmaker views improve representation learning for the task of human activity recognition (HAR), for example identifying whether a user is jumping rope, running, or cycling.
+
+# 6.1 SELF-SUPERVISED LEARNING SETUP
+
+We consider the Pamap2 dataset (Reiss & Stricker, 2012), a dataset of 12 different activities performed by 9 participants. Each activity contains 52 different time series, including heart rate, accelerometer, gyroscope, and magnetometer data collected from sensors on the ankle, hand, and chest (all sampled at $1 0 0 \mathrm { H z }$ , except heart rate, which is sampled at approximately 9Hz). We linearly interpolate missing data, then take random 10s windows from subject recordings, using the same train/validation/test splits as prior work $( \mathbb { M o y a R u e d a e t a l . } ) \lbrack 2 0 1 8 \rbrack )$ . To create inputs for our model, we generate a multi-channel image composed of one 32x32 log spectrogram for each sensor timeseries window. Unlike speech data, we do not use the mel scale when generating the spectrogram. We then normalize the training and validation datasets by subtracting the mean and then dividing by the standard deviation of the training dataset.
+
+We train with both our learned views and the spectral views (Park et al., 2019) that were most successful in the speech domain (for multi-channel spectral masking, we apply the same randomly chosen mask to all channels). We also compare against a variant of these views with spectrogram noise removed, which we find improves this baseline’s performance.
+
+# 6.2 SENSOR-BASED ACTIVITY RECOGNITION RESULTS
+
+We train a linear classifier on the frozen encoder representations for 50 epochs, reporting accuracy on the validation set. We sample 10k examples for each training epoch and 50k examples for validation. Our views significantly outperform spectral masking by 12.8 percentage points when using the same $\epsilon = 0 . 0 5$ as image and speech, and by 16.7 points when using a larger $\epsilon = 0 . 5$ (Table 3). We also find that a broad range of distortion budgets produces useful representations, although overly-aggressive budgets prevent learning (Table $\textcircled { 3 }$ . These results provide further evidence that our method for learning views has broad applicability across different domains.
+
+# 6.3 SEMI-SUPERVISED EXPERIMENTS
+
+An especially important setting for self-supervised learning is domains where labeled data is scarce or costly to acquire. Here, we show that our method can enable strong performance when labels for only a single participant (Participant 1) out of seven are available. We compare simple supervised learning on Participant 1’s labels against linear evaluation of our best pretrained model, which was trained on unlabeled data from all 7 participants. The model architectures and training procedures are otherwise identical to the previous section. As Figure $\sharp$ shows, pretraining with our method on unlabeled data enables significant gains over pure supervised learning when data is scarce, and even slightly outperforms the hand-crafted views trained on all 7 participants (cf. Table 3).
+
+Table 4: Our method enables superior results in a semi-supervised setting where labels for data from only one participant are available. Validation accuracy for activity recognition on Pamap2. Supervised Learning refers to training a randomly initialized model on the labeled data until convergence. Pretrain & Transfer refers to training a linear classifier off of the best pretrained model above. 1 or 7 Participants refers to the number of participants comprising the training set.   
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="2">Supervised Learning</td><td colspan="2">Pretrain (Ours)&amp; Transfer</td></tr><tr><td>1 Participant</td><td>7 Participants</td><td>1 Participant</td><td>7 Participants</td></tr><tr><td>Pamap2</td><td>58.3</td><td>97.1</td><td>75.1</td><td>91.3</td></tr></table>
+
+# 7 CONCLUSION
+
+We introduce a method for learning views for unsupervised learning, demonstrating its effectiveness through strong performance on image, speech, and wearable sensor modalities. Our novel generative model—viewmaker networks—enables us to efficiently learn views as part of the representation learning process, as opposed to relying on domain-specific knowledge or costly trial and error. There are many interesting avenues for future work. For example, while the $\ell _ { 1 }$ constraint is simple by design, there may be other kinds of constraints that enable richer spaces of views and better performance. In addition, viewmaker networks may find use in supervised learning, for the purposes of data augmentation or improving robustness. Finally, it is interesting to consider what happens as the viewmaker networks increase in size: do we see performance gains or robustnessaccuracy trade-offs (Raghunathan et al., 2019)? Ultimately, our work is a step towards more general self-supervised algorithms capable of pretraining on arbitrary data and domains.
+
+# ACKNOWLEDGEMENTS
+
+We would like to thank Dan Yamins, Chengxu Zhuang, Shyamal Buch, Jesse Mu, Jared Davis, Aditi Raghunathan, Pranav Rajpurkar, Margalit Glasgow, and Jesse Michel for useful discussions and comments on drafts. AT is supported by an Open Phil AI Fellowship. MW is supported by the Stanford Interdisciplinary Graduate Fellowship as the Karr Family Fellow.
+
+# REFERENCES
+
+Nasir Ahmed, T Natarajan, and Kamisetty R Rao. Discrete cosine transform. IEEE transactions on Computers, 100(1):90–93, 1974.
+
+Antreas Antoniou, Amos Storkey, and Harrison Edwards. Data augmentation generative adversarial networks, 2017.
+
+Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In Advances in Neural Information Processing Systems, pp. 15535–15545, 2019.
+
+Suzanna Becker and Geoffrey E Hinton. Self-organizing neural network that discovers surfaces in random-dot stereograms. Nature, 355(6356):161–163, 1992.
+
+Soren Becker, Marcel Ackermann, Sebastian Lapuschkin, Klaus-Robert M ¨ uller, and Wojciech ¨ Samek. Interpreting and explaining deep neural networks for classification of audio signals, 2018.
+
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013.
+
+Lukas Biewald. Experiment tracking with weights and biases, 2020. URL https://www. wandb.com/. Software available from wandb.com.   
+Avishek Joey Bose, Huan Ling, and Yanshuai Cao. Adversarial contrastive estimation. arXiv preprint arXiv:1805.03642, 2018.   
+Christopher Bowles, Liang Chen, Ricardo Guerrero, Paul Bentley, Roger Gunn, Alexander Hammers, David Alexander Dickie, Maria Valdes Hern ´ andez, Joanna Wardlaw, and Daniel Rueckert. ´ Gan augmentation: Augmenting training data using generative adversarial networks, 2018.   
+Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020.   
+Olivier Chapelle, Jason Weston, Leon Bottou, and Vladimir Vapnik. Vicinal risk minimization. In ´ Advances in neural information processing systems, pp. 416–422, 2001.   
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020a.   
+Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey Hinton. Big selfsupervised models are strong semi-supervised learners. arXiv preprint arXiv:2006.10029, 2020b.   
+Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020c.   
+Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. arXiv preprint arXiv:1805.09501, 2018.   
+Ekin D Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V Le. Randaugment: Practical automated data augmentation with a reduced search space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 702–703, 2020.   
+Terrance DeVries and Graham W. Taylor. Dataset augmentation in feature space, 2017.   
+Jeff Donahue and Karen Simonyan. Large scale adversarial representation learning. In Advances in Neural Information Processing Systems, pp. 10542–10552, 2019.   
+Jeff Donahue, Philipp Krahenb ¨ uhl, and Trevor Darrell. Adversarial feature learning. ¨ arXiv preprint arXiv:1605.09782, 2016.   
+Alexey Dosovitskiy, Jost Tobias Springenberg, Martin Riedmiller, and Thomas Brox. Discriminative unsupervised feature learning with convolutional neural networks. In Advances in neural information processing systems, pp. 766–774, 2014.   
+WA Falcon. Pytorch lightning. GitHub. Note: https://github.com/PyTorchLightning/pytorchlightning, 3, 2019.   
+Raphael Gontijo-Lopes, Sylvia J Smullin, Ekin D Cubuk, and Ethan Dyer. Affinity and diversity: Quantifying mechanisms of data augmentation. arXiv preprint arXiv:2002.08973, 2020.   
+Ian Goodfellow. Nips 2016 tutorial: Generative adversarial networks. arXiv preprint arXiv:1701.00160, 2016.   
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.   
+Jean-Bastien Grill, Florian Strub, Florent Altche, Corentin Tallec, Pierre H Richemond, Elena ´ Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.
+
+Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In 2006 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’06), volume 2, pp. 1735–1742. IEEE, 2006.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition, 2015.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9729–9738, 2020.
+
+Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. arXiv preprint arXiv:1903.12261, 2019.
+
+Dan Hendrycks, Steven Basart, Norman Mu, Saurav Kadavath, Frank Wang, Evan Dorundo, Rahul Desai, Tyler Zhu, Samyak Parajuli, Mike Guo, et al. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020.
+
+Daniel Ho, Eric Liang, Xi Chen, Ion Stoica, and Pieter Abbeel. Population based augmentation: Efficient learning of augmentation policy schedules. In International Conference on Machine Learning, pp. 2731–2741. PMLR, 2019.
+
+Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In Bastian Leibe, Jiri Matas, Nicu Sebe, and Max Welling (eds.), Computer Vision – ECCV 2016, pp. 694–711, Cham, 2016. Springer International Publishing. ISBN 978-3- 319-46475-6.
+
+Eugene Kharitonov, Morgane Riviere, Gabriel Synnaeve, Lior Wolf, Pierre-Emmanuel Mazar \` e,´ Matthijs Douze, and Emmanuel Dupoux. Data augmenting contrastive learning of speech representations in the time domain. arXiv preprint arXiv:2007.00991, 2020.
+
+Minseon Kim, Jihoon Tack, and Sung Ju Hwang. Adversarial self-supervised contrastive learning, 2020.
+
+Gyorgy Kov ¨ acs, L ´ aszl ´ o T ´ oth, Dirk Van Compernolle, and Sriram Ganapathy. Increasing the ro- ´ bustness of cnn acoustic models using autoregressive moving average spectrogram features and channel dropout. Pattern Recognition Letters, 100:44–50, 2017.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Oscar D Lara and Miguel A Labrador. A survey on human activity recognition using wearable sensors. IEEE communications surveys & tutorials, 15(3):1192–1209, 2012.
+
+Siddique Latif, Rajib Rana, Sara Khalifa, Raja Jurdak, Junaid Qadir, and Bjorn W Schuller. Deep ¨ representation learning in speech processing: Challenges, recent advances, and future trends. arXiv preprint arXiv:2001.00378, 2020.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Sungbin Lim, Ildoo Kim, Taesup Kim, Chiheon Kim, and Sungwoong Kim. Fast autoaugment. In Advances in Neural Information Processing Systems, pp. 6665–6675, 2019.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European conference on computer vision, pp. 740–755. Springer, 2014.
+
+Raphael Gontijo Lopes, Dong Yin, Ben Poole, Justin Gilmer, and Ekin D Cubuk. Improving robustness without sacrificing accuracy with patch gaussian augmentation. arXiv preprint arXiv:1906.02611, 2019.
+
+Loren Lugosch, Mirco Ravanelli, Patrick Ignoto, Vikrant Singh Tomar, and Yoshua Bengio. Speech model pre-training for end-to-end spoken language understanding, 2019.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Matthias Minderer, Olivier Bachem, Neil Houlsby, and Michael Tschannen. Automatic shortcut removal for self-supervised representation learning. arXiv preprint arXiv:2002.08822, 2020.
+
+Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6707–6717, 2020.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993, 2018.
+
+Fernando Moya Rueda, Rene Grzeszick, Gernot A Fink, Sascha Feldhorst, and Michael Ten Hom- ´ pel. Convolutional neural networks for human activity recognition using body-worn sensors. In Informatics, volume 5, pp. 26. Multidisciplinary Digital Publishing Institute, 2018.
+
+Arsha Nagrani, Joon Son Chung, and Andrew Zisserman. Voxceleb: a large-scale speaker identification dataset, 2017.
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.
+
+Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345–1359, 2009.
+
+Vassil Panayotov, Guoguo Chen, Daniel Povey, and Sanjeev Khudanpur. Librispeech: An asr corpus based on public domain audio books. pp. 5206–5210, 04 2015. doi: 10.1109/ICASSP.2015. 7178964.
+
+Daniel S Park, William Chan, Yu Zhang, Chung-Cheng Chiu, Barret Zoph, Ekin D Cubuk, and Quoc V Le. Specaugment: A simple data augmentation method for automatic speech recognition. arXiv preprint arXiv:1904.08779, 2019.
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, highperformance deep learning library. In Advances in neural information processing systems, pp. 8026–8037, 2019.
+
+Luis Perez and Jason Wang. The effectiveness of data augmentation in image classification using deep learning. arXiv preprint arXiv:1712.04621, 2017.
+
+Senthil Purushwalkam and Abhinav Gupta. Demystifying contrastive self-supervised learning: Invariances, augmentations and dataset biases. arXiv preprint arXiv:2007.13916, 2020.
+
+Aditi Raghunathan, Jacob Steinhardt, and Percy Liang. Certified defenses against adversarial examples. arXiv preprint arXiv:1801.09344, 2018.
+
+Aditi Raghunathan, Sang Michael Xie, Fanny Yang, John C Duchi, and Percy Liang. Adversarial training can hurt generalization. arXiv preprint arXiv:1906.06032, 2019.
+
+Alexander J Ratner, Henry Ehrenberg, Zeshan Hussain, Jared Dunnmon, and Christopher Re. Learn- ´ ing to compose domain-specific transformations for data augmentation. In Advances in neural information processing systems, pp. 3236–3246, 2017.
+
+Attila Reiss and Didier Stricker. Introducing a new benchmarked dataset for activity monitoring. In 2012 16th International Symposium on Wearable Computers, pp. 108–109. IEEE, 2012.
+
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computerassisted intervention, pp. 234–241. Springer, 2015.
+
+Mehdi SM Sajjadi, Giambattista Parascandolo, Arash Mehrjou, and Bernhard Scholkopf. Tempered ¨ adversarial networks. arXiv preprint arXiv:1802.04374, 2018.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.
+
+Yonglong Tian, Chen Sun, Ben Poole, Dilip Krishnan, Cordelia Schmid, and Phillip Isola. What makes for good views for contrastive learning. arXiv preprint arXiv:2005.10243, 2020.
+
+Laszl ´ o T´ oth, Gy ´ orgy Kov ¨ acs, and Dirk Van Compernolle. A perceptually inspired data augmenta- ´ tion method for noise robust cnn acoustic models. In International Conference on Speech and Computer, pp. 697–706. Springer, 2018.
+
+Toan Tran, Trung Pham, Gustavo Carneiro, Lyle Palmer, and Ian Reid. A bayesian data augmentation approach for learning deep models, 2017.
+
+Eleni Triantafillou, Tyler Zhu, Vincent Dumoulin, Pascal Lamblin, Utku Evci, Kelvin Xu, Ross Goroshin, Carles Gelada, Kevin Swersky, Pierre-Antoine Manzagol, and Hugo Larochelle. Metadataset: A dataset of datasets for learning to learn from few examples, 2019.
+
+Riccardo Volpi, Hongseok Namkoong, Ozan Sener, John Duchi, Vittorio Murino, and Silvio Savarese. Generalizing to unseen domains via adversarial data augmentation, 2018.
+
+Pete Warden. Speech commands: A dataset for limited-vocabulary speech recognition, 2018.
+
+Eric Wong and J. Zico Kolter. Learning perturbation sets for robust machine learning, 2020.
+
+Mike Wu, Chengxu Zhuang, Milan Mosse, Daniel Yamins, and Noah Goodman. On mutual information in contrastive learning for visual representations. arXiv preprint arXiv:2005.13149, 2020.
+
+Zhirong Wu, Yuanjun Xiong, Stella Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance-level discrimination. arXiv preprint arXiv:1805.01978, 2018.
+
+Chaowei Xiao, Bo Li, Jun-Yan Zhu, Warren He, Mingyan Liu, and Dawn Song. Generating adversarial examples with adversarial networks, 2018.
+
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017.
+
+Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In Proceedings of the IEEE International Conference on Computer Vision, pp. 6023–6032, 2019.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017.
+
+Xinyu Zhang, Qiang Wang, Jian Zhang, and Zhao Zhong. Adversarial autoaugment. arXiv preprint arXiv:1912.11188, 2019.
+
+Chengxu Zhuang, Alex Lin Zhai, and Daniel Yamins. Local aggregation for unsupervised learning of visual embeddings. In Proceedings of the IEEE International Conference on Computer Vision, pp. 6002–6012, 2019.

parse/train/enoVQWLsfyL/enoVQWLsfyL_content_list.json

@@ -0,0 +1,1609 @@
+[
+    {
+        "type": "text",
+        "text": "VIEWMAKER NETWORKS: LEARNING VIEWS FOR UNSUPERVISED REPRESENTATION LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            769,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alex Tamkin, Mike Wu, Noah Goodman   \nDepartment of Computer Science   \nStanford University   \nStanford, CA 94305, USA   \n{atamkin, wumike, ngoodman}@stanford.edu ",
+        "bbox": [
+            184,
+            169,
+            575,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many recent methods for unsupervised representation learning train models to be invariant to different “views,” or distorted versions of an input. However, designing these views requires considerable trial and error by human experts, hindering widespread adoption of unsupervised representation learning methods across domains and modalities. To address this, we propose viewmaker networks: generative models that learn to produce useful views from a given input. Viewmakers are stochastic bounded adversaries: they produce views by generating and then adding an $\\ell _ { p }$ -bounded perturbation to the input, and are trained adversarially with respect to the main encoder network. Remarkably, when pretraining on CIFAR-10, our learned views enable comparable transfer accuracy to the welltuned SimCLR augmentations—despite not including transformations like cropping or color jitter. Furthermore, our learned views significantly outperform baseline augmentations on speech recordings $^ { + 9 }$ points on average) and wearable sensor data $+ 1 7$ points on average). Viewmaker views can also be combined with handcrafted views: they improve robustness to common image corruptions and can increase transfer performance in cases where handcrafted views are less explored. These results suggest that viewmakers may provide a path towards more general representation learning algorithms—reducing the domain expertise and effort needed to pretrain on a much wider set of domains. Code is available at https://github.com/alextamkin/viewmaker. ",
+        "bbox": [
+            232,
+            306,
+            764,
+            584
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0ad74b113dfb1890cf9bad006c8d5ce9860843ba7f9fbb220c81b43547e6f72.jpg",
+        "image_caption": [
+            "Figure 1: Viewmaker networks generate complex and diverse input-dependent views for unsupervised learning. Examples shown are for CIFAR-10. Original image in center with pink border. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            608,
+            813,
+            724
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            795,
+            336,
+            810
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised representation learning has made significant recent strides, including in computer vision, where view-based methods have enabled strong performance on benchmark tasks (Wu et al., 2018; Oord et al., 2018; Bachman et al., 2019; Zhuang et al., 2019; Misra & Maaten, 2020; He et al., 2020; Chen et al., 2020a). Views here refer to human-defined data transformations, which target capabilities or invariances thought to be useful for transfer tasks. In particular, in contrastive learning of visual representations, models are trained to maximize the mutual information between different views of an image, including crops, blurs, noise, and changes to color and contrast (Bachman et al., ",
+        "bbox": [
+            173,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2019; Chen et al., 2020a). Much work has investigated the space of possible image views (and their compositions) and understanding their effects on transfer learning (Chen et al., 2020a; Wu et al., 2020; Tian et al., 2019; Purushwalkam & Gupta, 2020) ",
+        "bbox": [
+            173,
+            103,
+            823,
+            147
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The fact that views must be hand designed is a significant limitation. While views for image classification have been refined over many years, new views must be developed from scratch for new modalities. Making matters worse, even within a modality, different domains may have different optimal views (Purushwalkam & Gupta, $\\textcircled { 2 0 2 0 }$ . Previous studies have investigated the properties of good views through the lens of mutual information (Tian et al., 2020; Wu et al., 2020), but a broadly-applicable approach for learning views remains unstudied. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            236
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present a general method for learning diverse and useful views for contrastive learning. Rather than searching through possible compositions of existing view functions $\\mathbb { ( C u b u k ) }$ et al., 2018; Lim et al., 2019), which may not be available for many modalities, our approach produces views with a generative model, called the viewmaker network, trained jointly with the encoder network. This flexibility enables learning a broad set of possible view functions, including input-dependent views, without resorting to hand-crafting or expert domain knowledge. The viewmaker network is trained adversarially to create views which increase the contrastive loss of the encoder network. Rather than directly outputting views for an image, the viewmaker instead outputs a stochastic perturbation that is added to the input. This perturbation is projected onto an $\\ell _ { p }$ sphere, controlling the effective strength of the view, similar to methods in adversarial robustness. This constrained adversarial training method enables the model to reduce the mutual information between different views while preserving useful input features for the encoder to learn from. ",
+        "bbox": [
+            173,
+            243,
+            825,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, we contribute: ",
+        "bbox": [
+            174,
+            417,
+            354,
+            431
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. Viewmaker networks: to our knowledge the first modality-agnostic method to learn views for unsupervised representation learning   \n2. On image data, where expert-designed views have been extensively optimized, our viewmaker-models achieve comparable transfer performance to state of the art contrastive methods while being more robust to common corruptions.   \n3. On speech data, our method significantly outperforms existing human-defined views on a range of speech recognition transfer tasks.   \n4. On time-series data from wearable sensors, our model significantly outperforms baseline views on the task of human activity recognition (e.g., cycling, running, jumping rope). ",
+        "bbox": [
+            210,
+            441,
+            825,
+            582
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            599,
+            341,
+            616
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised representation learning Learning useful representations from unlabeled data is a fundamental problem in machine learning (Pan & Yang, 2009; Bengio et al., 2013). A recently successful framework for unsupervised representation learning for images involves training a model to be invariant to various data transformations (Bachman et al., 2019; Misra & Maaten, 2020), although the idea has much earlier roots (Becker & Hinton, 1992; Hadsell et al., 2006; Dosovitskiy et al., 2014). This idea has been expanded by a number of contrastive learning approaches which push embeddings of different views, or transformed inputs, closer together, while pushing other pairs apart (Tian et al., 2019; He et al., 2020; Chen et al., $\\boxed { 2 0 2 0 \\mathrm { a } } \\boxed { \\mathrm { b } } \\boxed { \\mathrm { c } }$ , as well as non-contrastive approaches which do not explicitly push apart unmatched views (Grill et al., 2020; Caron et al., 2020) Related but more limited setups have been explored for speech, where data augmentation strategies are less explored (Oord et al., 2018; Kharitonov et al., 2020). ",
+        "bbox": [
+            173,
+            631,
+            825,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Understanding and designing views Several works have studied the role of views in contrastive learning, including from a mutual-information perspective $\\mathrm { ( W u ~ e t ~ a l . } , \\mathbb { Z } 0 2 0 )$ , in relation to specific transfer tasks $( \\overbrace { [ 1 \\mathrm { a n ~ e t ~ a l . } ] } ^ { \\sim } , \\overbrace { 2 0 1 9 } )$ , with respect to different kinds of invariances $( \\mathbf { \\mathbb { P u r u s h w a l k a m \\& } } ]$ $\\overline { { \\mathrm { G u p t a } } } , \\overline { { \\vert 2 0 2 0 \\vert } }$ , or via careful empirical studies $\\mathrm { ( } \\mathrm { C h e n \\ e t \\ a l . } \\mathrm { , } \\mathrm { 2 0 2 0 a } \\mathrm { ) }$ . Outside of a contrastive learning framework, Gontijo-Lopes et al. $\\underline { { ( 2 0 2 0 ) } }$ study how data augmentation aids generalization in vision models. Much work has explored different handcrafted data augmentation methods for supervised learning of images (Hendrycks et al., 2020; Lopes et al., 2019; Perez & Wang, 2017; Yun et al., 2019; Zhang et al., 2017), speech (Park et al., 2019; Kovacs et al., 2017; T ´ oth et al., 2018; Kharitonov et al., ´ 2020), or in feature space (DeVries & Taylor, 2017). ",
+        "bbox": [
+            173,
+            799,
+            825,
+            925
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae184fa82ff4181505f881e74ed5776fe0a9ac2a0be921111a116fa38e2f1f19.jpg",
+        "image_caption": [
+            "Figure 2: Diagram of our method. The viewmaker network is trained to produce stochastic adversarial views restricted to an $\\ell _ { 1 }$ sphere around the input. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            820,
+            214
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Adversarial methods Our work is related to and inspired by work on adversarial methods, including the $\\ell _ { p }$ balls studied in adversarial robustness (Szegedy et al., 2013; Madry et al., 2017; Raghunathan et al., 2018) and training networks with adversarial objectives (Goodfellow et al., 2014; Xiao et al., $\\overline { { \\boxed { 2 0 1 8 } } }$ . Our work is also connected to the vicinal risk minimization principle (Chapelle et al., 2001) and can be interpreted as producing amortized virtual adversarial examples (Miyato et al., $\\boxed { 2 0 1 8 }$ . Previous adversarial view-based pretraining methods add adversarial noise on top of existing handcrafted views $\\mathrm { ( K i m ~ e t ~ a l . ) } \\mathrm { [ 2 0 2 0 ] } $ or require access to specific transfer tasks during pretraining (Tian et al., 2020). In contrast, our method is more general: it is neither specialized to a particular downstream task, nor requires neither human-defined view families. Outside of multi-view learning paradigms, adversarial methods have also seen use for representation learning in GANs (Donahue et al., 2016; Donahue & Simonyan, 2019) or in choosing harder negative samples $\\mathrm { \\textregistered B o s e ~ e t ~ a l . } \\mathrm { \\textnot { B } } ^ { \\mathrm { \\scriptsize { B } } \\mathrm { { o } } 1 8 \\mathrm { \\textmu } }$ as well as for data augmentation (Antoniou et al., 2017; Volpi et al., 2018; Bowles et al., 2018). Adversarial networks that perturb inputs have also been investigated to improve GAN training (Sajjadi et al., 2018) and to remove “shortcut” features (e.g., watermarks) for self-supervised pretext tasks (Minderer et al., 2020). ",
+        "bbox": [
+            173,
+            285,
+            826,
+            496
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning views Outside of adversarial approaches, our work is related to other studies that seek to learn data augmentation strategies by composing existing human-designed augmentations (Ratner et al., 2017; Cubuk et al., 2018; Zhang et al., 2019; Ho et al., 2019; Lim et al., 2019; Cubuk et al., 2020) or by modeling variations specific to the data distribution (Tran et al., 2017; Wong & Kolter, 2020). By contrast, our method requires no human-defined view functions, does not require first pretraining a generative model, and can generate perturbations beyond naturally-occurring variation observed in the training data (e.g. brightness or contrast), potentially conferring robustness benefits, as we explore in Section 4.3. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            626
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            646,
+            282,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In contrastive learning, the objective is to push embeddings of positive views (derived from the same input) close together, while pushing away embeddings of negative views (derived from different inputs). We focus mainly on the simple, yet performant, SimCLR contrastive learning algorithm $\\mathbb { C } \\mathrm { h e n }$ $\\boxed { \\mathrm { e t ~ a l . } } \\boxed { 2 0 2 0 \\mathrm { a } }$ , but we also consider a memory bank-based algorithm $\\mathtt { ( W u ~ e t ~ a l . } ] \\mathtt { \\tilde { 2 } O l 8 } $ in Section 4. As our method is agnostic to the specific pretraining loss used, it is naturally compatible with other view-based algorithms such as MoCo $\\pmb { \\mathrm { ( f l e ~ e t ~ a l . ) } } \\widetilde { \\pmb { 2 0 2 0 } } \\}$ , BYOL $\\mathrm { ( } \\overline { { \\mathrm { G r i l l ~ e t ~ a l . } } } \\mathrm { , } \\overline { { 2 0 2 0 } } \\mathrm { ) }$ , and SwAV (Caron et al., 2020) by similarly substituting the data transformation pipeline with a viewmaker network. ",
+        "bbox": [
+            173,
+            679,
+            826,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, given a batch of $N$ pairs of positive views $( i , j )$ the SimCLR loss is ",
+        "bbox": [
+            173,
+            784,
+            684,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91dafb029ad2d0bcc09c3f6cb288fd6ca719a1127937072ab79c0aaf74ff1224.jpg",
+        "text": "$$\n{ \\mathcal { L } } = { \\frac { 1 } { 2 N } } \\sum _ { k = 1 } ^ { N } [ \\ell ( 2 k - 1 , 2 k ) + \\ell ( 2 k , 2 k - 1 ) ] { \\mathrm { ~ w h e r e ~ } } \\ell ( i , j ) = - \\log { \\frac { \\exp ( s _ { i , j } / \\tau ) } { \\sum _ { k = 1 } ^ { 2 N } { \\mathbb { 1 } } _ { [ k \\neq i ] } \\exp ( s _ { i , k } / \\tau ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            808,
+            810,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and $s _ { a , b }$ is the cosine similarity of the embeddings of views $a$ and $b$ . ",
+        "bbox": [
+            173,
+            859,
+            619,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We generate views by perturbing examples with a viewmaker network $V$ , trained jointly with the main encoder network $M$ . There are three attributes desirable for useful perturbations, each of which motivates an aspect of our method: ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Challenging: The perturbations should be complex and strong enough that an encoder must develop useful representations to perform the self-supervised task. We accomplish this by generating perturbations with a neural network that is trained adversarially to increase the loss of the encoder network. Specifically, we use a neural network that ingests the input $X$ and outputs a view $X + V ( X )$ . ",
+        "bbox": [
+            214,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2. Faithful: The perturbations must not make the encoder task impossible, being so strong that they destroy all features of the input. For example, perturbations should not be able to zero out the input, making learning impossible. We accomplish this by constraining the perturbations to an $\\ell _ { p }$ sphere around the original input. $\\ell _ { p }$ constraints are common in the adversarial robustness literature where perturbations are expected to be indistinguishable. In our experiments, we find the best results are achieved with an $\\ell _ { 1 }$ sphere, which grants the viewmaker a distortion budget that it can spend on a small perturbation for a large part of the input or a more extreme perturbation for a smaller portion. ",
+        "bbox": [
+            212,
+            180,
+            825,
+            291
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3. Stochastic: The method should be able to generate a variety of perturbations for a single input, as the encoder objective requires contrasting two different views of an input against each other. To do this, we inject random noise into the viewmaker, such that the model can learn a stochastic function that produces a different perturbed input each forward pass. ",
+        "bbox": [
+            214,
+            297,
+            825,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure $\\bigstar$ summarizes our method. The encoder and viewmaker are optimized in alternating steps to minimize and maximize $\\mathcal { L }$ , respectively. We use an image-to-image neural network as our viewmaker network, with an architecture adapted from work on style transfer $\\left( \\mathrm { J o h n s o n e t a l . } \\right) \\left[ \\mathrm { 2 0 1 6 } \\right)$ See the Appendix for more details. This network ingests the input image and outputs a perturbation that is constrained to an $\\ell _ { 1 }$ sphere. The sphere’s radius is determined by the volume of the input tensor times a hyperparameter $\\epsilon$ , the distortion budget, which determines the strength of the applied perturbation. This perturbation is added to the input image and optionally clamped in the case of images to ensure all pixels are in $[ 0 , 1 ]$ . Algorithm 1 describes this process precisely. ",
+        "bbox": [
+            173,
+            368,
+            825,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: Viewmaker network $V$ , $C \\times W \\times H$ image X, $\\ell _ { 1 }$ distortion budget ✏, noise \u0000   \nOutput: Perturbed $C \\times W \\times H$ image $X$   \n$P  V ( X , \\delta ) \\ / ,$ / generate perturbation   \n$\\begin{array} { r } { P \\gets \\frac { \\epsilon C W H } { | P | _ { 1 } } P \\gets | / \\langle } \\end{array}$ project to $\\ell _ { 1 }$ sphere   \n$X  X + P / /$ apply perturbation   \n$X \\gets \\mathrm { c l a m p } ( X , 0 , 1 ) / /$ clamp (images only) ",
+        "bbox": [
+            174,
+            511,
+            733,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 IMAGES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            627,
+            272,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We begin by applying the viewmaker to contrastive learning for images. In addition to SimCLR (Chen et al., 2020a), we also consider a memory bank-based instance discrimination framework (Wu et al., 2018, henceforth InstDisc). ",
+        "bbox": [
+            174,
+            660,
+            825,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We pretrain ResNet-18 $\\mathbb { ( H e \\ e t \\ a l . ) } \\mathbb { 2 0 1 5 } )$ models on CIFAR-10 (Krizhevsky, 2009) for 200 epochs with a batch size of 256. We train a viewmaker-encoder system with a distortion budget of $\\epsilon = 0 . 0 5$ . We tried distortion budgets $\\epsilon \\in \\lbrace 0 . 1 , 0 . 0 5 , 0 . 0 2 \\rbrace$ and found 0.05 to work best; however, we anticipate that further tuning would yield additional gains. As we can see in Figure $^ { 1 , }$ the learned views are diverse, consisting of qualitatively different kinds of perturbations and affecting different parts of the input. We compare the resulting encoder representations with a model trained with the expert views used for SimCLR, comprised of many human-defined transformations targeting different kinds of invariances useful for image classification: cropping-and-resizing, blurring, horizontal flipping, color dropping, and shifts in brightness, contrast, saturation, and hue (Chen et al., 2020a). ",
+        "bbox": [
+            174,
+            708,
+            825,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 TRANSFER RESULTS ON IMAGE CLASSIFICATION TASKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            856,
+            598,
+            869
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our models on CIFAR-10, as well as eleven transfer tasks including MetaDataset $\\underline { { ( \\Pi \\dot { } \\mathbf { i } ) } }$ antafillou et al., 2019), MSCOCO (Lin et al., 2014), MNIST (LeCun et al., 1998), and FashionMNIST (Xiao et al., 2017). We use the standard linear evaluation protocol, which trains a logistic regression on top of representations from a frozen model. We apply the same views as in pretraining, freezing the final viewmaker when using learned views; we apply no views during validation. Table $\\bigtriangledown$ shows our results, indicating comparable overall performance with SimCLR and InstDisc, all without the use of human-crafted view functions. This performance is noteworthy as our $\\ell _ { 1 }$ views cannot implement cropping-and-rescaling, which was shown to be the most important view function in Chen et al. $\\textcircled { 1 2 0 2 0 2 }$ . We speculate that the ability of the viewmaker to implement partial masking of an image may enable a similar kind of spatial information ablation as cropping. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/cfd78ef6319bb13476c24b694d21ec4c1580d0dc800dbd17ffbeb41154322203.jpg",
+        "table_caption": [
+            "Table 1: Our learned views (Ours) enable comparable transfer performance to expert views (Expt) on CIFAR-10. Suite of transfer tasks using pretrained representations from CIFAR-10 for both the SimCLR and InstDisc pretraining setups. Numbers are percent accuracy with the exception of CelebA which is F1. FaMNIST stands for FashionMNIST. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">SimCLR</td><td colspan=\"2\">InstDisc</td><td></td><td colspan=\"2\">SimCLR</td><td colspan=\"2\">InstDisc</td></tr><tr><td>Dataset</td><td>Expt</td><td>Ours</td><td>Expt</td><td>Ours</td><td>Dataset</td><td>Expt</td><td>Ours</td><td>Expt</td><td>Ours</td></tr><tr><td>CIFAR-10</td><td>86.2</td><td>84.5</td><td>82.4</td><td>80.1</td><td>MNIST</td><td>97.1</td><td>98.7</td><td>98.7</td><td>98.9</td></tr><tr><td>MSCOCO</td><td>49.9</td><td>50.4</td><td>48.6</td><td>50.2</td><td>FaMNIST</td><td>88.3</td><td>91.5</td><td>89.2</td><td>91.4</td></tr><tr><td>CelebA (F1)</td><td>51.0</td><td>51.8</td><td>57.0</td><td>53.7</td><td>CUBirds</td><td>11.2</td><td>8.7</td><td>13.7</td><td>9.4</td></tr><tr><td>LSUN</td><td>56.2</td><td>55.0</td><td>56.0</td><td>55.6</td><td>VGGFlower</td><td>53.3</td><td>53.6</td><td>61.5</td><td>54.8</td></tr><tr><td>Aircraft</td><td>32.5</td><td>31.7</td><td>37.7</td><td>33.5</td><td>TrafficSign</td><td>96.6</td><td>94.9</td><td>98.9</td><td>94.3</td></tr><tr><td>DTD</td><td>30.4</td><td>28.8</td><td>29.8</td><td>29.8</td><td>Fungi</td><td>2.2</td><td>2.0</td><td>2.6</td><td>2.1</td></tr></table>",
+        "bbox": [
+            184,
+            101,
+            813,
+            234
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            328,
+            825,
+            426
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 COMPARISON TO RANDOM $\\ell _ { 1 }$ NOISE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            443,
+            477,
+            457
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Is random noise sufficient to produce domain-agnostic views? To assess how important adversarial training is to the quality of the learned representations, we perform an ablation where we generate views by adding Gaussian noise normalized to the same $\\epsilon = 0 . 0 5$ budget as used in the previous section. Transfer accuracy on CIFAR-10 is significantly hurt by this ablation, reaching $5 2 . 0 1 \\%$ for a SimCLR model trained with random noise views compared to $\\mathbf { 8 4 . 5 0 \\% }$ for our method, demonstrating the importance of adversarial training to our method. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 THE IMPORTANCE OF INTER-PATCH MUTUAL INFORMATION AND CROPPING VIEWS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            569,
+            797,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Cropping-and-resizing has been identified as a crucial view function when pretraining on ImageNet (Chen et al., 2020a). However, what properties of a pretraining dataset make cropping useful? We hypothesize that such a dataset must have images whose patches have high mutual information. In other words, there must be some way for the model to identify that different patches of the same image come from the same image. While this may be true for many object or scene recognition datasets, it may be false for other important pretraining datasets, including medical or satellite imagery, where features of interest are isolated to particular parts of the image. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To investigate this hypothesis, we modify the CIFAR-10 dataset to reduce the inter-patch mutual information by replacing each 16x16 corner of the image with the corner from another image in the training dataset (see Figure $\\perp$ for an example). Thus, random crops on this dataset, which we call CIFAR-10-Corners, will often contain completely unrelated information. When pretrained on CIFAR-10-Corners, expert views achieve $6 3 . 3 \\%$ linear evaluation accuracy on the original CIFAR10 dataset, while viewmaker views achieve $6 8 . 8 \\%$ . This gap suggests that viewmaker views are less reliant on inter-patch mutual information than the expert views. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            795
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 COMBINING VIEWMAKER AND HANDCRAFTED VIEWS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            586,
+            827
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Can viewmakers improve performance in cases where some useful handcrafted views have already been identified? $\\boxed { \\mathrm { C h e n ~ e t ~ a l . } } \\textcircled { 2 0 2 0 a } )$ show that views produced through cropping are significantly improved by a suite of color-based augmentations, which they argue prevents the network from relying solely on color statistics to perform the contrastive task. Here, we show that viewmaker networks also enable strong gains when added on top of cropping and horizontal flipping views when pretraining on CIFAR-10—without any domain-specific knowledge. Alone, this subset of ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd65f0b26e7ed3d0124667590f6c3e4dacc67ceb47f41bcbf95794567d036736.jpg",
+        "image_caption": [
+            "Figure 3: Our learned views are still able to yield useful information even when the inter-patch mutual information in a dataset is low, as in Figure 3b. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            259,
+            103,
+            741,
+            207
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/48bc6d003b212192c3fc8b38635105a11b5597c111aa556a93a24d83d7c0ff5d.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(a) Accuracy on CIFAR-10 and CIFAR-10-C. ⇤Overlap with CIFAR-10-C corruptions. "
+        ],
+        "table_body": "<table><tr><td>Views</td><td>Clean</td><td>Corrupted</td><td>Diff</td></tr><tr><td>Ours</td><td>84.5</td><td>71.4</td><td>-13.1</td></tr><tr><td>SimCLR*</td><td>86.2</td><td>77.1</td><td>-9.1</td></tr><tr><td>Combined*</td><td>86.3</td><td>79.8</td><td>-6.5</td></tr></table>",
+        "bbox": [
+            202,
+            294,
+            500,
+            366
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/7256165d389e3e07b022a12e6ea06b8a2ae93227c6369be26f829c35cf64be0b.jpg",
+        "image_caption": [
+            "(b) Accuracy gain on CIFAR-10-C by from adding our learned views atop expert views. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            539,
+            265,
+            754,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 4: Performance of different views on CIFAR-10-C corruptions. Our learned views enable solid performance in the face of unseen corruptions despite not explicitly including any blurring, contrast, or brightness transformations during training, unlike the expert views. Adding our learned views on top of SimCLR yields additional gains in robust accuracy, especially on different kinds of noise corruptions and glass blurring. ",
+        "bbox": [
+            173,
+            440,
+            826,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "handcrafted augmentations achieves $7 3 . 2 \\%$ linear evaluation accuracy on CIFAR-10. Combining these views with learned viewmaker perturbations $\\epsilon = 0 . 0 5$ ) achieves $8 3 . 1 \\% \\big \\Updownarrow$ This suggests that viewmakers can significantly improve representation learning even in cases where some domainspecific views have already been developed. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            595
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 ROBUSTNESS TO COMMON CORRUPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            616,
+            501,
+            628
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Image classification systems should behave robustly even when the data distribution is slightly different from that seen during training. Does using a viewmaker improve robustness against common types of corruptions not experienced at train time? To answer this, we evaluate both learned views, expert views, and their composition on the CIFAR-10-C dataset (Hendrycks & Dietterich, 2019) which assesses robustness to corruptions like snow, pixelation, and blurring. In this setting, corruptions are applied only at test time, evaluating whether the classification system is robust to some types of corruptions to which humans are robust. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            739
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When considering methods in isolation, SimCLR augmentations result in less of an accuracy drop from clean to corrupted data compared to our learned views, as shown in Table $4 \\mathrm { a } .$ This gap is expected, as the expert views overlap significantly with the CIFAR-10-C corruptions: both include blurring, brightness, and contrast transformations. Interestingly, however, when we train a viewmaker network while also applying expert augmentations (“Combined,” Table $\\mathrm { 4 a ) }$ , we can further improve the robust accuracy, with notable gains on noise and glass blur corruptions (Figure $\\textcircled { 4 6 }$ This is noteworthy, as our learned views have no explicit overlap with the CIFAR-10-C corruptions, unlike the expert augmentations $\\cdot ^ { 2 }$ In the Combined setting, we use a distortion budget of $\\epsilon = 0 . 0 1$ , which we find works better than $\\epsilon = 0 . 0 5$ , likely because combining the two augmentations at their full strength would make the learning task too difficult. ",
+        "bbox": [
+            173,
+            746,
+            825,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/886515a7ccf49327e20aca6bd4edade92990371ec17db8d05a30a14e4cdac69c.jpg",
+        "table_caption": [
+            "Table 2: Our learned views significantly outperform existing views for speech transfer tasks. Linear evaluation accuracy for SimCLR models trained on LibriSpeech. Left: ResNet- $1 8 +$ Librispeech 100 hour, Right: ResNet- $5 0 +$ Librispeech $9 6 0 \\mathrm { { h r } }$ . “Time” refers to view functions applied in the time domain (Kharitonov et al., $\\boxed { 2 0 2 0 }$ , while “Spec.” refers to view functions applied directly to the spectrogram (Park et al., 2019). 0.05 and 0.1 denote viewmaker distortion bounds $\\epsilon$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">ResNet-18,100hr</td><td colspan=\"2\">Expert</td><td colspan=\"2\">Ours (ε)</td></tr><tr><td>Time</td><td>Spec.</td><td>0.05</td><td>0.1</td></tr><tr><td>LibriSpeech Sp. ID</td><td>97.1</td><td>91.6</td><td>88.3</td><td>84.0</td></tr><tr><td>VoxCeleb1 Sp. ID</td><td>5.7</td><td>7.8</td><td>12.1</td><td>9.1</td></tr><tr><td>AudioMNIST</td><td>31.7</td><td>63.9</td><td>93.3</td><td>87.9</td></tr><tr><td>Google Commands</td><td>27.1</td><td>31.9</td><td>47.4</td><td>41.6</td></tr><tr><td>Fluent Actions</td><td>29.4</td><td>32.0</td><td>41.6</td><td>37.9</td></tr><tr><td>Fluent Objects</td><td>37.1</td><td>40.3</td><td>47.6</td><td>47.6</td></tr><tr><td>Fluent Locations</td><td>59.7</td><td>63.3</td><td>66.5</td><td>68.3</td></tr></table>",
+        "bbox": [
+            183,
+            101,
+            545,
+            247
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9d5b733d5e7a5ab7419aad92d54e3ec61feb4de3a069f9298a5f6dfa42135ee3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>ResNet-50,960hr</td><td>Spec.</td><td>0.05</td></tr><tr><td>LibriSpeech Sp. ID</td><td>95.9</td><td>90.0</td></tr><tr><td>VoxCeleb1 Sp.ID AudioMNIST</td><td>8.6</td><td>10.7</td></tr><tr><td></td><td>80.2</td><td>88.0</td></tr><tr><td>Google Commands</td><td>28.3</td><td>32.6</td></tr><tr><td>Fluent Actions</td><td>30.5</td><td>42.5</td></tr><tr><td>Fluent Objects</td><td>36.2</td><td>50.8</td></tr><tr><td>Fluent Locations</td><td>62.0</td><td>68.9</td></tr></table>",
+        "bbox": [
+            555,
+            109,
+            815,
+            238
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            356,
+            823,
+            385
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "These results suggest that learned views are a promising avenue for improving robustness in selfsupervised learning models. ",
+        "bbox": [
+            174,
+            391,
+            821,
+            420
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 SPEECH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            440,
+            272,
+            457
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Representation learning on speech data is an emerging and important research area, given the large amount of available unlabeled data and the increasing prevalence of speech-based human-computer interaction (Latif et al., 2020). However, compared to images, there is considerably less work on self-supervised learning and data augmentations for speech data. Thus, it is a compelling setting to investigate whether viewmaker augmentations are broadly applicable across modalities. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            542
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 SELF-SUPERVISED LEARNING SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            560,
+            467,
+            575
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We adapt the contrastive learning setup from SimCLR (Chen et al., 2020a). Training proceeds largely the same as for images, but the inputs are 2D log mel spectrograms. We consider both view functions applied in the time-domain before the STFT, including noise, reverb, pitch shifts, and changes in loudness (Kharitonov et al., $\\boxed { 2 0 2 0 }$ , as well as spectral views, which involve masking or noising different parts of the spectrogram (Park et al., 2019). To generate learned views, we pass the spectrogram as input to the viewmaker. We normalize the spectrogram to mean zero and variance one before passing it through the viewmaker, and do not clamp the resulting perturbed spectrogram. See the Appendix for more details. We train on the Librispeech dataset (Panayotov et al., 2015) for 200 epochs, and display some examples of learned views in the Appendix. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            713
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 SPEECH CLASSIFICATION RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            731,
+            452,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate on three speech classification datasets: Fluent Speech Commands (Lugosch et al., $\\bigstar$ Google Speech Commands $\\left( \\mathrm { W a r d e n } \\right) , \\left[ 2 0 1 8 \\right)$ , and spoken digit classification (Becker et al., 2018), as well as speaker classification on VoxCeleb $( \\mathrm { I N a g r a n i e t a l . } \\mathrm { \\bar { 2 0 1 7 } } )$ and Librispeech (Panayotov et al., $\\boxed { 2 0 1 5 }$ , all using the linear evaluation protocol for 100 epochs. In Table $\\bigtriangledown$ we report results with both the same distortion budget $\\epsilon = 0 . 0 5$ as in the image domain, as well as a larger $\\epsilon = 0 . 1$ , for comparison. Both versions significantly outperform the preexisting waveform and spectral augmentations, with a $+ 9$ percentage point improvement on average for the ResNet-18 $\\acute { \\epsilon } = 0 . 0 5 )$ ) viewmaker model over the best expert views. The gains for real-world tasks such as command identification are compelling. One notable exception is the task of LibriSpeech speaker identification. Since LibriSpeech is the same dataset the model was pretrained on, and this effect is not replicated on VoxCeleb1, the other speaker classification dataset, we suspect the model may be picking up on dataset-specific artifacts (e.g. background noise, microphone type) which may make the speaker ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4eaf02730a69c10302c96a1d96e015e0464d8e8ed6c3ed33b40e1e19061d9a74.jpg",
+        "table_caption": [
+            "Table 3: Our learned views significantly outperform existing views for activity recognition on wearable sensor data. Our method learns superior representations across a large range of distortion budgets $\\epsilon$ , although budgets that are too strong prevent learning. Linear evaluation accuracy for ResNet18 models trained on Pamap2 with SimCLR. “Spectral” refers to view functions applied directly to the spectrogram (Park et al., 2019). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Spectral</td><td colspan=\"5\">Ours (e)</td></tr><tr><td>Dataset</td><td>With Noise</td><td>Without Noise</td><td>0.02</td><td>0.05</td><td>0.2</td><td>0.5</td><td>2.0</td></tr><tr><td>Pamap2</td><td>71.0</td><td>74.6</td><td>83.0</td><td>87.4</td><td>88.6</td><td>91.3</td><td>9.1</td></tr></table>",
+        "bbox": [
+            236,
+            101,
+            759,
+            165
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ID task artificially easier. An interesting possibility is that the worse performance of viewmaker views may result from the model being able to identify and ablate such spurious correlations in the spectrograms. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            315
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 WEARABLE SENSOR DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            335,
+            421,
+            352
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To further validate that our method for learning views is useful across different modalities, we consider time-series data from wearable sensors. Wearable sensor data has a broad range of applications, including health care, entertainment, and education (Lara & Labrador, 2012). We specifically consider whether viewmaker views improve representation learning for the task of human activity recognition (HAR), for example identifying whether a user is jumping rope, running, or cycling. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            438
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.1 SELF-SUPERVISED LEARNING SETUP ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            455,
+            467,
+            468
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We consider the Pamap2 dataset (Reiss & Stricker, 2012), a dataset of 12 different activities performed by 9 participants. Each activity contains 52 different time series, including heart rate, accelerometer, gyroscope, and magnetometer data collected from sensors on the ankle, hand, and chest (all sampled at $1 0 0 \\mathrm { H z }$ , except heart rate, which is sampled at approximately 9Hz). We linearly interpolate missing data, then take random 10s windows from subject recordings, using the same train/validation/test splits as prior work $( \\mathbb { M o y a R u e d a e t a l . } ) \\lbrack 2 0 1 8 \\rbrack )$ . To create inputs for our model, we generate a multi-channel image composed of one 32x32 log spectrogram for each sensor timeseries window. Unlike speech data, we do not use the mel scale when generating the spectrogram. We then normalize the training and validation datasets by subtracting the mean and then dividing by the standard deviation of the training dataset. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            619
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We train with both our learned views and the spectral views (Park et al., 2019) that were most successful in the speech domain (for multi-channel spectral masking, we apply the same randomly chosen mask to all channels). We also compare against a variant of these views with spectrogram noise removed, which we find improves this baseline’s performance. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.2 SENSOR-BASED ACTIVITY RECOGNITION RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            700,
+            562,
+            714
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We train a linear classifier on the frozen encoder representations for 50 epochs, reporting accuracy on the validation set. We sample 10k examples for each training epoch and 50k examples for validation. Our views significantly outperform spectral masking by 12.8 percentage points when using the same $\\epsilon = 0 . 0 5$ as image and speech, and by 16.7 points when using a larger $\\epsilon = 0 . 5$ (Table 3). We also find that a broad range of distortion budgets produces useful representations, although overly-aggressive budgets prevent learning (Table $\\textcircled { 3 }$ . These results provide further evidence that our method for learning views has broad applicability across different domains. ",
+        "bbox": [
+            174,
+            726,
+            825,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.3 SEMI-SUPERVISED EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            446,
+            856
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "An especially important setting for self-supervised learning is domains where labeled data is scarce or costly to acquire. Here, we show that our method can enable strong performance when labels for only a single participant (Participant 1) out of seven are available. We compare simple supervised learning on Participant 1’s labels against linear evaluation of our best pretrained model, which was trained on unlabeled data from all 7 participants. The model architectures and training procedures are otherwise identical to the previous section. As Figure $\\sharp$ shows, pretraining with our method on unlabeled data enables significant gains over pure supervised learning when data is scarce, and even slightly outperforms the hand-crafted views trained on all 7 participants (cf. Table 3). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/93fabd96097ba3e04daf967edc2a681d23090733dd8fd7382d334de3529c87f8.jpg",
+        "table_caption": [
+            "Table 4: Our method enables superior results in a semi-supervised setting where labels for data from only one participant are available. Validation accuracy for activity recognition on Pamap2. Supervised Learning refers to training a randomly initialized model on the labeled data until convergence. Pretrain & Transfer refers to training a linear classifier off of the best pretrained model above. 1 or 7 Participants refers to the number of participants comprising the training set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td colspan=\"2\">Supervised Learning</td><td colspan=\"2\">Pretrain (Ours)&amp; Transfer</td></tr><tr><td>1 Participant</td><td>7 Participants</td><td>1 Participant</td><td>7 Participants</td></tr><tr><td>Pamap2</td><td>58.3</td><td>97.1</td><td>75.1</td><td>91.3</td></tr></table>",
+        "bbox": [
+            250,
+            172,
+            746,
+            238
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            347,
+            318,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We introduce a method for learning views for unsupervised learning, demonstrating its effectiveness through strong performance on image, speech, and wearable sensor modalities. Our novel generative model—viewmaker networks—enables us to efficiently learn views as part of the representation learning process, as opposed to relying on domain-specific knowledge or costly trial and error. There are many interesting avenues for future work. For example, while the $\\ell _ { 1 }$ constraint is simple by design, there may be other kinds of constraints that enable richer spaces of views and better performance. In addition, viewmaker networks may find use in supervised learning, for the purposes of data augmentation or improving robustness. Finally, it is interesting to consider what happens as the viewmaker networks increase in size: do we see performance gains or robustnessaccuracy trade-offs (Raghunathan et al., 2019)? Ultimately, our work is a step towards more general self-supervised algorithms capable of pretraining on arbitrary data and domains. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            334,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Dan Yamins, Chengxu Zhuang, Shyamal Buch, Jesse Mu, Jared Davis, Aditi Raghunathan, Pranav Rajpurkar, Margalit Glasgow, and Jesse Michel for useful discussions and comments on drafts. AT is supported by an Open Phil AI Fellowship. MW is supported by the Stanford Interdisciplinary Graduate Fellowship as the Karr Family Fellow. ",
+        "bbox": [
+            176,
+            573,
+            825,
+            628
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            285,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nasir Ahmed, T Natarajan, and Kamisetty R Rao. Discrete cosine transform. IEEE transactions on Computers, 100(1):90–93, 1974. ",
+        "bbox": [
+            173,
+            674,
+            823,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Antreas Antoniou, Amos Storkey, and Harrison Edwards. Data augmentation generative adversarial networks, 2017. ",
+        "bbox": [
+            173,
+            712,
+            823,
+            741
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In Advances in Neural Information Processing Systems, pp. 15535–15545, 2019. ",
+        "bbox": [
+            174,
+            751,
+            821,
+            792
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Suzanna Becker and Geoffrey E Hinton. Self-organizing neural network that discovers surfaces in random-dot stereograms. Nature, 355(6356):161–163, 1992. ",
+        "bbox": [
+            173,
+            804,
+            823,
+            832
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Soren Becker, Marcel Ackermann, Sebastian Lapuschkin, Klaus-Robert M ¨ uller, and Wojciech ¨ Samek. Interpreting and explaining deep neural networks for classification of audio signals, 2018. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lukas Biewald. Experiment tracking with weights and biases, 2020. URL https://www. wandb.com/. Software available from wandb.com.   \nAvishek Joey Bose, Huan Ling, and Yanshuai Cao. Adversarial contrastive estimation. arXiv preprint arXiv:1805.03642, 2018.   \nChristopher Bowles, Liang Chen, Ricardo Guerrero, Paul Bentley, Roger Gunn, Alexander Hammers, David Alexander Dickie, Maria Valdes Hern ´ andez, Joanna Wardlaw, and Daniel Rueckert. ´ Gan augmentation: Augmenting training data using generative adversarial networks, 2018.   \nMathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020.   \nOlivier Chapelle, Jason Weston, Leon Bottou, and Vladimir Vapnik. Vicinal risk minimization. In ´ Advances in neural information processing systems, pp. 416–422, 2001.   \nTing Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020a.   \nTing Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey Hinton. Big selfsupervised models are strong semi-supervised learners. arXiv preprint arXiv:2006.10029, 2020b.   \nXinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020c.   \nEkin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. arXiv preprint arXiv:1805.09501, 2018.   \nEkin D Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V Le. Randaugment: Practical automated data augmentation with a reduced search space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 702–703, 2020.   \nTerrance DeVries and Graham W. Taylor. Dataset augmentation in feature space, 2017.   \nJeff Donahue and Karen Simonyan. Large scale adversarial representation learning. In Advances in Neural Information Processing Systems, pp. 10542–10552, 2019.   \nJeff Donahue, Philipp Krahenb ¨ uhl, and Trevor Darrell. Adversarial feature learning. ¨ arXiv preprint arXiv:1605.09782, 2016.   \nAlexey Dosovitskiy, Jost Tobias Springenberg, Martin Riedmiller, and Thomas Brox. Discriminative unsupervised feature learning with convolutional neural networks. In Advances in neural information processing systems, pp. 766–774, 2014.   \nWA Falcon. Pytorch lightning. GitHub. Note: https://github.com/PyTorchLightning/pytorchlightning, 3, 2019.   \nRaphael Gontijo-Lopes, Sylvia J Smullin, Ekin D Cubuk, and Ethan Dyer. Affinity and diversity: Quantifying mechanisms of data augmentation. arXiv preprint arXiv:2002.08973, 2020.   \nIan Goodfellow. Nips 2016 tutorial: Generative adversarial networks. arXiv preprint arXiv:1701.00160, 2016.   \nIan Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.   \nJean-Bastien Grill, Florian Strub, Florent Altche, Corentin Tallec, Pierre H Richemond, Elena ´ Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020. ",
+        "bbox": [
+            171,
+            74,
+            828,
+            933
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In 2006 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’06), volume 2, pp. 1735–1742. IEEE, 2006. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition, 2015. ",
+        "bbox": [
+            173,
+            155,
+            821,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9729–9738, 2020. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            237
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. arXiv preprint arXiv:1903.12261, 2019. ",
+        "bbox": [
+            173,
+            246,
+            823,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Steven Basart, Norman Mu, Saurav Kadavath, Frank Wang, Evan Dorundo, Rahul Desai, Tyler Zhu, Samyak Parajuli, Mike Guo, et al. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            328
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Ho, Eric Liang, Xi Chen, Ion Stoica, and Pieter Abbeel. Population based augmentation: Efficient learning of augmentation policy schedules. In International Conference on Machine Learning, pp. 2731–2741. PMLR, 2019. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            380
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In Bastian Leibe, Jiri Matas, Nicu Sebe, and Max Welling (eds.), Computer Vision – ECCV 2016, pp. 694–711, Cham, 2016. Springer International Publishing. ISBN 978-3- 319-46475-6. ",
+        "bbox": [
+            173,
+            388,
+            825,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eugene Kharitonov, Morgane Riviere, Gabriel Synnaeve, Lior Wolf, Pierre-Emmanuel Mazar \\` e,´ Matthijs Douze, and Emmanuel Dupoux. Data augmenting contrastive learning of speech representations in the time domain. arXiv preprint arXiv:2007.00991, 2020. ",
+        "bbox": [
+            176,
+            455,
+            821,
+            497
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Minseon Kim, Jihoon Tack, and Sung Ju Hwang. Adversarial self-supervised contrastive learning, 2020. ",
+        "bbox": [
+            173,
+            507,
+            820,
+            536
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gyorgy Kov ¨ acs, L ´ aszl ´ o T ´ oth, Dirk Van Compernolle, and Sriram Ganapathy. Increasing the ro- ´ bustness of cnn acoustic models using autoregressive moving average spectrogram features and channel dropout. Pattern Recognition Letters, 100:44–50, 2017. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            588
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009. ",
+        "bbox": [
+            171,
+            598,
+            803,
+            614
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oscar D Lara and Miguel A Labrador. A survey on human activity recognition using wearable sensors. IEEE communications surveys & tutorials, 15(3):1192–1209, 2012. ",
+        "bbox": [
+            174,
+            622,
+            823,
+            652
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Siddique Latif, Rajib Rana, Sara Khalifa, Raja Jurdak, Junaid Qadir, and Bjorn W Schuller. Deep ¨ representation learning in speech processing: Challenges, recent advances, and future trends. arXiv preprint arXiv:2001.00378, 2020. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            704
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            171,
+            713,
+            823,
+            742
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sungbin Lim, Ildoo Kim, Taesup Kim, Chiheon Kim, and Sungwoong Kim. Fast autoaugment. In Advances in Neural Information Processing Systems, pp. 6665–6675, 2019. ",
+        "bbox": [
+            171,
+            751,
+            823,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European conference on computer vision, pp. 740–755. Springer, 2014. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            834
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Raphael Gontijo Lopes, Dong Yin, Ben Poole, Justin Gilmer, and Ekin D Cubuk. Improving robustness without sacrificing accuracy with patch gaussian augmentation. arXiv preprint arXiv:1906.02611, 2019. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Loren Lugosch, Mirco Ravanelli, Patrick Ignoto, Vikrant Singh Tomar, and Yoshua Bengio. Speech model pre-training for end-to-end spoken language understanding, 2019. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthias Minderer, Olivier Bachem, Neil Houlsby, and Michael Tschannen. Automatic shortcut removal for self-supervised representation learning. arXiv preprint arXiv:2002.08822, 2020. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6707–6717, 2020. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            237
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993, 2018. ",
+        "bbox": [
+            174,
+            246,
+            826,
+            290
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Fernando Moya Rueda, Rene Grzeszick, Gernot A Fink, Sascha Feldhorst, and Michael Ten Hom- ´ pel. Convolutional neural networks for human activity recognition using body-worn sensors. In Informatics, volume 5, pp. 26. Multidisciplinary Digital Publishing Institute, 2018. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            342
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arsha Nagrani, Joon Son Chung, and Andrew Zisserman. Voxceleb: a large-scale speaker identification dataset, 2017. ",
+        "bbox": [
+            171,
+            351,
+            823,
+            380
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. ",
+        "bbox": [
+            171,
+            388,
+            823,
+            419
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345–1359, 2009. ",
+        "bbox": [
+            171,
+            428,
+            823,
+            457
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vassil Panayotov, Guoguo Chen, Daniel Povey, and Sanjeev Khudanpur. Librispeech: An asr corpus based on public domain audio books. pp. 5206–5210, 04 2015. doi: 10.1109/ICASSP.2015. 7178964. ",
+        "bbox": [
+            176,
+            465,
+            825,
+            508
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel S Park, William Chan, Yu Zhang, Chung-Cheng Chiu, Barret Zoph, Ekin D Cubuk, and Quoc V Le. Specaugment: A simple data augmentation method for automatic speech recognition. arXiv preprint arXiv:1904.08779, 2019. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            560
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, highperformance deep learning library. In Advances in neural information processing systems, pp. 8026–8037, 2019. ",
+        "bbox": [
+            173,
+            570,
+            825,
+            627
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Luis Perez and Jason Wang. The effectiveness of data augmentation in image classification using deep learning. arXiv preprint arXiv:1712.04621, 2017. ",
+        "bbox": [
+            173,
+            637,
+            821,
+            666
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Senthil Purushwalkam and Abhinav Gupta. Demystifying contrastive self-supervised learning: Invariances, augmentations and dataset biases. arXiv preprint arXiv:2007.13916, 2020. ",
+        "bbox": [
+            173,
+            674,
+            823,
+            705
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aditi Raghunathan, Jacob Steinhardt, and Percy Liang. Certified defenses against adversarial examples. arXiv preprint arXiv:1801.09344, 2018. ",
+        "bbox": [
+            173,
+            713,
+            823,
+            742
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aditi Raghunathan, Sang Michael Xie, Fanny Yang, John C Duchi, and Percy Liang. Adversarial training can hurt generalization. arXiv preprint arXiv:1906.06032, 2019. ",
+        "bbox": [
+            171,
+            751,
+            823,
+            781
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander J Ratner, Henry Ehrenberg, Zeshan Hussain, Jared Dunnmon, and Christopher Re. Learn- ´ ing to compose domain-specific transformations for data augmentation. In Advances in neural information processing systems, pp. 3236–3246, 2017. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            834
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Attila Reiss and Didier Stricker. Introducing a new benchmarked dataset for activity monitoring. In 2012 16th International Symposium on Wearable Computers, pp. 108–109. IEEE, 2012. ",
+        "bbox": [
+            169,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computerassisted intervention, pp. 234–241. Springer, 2015. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mehdi SM Sajjadi, Giambattista Parascandolo, Arash Mehrjou, and Bernhard Scholkopf. Tempered ¨ adversarial networks. arXiv preprint arXiv:1802.04374, 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            173,
+            146,
+            823,
+            176
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019. ",
+        "bbox": [
+            173,
+            190,
+            823,
+            219
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yonglong Tian, Chen Sun, Ben Poole, Dilip Krishnan, Cordelia Schmid, and Phillip Isola. What makes for good views for contrastive learning. arXiv preprint arXiv:2005.10243, 2020. ",
+        "bbox": [
+            173,
+            233,
+            825,
+            263
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Laszl ´ o T´ oth, Gy ´ orgy Kov ¨ acs, and Dirk Van Compernolle. A perceptually inspired data augmenta- ´ tion method for noise robust cnn acoustic models. In International Conference on Speech and Computer, pp. 697–706. Springer, 2018. ",
+        "bbox": [
+            178,
+            277,
+            823,
+            320
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Toan Tran, Trung Pham, Gustavo Carneiro, Lyle Palmer, and Ian Reid. A bayesian data augmentation approach for learning deep models, 2017. ",
+        "bbox": [
+            174,
+            335,
+            821,
+            364
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eleni Triantafillou, Tyler Zhu, Vincent Dumoulin, Pascal Lamblin, Utku Evci, Kelvin Xu, Ross Goroshin, Carles Gelada, Kevin Swersky, Pierre-Antoine Manzagol, and Hugo Larochelle. Metadataset: A dataset of datasets for learning to learn from few examples, 2019. ",
+        "bbox": [
+            179,
+            378,
+            821,
+            421
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Riccardo Volpi, Hongseok Namkoong, Ozan Sener, John Duchi, Vittorio Murino, and Silvio Savarese. Generalizing to unseen domains via adversarial data augmentation, 2018. ",
+        "bbox": [
+            176,
+            436,
+            825,
+            465
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Pete Warden. Speech commands: A dataset for limited-vocabulary speech recognition, 2018. ",
+        "bbox": [
+            173,
+            479,
+            782,
+            496
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong and J. Zico Kolter. Learning perturbation sets for robust machine learning, 2020. ",
+        "bbox": [
+            173,
+            510,
+            776,
+            525
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mike Wu, Chengxu Zhuang, Milan Mosse, Daniel Yamins, and Noah Goodman. On mutual information in contrastive learning for visual representations. arXiv preprint arXiv:2005.13149, 2020. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            582
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhirong Wu, Yuanjun Xiong, Stella Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance-level discrimination. arXiv preprint arXiv:1805.01978, 2018. ",
+        "bbox": [
+            173,
+            597,
+            823,
+            626
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chaowei Xiao, Bo Li, Jun-Yan Zhu, Warren He, Mingyan Liu, and Dawn Song. Generating adversarial examples with adversarial networks, 2018. ",
+        "bbox": [
+            173,
+            640,
+            823,
+            670
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017. ",
+        "bbox": [
+            173,
+            684,
+            823,
+            713
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In Proceedings of the IEEE International Conference on Computer Vision, pp. 6023–6032, 2019. ",
+        "bbox": [
+            178,
+            727,
+            825,
+            771
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017. ",
+        "bbox": [
+            171,
+            785,
+            825,
+            814
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xinyu Zhang, Qiang Wang, Jian Zhang, and Zhao Zhong. Adversarial autoaugment. arXiv preprint arXiv:1912.11188, 2019. ",
+        "bbox": [
+            171,
+            829,
+            823,
+            858
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chengxu Zhuang, Alex Lin Zhai, and Daniel Yamins. Local aggregation for unsupervised learning of visual embeddings. In Proceedings of the IEEE International Conference on Computer Vision, pp. 6002–6012, 2019. ",
+        "bbox": [
+            173,
+            872,
+            825,
+            915
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rygrBhC5tQ/rygrBhC5tQ.md

@@ -0,0 +1,425 @@
+# COMPOSING COMPLEX SKILLS BY LEARNING TRANSITION POLICIES
+
+Youngwoon Lee∗, Shao-Hua $\mathbf { S u n ^ { * } }$ , Sriram Somasundaram, Edward S. Hu, Joseph J. Lim   
+University of Southern California   
+$\{ \mathrm { 1 e e 5 0 ~ \dot { 4 } }$ ,shaohuas,sriramso,hues,limjj}@usc.edu
+
+# ABSTRACT
+
+Humans acquire complex skills by exploiting previously learned skills and making transitions between them. To empower machines with this ability, we propose a method that can learn transition policies which effectively connect primitive skills to perform sequential tasks without handcrafted rewards. To efficiently train our transition policies, we introduce proximity predictors which induce rewards gauging proximity to suitable initial states for the next skill. The proposed method is evaluated on a set of complex continuous control tasks in bipedal locomotion and robotic arm manipulation which traditional policy gradient methods struggle at. We demonstrate that transition policies enable us to effectively compose complex skills with existing primitive skills. The proposed induced rewards computed using the proximity predictor further improve training efficiency by providing more dense information than the sparse rewards from the environments. We make our environments, primitive skills, and code public for further research at https://youngwoon.github.io/transition.
+
+# 1 INTRODUCTION
+
+While humans are capable of learning complex tasks by reusing previously learned skills, composing and mastering complex skills are not as trivial as sequentially executing those acquired skills. Instead, it requires a smooth transition between skills since the final pose of one skill may not be appropriate to initiate the following one. For example, scoring in basketball with a quick shot after receiving a ball can be decomposed into catching and shooting. However, it is still difficult for beginners who have learned to catch passes and statically shoot. To master this skill, players must practice adjusting their footwork and body into a comfortable shooting pose after catching a pass.
+
+Can machines similarly learn new and complex tasks by reusing acquired skills and learning transitions between them? Learning to perform composite and long-term tasks from scratch requires extensive exploration and sophisticated reward design, which can introduce undesired behaviors (Riedmiller et al., 2018). Thus, instead of employing intricate reward functions and learning from scratch, modular methods sequentially execute acquired skills with a rule-based meta-policy, enabling machines to solve complicated tasks (Pastor et al., 2009; Mulling et al., 2013; Andreas et al., 2017). ¨ These modular approaches assume that a task can be clearly decomposed into several subtasks which are smoothly connected to each other. In other words, an ending state of one subtask falls within the set of starting states, initiation set, of the next subtask (Sutton et al., 1999). However, this assumption does not hold in many continuous control problems where a given skill may be executed in starting states not considered during training or designing and thus, fail to achieve its goal.
+
+To bridge the gap between skills, we propose a transition policy which learns to smoothly navigate from an ending state of a skill to suitable initial states of the following skill, as illustrated in Figure 1. However, learning a transition policy between skills without reward shaping is difficult as the only available learning signal is the sparse reward for the successful execution of the next skill. Sparse success/failure reward is challenging to learn from due to the temporal credit assignment problem (Sutton, 1984) and the lack of information from failing trajectories. To alleviate these problems, we propose a proximity predictor which outputs the proximity to the initiation set of the next skill and acts as a dense reward function for the transition policy.
+
+![](images/61453ca454e4286d9d344b3ec799c0534741f79e38df5b1fe2c8eea056a8b713.jpg)  
+Figure 1: Concept of a transition policy. Composing complex skills using primitive skills requires smooth transition between primitive skills since a following primitive skill might not be robust to ending states of the previous one. In this example, the ending states (red circles) of the primitive policy $p _ { \mathrm { j u m p } }$ are not good initial states to execute the following policy $p _ { \mathrm { w a l k } }$ . Therefore, executing $p _ { \mathrm { w a l k } }$ from these states will fail (red arrow). To smoothly connect the two primitive policies, we propose a transition policy which navigates an agent to suitable initial states for $p _ { \mathrm { w a l k } }$ (dashed arrow), leading to a successful execution of $p _ { \mathrm { w a l k } }$ (green arrow).
+
+The main contributions of this paper include (1) the concept of learning transition policies to FINALsmoothly connect primitive skills; (2) a novel modular framework with transition policies that is able to compose complex skills by reusing existing skills; and (3) a joint training algorithm with the proximity predictor specifically designed for efficiently training transition policies. This framework is suited for learning complex skills that require sequential execution of acquired primitive skills, which are common for humans yet relatively unexplored in robot learning. Our experiments on simulated environments demonstrate that employing transition policies solves complex continuous control tasks which traditional policy gradient methods struggle at.
+
+# 2 RELATED WORK
+
+Learning continuous control of diverse behaviors in locomotion (Merel et al., 2017; Heess et al., 2017; Peng et al., 2017) and robotic manipulation (Ghosh et al., 2018) is an active research area in reinforcement learning (RL). While some complex tasks can be solved through extensive reward engineering $\mathrm { N g }$ et al., 1999), undesired behaviors often emerge (Riedmiller et al., 2018) when tasks require several different primitive skills. Moreover, training complex skills from scratch is not computationally practical.
+
+Real-world tasks often require diverse behaviors and longer temporal dependencies. In hierarchical reinforcement learning, the option framework (Sutton et al., 1999) learns meta actions (options), a series of primitive actions over a period of time. Typically, a hierarchical reinforcement learning framework consists of two components: a high-level meta-controller and low-level controllers. A meta-controller determines the order of subtasks to achieve the final goal and chooses corresponding low-level controllers that generate a sequence of primitive actions. Unsupervised approaches to discover meta actions have been proposed (Schmidhuber, 1990; Daniel et al., 2016; Bacon et al., 2017; Vezhnevets et al., 2017; Dilokthanakul et al., 2017; Levy et al., 2017; Frans et al., 2018; Co-Reyes et al., 2018; Mao et al., 2018). However, to deal with more complex tasks, additional supervision signals (Andreas et al., 2017; Merel et al., 2017; Shu et al., 2018) or pre-defined lowlevel controllers (Kulkarni et al., 2016; Oh et al., 2017) are required.
+
+To exploit pre-trained modules as low-level controllers, neural module networks (Andreas et al., 2016) have been proposed, which construct a new network dedicated to a given query using a collection of reusable modules. In the RL domain, a meta-controller is trained to follow instructions (Oh et al., 2017) and demonstrations (Xu et al., 2017), and support multi-level hierarchies (Gudimella et al., 2017). In the robotics domain, Pastor et al. (2009); Kober et al. (2010); Mulling et al. (2013) ¨ have proposed a modular approach that learns table tennis by selecting appropriate low-level controllers. On the other hand, Andreas et al. (2017); Frans et al. (2018) learn abstract skills while experiencing a distribution of tasks and then solve a new task with the learned primitive skills. However, these modular approaches result in undefined behavior when two skills are not smoothly connected. Our proposed framework aims to bridge this gap by training transition policies in a model-free manner to navigate the agent from unseen states for following skills to suitable initial states.
+
+![](images/cc1ede4f3e622160e3e86e6149c75a64226e1db6943d107f07a6604700747bf2.jpg)  
+Figure 2: Our modular network augmented with transition policies. To perform a complex task, our model repeats the following steps: (1) The meta-policy chooses a primitive policy of index $c _ { \cdot }$ ; (2) The corresponding transition policy helps initiate the chosen primitive policy; (3) The primitive policy executes the skill; and (4) A success or failure signal for the primitive skill is produced.
+
+Deep RL techniques for continuous control demand dense reward signals; otherwise, they suffer from long training time. Instead of manual reward shaping for denser reward, adversarial reinforcement learning (Ho & Ermon, 2016; Merel et al., 2017; Wang et al., 2017; Bahdanau et al., 2019) employs a discriminator which learns to judge the state or the policy, and the policy takes as rewards the output of the discriminator. While those methods assume ground truth trajectories or goal states are given, our method collects both success and failure trajectories online to train proximity predictors which provide rewards for transition policies.
+
+# 3 APPROACH
+
+In this paper, we address the problem of solving a complex task that requires sequential composition of primitive skills given only sparse and binary rewards (i.e. subtask completion reward). The sequential execution of primitive skills fails when two consecutive skills are not smoothly connected. We propose a modular framework with transition policies that learn to make transition between one policy to the subsequent policy, and therefore, can exploit the given primitive skills to compose complex skills. To accelerate training of transition policies, additional networks, proximity predictors, are jointly trained to provide proximity rewards as intermediate feedback to transition policies. In Section 3.2, we describe our framework in details. Next, in Section 3.3, we elaborate how transition policies are efficiently trained with induced proximity reward.
+
+# 3.1 PRELIMINARIES
+
+We formulate our problem as a Markov decision process defined by a tuple $\{ s , { \mathcal A } , { \mathcal T } , R , \rho , { \gamma } \}$ of states, actions, transition probability, reward, initial state distribution, and discount factor. An action distribution of an agent is represented as a policy $\pi _ { \boldsymbol { \theta } } ( a _ { t } | \boldsymbol { s } _ { t } )$ , where $s _ { t } \in S$ is a state, $a _ { t } \in \mathcal A$ is an action at time $t$ , and $\theta$ are the parameters of the policy. An initial state $s _ { 0 }$ is randomly sampled from $\rho$ , and then, an agent iteratively takes an action $a _ { t }$ sampled from a policy $\pi _ { \boldsymbol { \theta } } { \left( a _ { t } | \boldsymbol { s } _ { t } \right) }$ and receives a reward $r _ { t }$ until the episode ends. The performance of the agent is evaluated based on a discounted return $\begin{array} { r } { R = \sum _ { t = 0 } ^ { T - 1 } \hat { \gamma ^ { t } } r _ { t } } \end{array}$ , where $T$ is the episode horizon.
+
+# 3.2 MODULAR FRAMEWORK WITH TRANSITION POLICIES
+
+To learn a new task given primitive skills $\{ p _ { 1 } , p _ { 2 } , \dots , p _ { n } \}$ , we design a modular framework that consists of the following components: a meta-policy, primitive policies, and transition policies. The meta-policy chooses a primitive skill $p _ { c }$ to execute at the beginning and whenever the primitive skill is terminated. Prior to running $p _ { c }$ , the transition policy for $p _ { c }$ is executed to bring the current state to a plausible initial state for $p _ { c }$ , and therefore, $p _ { c }$ can be successfully performed. This procedure is repeated to compose complex skills as illustrated in Figure 2 and Algorithm 2.
+
+![](images/2d33765f362f87f9cb764776b55285078b1dfadfa2c9c63831ca553f698fb468.jpg)  
+Figure 3: Training of transition policies and proximity predictors. After executing a primitive policy, a previously performed transition trajectory is labeled and added to a replay buffer based on the execution success. A proximity predictor is trained on states sampled from the two buffers to output the proximity to the initiation set. The predicted proximity serves as a reward to encourage the transition policy to move toward good initial states for the corresponding primitive policy.
+
+We denote the meta-policy as $\pi _ { m e t a } ( p _ { c } | s )$ , where $c \in [ 1 , n ]$ is a primitive policy index. The observation of the meta-policy contains the low-level information of primitives and task specifications indicating high-level goals (e.g. moving direction and target object position). For example, a walking primitive only takes joint information as observation while the meta-policy additionally takes target direction. In this paper, we use a rule-based meta-policy and focus on transitioning between consecutive primitive policies.
+
+Once a primitive skill $p _ { c }$ is chosen to be executed, the agent generates an action $a _ { t } \sim \pi _ { p _ { c } } ( a | s _ { t } )$ based on the current state $s _ { t }$ . Note that we did not differentiate state spaces for primitive polices because of the simplicity of notations (e.g. the observation of the jumping primitive contains a distance to a curb while that of the walking primitive only has joint pose and velocities). Every primitive policy is required to generate termination signals $\tau _ { p _ { c } } \in \{ \mathrm { c o n t i n u e } , \mathrm { s u c c e s s } , \mathrm { f a i l } \}$ to indicate policy completion and whether it believes the execution is successful or not. While our method is agnostic to the form of primitive policies (e.g. rule-based, inverse kinematics), we consider the case of a pre-trained neural network in this paper.
+
+For smooth transitions between primitive policies, we add a transition policy $\pi _ { \phi _ { c } } ( a | s )$ before executing primitive skill $p _ { c }$ , which guides an agent to $p _ { c }$ ’s initiation set, where $\phi _ { c }$ is the parameters of the transition policy for $p _ { c }$ . Note that the transition policy for $p _ { c }$ is shared across different preceding primitive policies since a successful transition is defined by the success of the following primitive skill $p _ { c }$ . For brevity of notation, we omit the primitive policy index $c$ in the following equations where unambiguous. The transition policy’s state and action space are the same as the primitive policy’s. The transition policy also learns a termination signal $\tau _ { \mathrm { t r a n s } }$ which indicates transition termination to successfully initiate $p _ { c }$ . Our framework contains one transition policy for each primitive skill, in total $n$ transition policies $\left\{ \pi _ { \phi _ { 1 } } , \pi _ { \phi _ { 2 } } , \ldots , \pi _ { \phi _ { n } } \right\}$ .
+
+# 3.3 TRAINING TRANSITION POLICIES
+
+In our framework, transition policies are trained to make the execution of the corresponding following primitive policies successful. During rollouts, transition trajectories are collected and each trajectory can be naively labeled by the success execution of its corresponding primitive policy. Then, transition policies are trained to maximize the average success of the respective primitive policy. In this scenario, by definition, the only available learning signal for the transition policies is the sparse and binary rewards for the completion of the next task.
+
+To alleviate the sparsity of rewards and maximize the objective of moving to viable initial states for the next primitive, we propose a proximity predictor that learns and provides a dense reward, dubbed proximity reward, of how close transition states are to the initiation set of the corresponding primitive $p _ { c }$ as shown in Figure 3. We denote a proximity predictor as $P _ { \omega _ { c } }$ which is parameterized by $\omega _ { c }$ . We define the proximity of a state as the future discounted proximity, $\ v { v } = \delta ^ { s t e p }$ , where step is the number of steps required to reach an initiation set of the following primitive policy. The proximity of a state can also be a linearly discounted function such as $v = 1 - \delta \cdot s t e p$ . We refer the readers to the supplementary for comparison of two proximity functions.
+
+The proximity predictor is trained to minimize a mean squared error of proximity prediction:
+
+$$
+L _ { P } ( \omega , \mathcal { B } ^ { S } , \mathcal { B } ^ { F } ) = \frac { 1 } { 2 } \mathbb { E } _ { ( s , v ) \sim \mathcal { B } ^ { S } } [ ( P _ { \omega } ( s ) - v ) ^ { 2 } ] + \frac { 1 } { 2 } \mathbb { E } _ { s \sim \mathcal { B } ^ { F } } [ P _ { \omega } ( s ) ^ { 2 } ] ,
+$$
+
+where $B ^ { S }$ and $B ^ { F }$ are collections of states from success and failure transition trajectories, respectively. To estimate the proximity to an initiation set, $B ^ { S }$ contains not only the state that directly leads to the success of the following primitive policy, but also the intermediate states of the successful trajectories with its proximity. By minimizing this objective, given a state, the proximity predictor is learned to predict 1 if the state is in the initiation set, a value that is between 0 and 1 if the state leads the agent to end up with a desired initial states, and 0 when the state leads to a failure.
+
+The goal of a transition policy is to get close to an initiation set which can be formulated as seeking a state $s$ predicted to be in the initiation set by the proximity predictor (i.e. $P _ { \omega } ( s )$ is close to 1). To achieve this goal, the transition policy learns to maximize proximity prediction at the ending state of the transition trajectory $P _ { \omega } ( s _ { T } )$ . In addition to providing reward at the end, we also use the increase of predicted proximity to the initiation set, $\mathsf { \bar { P } } _ { \omega } ( s _ { t + 1 } ) - P _ { \omega } ( s _ { t } )$ , at every timestep as a reward, dubbed proximity reward, to create a denser reward. The transition policy is trained to maximize the expected discounted return:
+
+$$
+R _ { \mathrm { t r a n s } } ( \phi ) = \mathbb { E } _ { ( s _ { 0 } , s _ { 1 } , \ldots , s _ { T } ) \sim \pi _ { \phi } } \Big [ \gamma ^ { T } P _ { \omega } ( s _ { T } ) + \sum _ { t = 0 } ^ { T - 1 } \gamma ^ { t } ( P _ { \omega } ( s _ { t + 1 } ) - P _ { \omega } ( s _ { t } ) ) \Big ] .
+$$
+
+However, in general skill learning scenarios, ground truth states ( $B ^ { S }$ and $B ^ { F }$ ) for training proximity predictors are not available. Hence, the training data for a proximity predictor is obtained online during training its corresponding transition policy. Specifically, we label the states in a transition trajectory as success or failure based on whether the following primitive is successfully executed or not, and add them into the corresponding buffers $B ^ { S }$ or $B ^ { F }$ , respectively. As stated in Algorithm 1, we train transition policies and proximity predictors by alternating between an Adam (Kingma & Ba, 2015) gradient step on $\omega$ to minimize Equation (1) with respect to $P _ { \omega }$ and a PPO (Schulman et al., 2017) step on $\phi$ to maximize Equation (2) with respect to $\pi _ { \phi }$ . We refer readers to the supplementary for further details on training.
+
+In summary, we propose to compose complex skills with transition policies that enable smooth transition between previously acquired primitive policies. Specifically, we propose to reward transition policies based on how close the current state is to suitable initial states of the subsequent policy (i.e. initiation set). To provide the proximity of a state, we collect failing and successful trajectories on the fly and train a proximity predictor to predict the proximity.
+
+Utilizing the learned proximity predictors and proximity rewards for training transition policies is beneficial in the following perspectives: (1) the dense rewards speed up transition policy training by differentiating failing states from states in a successful trajectory; and (2) the joint training mechanism prevents a transition policy from getting stuck in local optima. Whenever a transition policy gets into a local optimum (i.e. fails the following skill with a high proximity reward), the proximity predictor learns to lower the proximity for the failing transition as those states are added to its failure buffer, escaping the local optimum.
+
+# 4 EXPERIMENTS
+
+We conducted experiments on two classes of continuous control tasks: robotic manipulation and locomotion. To illustrate the potential of the proposed framework, modular framework with Transition Policies (TP), we designed a set of complex tasks that require agents to utilize diverse primitive skills which are not optimized for smooth composition. All of our environments are simulated in the MuJoCo physics engine (Todorov et al., 2012).
+
+![](images/297e61018da14f32af1806114b0472849bca0c0487d209502cbf63d7e4b9bd8f.jpg)  
+Figure 4: Tasks and success count curves of our model (blue), TRPO (purple), PPO (magenta), and transition policies (TP) trained on task reward (green) and sparse proximity reward (yellow). Our model achieves the best performance and convergence time. Note that TRPO and PPO are trained 5 times longer than ours with dense rewards since TRPO and PPO do not have primitive skills and learn from scratch. In the success count curves, different temporal scales are used for TRPO and PPO (bottom x-axis) and ours (top $\mathbf { X }$ -axis).
+
+# 4.1 BASELINES
+
+We evaluate our method to answer how transition policies benefit complex task learning and how joint training with proximity predictors boosts training of transition policies. To investigate the impact of the transition policy, we compared policies learned from dense rewards with our modular framework that only learns from sparse and binary rewards (i.e. subtask completion rewards). Moreover, we conducted ablation studies to dissect each component in the training method of transition polices. To answer these questions, we compare the following methods:
+
+• Trust Region Policy Optimization with dense reward (TRPO) represents a state-of-the-art policy gradient method (Schulman et al., 2015), which we use for the standard RL comparison.   
+• Proximal Policy Optimization with dense reward (PPO) is another state-of-the-art policy gradient method (Schulman et al., 2017), which is more stable than TRPO with smaller batch sizes.   
+• Without transition policies (Without-TP) sequentially executes primitive policies without transition policies and has no learnable components.   
+• Transition policies trained on task rewards (TP-Task) represents a modular network augmented with transition policies learned from the sparse and binary reward (i.e. subtask completion reward), whereas our model learns from the dense proximity reward.   
+• Transition policies trained on sparse proximity rewards (TP-Sparse) is a variant of our model which has the proximity reward only at the end of the transition trajectory. In contrast, our model learns from dense proximity rewards generated every timestep.
+
+Table 1: Success count for robotic manipulation, comparing our method against baselines with or without transition policies (TP). Our method achieves the best performance over both RL baselines and the ablated variants. Each entry in the table represents average success count and standard deviation over 50 runs with 3 random seeds.   
+
+<table><tr><td></td><td>Reward</td><td>Repetitive picking up</td><td>Repetitive catching</td><td>Serve</td></tr><tr><td>TRPO</td><td>dense</td><td>0.69± 0.46</td><td>4.54 ± 1.21</td><td>0.32 ± 0.47</td></tr><tr><td>PPO</td><td>dense</td><td>0.95 ± 0.53</td><td>4.26 ± 1.63</td><td>0.00± 0.00</td></tr><tr><td>Without TP</td><td>sparse</td><td>0.99±0.08</td><td>1.00 ± 0.00</td><td>0.11 ±0.32</td></tr><tr><td>TP-Task</td><td>sparse</td><td>0.99 ± 0.08</td><td>4.87 ± 0.58</td><td>0.05 ± 0.21</td></tr><tr><td>TP-Sparse</td><td>sparse</td><td>1.52 ± 1.12</td><td>4.88 ± 0.59</td><td>0.92 ± 0.27</td></tr><tr><td>TP-Dense (ours)</td><td>sparse</td><td>4.84 ± 0.63</td><td>4.97 ± 0.33</td><td>0.92 ± 0.27</td></tr></table>
+
+• Transition policies trained on dense proximity rewards (TP-Dense, Ours) is our final model where transition policies learn from dense proximity rewards.
+
+Initially, we tried comparing baseline methods with our method using only sparse and binary rewards. However, the baselines could not solve any of the tasks due to the complexity and sparse reward of the environments. To provide more competitive comparisons, we engineer dense rewards for baselines (TRPO and PPO) to boost their performance and give baselines 5 times longer training times. We show that transitions with sparse rewards can compete with and even outperform baselines learning from dense rewards. As the performance of TRPO and PPO varies significantly between runs, we train each task with 3 different random seeds and report mean and standard deviation in Figure 4.
+
+# 4.2 ROBOTIC MANIPULATION
+
+For robotic manipulation, we simulate a Kinova Jaco, a 9 DoF robotic arm with 3 fingers. The agent receives full state information, including the absolute location of external objects. The agent uses joint torque control to perform actions. The results are shown in Figure 4 and Table 1.
+
+Pre-trained primitives. There are four pre-trained primitives available: Picking up, Catching, Tossing, and Hitting. Picking up requires the robotic arm to pick up a small block, which is randomly placed on the table. If the box is not picked up after a certain amount of time, the agent fails. Catching learns to catch a block that is thrown towards the arm with random initial position and velocity. The agent fails if it does not catch and stably hold the box for a certain amount of time. Tossing requires the robot to pick up a box, toss it vertically in the air, and land the box at a specified position. Hitting requires the robot to hit a box dropped overhead at a target ball.
+
+Repetitive picking up. The Repetitive picking up task requires the agent to complete the Picking up task 5 times. After each successful pick, the box disappears and a new box will be placed randomly on the table again. Our model achieves the best performance and converges the fastest by learning from the proposed proximity reward. With our dense proximity reward at every transition step, we alleviate credit assignment when compared to providing a sparse proximity reward (TP-Sparse) or using a sparse task reward (TP-Task). Conversely, TRPO and PPO with dense rewards take significantly longer to learn and is unable to pick up the second box as the ending pose after the first picking up is too unstable to initialize the next picking up.
+
+Repetitive catching. Similar to Repetitive picking up, the Repetitive catching task requires the agent to catch boxes consecutively up to 5 times. In this task, other than the modular network without a transition policy, all baselines are able to eventually learn while our model still learns the fastest. We believe this is because the Catching primitive policy has a larger initiation set and therefore, the sparse reward problem is less severe since random exploration is able to succeed with a higher chance.
+
+Serve. Inspired by tennis, Serve requires the robot to toss the ball and hit it at a target. Even with an extensively engineered reward, TRPO and PPO baselines fail to learn because Hitting is not able to learn to cover all terminal states of Tossing (i.e. a set of initial states for Hitting is large which demands longer training time). In contrast, learning to recover from Tossing’s ending states to Hitting’s initiation set is easier for exploration ( $1 1 \%$ of Tossing’s ending states are covered by
+
+Table 2: Success count for locomotion, comparing our method against baselines with or without transition policies (TP). Our method outperforms all baselines in Patrol and Obstacle course. In Hurdle, the reward function for TRPO was extensively engineered, which is not directly comparable to our method. Our method outperforms baselines learning from sparse reward, showing the effectiveness of the proposed proximity predictor. Each entry in the table represents average success count and standard deviation over 50 runs with 3 random seeds.   
+
+<table><tr><td></td><td>Reward</td><td>Patrol</td><td>Hurdle</td><td>Obstacle course</td></tr><tr><td>TRPO</td><td>dense</td><td>1.37 ± 0.52</td><td>4.13 ± 1.54</td><td>0.98 ±1.09</td></tr><tr><td>PPO</td><td>dense</td><td>1.53 ± 0.53</td><td>2.87 ± 1.92</td><td>0.85 ±1.07</td></tr><tr><td>Without TP</td><td>sparse</td><td>1.02 ± 0.14</td><td>0.49 ± 0.75</td><td>0.72 ± 0.72</td></tr><tr><td>TP-Task</td><td>sparse</td><td>1.69 ± 0.63</td><td>1.73 ± 1.28</td><td>1.08 ± 0.78</td></tr><tr><td>TP-Sparse</td><td>sparse</td><td>2.51 ± 1.26</td><td>1.47 ± 1.53</td><td>1.32 ± 0.99</td></tr><tr><td>TP-Dense (Ours)</td><td>sparse</td><td>3.33 ± 1.38</td><td>3.14 ± 1.69 *</td><td>1.90 ± 1.45</td></tr></table>
+
+Hitting’s initiation set as can be seen in Table 1), which reduces the complexity of the task. Thus, our method and the sparse proximity reward baseline are both able to solve it. However, the ablated variant trained on task reward shows high success rates at the beginning of training and collapses after 100 iterations. The performance drops because the transition policy tries to solve failure cases by increasing the transition length and it reaches to a point that it hardly gets reward. This result shows that once the policy falls into local optima, it is not able to escape because the policy will never get a sparse task reward. On the other hand, our method is robust to local optima since the jointly learned dense proximity reward provides a learning signal to an agent even though it cannot get a task reward.
+
+# 4.3 LOCOMOTION
+
+For locomotion, we simulate a 9 DoF planar (2D) bipedal walker. The observation of the agent includes joint position, rotation, and velocity. When the agent needs to interact with objects in the environment, we provide additional input such as distance to the curb and ceiling in front of the agent. The agent uses joint torque control to perform actions. The results are shown in Figure 4 and Table 2.
+
+Pre-trained primitives. Forward and Backward require the walker to walk forward and backward with a certain velocity, respectively. Balancing requires the walker to robustly stand still under the random external forces. Jumping requires the walker jump over a randomly located curb and land safely. Crawling requires the walker to crawl under a ceiling. In all the aforementioned scenarios, the walker fails when the height of the walker is lower than a threshold.
+
+Patrol (Forward and backward). The Patrol task involves walking forward and backward toward goal points on either side and balancing in between to smoothly change its direction. As illustrated in Figure 4, our method consistently outperforms TRPO, PPO, and ablated baselines in stably walking forward and transitioning to walk backward. The agent trained with dense rewards is not able to consistently switch directions, whereas our model can utilize previously learned primitives including Balancing to stabilize a reversal in velocity.
+
+Hurdle (Walking forward and jumping). The Hurdle task requires the agent to walk forward and jump across curbs, which requires a transition between walking and jumping as well as landing the jump to walking forward. As shown in Figure 4, our method outperforms the sparse reward baselines, showing the efficiency our proposed proximity reward. While TRPO with dense rewards can learn this task as well, it requires dense rewards consisting of eight different components to collectively enable TRPO to learn the task. It can be considered as learning both primitive skills and transition between skills from dense rewards. However, the main focus of this paper is to learn a complex task by reusing acquired skills, avoiding an extensive reward design.
+
+Obstacle Course (Walking forward, jumping, and crawling). Obstacle Course is the most difficult among the locomotion tasks, where the walker must walk forward, jump across curbs, and crawl underneath ceilings. It requires three different behaviors and transitions between two very different primitive skills: crawling and jumping. Since the task requires significantly different behaviors that are hard to transition between, TRPO fails to learn the task and only tries to crawl toward the curb without attempting to jump. In contrast, our method learns to transition between all pairs of primitive skills and often succeeds in crossing multiple obstacles.
+
+![](images/ceecaeb0048d336f2e3dbfcb29ff58a7a502d9d2819e590fe08329fb672a296f.jpg)  
+Figure 5: Average transition length and average proximity reward of transition trajectories over training on Manipulation (left) and Patrol (right).
+
+# 4.4 ABLATION STUDY
+
+We conducted additional experiments to understand the contribution of transition policies, proximFINAity predictors, and dense proximity rewards. The modular framework without transition policies (Without-TP) tends to fail the execution of the second skill since the second skill is not trained to cover ending states of the first skill. Especially, in continuous control making a primitive skill that can cover all possible states is very challenging. Transition policies trained from task completion reward (TP-Task) and sparse proximity reward (TP-Sparse) learn to connect consecutive primitives slower because sparse reward is hard to learn from due to the credit assignment problem. On the other hand, our model alleviates the credit assignment problem and learns quickly by giving predicted proximity reward for every transition state-action pair.
+
+# .5 TRAINING OF TRANSITION AND PROXIMITY PREDICTOR
+
+To investigate how transition polices learn to solve the tasks, we present the lengths of transition trajectories and the obtained proximity rewards during training in Figure 5. For manipulation, we show the results of Repetitive picking up and Repetitive catching. For locomotion, we show Patrol with three different transition policies.
+
+The transition policy quickly learns to maximize the proximity reward regardless of the accuracy of the proximity predictor. All the transition policies increase the length while exploring in the beginning, especially for picking up (55 steps) and balance (45 steps). This is because a randomly initialized proximity predictor outputs high proximity for unseen states and a transition policy tries to get a high reward by visiting these states. However, as these failing initial states with high proximity are collected in the failure buffers, the proximity predictor lowers their proximity and the transition policy learns to avoid them. In other words, the transition policy will end up seeking successful states. As transition policies learn to transition to the following skills, the length decreases to get higher proximity rewards earlier.
+
+# 4.6 VISUALIZING TRANSITION TRAJECTORY
+
+Figure 6a shows two transition trajectories (from $s _ { 0 }$ to $t _ { 0 }$ and $s _ { 1 }$ to $t _ { 1 }$ ) and two-dimensional PCA embedding of the ending states (blue) and initiation states (red) of the Picking up primitive. A transition policy starts from states $s _ { 0 }$ and $s _ { 1 }$ where the previous Picking up primitive is terminated. As can be seen in Figure 6a, the proximity predictor outputs small values for $s _ { 0 }$ and $s _ { 1 }$ since they are far from the initiation set of Picking up primitive. Trajectories in the figure show that as the transition policy moves toward states with higher proximity, and finally ends up with states $t _ { 0 }$ and $t _ { 1 }$ which are in the initiation set of the primitive policy.
+
+Figure 6b illustrates PCA embeddings of initiation sets of three primitive skills, Forward (green), Backward (orange), and Balancing (blue). A transition from Forward to Balancing has very long trajectory, but predicted proximity helps the transition policy to reach to an initiation state $t _ { 0 }$ . On the other hand, transitioning between Balancing and Backward only requires 7 steps.
+
+![](images/f94fb4223e35f8021bc9ac596662daec4f63a0d4a4998f038b59caaa44536b97.jpg)  
+Figure 6: Visualization of transition trajectories of (a) Repetitive picking up and (b) Patrol. TOP AND BOTTOM ROWS: contain rendered frames of transition trajectories. MIDDLE ROW: contains states extracted from each primitive skill execution projected onto PCA space. The dots connected with lines are extracted from the same transition trajectory, where the marker color indicates the proximity prediction $P ( s )$ . A higher $P ( s )$ value indicates proximity to states suitable for initializing the next primitive skill. LEFT: two picking up transition trajectories demonstrate that the transition policy learns to navigate from terminate states $s _ { 0 }$ and $s _ { 1 }$ to $t _ { 0 }$ and $t _ { 1 }$ . RIGHT: the forward to balance transition moves between the forward and balance state distributions and the balance to backward transition moves from the balancing states close to the backward states.
+
+# 5 CONCLUSION
+
+In this work, we propose a modular framework with transition policies to empower reinforcement learning agents to learn complex tasks with sparse reward by utilizing prior knowledge. Specifically, we formulate the problem as executing existing primitive skills while smoothly transitioning between primitive skills. To learn transition polices in a sparse reward setting, we propose a proximity predictor which generates dense reward signals and jointly train transition policies and proximity predictors. Our experimental results on robotic manipulation and locomotion tasks demonstrate the effectiveness of employing transition policies. The proposed framework solves complex tasks without reward shaping and outperforms baseline RL algorithms and other ablated baselines.
+
+There are many future directions to investigate. Our method is designed to focus on acquiring transition policies that connect a given set of primitive policies under the predefined meta-policy. We believe that joint learning of a meta-policy and transition policies on a new task would make our framework more flexible. Moreover, we made an assumption that successful transition between two consecutive policies should be achievable by random exploration. To alleviate the exploration problem with sparse rewards, our transition policy training can incorporate exploration methods such as count-based exploration bonuses (Bellemare et al., 2016; Martin et al., 2017) and curiositydriven intrinsic reward (Pathak et al., 2017). We also assume our primitive policies return a signal that indicates whether the execution should be terminated or not, similar to Kulkarni et al. (2016); Oh et al. (2017); Le et al. (2018). Learning to assess the successful termination of primitive policies together with learning transition policies is a promising future direction.
+
+# ACKNOWLEDGMENTS
+
+This project was supported by the center for super intelligence, Kakao Brain, and SKT. The authors would like to thank Yuan-Hong Liao for helpful discussions during initial ideation.
+
+# REFERENCES
+
+Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural module networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.
+
+Jacob Andreas, Dan Klein, and Sergey Levine. Modular multitask reinforcement learning with policy sketches. In International Conference on Machine Learning, 2017.
+
+Pierre-Luc Bacon, Jean Harb, and Doina Precup. The option-critic architecture. In Association for the Advancement of Artificial Intelligence, 2017.
+
+Dzmitry Bahdanau, Felix Hill, Jan Leike, Edward Hughes, Pushmeet Kohli, and Edward Grefenstette. Learning to understand goal specifications by modelling reward. In International Conference on Learning Representations, 2019.
+
+Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, 2016.
+
+John Co-Reyes, YuXuan Liu, Abhishek Gupta, Benjamin Eysenbach, Pieter Abbeel, and Sergey Levine. Self-consistent trajectory autoencoder: Hierarchical reinforcement learning with trajectory embeddings. In International Conference on Machine Learning, 2018.
+
+Christian Daniel, Herke Van Hoof, Jan Peters, and Gerhard Neumann. Probabilistic inference for determining options in reinforcement learning. Machine Learning, 2016.
+
+Prafulla Dhariwal, Christopher Hesse, Oleg Klimov, Alex Nichol, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, Yuhuai Wu, and Peter Zhokhov. Openai baselines. https: //github.com/openai/baselines, 2017.
+
+Nat Dilokthanakul, Christos Kaplanis, Nick Pawlowski, and Murray Shanahan. Feature control as intrinsic motivation for hierarchical reinforcement learning. In IEEE Transactions on Neural Networks and Learning Systems, 2017.
+
+Kevin Frans, Jonathan Ho, Xi Chen, Pieter Abbeel, and John Schulman. Meta learning shared hierarchies. In International Conference on Learning Representations, 2018.
+
+Dibya Ghosh, Avi Singh, Aravind Rajeswaran, Vikash Kumar, and Sergey Levine. Divide and conquer reinforcement learning. In International Conference on Learning Representations, 2018.
+
+Aditya Gudimella, Ross Story, Matineh Shaker, Ruofan Kong, Matthew Brown, Victor Shnayder, and Marcos Campos. Deep reinforcement learning for dexterous manipulation with concept networks. arXiv preprint arXiv: 1709.06977, 2017.
+
+Nicolas Heess, Dhruva TB, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, S. M. Ali Eslami, Martin A. Riedmiller, and David Silver. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv: 1707.02286, 2017.
+
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, 2016.
+
+Diederick P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.
+
+Jens Kober, Katharina Mulling, Oliver Kr ¨ omer, Christoph H Lampert, Bernhard Sch ¨ olkopf, and Jan ¨ Peters. Movement templates for learning of hitting and batting. In International Conference on Robotics and Automation, 2010.
+
+Tejas D Kulkarni, Karthik Narasimhan, Ardavan Saeedi, and Josh Tenenbaum. Hierarchical deep reinforcement learning: Integrating temporal abstraction and intrinsic motivation. In Advances in Neural Information Processing Systems, 2016.
+
+Hoang Le, Nan Jiang, Alekh Agarwal, Miroslav Dudik, Yisong Yue, and Hal Daume, III. Hierar- ´ chical imitation and reinforcement learning. In International Conference on Machine Learning, 2018.
+
+Andrew Levy, Robert Platt, and Kate Saenko. Hierarchical actor-critic. arXiv preprint arXiv:1712.00948, 2017.
+
+Jiayuan Mao, Honghua Dong, and Joseph J. Lim. Universal agent for disentangling environments and tasks. In International Conference on Learning Representations, 2018.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In IEEE International Conference on Computer Vision, 2017.
+
+Jarryd Martin, S Suraj Narayanan, Tom Everitt, and Marcus Hutter. Count-based exploration in feature space for reinforcement learning. In Association for the Advancement of Artificial Intelligence, 2017.
+
+Josh Merel, Yuval Tassa, Dhruva TB, Sriram Srinivasan, Jay Lemmon, Ziyu Wang, Greg Wayne, and Nicolas Heess. Learning human behaviors from motion capture by adversarial imitation. arXiv preprint arXiv: 1707.02201, 2017.
+
+Katharina Mulling, Jens Kober, Oliver Kroemer, and Jan Peters. Learning to select and generalize ¨ striking movements in robot table tennis. International Journal of Robotics Research, 2013.
+
+Andrew Y Ng, Daishi Harada, and Stuart Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In International Conference on Machine Learning, 1999.
+
+Junhyuk Oh, Satinder Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization with multi-task deep reinforcement learning. In International Conference on Machine Learning, 2017.
+
+Peter Pastor, Heiko Hoffmann, Tamim Asfour, and Stefan Schaal. Learning and generalization of motor skills by learning from demonstration. In International Conference on Robotics and Automation, 2009.
+
+Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In International Conference on Machine Learning, 2017.
+
+Xue Bin Peng, Glen Berseth, KangKang Yin, and Michiel Van De Panne. Deeploco: Dynamic locomotion skills using hierarchical deep reinforcement learning. ACM Transactions on Graphics, 2017.
+
+Martin Riedmiller, Roland Hafner, Thomas Lampe, Michael Neunert, Jonas Degrave, Tom van de Wiele, Vlad Mnih, Nicolas Heess, and Jost Tobias Springenberg. Learning by playing solving sparse reward tasks from scratch. In International Conference on Machine Learning, 2018.
+
+Jurgen Schmidhuber. Towards compositional learning with dynamic neural networks. 1990. ¨
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Tianmin Shu, Caiming Xiong, and Richard Socher. Hierarchical and interpretable skill acquisition in multi-task reinforcement learning. In International Conference on Learning Representations, 2018.
+
+Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 1999.
+
+Richard Stuart Sutton. Temporal credit assignment in reinforcement learning. PhD thesis, University of Massachusetts, Amherst, 1984.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems, 2012.
+
+Alexander Sasha Vezhnevets, Simon Osindero, Tom Schaul, Nicolas Heess, Max Jaderberg, David Silver, and Koray Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. In International Conference on Machine Learning, 2017.
+
+Ziyu Wang, Josh S Merel, Scott E Reed, Nando de Freitas, Gregory Wayne, and Nicolas Heess. Robust imitation of diverse behaviors. In Advances in Neural Information Processing Systems, 2017.
+
+Danfei Xu, Suraj Nair, Yuke Zhu, Julian Gao, Animesh Garg, Li Fei-Fei, and Silvio Savarese. Neural task programming: Learning to generalize across hierarchical tasks. In International Conference on Robotics and Automation, 2017.
+
+# A ACQUIRING PRIMITIVE POLICIES
+
+The modular framework proposed in this paper allows a primitive policy to be any of a pre-trained neural network, inverse kinematics module, or hard-coded policy. In this paper, we use neural networks trained with TRPO (Schulman et al., 2015) on dedicated environments as primitive policies (see Section C for the details of environments and reward functions). All policy networks we used consists of 2 layers of 32 hidden units with tanh nonlinearities and predicts the mean and standard deviation of a Gaussian distribution over an action space. We trained all primitive policies until the total return converged (up to 10,000 iterations).
+
+Given a state, a primitive policy outputs an action as well as a termination signal indicating whether the execution is done and if the skill was successfully performed (see Section C for details on primitive skills and termination conditions).
+
+# B TRAINING DETAILS
+
+# B.1 IMPLEMENTATION DETAILS
+
+For the TRPO and PPO implementation, we used OpenAI baselines (Dhariwal et al., 2017) with default hyperparameters including learning rate, KL penalty, and entropy coefficients unless specified below.   
+
+<table><tr><td>Hyperparameters</td><td>Transition policy</td><td>Proximity predictor</td><td>Primitive policy</td><td>TRPO</td><td>PPO</td></tr><tr><td>Learning rate</td><td>1e-4</td><td>1e-4</td><td>1e-3 (for critic)</td><td>1e-3 (for critic)</td><td>1e-4</td></tr><tr><td># Mini-batch</td><td>150</td><td>150</td><td>32</td><td>150</td><td>150</td></tr><tr><td>Mini-batch size</td><td>64</td><td>64</td><td>64</td><td>64</td><td>64</td></tr><tr><td>Learning rate decay</td><td>no</td><td>no</td><td>no</td><td>no</td><td>linear decay</td></tr></table>
+
+Table 3: Hyperparameter values for transition policy, proximity predictor, and primitive policy as well as TRPO and PPO baselines.
+
+For all networks, we use the Adam optimizer with mini-batch size of 64. We use 4 workers for rollout and parameter update. The size of rollout for each update is 10,000 steps. We limit the maximum length of a transition trajectory as 100.
+
+# B.2 REPLAY BUFFERS
+
+A success buffer $B ^ { S }$ contains states and their proximity to the corresponding initiation set in successful transitions. On the other hand, a failure buffer $B ^ { F }$ contains states in failure transitions. Both the two buffers are FIFO (i.e. new items are added on one end and once a buffer is full, a corresponding number of items are discarded from the opposite end). For all experiments, we use buffers, $| B ^ { S }$ and $B ^ { F }$ , with a capacity of one million states.
+
+For efficient training of the proximity predictors, we collect successful trajectories of primitive skills which can be sampled during the training of primitive skills. We run 1,000 episodes for each primitive and put the first $10 \text{‰}$ in trajectories into the success buffer as an initiation set. While initiation sets can be discovered via random exploration, we found that this initialization of success buffers improves the efficiency of training by providing initial training data for the proximity predictors.
+
+# B.3 PROXIMITY REWARD
+
+Transition policies receive rewards based on the outputs of proximity predictors. Before computing the reward at every time step, we clip the output of the proximity predictor $P$ by $\mathrm { c l i p } ( P ( s ) , 0 , 1 { \bar { ) } }$ which indicates how close the state $s$ is to the initiation set of the following primitive (higher values correspond to closer states). We define the proximity of a state to an initiation set as an exponentially discounted function $\delta ^ { s t e p }$ , where step is the shortest number of timesteps required to get to a state in the initiation set. We use $\delta = 0 . 9 5$ for all experiments. To make the reward denser, for every timestep $t$ , we provide the increase in proximity, $P ( s _ { t + 1 } ) - P ( s _ { t } )$ , as a reward for transition policy.
+
+![](images/6c28fae4fcfe61716a220a6b3fbccb00222d402fb9348abb18797f41db467944.jpg)  
+Figure 7: Success count curves of our model with exponentially discounted proximity function and linearly discounted proximity function over training on Obstacle course (left) and Repetitive catching (right).
+
+Using a linearly discounted proximity function, $1 - \delta \cdot s t e p$ , is also a valid choice. We compare the two proximity functions on a manipulation task (Repetitive catching) and a locomotion task (Obstacle course), as shown in Figure 7, where $\delta$ for exponential decay and linear decay are 0.95 and 0.01, respectively. The results demonstrate that our model is able to learn well with both proximity functions and they perform similarly.
+
+Originally, we opted for the exponential proximity function with the intuition that the faster initial decay near the initiation set would help the policy discriminate successful states from failing states near the initiation set. Also, in our experiments, as we use 0.95 as a decaying factor, the proximity is still reasonably large (e.g., 0.35 for 20 time-steps and 0.07 for 50 time-steps). In this paper, we use the exponential proximity function for all experiments.
+
+# B.4 PROXIMITY PREDICTOR
+
+A proximity predictor takes a state as input which includes joint state information, joint acceleration, and any task specification, such as ceiling and curb information. A proximity predictor consists of 2 fully connected layers of 96 hidden units with ReLU nonlinearities and predicts the proximity to the initiation set based on the states sampled from the success and failure buffers. Each training iteration consists of 10 epochs over a batch size of 64 and use a learning rate of $1 0 ^ { - 4 }$ . The predictor optimizes the loss in Equation (1), similar to the LSGAN loss (Mao et al., 2017).
+
+# B.5 TRANSITION POLICIES
+
+An observation space of a transition policy consists of joint state information and joint acceleration. A transition policy consists of 2 fully connected layers of 32 hidden units with tanh nonlinearities and predicts the mean and standard deviation of a Gaussian distribution over an action space. A 2-way softmax layer is followed by the last fully connected layer to predict whether to terminate the current transition or not. We train all transition policies using PPO (Schulman et al., 2017) since PPO is robust on smaller batch sizes and the transition states collected for each update is much smaller than the size of a rollout. Each training iteration consists of 5 epochs over a batch.
+
+# Algorithm 1 TRAIN
+
+1: Input: Primitive polices $\{ \pi _ { p _ { 1 } } , . . . , \pi _ { p _ { n } } \}$ .   
+2: Initialize success buffers $\{ B _ { 1 } ^ { \mathrm { S } } , . . . , B _ { n } ^ { \mathrm { S } } \}$ with successful trajectories of primitive policies.   
+3: Initialize failure buffers $\{ B _ { 1 } ^ { \mathrm { F } } , . . . , B _ { n } ^ { \mathrm { F } } \}$ .   
+4: Randomly initialize parameters of transition policies $\big \{ \phi _ { 1 } , . . . , \phi _ { n } \big \}$ and proximity predictors $\{ \omega _ { 1 }$ ,   
+$\ldots , \omega _ { n } \}$ .   
+5: repeat   
+6: Initialize rollout buffers $\{ \mathcal { R } _ { 1 } , . . . , \mathcal { R } _ { n } \}$ .   
+7: Collect trajectories using ROLLOUT.   
+8: for $i = 1$ to $n$ do   
+9: Update $P _ { \omega _ { i } }$ to minimize Equation (1) using $B _ { i } ^ { \mathrm { S } }$ and $B _ { i } ^ { \mathrm { F } }$ .   
+10: Update $\pi _ { \phi _ { i } }$ to maximize Equation (2) using $\mathcal { R } _ { i }$ .   
+11: end for   
+12: until convergence
+
+# Algorithm 2 ROLLOUT
+
+1: Input: Meta policy $\pi _ { \mathrm { m e t a } }$ , primitive policies $\{ \pi _ { p _ { 1 } } , . . . , \pi _ { p _ { n } } \}$ , transition policies $\{ \pi _ { \phi _ { 1 } } , . . . , \pi _ { \phi _ { n } } \}$ ,   
+and proximity predictors $\{ P _ { \omega _ { 1 } } , . . . , P _ { \omega _ { n } } \}$ .   
+2: Initialize an episode and receive initial state $s _ { 0 }$ .   
+3: $t \gets 0$   
+4: while episode is not terminated do   
+5: $c \sim \bar { \pi } _ { \mathrm { m e t a } } ( s _ { t } )$   
+6: Initialize a rollout buffer $\boldsymbol { B }$ .   
+7: while episode is not terminated do   
+8: $a _ { t } , \tau _ { \mathrm { t r a n s } } \sim \pi _ { \phi _ { c } } ( s _ { t } )$   
+9: Terminate the transition policy if $\tau _ { \mathrm { t r a n s } } =$ terminate.   
+10: st+1, $\tau _ { \mathrm { e n v } } \gets \mathrm { E N V } ( s _ { t } , a _ { t } )$   
+11: $r _ { t } \gets P _ { \omega _ { c } } ( s _ { t + 1 } ) - P _ { \omega _ { c } } ( s _ { t } )$   
+12: Store $\left( s _ { t } , a _ { t } , r _ { t } , \tau _ { \mathrm { e n v } } , s _ { t + 1 } \right)$ in $\boldsymbol { B }$   
+13: $t \gets t + 1$   
+14: end while   
+15: while episode is not terminated do   
+16: $a _ { t } , \tau _ { p _ { c } } \sim \pi _ { p _ { c } } ( s _ { t } )$   
+17: Terminate the primitive policy if $\tau _ { p _ { c } } \neq$ continue.   
+18: $\mathbf { \Lambda } _ { t + 1 } ^ { s _ { t + 1 } , \tau _ { \mathrm { e n v } } } \gets \dot { \mathrm { E N V } } ( s _ { t } , a _ { t } )$   
+19:   
+20: end while   
+21: Compute the discounted proximity $v$ of each state $s$ in $\boldsymbol { B }$ .   
+22: Add pairs of (s, v) to BSc or BFc according to τpc .   
+23: Add $\boldsymbol { B }$ to the rollout buffer $\mathcal { R } _ { c }$ .   
+24: end while
+
+# B.6 SCALABILITY
+
+Each sub-policy requires its corresponding transition policy, proximity predictor, and two buffers. Hence, both the time and memory complexities of our method are linearly dependent on the number of sub-policies. The memory overhead is affordable since a transition policy (2 layers of 32 hidden units), a proximity predictor (2 layers of 96 hidden units), and replay buffers (1M states) are small.
+
+# C ENVIRONMENT DESCRIPTIONS
+
+For every task, we add a control penalty, $- 0 . 0 0 1 * \| a \| ^ { 2 }$ , to regularize the magnitude of actions where $a$ is a torque action performed by an agent. Note that all measures are in meters, and we omit the measures here for clarity of the presentation.
+
+# C.1 ROBOTIC MANIPULATION
+
+In object manipulation tasks, a 9-DOF Jaco robotic $\mathrm { a r m } ^ { 1 }$ is used as an agent and a cube with the side length $0 . 0 6 \mathrm { m }$ is used as a target object. We follow the tasks and environment settings proposed in Ghosh et al. (2018). The observation consists of the position of the base of the Jaco arm, joint angles, angular velocities as well as the position, rotation, velocity, and angular velocity of the cube. The action space is a torque control on 9 joints.
+
+# C.1.1 REWARD DESIGN AND TERMINATION CONDITION
+
+Picking up: In the Picking up task, the position of the box is randomly initialized within a square region of size $0 . 1 \textrm { m } \times 0 . 1 \textrm { m }$ with a center (0.5, 0.2). There is an initial guide reward to guide the arm to the box. There is also an over reward to guide the hand directly over the box. When the arm is not picking up the box, there is a pick reward to incentivize the arm to pick the box up. There is an additional hold reward that makes the arm hold the box in place after picking up. Finally, there is a success reward given after the arm has held the box for 50 frames. The success reward is scaled with number of timesteps to encourage the arm to succeed as quickly as possible.
+
+$R ( s ) = \lambda _ { g u i d e }$ ·1Box not picked and Box on ground $+ \lambda _ { p i c k }$ ·1Box in hand and not picked $+ \lambda _ { h o l d }$ ·1Box picked and near hold point
+
+$$
+\lambda _ { g u i d e } = 2 , \lambda _ { p i c k } = 1 0 0 , \lambda _ { h o l d } = 0 . 1
+$$
+
+Catching: The position of the box is initialized at (0, 2.0, 1.5) and the directional force of size 110 is applied to throw the box toward the agent with randomness $( 0 . 1 \mathrm { m } \times 0 . 1 \mathrm { m } )$ ).
+
+Tossing: The box is randomly initialized on the ground at (0.4, 0.3, 0.05) within a $0 . 0 0 5 \times 0 . 0 0 5$ square region. A guide reward is given to guide the arm to the top of the box. A pick reward is then given to lift the box up to a specified release height. A release reward is given if the box is no longer in the hand. A stable reward is given to minimize variation in the box’s x and y direction. An up reward is given while the ball is traveling upwards in air, up until the box hits a specified z height. Finally, a success reward $+ 1 0 0$ is given based on the landing position of the box and the specified landing position.
+
+Hitting: The box is randomly initialized overhead the arm at (0.4, 0.3, 1.2) within a $0 . 0 0 5 \times 0 . 0 0 5$ m square region. The box falls and the arm is given a hit reward $+ 1 0$ for hitting the box. Once the box has been hit, a target reward is given based on how close the box is to the target.
+
+Repetitive picking up: The Repetitive picking up task has two reward variants. The sparse version gives a reward $+ 1$ for every successful pick. The dense reward version gives a guide reward to the box after each successful pick following the reward for the Picking up task.
+
+Repetitive catching: The Repetitive catching task gives a reward $+ 1$ for every successful catch.   
+For dense reward, it uses the same reward function with that of the Catching task.
+
+Serve: The Serve task gives a toss reward $+ 1$ for a successful toss and a target reward $+ 1$ for successfully hitting the target. The dense reward setting provides the Tossing and Hitting reward according to box position.
+
+# C.2 LOCOMOTION
+
+A 9-DOF bipedal planar walker is used for simulating locomotion tasks. The observation consists of the position and velocity of the torso, joint angles, and angular velocities. The action space is torque control on the 6 joints.
+
+# C.2.1 REWARD DESIGN
+
+Different locomotion tasks share many components of reward design, such as velocity, stability, and posture. We use the same form of reward functions, but with different hyperparameters for each task. The basic form of the reward function is as following:
+
+$$
+\begin{array} { r l } & { R ( s ) = \lambda _ { v e l } \cdot \mathrm { a b s } ( v _ { x } - v _ { t a r g e t } ) + \lambda _ { a l i v e } - \lambda _ { h e i g h t } \cdot \mathrm { a b s } ( 1 . 1 - m i n ( 1 . 1 , \Delta h ) ) + } \\ & { ~ \lambda _ { a n g l e } \cdot \mathrm { c o s } ( a n g l e ) - \lambda _ { f o o t } ( v _ { r i g h t . f o o t } + v _ { l e f t . f o o t } ) , } \end{array}
+$$
+
+where $v _ { x }$ $, v _ { r i g h t . f o o t }$ , and $v _ { l e f t _ { - } f o o t }$ are forward velocity, right foot angular velocity, left foot angular velocity; and $\Delta h$ and angle are the distance between the foot and torso and the angle of the torso, respectively. The foot velocities help the agent to move its feet naturally. $\Delta h$ and angle are used to maintain height of the torso and encourage an upright pose.
+
+Forward: The Forward task requires the walker agent to walk forward for 20 meters. To make the agent robust, we apply a random force with arbitrary magnitude and direction to a randomly selected joint every 10 timesteps.
+
+$$
+\lambda _ { v e l } = 2 , \lambda _ { a l i v e } = 1 , \lambda _ { h e i g h t } = 2 , \lambda _ { a n g l e } = 0 . 1 , \lambda _ { f o o t } = 0 . 0 1 , \mathrm { ~ a n d ~ } v _ { t a r g e t } = 3
+$$
+
+Backward: Similar to Forward, the Backward task requires the walker to walk backward for 20 meters under random forces.
+
+$$
+\lambda _ { v e l } = 2 , \lambda _ { a l i v e } = 1 , \lambda _ { h e i g h t } = 2 , \lambda _ { a n g l e } = 0 . 1 , \lambda _ { f o o t } = 0 . 0 1 , \mathrm { ~ a n d ~ } v _ { t a r g e t } = - 3
+$$
+
+Balancing: In the Balancing task, the agent learns to balance under strong random forces for 1000 timesteps. Similar to other tasks, the random forces are applied to a random joint every 10 timesteps, but with magnitude 5 times larger.
+
+$$
+\lambda _ { v e l } = 1 , \lambda _ { a l i v e } = 1 , \lambda _ { h e i g h t } = 0 . 5 , \lambda _ { a n g l e } = 0 . 1 , \lambda _ { f o o t } = 0 , \mathrm { ~ a n d ~ } v _ { t a r g e t } = 0
+$$
+
+Crawling: In the Crawling task, a ceiling of height 1.0 and length 16 is located in front of the agent, and the agent is required to crawl under the ceiling without touching it. If the agent touches the ceiling, we terminate the episode. The task can be completed when the agent passes a point 1.5 after the ceiling and the agent gets 100 additional reward.
+
+$$
+\lambda _ { v e l } = 2 , \lambda _ { a l i v e } = 1 , \lambda _ { h e i g h t } = 0 , \lambda _ { a n g l e } = 0 . 1 , \lambda _ { f o o t } = 0 . 0 1 , \mathrm { ~ a n d ~ } v _ { t a r g e t } = 3
+$$
+
+Jumping: In the Jumping task, a curb of height 0.4 and length 0.2 is located in front of the walker agent. The observation contains a distance to the curb in addition to the 17-dimensional joint information, where the distance is clipped by 3. The $\mathbf { X }$ location of the curb is randomly chosen from [2.5, 5.5]. In addition to the reward function above, it also gets an additional 100 reward for passing the curb and $2 0 0 \cdot v _ { y }$ when the agent passes the front, middle, and end slices of the curb, where $v _ { y }$ is y-velocity. If the agent touches the curb, the agent gets -10 penalty and the episode is terminated.
+
+Patrol: The Patrol task is repetitive running forward and backward between two goals at $x = - 2$ and $x = 2$ . Once the agent touches a goal, the target is changed to another goal and the sparse reward $+ 1$ is given. The dense reward alternates between the reward functions of Forward and Backward. The agent gets the reward of Forward when the agent is heading toward $x = 2$ and gets the reward of Backward, otherwise.
+
+Hurdle: The Hurdle environment consists of 5 curbs positioned at $x = \{ 8 , 1 8 , 2 8 , 3 8 , 4 8 \}$ and requires repetitive walking and jumping behaviors. The position of each curb is randomized with a uniformly sampled value from $[ - 0 . 5 , 0 . 5 ]$ . The sparse reward $+ 1$ is given when the agent jumps over a curb (i.e. pass a point 1.5 after a curb).
+
+The dense reward for Hurdle is same with Jumping and has 8 reward components to guide the agent to learn the desired behavior. By extensively designing dense rewards, it is possible to solve complex tasks. In comparison, our proposed method learns from sparse reward by re-using prior knowledge and doesn’t require reward shaping.
+
+Obstacle Course: The Obstacle Course environment replaces two curbs in Hurdle with a ceiling of height 1.0 and length 3. The sparse reward $+ 1$ is given when the agent jumps over a curb or passes through a ceiling (i.e. pass a point 1.5 after a curb or a ceiling). The dense reward is alternating between Jumping before the curb and Crawling before the ceiling.
+
+# C.2.2 TERMINATION SIGNAL
+
+Locomotion tasks except Crawling fail if $h < 0 . 8$ and Crawling fails if $h \ : < \ : 0 . 3$ . Forward and Backward tasks are considered as success when the walker reaches to the target or 5 in front of obstacles. Balancing task is considered successful when the agent does not fail for 50 timesteps. The agent succeeds on Jumping and Crawling if the agent passes the obstacles by a distance of 1.5.