Add files using upload-large-folder tool

parse/train/B1VZqjAcYX/B1VZqjAcYX.md

@@ -0,0 +1,330 @@
+# SNIP: SINGLE-SHOT NETWORK PRUNING BASED ONCONNECTION SENSITIVITY
+
+Namhoon Lee, Thalaiyasingam Ajanthan & Philip H. S. Torr University of Oxford {namhoon,ajanthan,phst}@robots.ox.ac.uk
+
+# ABSTRACT
+
+Pruning large neural networks while maintaining their performance is often desirable due to the reduced space and time complexity. In existing methods, pruning is done within an iterative optimization procedure with either heuristically designed pruning schedules or additional hyperparameters, undermining their utility. In this work, we present a new approach that prunes a given network once at initialization prior to training. To achieve this, we introduce a saliency criterion based on connection sensitivity that identifies structurally important connections in the network for the given task. This eliminates the need for both pretraining and the complex pruning schedule while making it robust to architecture variations. After pruning, the sparse network is trained in the standard way. Our method obtains extremely sparse networks with virtually the same accuracy as the reference network on the MNIST, CIFAR-10, and Tiny-ImageNet classification tasks and is broadly applicable to various architectures including convolutional, residual and recurrent networks. Unlike existing methods, our approach enables us to demonstrate that the retained connections are indeed relevant to the given task.
+
+# 1 INTRODUCTION
+
+Despite the success of deep neural networks in machine learning, they are often found to be highly overparametrized making them computationally expensive with excessive memory requirements. Pruning such large networks with minimal loss in performance is appealing for real-time applications, especially on resource-limited devices. In addition, compressed neural networks utilize the model capacity efficiently, and this interpretation can be used to derive better generalization bounds for neural networks (Arora et al. (2018)).
+
+In network pruning, given a large reference neural network, the goal is to learn a much smaller subnetwork that mimics the performance of the reference network. The majority of existing methods in the literature attempt to find a subset of weights from the pretrained reference network either based on a saliency criterion (Mozer & Smolensky (1989); LeCun et al. (1990); Han et al. (2015)) or utilizing sparsity enforcing penalties (Chauvin (1989); Carreira-Perpin˜an & Idelbayev (2018)). ´ Unfortunately, since pruning is included as a part of an iterative optimization procedure, all these methods require many expensive prune – retrain cycles and heuristic design choices with additional hyperparameters, making them non-trivial to extend to new architectures and tasks.
+
+In this work, we introduce a saliency criterion that identifies connections in the network that are important to the given task in a data-dependent way before training. Specifically, we discover important connections based on their influence on the loss function at a variance scaling initialization, which we call connection sensitivity. Given the desired sparsity level, redundant connections are pruned once prior to training (i.e., single-shot), and then the sparse pruned network is trained in the standard way. Our approach has several attractive properties:
+
+• Simplicity. Since the network is pruned once prior to training, there is no need for pretraining and complex pruning schedules. Our method has no additional hyperparameters and once pruned, training of the sparse network is performed in the standard way.   
+• Versatility. Since our saliency criterion chooses structurally important connections, it is robust to architecture variations. Therefore our method can be applied to various architectures including convolutional, residual and recurrent networks with no modifications.
+
+• Interpretability. Our method determines important connections with a mini-batch of data at single-shot. By varying this mini-batch used for pruning, our method enables us to verify that the retained connections are indeed essential for the given task.
+
+We evaluate our method on MNIST, CIFAR-10, and Tiny-ImageNet classification datasets with widely varying architectures. Despite being the simplest, our method obtains extremely sparse networks with virtually the same accuracy as the existing baselines across all tested architectures. Furthermore, we investigate the relevance of the retained connections as well as the effect of the network initialization and the dataset on the saliency score.
+
+# 2 RELATED WORK
+
+Classical methods. Essentially, early works in network pruning can be categorized into two groups (Reed (1993)): 1) those that utilize sparsity enforcing penalties; and 2) methods that prune the network based on some saliency criterion. The methods from the former category (Chauvin (1989); Weigend et al. (1991); Ishikawa (1996)) augment the loss function with some sparsity enforcing penalty terms (e.g., $L _ { 0 }$ or $L _ { 1 }$ norm), so that back-propagation effectively penalizes the magnitude of the weights during training. Then weights below a certain threshold may be removed. On the other hand, classical saliency criteria include the sensitivity of the loss with respect to the neurons (Mozer & Smolensky (1989)) or the weights (Karnin (1990)) and Hessian of the loss with respect to the weights (LeCun et al. (1990); Hassibi et al. (1993)). Since these criteria are heavily dependent on the scale of the weights and are designed to be incorporated within the learning process, these methods are prohibitively slow requiring many iterations of pruning and learning steps. Our approach identifies redundant weights from an architectural point of view and prunes them once at the beginning before training.
+
+Modern advances. In recent years, the increased space and time complexities as well as the risk of overfitting in deep neural networks prompted a surge of further investigation in network pruning. While Hessian based approaches employ the diagonal approximation due to its computational simplicity, impressive results (i.e., extreme sparsity without loss in accuracy) are achieved using magnitude of the weights as the criterion (Han et al. (2015)). This made them the de facto standard method for network pruning and led to various implementations (Guo et al. (2016); Carreira-Perpin˜an & ´ Idelbayev (2018)). The magnitude criterion is also extended to recurrent neural networks (Narang et al. (2017)), yet with heavily tuned hyperparameter setting. Unlike our approach, the main drawbacks of magnitude based approaches are the reliance on pretraining and the expensive prune – retrain cycles. Furthermore, since pruning and learning steps are intertwined, they often require highly heuristic design choices which make them non-trivial to be extended to new architectures and different tasks. Meanwhile, Bayesian methods are also applied to network pruning (Ullrich et al. (2017); Molchanov et al. (2017a)) where the former extends the soft weight sharing in Nowlan & Hinton (1992) to obtain a sparse and compressed network, and the latter uses variational inference to learn the dropout rate which can then be used to prune the network. Unlike the above methods, our approach is simple and easily adaptable to any given architecture or task without modifying the pruning procedure.
+
+Network compression in general. Apart from weight pruning, there are approaches focused on structured simplification such as pruning filters (Li et al. (2017); Molchanov et al. (2017b)), structured sparsity with regularizers (Wen et al. (2016)), low-rank approximation (Jaderberg et al. (2014)), matrix and tensor factorization (Novikov et al. (2015)), and sparsification using expander graphs (Prabhu et al. (2018)) or Erdos-R ˝ enyi random graph (Mocanu et al. (2018)). In addition, ´ there is a large body of work on compressing the representation of weights. A non-exhaustive list includes quantization (Gong et al. (2014)), reduced precision (Gupta et al. (2015)) and binary weights (Hubara et al. (2016)). In this work, we focus on weight pruning that is free from structural constraints and amenable to further compression schemes.
+
+# 3 NEURAL NETWORK PRUNING
+
+The main hypothesis behind the neural network pruning literature is that neural networks are usually overparametrized, and comparable performance can be obtained by a much smaller network (Reed (1993)) while improving generalization (Arora et al. (2018)). To this end, the objective is to learn
+
+a sparse network while maintaining the accuracy of the standard reference network. Let us first formulate neural network pruning as an optimization problem.
+
+Given a dataset $\mathbfcal { D } = \{ ( \mathbf { x } _ { i } , \mathbf { y } _ { i } ) \} _ { i = 1 } ^ { n }$ , and a desired sparsity level $\kappa$ (i.e., the number of non-zero weights) neural network pruning can be written as the following constrained optimization problem:
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { m i n } _ { \mathbf { w } } L ( \mathbf { w } ; \mathcal { D } ) = \displaystyle \operatorname* { m i n } _ { \mathbf { w } } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \ell ( \mathbf { w } ; ( \mathbf { x } _ { i } , \mathbf { y } _ { i } ) ) ~ , } \\ { \mathrm { s . t . } \quad \mathbf { w } \in \mathbb { R } ^ { m } , \quad \| \mathbf { w } \| _ { 0 } \leq \kappa ~ . } \end{array}
+$$
+
+Here, $\ell ( \cdot )$ is the standard loss function (e.g., cross-entropy loss), w is the set of parameters of the neural network, $m$ is the total number of parameters and $\| \cdot \| _ { 0 }$ is the standard $L _ { 0 }$ norm.
+
+The conventional approach to optimize the above problem is by adding sparsity enforcing penalty terms (Chauvin (1989); Weigend et al. (1991); Ishikawa (1996)). Recently, Carreira-Perpin˜an´ $\&$ Idelbayev (2018) attempts to minimize the above constrained optimization problem using the stochastic version of projected gradient descent (where the projection is accomplished by pruning). However, these methods often turn out to be inferior to saliency based methods in terms of resulting sparsity and require heavily tuned hyperparameter settings to obtain comparable results.
+
+On the other hand, saliency based methods treat the above problem as selectively removing redundant parameters (or connections) in the neural network. In order to do so, one has to come up with a good criterion to identify such redundant connections. Popular criteria include magnitude of the weights, i.e., weights below a certain threshold are redundant (Han et al. (2015); Guo et al. (2016)) and Hessian of the loss with respect to the weights, i.e., the higher the value of Hessian, the higher the importance of the parameters (LeCun et al. (1990); Hassibi et al. (1993)), defined as follows:
+
+$$
+s _ { j } = \left\{ \begin{array} { l l } { \left| w _ { j } \right| , } & { \mathrm { f o r m a g n i t u d e ~ b a s e d } } \\ { \frac { w _ { j } ^ { 2 } H _ { j j } } { 2 } } & { \mathrm { o r } \frac { w _ { j } ^ { 2 } } { 2 H _ { j j } ^ { - 1 } } } & { \mathrm { f o r } \mathrm { H e s s i a n ~ b a s e d } . } \end{array} \right.
+$$
+
+Here, for connection $j , s _ { j }$ is the saliency score, $w _ { j }$ is the weight, and $H _ { j j }$ is the value of the Hessian matrix, where the Hessian $\mathbf { H } = \partial ^ { 2 } L / \partial \mathbf { w } ^ { 2 } \in \mathbb { R } ^ { m \times m }$ . Considering Hessian based methods, the Hessian matrix is neither diagonal nor positive definite in general, approximate at best, and intractable to compute for large networks.
+
+Despite being popular, both of these criteria depend on the scale of the weights and in turn require pretraining and are very sensitive to the architectural choices. For instance, different normalization layers affect the scale of the weights in a different way, and this would non-trivially affect the saliency score. Furthermore, pruning and the optimization steps are alternated many times throughout training, resulting in highly expensive prune – retrain cycles. Such an exorbitant requirement hinders the use of pruning methods in large-scale applications and raises questions about the credibility of the existing pruning criteria.
+
+In this work, we design a criterion which directly measures the connection importance in a datadependent manner. This alleviates the dependency on the weights and enables us to prune the network once at the beginning, and then the training can be performed on the sparse pruned network. Therefore, our method eliminates the need for the expensive prune – retrain cycles, and in theory, it can be an order of magnitude faster than the standard neural network training as it can be implemented using software libraries that support sparse matrix computations.
+
+# 4 SINGLE-SHOT NETWORK PRUNING BASED ON CONNECTION SENSITIVITY
+
+Given a neural network and a dataset, our goal is to design a method that can selectively prune redundant connections for the given task in a data-dependent way even before training. To this end, we first introduce a criterion to identify important connections and then discuss its benefits.
+
+# 4.1 CONNECTION SENSITIVITY: ARCHITECTURAL PERSPECTIVE
+
+Since we intend to measure the importance (or sensitivity) of each connection independently of its weight, we introduce auxiliary indicator variables $\mathbf { c } \in \{ 0 , 1 \} ^ { m }$ representing the connectivity of
+
+parameters w.1 Now, given the sparsity level $\kappa$ , Equation 1 can be correspondingly modified as:
+
+$$
+\begin{array} { r l } { \displaystyle \operatorname* { m i n } _ { \mathbf { c } , \mathbf { w } } L ( \mathbf { c } \odot \mathbf { w } ; \mathcal { D } ) = \displaystyle \operatorname* { m i n } _ { \mathbf { c } , \mathbf { w } } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \ell ( \mathbf { c } \odot \mathbf { w } ; ( \mathbf { x } _ { i } , \mathbf { y } _ { i } ) ) ~ , } & { } \\ { \mathrm { s . t . } \quad \mathbf { w } \in \mathbb { R } ^ { m } ~ , } & { } \\ { \displaystyle \quad \mathbf { c } \in \{ 0 , 1 \} ^ { m } , \quad \| \mathbf { c } \| _ { 0 } \leq \kappa ~ , } \end{array}
+$$
+
+where $\odot$ denotes the Hadamard product. Compared to Equation 1, we have doubled the number of learnable parameters in the network and directly optimizing the above problem is even more difficult. However, the idea here is that since we have separated the weight of the connection (w) from whether the connection is present or not (c), we may be able to determine the importance of each connection by measuring its effect on the loss function.
+
+For instance, the value of $c _ { j }$ indicates whether the connection $j$ is active $( c _ { j } = 1 )$ ) in the network or pruned $( c _ { j } = 0 )$ . Therefore, to measure the effect of connection $j$ on the loss, one can try to measure the difference in loss when $c _ { j } = 1$ and $c _ { j } = 0$ , keeping everything else constant. Precisely, the effect of removing connection $j$ can be measured by,
+
+$$
+\begin{array} { r } { \Delta L _ { j } ( \mathbf { w } ; \mathcal { D } ) = L \big ( \mathbf { 1 } \odot \mathbf { w } ; \mathcal { D } \big ) - L \big ( \big ( \mathbf { 1 } - \mathbf { e } _ { j } \big ) \odot \mathbf { w } ; \mathcal { D } \big ) , } \end{array}
+$$
+
+where $\mathbf { e } _ { j }$ is the indicator vector of element $j$ (i.e., zeros everywhere except at the index $j$ where it is one) and 1 is the vector of dimension $m$ .
+
+Note that computing $\Delta L _ { j }$ for each $j \in \{ 1 \ldots m \}$ is prohibitively expensive as it requires $m + 1$ (usually in the order of millions) forward passes over the dataset. In fact, since $\mathbf { c }$ is binary, $L$ is not differentiable with respect to $\mathbf { c }$ , and it is easy to see that $\Delta L _ { j }$ attempts to measure the influence of connection $j$ on the loss function in this discrete setting. Therefore, by relaxing the binary constraint on the indicator variables c, $\Delta L _ { j }$ can be approximated by the derivative of $L$ with respect to $c _ { j }$ , which we denote $g _ { j } ( \mathbf { w } ; \mathcal { D } )$ . Hence, the effect of connection $j$ on the loss can be written as:
+
+$$
+\Delta L _ { j } ( \mathbf { w } ; \mathcal { D } ) \approx g _ { j } ( \mathbf { w } ; \mathcal { D } ) = \left. \frac { \partial L ( \mathbf { c } \odot \mathbf { w } ; \mathcal { D } ) } { \partial c _ { j } } \right| _ { \mathbf { c } = \mathbf { 1 } } = \operatorname* { l i m } _ { \delta \to 0 } \left. \frac { L ( \mathbf { c } \odot \mathbf { w } ; \mathcal { D } ) - L ( ( \mathbf { c } - \delta \mathbf { e } _ { j } ) \odot \mathbf { w } ; \mathcal { D } ) } { \delta } \right| _ { \mathbf { c } = \mathbf { 1 } } .
+$$
+
+In fact, $\partial L / \partial c _ { j }$ is an infinitesimal version of $\Delta L _ { j }$ , that measures the rate of change of $L$ with respect to an infinitesimal change in $c _ { j }$ from $1  1 - \delta$ . This can be computed efficiently in one forward-backward pass using automatic differentiation, for all $j$ at once. Notice, this formulation can be viewed as perturbing the weight $w _ { j }$ by a multiplicative factor $\delta$ and measuring the change in loss. This approximation is similar in spirit to Koh & Liang (2017) where they try to measure the influence of a datapoint to the loss function. Here we measure the influence of connections. Furthermore, $\partial L / \partial c _ { j }$ is not to be confused with the gradient with respect to the weights $( \partial L / \partial w _ { j } )$ , where the change in loss is measured with respect to an additive change in weight $w _ { j }$ .
+
+Notably, our interest is to discover important (or sensitive) connections in the architecture, so that we can prune unimportant ones in single-shot, disentangling the pruning process from the iterative optimization cycles. To this end, we take the magnitude of the derivatives $g _ { j }$ as the saliency criterion. Note that if the magnitude of the derivative is high (regardless of the sign), it essentially means that the connection $c _ { j }$ has a considerable effect on the loss (either positive or negative), and it has to be preserved to allow learning on $w _ { j }$ . Based on this hypothesis, we define connection sensitivity as the normalized magnitude of the derivatives:
+
+$$
+s _ { j } = \frac { | g _ { j } ( \mathbf { w } ; \mathcal { D } ) | } { \sum _ { k = 1 } ^ { m } | g _ { k } ( \mathbf { w } ; \mathcal { D } ) | } .
+$$
+
+Once the sensitivity is computed, only the top- $\kappa$ connections are retained, where $\kappa$ denotes the desired number of non-zero weights. Precisely, the indicator variables $\mathbf { c }$ are set as follows:
+
+$$
+c _ { j } = \mathbb { 1 } [ s _ { j } - \tilde { s } _ { \kappa } \geq 0 ] , \quad \forall j \in \{ 1 \ldots m \} ,
+$$
+
+where $\tilde { s } _ { \kappa }$ is the $\kappa$ -th largest element in the vector s and $\mathbb { 1 } [ \cdot ]$ is the indicator function. Here, for exactly $\kappa$ connections to be retained, ties can be broken arbitrarily.
+
+We would like to clarify that the above criterion (Equation 6) is different from the criteria used in early works by Mozer & Smolensky (1989) or Karnin (1990) which do not entirely capture the connection sensitivity. The fundamental idea behind them is to identify elements (e.g. weights or neurons) that least degrade the performance when removed. This means that their saliency criteria (i.e. $- \partial L / \partial \mathbf { w }$ or $- \partial L / \partial \pmb { \alpha }$ ; $_ { \pmb { \alpha } }$ refers to the connectivity of neurons), in fact, depend on the loss value before pruning, which in turn, require the network to be pre-trained and iterative optimization cycles to ensure minimal loss in performance. They also suffer from the same drawbacks as the magnitude and Hessian based methods as discussed in Section 3. In contrast, our saliency criterion (Equation 6) is designed to measure the sensitivity as to how much influence elements have on the loss function regardless of whether it is positive or negative. This criterion alleviates the dependency on the value of the loss, eliminating the need for pre-training. These fundamental differences enable the network to be pruned at single-shot prior to training, which we discuss further in the next section.
+
+<table><tr><td colspan="3">Algorithm1 SNIP: Single-shot Network Pruning based on Connection Sensitivity</td></tr><tr><td>Ensure: | w*|lo ≤ κ</td><td>Require: Loss function L, training dataset D, sparsity level K</td><td>Refer Equation 3</td></tr><tr><td></td><td>1:w_← VarianceScalingInitialization</td><td>Refer Section 4.2</td></tr><tr><td></td><td>2:Db={（xi,yi）}=1 ~D</td><td>&gt; Sample a mini-batch of training data</td></tr><tr><td>3:Sj←</td><td>l9j(w;Db) ∑=1l9k(（w;Db)l ， ∀j∈{1...m}</td><td>Connection sensitivity</td></tr><tr><td></td><td>4:s ← SortDescending(s)</td><td></td></tr><tr><td></td><td>5:cj←1[sj-$κ≥0]，∀j∈{1...m}</td><td>&gt;Pruning: choose top-k connections</td></tr><tr><td>7: w* ← c⊙w*</td><td>6: W* ← arg minw∈Rm L(c ③ w;D)</td><td>Regular training</td></tr></table>
+
+# 4.2 SINGLE-SHOT PRUNING AT INITIALIZATION
+
+Note that the saliency measure defined in Equation 6 depends on the value of weights w used to evaluate the derivative as well as the dataset $\mathcal { D }$ and the loss function $L$ . In this section, we discuss the effect of each of them and show that it can be used to prune the network in single-shot with initial weights w.
+
+Firstly, in order to minimize the impact of weights on the derivatives $\partial L / \partial c _ { j }$ , we need to choose these weights carefully. For instance, if the weights are too large, the activations after the non-linear function (e.g., sigmoid) will be saturated, which would result in uninformative gradients. Therefore, the weights should be within a sensible range. In particular, there is a body of work on neural network initialization (Goodfellow et al. (2016)) that ensures the gradients to be in a reasonable range, and our saliency measure can be used to prune neural networks at any such initialization.
+
+Furthermore, we are interested in making our saliency measure robust to architecture variations. Note that initializing neural networks is a random process, typically done using normal distribution. However, if the initial weights have a fixed variance, the signal passing through each layer no longer guarantees to have the same variance, as noted by LeCun et al. (1998). This would make the gradient and in turn our saliency measure, to be dependent on the architectural characteristics. Thus, we advocate the use of variance scaling methods (e.g., Glorot & Bengio (2010)) to initialize the weights, such that the variance remains the same throughout the network. By ensuring this, we empirically show that our saliency measure computed at initialization is robust to variations in the architecture.
+
+Next, since the dataset and the loss function defines the task at hand, by relying on both of them, our saliency criterion in fact discovers the connections in the network that are important to the given task. However, the practitioner needs to make a choice on whether to use the whole training set, or a mini-batch or the validation set to compute the connection saliency. Moreover, in case there are memory limitations (e.g., large model or dataset), one can accumulate the saliency measure over multiple batches or take an exponential moving average. In our experiments, we show that using only one mini-batch of a reasonable number of training examples can lead to effective pruning.
+
+Finally, in contrast to the previous approaches, our criterion for finding redundant connections is simple and directly based on the sensitivity of the connections. This allows us to effectively identify and prune redundant connections in a single step even before training. Then, training can be performed on the resulting pruned (sparse) network. We name our method SNIP for Single-shot Network Pruning, and the complete algorithm is given in Algorithm 1.
+
+![](images/3926bf85ac622a47d0b4130ae5dbb2c6cc89a43e80cedae36061229911cdf321.jpg)  
+Figure 1: Test errors of LeNets pruned at varying sparsity levels $\bar { \kappa }$ , where $\bar { \kappa } = 0$ refers to the reference network trained without pruning. Our approach performs as good as the reference network across varying sparsity levels on both the models.
+
+# 5 EXPERIMENTS
+
+We evaluate our method, SNIP, on MNIST, CIFAR-10 and Tiny-ImageNet classification tasks with a variety of network architectures. Our results show that SNIP yields extremely sparse models with minimal or no loss in accuracy across all tested architectures, while being much simpler than other state-of-the-art alternatives. We also provide clear evidence that our method prunes genuinely explainable connections rather than performing blind pruning.
+
+Experiment setup For brevity, we define the sparsity level to be $\bar { \kappa } = ( m - \kappa ) / m \cdot 1 0 0 ( \% )$ , where $m$ is the total number of parameters and $\kappa$ is the desired number of non-zero weights. For a given sparsity level $\bar { \kappa }$ , the sensitivity scores are computed using a batch of 100 and 128 examples for MNIST and CIFAR experiments, respectively. After pruning, the pruned network is trained in the standard way. Specifically, we train the models using SGD with momentum of 0.9, batch size of 100 for MNIST and 128 for CIFAR experiments and the weight decay rate of 0.0005, unless stated otherwise. The initial learning rate is set to 0.1 and decayed by 0.1 at every 25k or $3 0 \mathrm { k }$ iterations for MNIST and CIFAR, respectively. Our algorithm requires no other hyperparameters or complex learning/pruning schedules as in most pruning algorithms. We spare $10 \%$ of the training data as a validation set and used only $90 \%$ for training. For CIFAR experiments, we use the standard data augmentation (i.e., random horizontal flip and translation up to 4 pixels) for both the reference and sparse models. The code can be found here: https://github.com/namhoonlee/snip-public.
+
+# 5.1 PRUNING LENETS WITH VARYING LEVELS OF SPARSITY
+
+We first test our approach on two standard networks for pruning, LeNet-300-100 and LeNet-5-Caffe. LeNet-300-100 consists of three fully-connected (fc) layers with $2 6 7 \mathrm { k }$ parameters and LeNet-5-Caffe consists of two convolutional (conv) layers and two fc layers with 431k parameters. We prune the LeNets for different sparsity levels $\bar { \kappa }$ and report the performance in error on the MNIST image classification task. We run the experiment 20 times for each $\bar { \kappa }$ by changing random seeds for dataset and network initialization. The results are reported in Figure 1.
+
+The pruned sparse LeNet-300-100 achieves performances similar to the reference $( \bar { \kappa } = 0$ ), only with negligible loss at $\bar { \kappa } = 9 0$ . For LeNet-5-Caffe, the performance degradation is nearly invisible. Note that our saliency measure does not require the network to be pre-trained and is computed at random initialization. Despite such simplicity, our approach prunes LeNets quickly (single-shot) and effectively (minimal accuracy loss) at varying sparsity levels.
+
+# 5.2 COMPARISONS TO EXISTING APPROACHES
+
+What happens if we increase the target sparsity to an extreme level? For example, would a model with only $1 \%$ of the total parameters still be trainable and perform well? We test our approach for extreme sparsity levels (e.g., up to $9 9 \%$ sparsity on LeNet-5-Caffe) and compare with various pruning algorithms as follows: LWC (Han et al. (2015)), DNS (Guo et al. (2016)), LC (Carreira-Perpin˜ an & ´
+
+Table 1: Pruning results on LeNets and comparisons to other approaches. Here, “many” refers to an arbitrary number often in the order of total learning steps, and “soft” refers to soft pruning in Bayesian based methods. Our approach is capable of pruning up to $98 \%$ for LeNet-300-100 and $9 9 \%$ for LeNet-5-Caffe with marginal increases in error from the reference network. Notably, our approach is considerably simpler than other approaches, with no requirements such as pretraining, additional hyperparameters, augmented training objective or architecture dependent constraints.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Criterion</td><td colspan="2">LeNet-300-100</td><td colspan="2">LeNet-5-Caffe</td><td rowspan="2">Pretrain</td><td rowspan="2">#Prune</td><td rowspan="2">Additional hyperparam.</td><td rowspan="2">Augment objective</td><td rowspan="2">Arch. constraints</td></tr><tr><td>K(%)</td><td>err. (%)</td><td>K(%)</td><td>err. (%)</td></tr><tr><td>Ref.</td><td></td><td></td><td>1.7</td><td>一</td><td>0.9</td><td></td><td>1</td><td>-&gt;</td><td>-xx&gt;</td><td>√</td></tr><tr><td>LWC</td><td>Magnitude</td><td>91.7</td><td>1.6</td><td>91.7</td><td>0.8</td><td></td><td>many</td><td></td><td></td><td></td></tr><tr><td>DNS</td><td>Magnitude</td><td>98.2</td><td>2.0</td><td>99.1</td><td>0.9</td><td></td><td>many</td><td></td><td></td><td>√</td></tr><tr><td>LC</td><td>Magnitude</td><td>99.0</td><td>3.2</td><td>99.0</td><td>1.1</td><td></td><td>many</td><td>√</td><td></td><td>X</td></tr><tr><td>SWS</td><td>Bayesian</td><td>95.6</td><td>1.9</td><td>99.5</td><td>1.0</td><td></td><td>soft</td><td>√</td><td>√</td><td>X</td></tr><tr><td>SVD</td><td>Bayesian</td><td>98.5</td><td>1.9</td><td>99.6</td><td>0.8</td><td>-&gt;&gt;&gt;&gt;&gt;</td><td>soft</td><td>√</td><td>√</td><td>X</td></tr><tr><td>OBD</td><td>Hessian</td><td>92.0</td><td>2.0</td><td>92.0</td><td>2.7</td><td>√</td><td>many</td><td>√</td><td>X</td><td>X</td></tr><tr><td>L-OBS</td><td>Hessian</td><td>98.5</td><td>2.0</td><td>99.0</td><td>2.1</td><td>√</td><td>many</td><td>√</td><td>X</td><td>√</td></tr><tr><td rowspan="2">SNIP (ours)</td><td>Connection</td><td>95.0</td><td>1.6</td><td>98.0</td><td>0.8</td><td>×</td><td></td><td>×</td><td>×</td><td>×</td></tr><tr><td>sensitivity</td><td>98.0</td><td>2.4</td><td>99.0</td><td>1.1</td><td></td><td>1</td><td></td><td></td><td></td></tr></table>
+
+Idelbayev (2018)), SWS (Ullrich et al. (2017)), SVD (Molchanov et al. (2017a)), OBD (LeCun et al.   
+(1990)), L-OBS (Dong et al. (2017)). The results are summarized in Table 1.
+
+We achieve errors that are comparable to the reference model, degrading approximately $0 . 7 \%$ and $0 . 3 \%$ while pruning $98 \%$ and $9 9 \%$ of the parameters in LeNet-300-100 and LeNet-5-Caffe respectively. For slightly relaxed sparsities (i.e., $9 5 \%$ for LeNet-300-100 and $98 \%$ for LeNet-5-Caffe), the sparse models pruned by SNIP record better performances than the dense reference network. Considering $9 9 \%$ sparsity, our method efficiently finds $1 \%$ of the connections even before training, that are sufficient to learn as good as the reference network. Moreover, SNIP is competitive to other methods, yet it is unparalleled in terms of algorithm simplicity.
+
+To be more specific, we enumerate some key points and non-trivial aspects of other algorithms and highlight the benefit of our approach. First of all, the aforementioned methods require networks to be fully trained (if not partly) before pruning. These approaches typically perform many pruning operations even if the network is well pretrained, and require additional hyperparameters (e.g., pruning frequency in Guo et al. (2016), annealing schedule in Carreira-Perpin˜an & Idelbayev (2018)). Some ´ methods augment the training objective to handle pruning together with training, increasing the complexity of the algorithm (e.g., augmented Lagrangian in Carreira-Perpin˜an & Idelbayev (2018), ´ variational inference in Molchanov et al. (2017a)). Furthermore, there are approaches designed to include architecture dependent constraints (e.g., layer-wise pruning schemes in Dong et al. (2017)).
+
+Compared to the above approaches, ours seems to cost almost nothing; it requires no pretraining or additional hyperparameters, and is applied only once at initialization. This means that one can easily plug-in SNIP as a preprocessor before training neural networks. Since SNIP prunes the network at the beginning, we could potentially expedite the training phase by training only the survived parameters (e.g., reduced expected FLOPs in Louizos et al. (2018)). Notice that this is not possible for the aforementioned approaches as they obtain the maximum sparsity at the end of the process.
+
+# 5.3 VARIOUS MODERN ARCHITECTURES
+
+In this section we show that our approach is generally applicable to more complex modern network architectures including deep convolutional, residual and recurrent ones. Specifically, our method is applied to the following models:
+
+• AlexNet-s and AlexNet-b: Models similar to Krizhevsky et al. (2012) in terms of the number of layers and size of kernels. We set the size of fc layers to 512 (AlexNet-s) and to 1024 (AlexNet-b) to adapt for CIFAR-10 and use strides of 2 for all conv layers instead of using pooling layers. • VGG-C, VGG-D and VGG-like: Models similar to the original VGG models described in Simonyan & Zisserman (2015). VGG-like (Zagoruyko (2015)) is a popular variant adapted for CIFAR-10 which has one less fc layers. For all VGG models, we set the size of fc layers to 512, remove dropout layers to avoid any effect on sparsification and use batch normalization instead. • WRN-16-8, WRN-16-10 and WRN-22-8: Same models as in Zagoruyko & Komodakis (2016).
+
+<table><tr><td>Architecture</td><td>Model</td><td>Sparsity (%)</td><td># Parameters</td><td>Error (%)</td><td></td><td>△</td></tr><tr><td rowspan="5">Convolutional</td><td>AlexNet-s</td><td>90.0</td><td>5.1m → 507k</td><td>14.12 →</td><td>14.99</td><td>+0.87</td></tr><tr><td>AlexNet-b</td><td>90.0</td><td>8.5m → 849k</td><td>13.92 →</td><td>14.50</td><td>+0.58</td></tr><tr><td>VGG-C</td><td>95.0</td><td>10.5m → 526k</td><td>6.82 →</td><td>7.27</td><td>+0.45</td></tr><tr><td>VGG-D</td><td>95.0</td><td>15.2m → 762k</td><td>6.76 →</td><td>7.09</td><td>+0.33</td></tr><tr><td>VGG-like</td><td>97.0</td><td>15.0m → 449k</td><td>8.26 →</td><td>8.00</td><td>-0.26</td></tr><tr><td rowspan="3">Residual</td><td>WRN-16-8</td><td>95.0</td><td>10.0m → 548k</td><td>6.21 →</td><td>6.63</td><td>+0.42</td></tr><tr><td>WRN-16-10</td><td>95.0</td><td>17.1m → 856k</td><td>5.91 →</td><td>6.43</td><td>+0.52</td></tr><tr><td>WRN-22-8</td><td>95.0</td><td>17.2m → 858k</td><td>6.14 →</td><td>5.85</td><td>-0.29</td></tr><tr><td rowspan="4">Recurrent</td><td>LSTM-s</td><td>95.0</td><td>137k → 6.8k</td><td>1.88 →</td><td>1.57</td><td>-0.31</td></tr><tr><td>LSTM-b</td><td>95.0</td><td>535k → 26.8k</td><td>1.15 →</td><td>1.35</td><td>+0.20</td></tr><tr><td>GRU-s</td><td>95.0</td><td>104k → 5.2k</td><td>1.87 →</td><td>2.41</td><td>+0.54</td></tr><tr><td>GRU-b</td><td>95.0</td><td>404k→ 20.2k</td><td>1.71 →</td><td>1.52</td><td>-0.19</td></tr></table>
+
+Table 2: Pruning results of the proposed approach on various modern architectures (before after). AlexNets, VGGs and WRNs are evaluated on CIFAR-10, and LSTMs and GRUs are evaluated on the sequential MNIST classification task. The approach is generally applicable regardless of architecture types and models and results in a significant amount of reduction in the number of parameters with minimal or no loss in performance.
+
+• LSTM-s, LSTM-b, GRU-s, GRU-b: One layer RNN networks with either LSTM (Zaremba et al. (2014)) or GRU (Cho et al. (2014)) cells. We develop two unit sizes for each cell type, 128 and 256 for $\{ \cdot \}$ -s and $\{ \cdot \}$ -b, respectively. The model is adapted for the sequential MNIST classification task, similar to Le et al. (2015). Instead of processing pixel-by-pixel, however, we perform rowby-row processing (i.e., the RNN cell receives each row at a time).
+
+The results are summarized in Table 2. Overall, our approach prunes a substantial amount of parameters in a variety of network models with minimal or no loss in accuracy $( < 1 \% )$ . Our pruning procedure does not need to be modified for specific architectural variations (e.g., recurrent connections), indicating that it is indeed versatile and scalable. Note that prior art that use a saliency criterion based on the weights (i.e., magnitude or Hessian based) would require considerable adjustments in their pruning schedules as per changes in the model.
+
+We note of a few challenges in directly comparing against others: different network specifications, learning policies, datasets and tasks. Nonetheless, we provide a few comparison points that we found in the literature. On CIFAR-10, SVD prunes $9 7 . 9 \%$ of the connections in VGG-like with no loss in accuracy (ours: $9 7 \%$ sparsity) while SWS obtained $9 3 . 4 \%$ sparsity on WRN-16-4 but with a non-negligible loss in accuracy of $2 \%$ . There are a couple of works attempting to prune RNNs (e.g., GRU in Narang et al. (2017) and LSTM in See et al. (2016)). Even though these methods are specifically designed for RNNs, none of them are able to obtain extreme sparsity without substantial loss in accuracy reflecting the challenges of pruning RNNs. To the best of our knowledge, we are the first to demonstrate on convolutional, residual and recurrent networks for extreme sparsities without requiring additional hyperparameters or modifying the pruning procedure.
+
+# 5.4 UNDERSTANDING WHICH CONNECTIONS ARE BEING PRUNED
+
+So far we have shown that our approach can prune a variety of deep neural network architectures for extreme sparsities without losing much on accuracy. However, it is not clear yet which connections are actually being pruned away or whether we are pruning the right (i.e., unimportant) ones. What if we could actually peep through our approach into this inspection?
+
+Consider the first layer in LeNet-300-100 parameterized by $\mathbf { w } _ { l = 1 } ~ \in ~ \mathbb { R } ^ { 7 8 4 \times 3 0 0 }$ . This is a layer fully connected to the input where input images are of size $2 8 \times 2 8 \ : = \ : 7 8 4$ . In order to understand which connections are retained, we can visualize the binary connectivity mask for this layer $\mathbf { c } _ { l = 1 }$ , by averaging across columns and then reshaping the vector into 2D matrix (i.e., $\begin{array} { r } { \mathbf { c } _ { l = 1 } ^ { \check { } } \in \{ \bar { 0 } , 1 \} ^ { \check { } 8 4 \times 3 0 \widetilde { 0 } }  \mathbb { R } ^ { 7 8 4 }  \mathbb { R } ^ { 2 8 \times 2 8 } } \end{array}$ ). Recall that our method computes c using a minibatch of examples. In this experiment, we curate the mini-batch of examples of the same class and see which weights are retained for that mini-batch of data. We repeat this experiment for all classes (i.e., digits for MNIST and fashion items for Fashion-MNIST) with varying sparsity levels $\bar { \kappa }$ . The results are displayed in Figure 2 (see Appendix A for more results).
+
+![](images/0f4107c55d7dc6d96c089d84572497bc1ec5a1fdb8c53251ac813dd698b02584.jpg)  
+Figure 2: Visualizations of pruned parameters of the first layer in LeNet-300-100; the parameters are reshaped to be visualized as an image. Each column represents the visualizations for a particular class obtained using a batch of 100 examples with varying levels of sparsity $\bar { \kappa }$ , from 10 (top) to 90 (bottom). Bright pixels indicate that the parameters connected to these region had high importance scores (s) and survived from pruning. As the sparsity increases, the parameters connected to the discriminative part of the image for classification survive and the irrelevant parts get pruned.
+
+The results are significant; important connections seem to reconstruct either the complete image (MNIST) or silhouettes (Fashion-MNIST) of input class. When we use a batch of examples of the digit 0 (i.e., the first column of MNIST results), for example, the parameters connected to the foreground of the digit 0 survive from pruning while the majority of background is removed. Also, one can easily determine the identity of items from Fashion-MNIST results. This clearly indicates that our method indeed prunes the unimportant connections in performing the classification task, receiving signals only from the most discriminative part of the input. This stands in stark contrast to other pruning methods from which carrying out such inspection is not straightforward.
+
+# 5.5 EFFECTS OF DATA AND WEIGHT INITIALIZATION
+
+Recall that our connection saliency measure depends on the network weights w as well as the given data $\mathcal { D }$ (Section 4.2). We study the effect of each of these in this section.
+
+Effect of data. Our connection saliency measure depends on a mini-batch of train examples $\mathcal { D } ^ { b }$ (see Algorithm 1). To study the effect of data, we vary the batch size used to compute the saliency $( | \mathcal { D } ^ { b } | )$ and check which connections are being pruned as well as how much performance change this results in on the corresponding sparse network. We test with LeNet-300-100 to visualize the remaining parameters, and set the sparsity level $\bar { \kappa } = 9 0$ . Note that the batch size used for training remains the same as 100 for all cases. The results are displayed in Figure 3.
+
+Effect of initialization. Our approach prunes a network at a stochastic initialization as discussed. We study the effect of the following initialization methods: 1) RN (random normal), 2) TN (truncated random normal), 3) VS-X (a variance scaling method using Glorot & Bengio (2010)), and 4) VS-H (a variance scaling method He et al. (2015)). We test on LeNets and RNNs on MNIST and run 20 sets of experiments by varying the seed for initialization. We set the sparsity level $\bar { \kappa } = 9 0$ , and train with Adam optimizer (Kingma & Ba (2015)) with learning rate of 0.001 without weight decay. Note that for training VS-X initialization is used in all the cases. The results are reported in Figure 3.
+
+For all models, VS-H achieves the best performance. The differences between initializers are marginal on LeNets, however, variance scaling methods indeed turns out to be essential for complex RNN models. This effect is significant especially for GRU where without variance scaling initialization, the pruned networks are unable to achieve good accuracies, even with different optimizers. Overall, initializing with a variance scaling method seems crucial to making our saliency measure reliable and model-agnostic.
+
+![](images/0571d02738677c85bfcc4968a17cec170d1e05716329724896a5e65b46ef5437.jpg)
+
+Figure 3: The effect of different batch sizes: (top-row) survived parameters in the first layer of LeNet-300-100 from pruning visualized as images; (bottom-row) the performance in errors of the pruned networks. For $| \mathcal { D } ^ { b } | \overset { - } { = } 1$ , the sampled example was 8; our pruning precisely retains the valid connections. As $| \mathcal { D } ^ { b } |$ increases, survived parameters get close to the average of all examples in the train set (last column), and the error decreases.   
+
+<table><tr><td>Init.</td><td>LeNet-300-100</td><td>LeNet-5-Caffe</td><td>LSTM-s</td><td>GRU-s</td></tr><tr><td>RN</td><td>1.90 ± (0.09)</td><td>0.89 ± (0.04)</td><td>2.93 ± (0.20)</td><td>47.61 ± (20.49)</td></tr><tr><td>TN</td><td>1.96 ± (0.11)</td><td>0.87 ± (0.05)</td><td>3.03 ± (0.17)</td><td>46.48± (22.25)</td></tr><tr><td>VS-X</td><td>1.91 ± (0.10)</td><td>0.88 ± (0.07)</td><td>1.48 ± (0.09)</td><td>1.80 ± (0.10)</td></tr><tr><td>VS-H</td><td>1.88 ± (0.10)</td><td>0.85 ± (0.05)</td><td>1.47 ± (0.08)</td><td>1.80 ± (0.14)</td></tr></table>
+
+Table 3: The effect of initialization on our saliency score. We report the classification errors ( $\pm$ std).   
+Variance scaling initialization (VS-X, VS-H) improves the performance, especially for RNNs.
+
+# 5.6 FITTING RANDOM LABELS
+
+To further explore the use cases of SNIP, we run the experiment introduced in Zhang et al. (2017) and check whether the sparse network obtained by SNIP memorizes the dataset. Specifically, we train LeNet-5-Caffe for both the reference model and pruned model (with $\bar { \kappa } = 9 9 $ ) on MNIST with either true or randomly shuffled labels. To compute the connection sensitivity, always true labels are used. The results are plotted in Figure 4.
+
+Given true labels, both the reference (red) and pruned (blue) models quickly reach to almost zero training loss. However, the reference model provided with random labels (green) also reaches to very low training loss, even with an explicit L2 regularizer (purple), indicating that neural networks have enough capacity to memorize completely random data. In contrast, the model pruned by SNIP (orange) fails to fit the random labels (high training error). The potential explanation is that the pruned network does not have sufficient capacity to fit the random labels, but it is able to classify MNIST with true labels, reinforcing the significance of our saliency criterion. It is possible that a similar experiment can be done with other pruning methods (Molchanov et al. (2017a)), however, being simple, SNIP enables such exploration much easier. We provide a further analysis on the effect of varying $\bar { \kappa }$ in Appendix B.
+
+![](images/9a651ab94be553eb9324682211e6a7c4d4dcea5b1a266aa2431d015c01647a2d.jpg)  
+Figure 4: The sparse model pruned by SNIP does not fit the random labels.
+
+# 6 DISCUSSION AND FUTURE WORK
+
+In this work, we have presented a new approach, SNIP, that is simple, versatile and interpretable; it prunes irrelevant connections for a given task at single-shot prior to training and is applicable to a variety of neural network models without modifications. While SNIP results in extremely sparse models, we find that our connection sensitivity measure itself is noteworthy in that it diagnoses important connections in the network from a purely untrained network. We believe that this opens up new possibilities beyond pruning in the topics of understanding of neural network architectures, multi-task transfer learning and structural regularization, to name a few. In addition to these potential directions, we intend to explore the generalization capabilities of sparse networks.
+
+# ACKNOWLEDGEMENTS
+
+This work was supported by the Korean Government Graduate Scholarship, the ERC grant ERC2012-AdG 321162-HELIOS, EPSRC grant Seebibyte EP/M013774/1 and EPSRC/MURI grant EP/N019474/1. We would also like to acknowledge the Royal Academy of Engineering and FiveAI.
+
+# REFERENCES
+
+Sanjeev Arora, Rong Ge, Behnam Neyshabur, and Yi Zhang. Stronger generalization bounds for deep nets via a compression approach. ICML, 2018.
+
+Leo Breiman. Better subset regression using the nonnegative garrote. Technometrics, 1995.
+
+Miguel A. Carreira-Perpi ´ n˜an and Yerlan Idelbayev. “Learning-compression” algorithms for neural ´ net pruning. CVPR, 2018.
+
+Yves Chauvin. A back-propagation algorithm with optimal use of hidden units. NIPS, 1989.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. EMNLP, 2014.
+
+Xin Dong, Shangyu Chen, and Sinno Pan. Learning to prune deep neural networks via layer-wise optimal brain surgeon. NIPS, 2017.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. AISTATS, 2010.
+
+Yunchao Gong, Liu Liu, Ming Yang, and Lubomir Bourdev. Compressing deep convolutional networks using vector quantization. arXiv preprint arXiv:1412.6115, 2014.
+
+Ian Goodfellow, Yoshua Bengio, Aaron Courville, and Yoshua Bengio. Deep learning. MIT press Cambridge, 2016.
+
+Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. NIPS, 2016.
+
+Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. ICML, 2015.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. NIPS, 2015.
+
+Babak Hassibi, David G Stork, and Gregory J Wolff. Optimal brain surgeon and general network pruning. Neural Networks, 1993.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. ICCV, 2015.
+
+Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks. NIPS, 2016.
+
+Masumi Ishikawa. Structural learning with forgetting. Neural Networks, 1996.
+
+Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. BMVC, 2014.
+
+Ehud D Karnin. A simple procedure for pruning back-propagation trained neural networks. Neural Networks, 1990.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015.
+
+Pang Wei Koh and Percy Liang. Understanding black-box predictions via influence functions. ICML, 2017.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. 2012.
+
+Quoc V Le, Navdeep Jaitly, and Geoffrey E Hinton. A simple way to initialize recurrent networks of rectified linear units. CoRR, 2015.
+
+Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. NIPS, 1990.
+
+Yann LeCun, Leon Bottou, Genevieve B. Orr, and Klaus-Robert M ´ uller. Efficient backprop. ¨ Neural Networks: Tricks of the Trade, 1998.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. ICLR, 2017.
+
+Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through $l _ { 0 }$ regularization. ICLR, 2018.
+
+Decebal Constantin Mocanu, Elena Mocanu, Peter Stone, Phuong H Nguyen, Madeleine Gibescu, and Antonio Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature Communications, 2018.
+
+Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. ICML, 2017a.
+
+Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference. ICLR, 2017b.
+
+Michael C Mozer and Paul Smolensky. Skeletonization: A technique for trimming the fat from a network via relevance assessment. NIPS, 1989.
+
+Sharan Narang, Erich Elsen, Gregory Diamos, and Shubho Sengupta. Exploring sparsity in recurrent neural networks. ICLR, 2017.
+
+Alexander Novikov, Dmitrii Podoprikhin, Anton Osokin, and Dmitry P Vetrov. Tensorizing neural networks. NIPS, 2015.
+
+Steven J Nowlan and Geoffrey E Hinton. Simplifying neural networks by soft weight-sharing. Neural Computation, 1992.
+
+Ameya Prabhu, Girish Varma, and Anoop Namboodiri. Deep expander networks: Efficient deep networks from graph theory. ECCV, 2018.
+
+Russell Reed. Pruning algorithms-a survey. Neural Networks, 1993.
+
+Abigail See, Minh-Thang Luong, and Christopher D Manning. Compression of neural machine translation models via pruning. CoNLL, 2016.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. ICLR, 2015.
+
+Karen Ullrich, Edward Meeds, and Max Welling. Soft weight-sharing for neural network compression. ICLR, 2017.
+
+Andreas S Weigend, David E Rumelhart, and Bernardo A Huberman. Generalization by weightelimination with application to forecasting. NIPS, 1991.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. NIPS, 2016.
+
+Sergey Zagoruyko. $9 2 . 4 5 \%$ on cifar-10 in torch. Torch Blog, 2015.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. BMVC, 2016.
+
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. ICLR, 2017.
+
+![](images/cc69ae2f5789c064a9d7ec25c2cae8be85125a7807f27c075058ab31684ccd3c.jpg)  
+Figure 5: Results of pruning with SNIP on inverted (Fashion-)MNIST (i.e., dark and bright regions are swapped). Notably, even if the data is inverted, the results are the same as the ones on the original (Fashion-)MNIST in Figure 2.
+
+![](images/7e10adb4cd3b78aa3523f4d7e8ead3c6621045e90fb560498f3758f598063b9e.jpg)  
+Figure 6: Results of pruning with $\partial L / \partial$ w on the original and inverted (Fashion-)MNIST. Notably, compared to the case of using SNIP (Figures 2 and 5), the results are different: Firstly, the results on the original (Fashion-)MNIST (i.e., (a) and (c) above) are not the same as the ones using SNIP (i.e., (a) and (b) in Figure 2). Moreover, the pruning patterns are inconsistent with different sparsity levels, either intra-class or inter-class. Furthermore, using ${ \partial L } / { \partial \mathbf { w } }$ results in different pruning patterns between the original and inverted data in some cases (e.g., the $2 ^ { \mathrm { n d } }$ columns between (c) and (d)).
+
+![](images/2c60ed92201d216f7acfecb7839cd7dcf12f0266b4e0e0b0daf88b490479c204.jpg)  
+Figure 7: The effect of varying sparsity levels $\left( \hat { \kappa } \right)$ . The lower $\bar { \kappa }$ becomes, the lower training loss is recorded, meaning that a network with more parameters is more vulnerable to fitting random labels. Recall, however, that all pruned models are able to learn to perform the classification task without losing much accuracy (see Figure 1). This potentially indicates that the pruned network does not have sufficient capacity to fit the random labels, but it is capable of performing the classification.
+
+# C TINY-IMAGENET
+
+<table><tr><td>Architecture</td><td>Model</td><td>Sparsity (%)</td><td># Parameters</td><td>Error (%)</td><td>△</td></tr><tr><td rowspan="5">Convolutional</td><td>AlexNet-s</td><td>90.0</td><td>5.1m → 507k</td><td>62.52 → 65.27</td><td>+2.75</td></tr><tr><td>AlexNet-b</td><td>90.0</td><td>8.5m → 849k</td><td>62.76 → 65.54</td><td>+2.78</td></tr><tr><td>VGG-C</td><td>95.0</td><td>10.5m → 526k</td><td>56.49 → 57.48</td><td>+0.99</td></tr><tr><td>VGG-D</td><td>95.0</td><td>15.2m → 762k</td><td>56.85 → 57.00</td><td>+0.15</td></tr><tr><td>VGG-like</td><td>95.0</td><td>15.0m → 749k</td><td>54.86 → 55.73</td><td>+0.87</td></tr></table>
+
+Table 4: Pruning results of SNIP on Tiny-ImageNet (before after). Tiny-ImageNet2 is a subset of the full ImageNet: there are 200 classes in total, each class has 500 and 50 images for training and validation respectively, and each image has the spatial resolution of $6 4 \times 6 4$ . Compared to CIFAR-10, the resolution is doubled, and to deal with this, the stride of the first convolution in all architectures is doubled, following the standard practice for this dataset. In general, the Tiny-ImageNet classification task is considered much more complex than MNIST or CIFAR-10. Even on Tiny-ImageNet, however, SNIP is still able to prune a large amount of parameters with minimal loss in performance. AlexNet models lose more accuracies than VGGs, which may be attributed to the fact that the first convolution stride for AlexNet is set to be 4 (by its design of no pooling) which is too large and could lead to high loss of information when pruned.
+
+D ARCHITECTURE DETAILS   
+
+<table><tr><td rowspan=1 colspan=8>Module         Weight         Stride     Bias      BatchNorm  ReLU</td></tr><tr><td rowspan=1 colspan=1>Conv</td><td rowspan=1 colspan=1>[11,11, 3,96]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>[2,2]</td><td rowspan=1 colspan=3>[96]          √</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>Conv</td><td rowspan=1 colspan=1>[5,5,96,256]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2j</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>[256]</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Conv</td><td rowspan=1 colspan=1>[3,3,256,384]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.2</td><td rowspan=1 colspan=2>[384]</td><td rowspan=1 colspan=2>√</td></tr><tr><td rowspan=1 colspan=1>Conv</td><td rowspan=1 colspan=1>[3,3,384,384]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=5>[384]</td></tr><tr><td rowspan=1 colspan=1>Conv</td><td rowspan=1 colspan=1>[3,3,384,256]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2,2</td><td rowspan=1 colspan=2>[256]</td><td rowspan=1 colspan=2>（</td></tr><tr><td rowspan=1 colspan=1>Linear</td><td rowspan=1 colspan=1>[256,1024 ×k]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>[1024×k]       √</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=3>Linear  [1024 × k,1024 ×k]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>[1024 × k]       √</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=8>Linear       [1024 × k,c]                    [c]           X         X</td></tr></table>
+
+Table 5: AlexNet-s $k = 1 ,$ ) and AlexNet-b $( k = 2 )$ ). In the last layer, $c$ denotes the number of possible classes: $c = 1 0$ for CIFAR-10 and $c = 2 0 0$ for Tiny-ImageNet. The strides in the first convolution layer for Tiny-ImageNet are set [4, 4] instead of [2, 2] to deal with the increase in the image resolution.   
+
+<table><tr><td>Module</td><td>Weight</td><td>Stride</td><td>Bias</td><td>BatchNorm</td><td>ReLU</td></tr><tr><td>Conv</td><td>[3,3,3,64]</td><td>[1,1]</td><td>[64]</td><td></td><td></td></tr><tr><td>Conv</td><td>[3,3, 64, 64]</td><td></td><td>[64]</td><td>广</td><td></td></tr><tr><td>Pool</td><td></td><td></td><td></td><td>×</td><td>&lt;&gt;x&gt;</td></tr><tr><td>Conv</td><td>[3,3,64,128]</td><td>1j</td><td>[128]</td><td>√</td><td></td></tr><tr><td>Conv</td><td>[3,3,128,128]</td><td>1j</td><td>[128]</td><td>√</td><td>√</td></tr><tr><td>Pool</td><td></td><td>18E.83. 2</td><td></td><td>X</td><td>X</td></tr><tr><td>Conv</td><td>[3,3,128,256]</td><td></td><td>[256]</td><td>√</td><td></td></tr><tr><td>Conv</td><td>[3,3,256,256]</td><td>1</td><td>[256]</td><td></td><td></td></tr><tr><td>Conv</td><td>[1/3/3,1/3/3,256,256]</td><td>1j</td><td>[256]</td><td>√</td><td></td></tr><tr><td>Pool</td><td></td><td>2j</td><td></td><td>X</td><td>X</td></tr><tr><td>Conv</td><td>[3,3,256,512]</td><td>1</td><td>[512]</td><td></td><td></td></tr><tr><td>Conv</td><td>[3,3,512, 512]</td><td>1j</td><td>[512]</td><td></td><td></td></tr><tr><td>Conv</td><td>[1/3/3,1/3/3,512,512]</td><td>1j</td><td>[512]</td><td></td><td></td></tr><tr><td>Pool</td><td></td><td>2</td><td></td><td></td><td></td></tr><tr><td>Conv</td><td>[3,3,512, 512]</td><td>1j</td><td>[512]</td><td></td><td></td></tr><tr><td>Conv</td><td>[3,3, 512,512]</td><td>1]</td><td>[512]</td><td></td><td></td></tr><tr><td>Conv</td><td>[1/3/3,1/3/3,512,512]</td><td>1]</td><td>[512]</td><td></td><td></td></tr><tr><td>Pool</td><td></td><td></td><td></td><td>X</td><td></td></tr><tr><td>Linear</td><td>[512, 512]</td><td></td><td>[512]</td><td>√</td><td>√</td></tr><tr><td>Linear</td><td>[512, 512]</td><td></td><td>[512]</td><td>√</td><td>√</td></tr><tr><td>Linear</td><td>[512,c]</td><td></td><td>[c]</td><td>X</td><td>X</td></tr></table>
+
+Table 6: VGG-C/D/like. In the last layer, $c$ denotes the number of possible classes: $c = 1 0$ for CIFAR10 and $c = 2 0 0$ for Tiny-ImageNet. The strides in the first convolution layer for Tiny-ImageNet are set [2, 2] instead of [1, 1] to deal with the increase in the image resolution. The second Linear layer is only used in VGG-C/D.

parse/train/B1VZqjAcYX/B1VZqjAcYX_content_list.json

@@ -0,0 +1,1773 @@
+[
+    {
+        "type": "text",
+        "text": "SNIP: SINGLE-SHOT NETWORK PRUNING BASED ONCONNECTION SENSITIVITY",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            805,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Namhoon Lee, Thalaiyasingam Ajanthan & Philip H. S. Torr University of Oxford {namhoon,ajanthan,phst}@robots.ox.ac.uk ",
+        "bbox": [
+            183,
+            170,
+            607,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pruning large neural networks while maintaining their performance is often desirable due to the reduced space and time complexity. In existing methods, pruning is done within an iterative optimization procedure with either heuristically designed pruning schedules or additional hyperparameters, undermining their utility. In this work, we present a new approach that prunes a given network once at initialization prior to training. To achieve this, we introduce a saliency criterion based on connection sensitivity that identifies structurally important connections in the network for the given task. This eliminates the need for both pretraining and the complex pruning schedule while making it robust to architecture variations. After pruning, the sparse network is trained in the standard way. Our method obtains extremely sparse networks with virtually the same accuracy as the reference network on the MNIST, CIFAR-10, and Tiny-ImageNet classification tasks and is broadly applicable to various architectures including convolutional, residual and recurrent networks. Unlike existing methods, our approach enables us to demonstrate that the retained connections are indeed relevant to the given task. ",
+        "bbox": [
+            233,
+            280,
+            764,
+            487
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            512,
+            336,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the success of deep neural networks in machine learning, they are often found to be highly overparametrized making them computationally expensive with excessive memory requirements. Pruning such large networks with minimal loss in performance is appealing for real-time applications, especially on resource-limited devices. In addition, compressed neural networks utilize the model capacity efficiently, and this interpretation can be used to derive better generalization bounds for neural networks (Arora et al. (2018)). ",
+        "bbox": [
+            174,
+            544,
+            825,
+            627
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In network pruning, given a large reference neural network, the goal is to learn a much smaller subnetwork that mimics the performance of the reference network. The majority of existing methods in the literature attempt to find a subset of weights from the pretrained reference network either based on a saliency criterion (Mozer & Smolensky (1989); LeCun et al. (1990); Han et al. (2015)) or utilizing sparsity enforcing penalties (Chauvin (1989); Carreira-Perpin˜an & Idelbayev (2018)). ´ Unfortunately, since pruning is included as a part of an iterative optimization procedure, all these methods require many expensive prune – retrain cycles and heuristic design choices with additional hyperparameters, making them non-trivial to extend to new architectures and tasks. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            746
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduce a saliency criterion that identifies connections in the network that are important to the given task in a data-dependent way before training. Specifically, we discover important connections based on their influence on the loss function at a variance scaling initialization, which we call connection sensitivity. Given the desired sparsity level, redundant connections are pruned once prior to training (i.e., single-shot), and then the sparse pruned network is trained in the standard way. Our approach has several attractive properties: ",
+        "bbox": [
+            174,
+            752,
+            825,
+            837
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Simplicity. Since the network is pruned once prior to training, there is no need for pretraining and complex pruning schedules. Our method has no additional hyperparameters and once pruned, training of the sparse network is performed in the standard way.   \n• Versatility. Since our saliency criterion chooses structurally important connections, it is robust to architecture variations. Therefore our method can be applied to various architectures including convolutional, residual and recurrent networks with no modifications. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Interpretability. Our method determines important connections with a mini-batch of data at single-shot. By varying this mini-batch used for pruning, our method enables us to verify that the retained connections are indeed essential for the given task. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method on MNIST, CIFAR-10, and Tiny-ImageNet classification datasets with widely varying architectures. Despite being the simplest, our method obtains extremely sparse networks with virtually the same accuracy as the existing baselines across all tested architectures. Furthermore, we investigate the relevance of the retained connections as well as the effect of the network initialization and the dataset on the saliency score. ",
+        "bbox": [
+            174,
+            156,
+            823,
+            226
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            244,
+            341,
+            261
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Classical methods. Essentially, early works in network pruning can be categorized into two groups (Reed (1993)): 1) those that utilize sparsity enforcing penalties; and 2) methods that prune the network based on some saliency criterion. The methods from the former category (Chauvin (1989); Weigend et al. (1991); Ishikawa (1996)) augment the loss function with some sparsity enforcing penalty terms (e.g., $L _ { 0 }$ or $L _ { 1 }$ norm), so that back-propagation effectively penalizes the magnitude of the weights during training. Then weights below a certain threshold may be removed. On the other hand, classical saliency criteria include the sensitivity of the loss with respect to the neurons (Mozer & Smolensky (1989)) or the weights (Karnin (1990)) and Hessian of the loss with respect to the weights (LeCun et al. (1990); Hassibi et al. (1993)). Since these criteria are heavily dependent on the scale of the weights and are designed to be incorporated within the learning process, these methods are prohibitively slow requiring many iterations of pruning and learning steps. Our approach identifies redundant weights from an architectural point of view and prunes them once at the beginning before training. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            455
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Modern advances. In recent years, the increased space and time complexities as well as the risk of overfitting in deep neural networks prompted a surge of further investigation in network pruning. While Hessian based approaches employ the diagonal approximation due to its computational simplicity, impressive results (i.e., extreme sparsity without loss in accuracy) are achieved using magnitude of the weights as the criterion (Han et al. (2015)). This made them the de facto standard method for network pruning and led to various implementations (Guo et al. (2016); Carreira-Perpin˜an & ´ Idelbayev (2018)). The magnitude criterion is also extended to recurrent neural networks (Narang et al. (2017)), yet with heavily tuned hyperparameter setting. Unlike our approach, the main drawbacks of magnitude based approaches are the reliance on pretraining and the expensive prune – retrain cycles. Furthermore, since pruning and learning steps are intertwined, they often require highly heuristic design choices which make them non-trivial to be extended to new architectures and different tasks. Meanwhile, Bayesian methods are also applied to network pruning (Ullrich et al. (2017); Molchanov et al. (2017a)) where the former extends the soft weight sharing in Nowlan & Hinton (1992) to obtain a sparse and compressed network, and the latter uses variational inference to learn the dropout rate which can then be used to prune the network. Unlike the above methods, our approach is simple and easily adaptable to any given architecture or task without modifying the pruning procedure. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            699
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Network compression in general. Apart from weight pruning, there are approaches focused on structured simplification such as pruning filters (Li et al. (2017); Molchanov et al. (2017b)), structured sparsity with regularizers (Wen et al. (2016)), low-rank approximation (Jaderberg et al. (2014)), matrix and tensor factorization (Novikov et al. (2015)), and sparsification using expander graphs (Prabhu et al. (2018)) or Erdos-R ˝ enyi random graph (Mocanu et al. (2018)). In addition, ´ there is a large body of work on compressing the representation of weights. A non-exhaustive list includes quantization (Gong et al. (2014)), reduced precision (Gupta et al. (2015)) and binary weights (Hubara et al. (2016)). In this work, we focus on weight pruning that is free from structural constraints and amenable to further compression schemes. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            832
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 NEURAL NETWORK PRUNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            852,
+            446,
+            867
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main hypothesis behind the neural network pruning literature is that neural networks are usually overparametrized, and comparable performance can be obtained by a much smaller network (Reed (1993)) while improving generalization (Arora et al. (2018)). To this end, the objective is to learn ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "a sparse network while maintaining the accuracy of the standard reference network. Let us first formulate neural network pruning as an optimization problem. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a dataset $\\mathbfcal { D } = \\{ ( \\mathbf { x } _ { i } , \\mathbf { y } _ { i } ) \\} _ { i = 1 } ^ { n }$ , and a desired sparsity level $\\kappa$ (i.e., the number of non-zero weights) neural network pruning can be written as the following constrained optimization problem: ",
+        "bbox": [
+            173,
+            138,
+            821,
+            167
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ebd04375ac44347d780918c47861ac8c8cb91d7f6944a11ee1010af8262106cf.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\operatorname* { m i n } _ { \\mathbf { w } } L ( \\mathbf { w } ; \\mathcal { D } ) = \\displaystyle \\operatorname* { m i n } _ { \\mathbf { w } } \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\ell ( \\mathbf { w } ; ( \\mathbf { x } _ { i } , \\mathbf { y } _ { i } ) ) ~ , } \\\\ { \\mathrm { s . t . } \\quad \\mathbf { w } \\in \\mathbb { R } ^ { m } , \\quad \\| \\mathbf { w } \\| _ { 0 } \\leq \\kappa ~ . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            171,
+            640,
+            232
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\ell ( \\cdot )$ is the standard loss function (e.g., cross-entropy loss), w is the set of parameters of the neural network, $m$ is the total number of parameters and $\\| \\cdot \\| _ { 0 }$ is the standard $L _ { 0 }$ norm. ",
+        "bbox": [
+            173,
+            236,
+            826,
+            265
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The conventional approach to optimize the above problem is by adding sparsity enforcing penalty terms (Chauvin (1989); Weigend et al. (1991); Ishikawa (1996)). Recently, Carreira-Perpin˜an´ $\\&$ Idelbayev (2018) attempts to minimize the above constrained optimization problem using the stochastic version of projected gradient descent (where the projection is accomplished by pruning). However, these methods often turn out to be inferior to saliency based methods in terms of resulting sparsity and require heavily tuned hyperparameter settings to obtain comparable results. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            356
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, saliency based methods treat the above problem as selectively removing redundant parameters (or connections) in the neural network. In order to do so, one has to come up with a good criterion to identify such redundant connections. Popular criteria include magnitude of the weights, i.e., weights below a certain threshold are redundant (Han et al. (2015); Guo et al. (2016)) and Hessian of the loss with respect to the weights, i.e., the higher the value of Hessian, the higher the importance of the parameters (LeCun et al. (1990); Hassibi et al. (1993)), defined as follows: ",
+        "bbox": [
+            173,
+            362,
+            825,
+            446
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c088681f4071600c4852356681f774de0be83b26f0fa5008c7ee00bef5d07c4c.jpg",
+        "text": "$$\ns _ { j } = \\left\\{ \\begin{array} { l l } { \\left| w _ { j } \\right| , } & { \\mathrm { f o r m a g n i t u d e ~ b a s e d } } \\\\ { \\frac { w _ { j } ^ { 2 } H _ { j j } } { 2 } } & { \\mathrm { o r } \\frac { w _ { j } ^ { 2 } } { 2 H _ { j j } ^ { - 1 } } } & { \\mathrm { f o r } \\mathrm { H e s s i a n ~ b a s e d } . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            452,
+            655,
+            503
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, for connection $j , s _ { j }$ is the saliency score, $w _ { j }$ is the weight, and $H _ { j j }$ is the value of the Hessian matrix, where the Hessian $\\mathbf { H } = \\partial ^ { 2 } L / \\partial \\mathbf { w } ^ { 2 } \\in \\mathbb { R } ^ { m \\times m }$ . Considering Hessian based methods, the Hessian matrix is neither diagonal nor positive definite in general, approximate at best, and intractable to compute for large networks. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Despite being popular, both of these criteria depend on the scale of the weights and in turn require pretraining and are very sensitive to the architectural choices. For instance, different normalization layers affect the scale of the weights in a different way, and this would non-trivially affect the saliency score. Furthermore, pruning and the optimization steps are alternated many times throughout training, resulting in highly expensive prune – retrain cycles. Such an exorbitant requirement hinders the use of pruning methods in large-scale applications and raises questions about the credibility of the existing pruning criteria. ",
+        "bbox": [
+            173,
+            570,
+            825,
+            669
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we design a criterion which directly measures the connection importance in a datadependent manner. This alleviates the dependency on the weights and enables us to prune the network once at the beginning, and then the training can be performed on the sparse pruned network. Therefore, our method eliminates the need for the expensive prune – retrain cycles, and in theory, it can be an order of magnitude faster than the standard neural network training as it can be implemented using software libraries that support sparse matrix computations. ",
+        "bbox": [
+            174,
+            675,
+            825,
+            760
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 SINGLE-SHOT NETWORK PRUNING BASED ON CONNECTION SENSITIVITY",
+        "text_level": 1,
+        "bbox": [
+            173,
+            780,
+            805,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a neural network and a dataset, our goal is to design a method that can selectively prune redundant connections for the given task in a data-dependent way even before training. To this end, we first introduce a criterion to identify important connections and then discuss its benefits. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 CONNECTION SENSITIVITY: ARCHITECTURAL PERSPECTIVE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            871,
+            629,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since we intend to measure the importance (or sensitivity) of each connection independently of its weight, we introduce auxiliary indicator variables $\\mathbf { c } \\in \\{ 0 , 1 \\} ^ { m }$ representing the connectivity of ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "parameters w.1 Now, given the sparsity level $\\kappa$ , Equation 1 can be correspondingly modified as: ",
+        "bbox": [
+            169,
+            102,
+            802,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad23c70798958ceacba7cc412e5f4821e5a573dd20685c7c524d2a4992c31a21.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\displaystyle \\operatorname* { m i n } _ { \\mathbf { c } , \\mathbf { w } } L ( \\mathbf { c } \\odot \\mathbf { w } ; \\mathcal { D } ) = \\displaystyle \\operatorname* { m i n } _ { \\mathbf { c } , \\mathbf { w } } \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\ell ( \\mathbf { c } \\odot \\mathbf { w } ; ( \\mathbf { x } _ { i } , \\mathbf { y } _ { i } ) ) ~ , } & { } \\\\ { \\mathrm { s . t . } \\quad \\mathbf { w } \\in \\mathbb { R } ^ { m } ~ , } & { } \\\\ { \\displaystyle \\quad \\mathbf { c } \\in \\{ 0 , 1 \\} ^ { m } , \\quad \\| \\mathbf { c } \\| _ { 0 } \\leq \\kappa ~ , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            119,
+            669,
+            194
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ denotes the Hadamard product. Compared to Equation 1, we have doubled the number of learnable parameters in the network and directly optimizing the above problem is even more difficult. However, the idea here is that since we have separated the weight of the connection (w) from whether the connection is present or not (c), we may be able to determine the importance of each connection by measuring its effect on the loss function. ",
+        "bbox": [
+            173,
+            196,
+            825,
+            267
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For instance, the value of $c _ { j }$ indicates whether the connection $j$ is active $( c _ { j } = 1 )$ ) in the network or pruned $( c _ { j } = 0 )$ . Therefore, to measure the effect of connection $j$ on the loss, one can try to measure the difference in loss when $c _ { j } = 1$ and $c _ { j } = 0$ , keeping everything else constant. Precisely, the effect of removing connection $j$ can be measured by, ",
+        "bbox": [
+            173,
+            273,
+            825,
+            330
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e6365ca8d23c010ba62a5254564ce85692ebeab191c5a566631d07f8358e87d8.jpg",
+        "text": "$$\n\\begin{array} { r } { \\Delta L _ { j } ( \\mathbf { w } ; \\mathcal { D } ) = L \\big ( \\mathbf { 1 } \\odot \\mathbf { w } ; \\mathcal { D } \\big ) - L \\big ( \\big ( \\mathbf { 1 } - \\mathbf { e } _ { j } \\big ) \\odot \\mathbf { w } ; \\mathcal { D } \\big ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            335,
+            674,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { e } _ { j }$ is the indicator vector of element $j$ (i.e., zeros everywhere except at the index $j$ where it is one) and 1 is the vector of dimension $m$ . ",
+        "bbox": [
+            174,
+            357,
+            823,
+            386
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that computing $\\Delta L _ { j }$ for each $j \\in \\{ 1 \\ldots m \\}$ is prohibitively expensive as it requires $m + 1$ (usually in the order of millions) forward passes over the dataset. In fact, since $\\mathbf { c }$ is binary, $L$ is not differentiable with respect to $\\mathbf { c }$ , and it is easy to see that $\\Delta L _ { j }$ attempts to measure the influence of connection $j$ on the loss function in this discrete setting. Therefore, by relaxing the binary constraint on the indicator variables c, $\\Delta L _ { j }$ can be approximated by the derivative of $L$ with respect to $c _ { j }$ , which we denote $g _ { j } ( \\mathbf { w } ; \\mathcal { D } )$ . Hence, the effect of connection $j$ on the loss can be written as: ",
+        "bbox": [
+            173,
+            391,
+            825,
+            477
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/42176d39e7cf3667a3a141ea6f0addeb9f8d4f8297d5e9bce08d1f31245171b5.jpg",
+        "text": "$$\n\\Delta L _ { j } ( \\mathbf { w } ; \\mathcal { D } ) \\approx g _ { j } ( \\mathbf { w } ; \\mathcal { D } ) = \\left. \\frac { \\partial L ( \\mathbf { c } \\odot \\mathbf { w } ; \\mathcal { D } ) } { \\partial c _ { j } } \\right| _ { \\mathbf { c } = \\mathbf { 1 } } = \\operatorname* { l i m } _ { \\delta \\to 0 } \\left. \\frac { L ( \\mathbf { c } \\odot \\mathbf { w } ; \\mathcal { D } ) - L ( ( \\mathbf { c } - \\delta \\mathbf { e } _ { j } ) \\odot \\mathbf { w } ; \\mathcal { D } ) } { \\delta } \\right| _ { \\mathbf { c } = \\mathbf { 1 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            481,
+            838,
+            517
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In fact, $\\partial L / \\partial c _ { j }$ is an infinitesimal version of $\\Delta L _ { j }$ , that measures the rate of change of $L$ with respect to an infinitesimal change in $c _ { j }$ from $1  1 - \\delta$ . This can be computed efficiently in one forward-backward pass using automatic differentiation, for all $j$ at once. Notice, this formulation can be viewed as perturbing the weight $w _ { j }$ by a multiplicative factor $\\delta$ and measuring the change in loss. This approximation is similar in spirit to Koh & Liang (2017) where they try to measure the influence of a datapoint to the loss function. Here we measure the influence of connections. Furthermore, $\\partial L / \\partial c _ { j }$ is not to be confused with the gradient with respect to the weights $( \\partial L / \\partial w _ { j } )$ , where the change in loss is measured with respect to an additive change in weight $w _ { j }$ . ",
+        "bbox": [
+            173,
+            529,
+            825,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Notably, our interest is to discover important (or sensitive) connections in the architecture, so that we can prune unimportant ones in single-shot, disentangling the pruning process from the iterative optimization cycles. To this end, we take the magnitude of the derivatives $g _ { j }$ as the saliency criterion. Note that if the magnitude of the derivative is high (regardless of the sign), it essentially means that the connection $c _ { j }$ has a considerable effect on the loss (either positive or negative), and it has to be preserved to allow learning on $w _ { j }$ . Based on this hypothesis, we define connection sensitivity as the normalized magnitude of the derivatives: ",
+        "bbox": [
+            173,
+            647,
+            825,
+            744
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8bb08f585f88b41a5785256eb41527e77555af8cf3e2c39ba70d686ef13e47a.jpg",
+        "text": "$$\ns _ { j } = \\frac { | g _ { j } ( \\mathbf { w } ; \\mathcal { D } ) | } { \\sum _ { k = 1 } ^ { m } | g _ { k } ( \\mathbf { w } ; \\mathcal { D } ) | } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            742,
+            583,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Once the sensitivity is computed, only the top- $\\kappa$ connections are retained, where $\\kappa$ denotes the desired number of non-zero weights. Precisely, the indicator variables $\\mathbf { c }$ are set as follows: ",
+        "bbox": [
+            171,
+            782,
+            823,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3bb568d384e6a4f34d439518abd1c66f802cd3f1ae4c509d77bbe48a995b13fe.jpg",
+        "text": "$$\nc _ { j } = \\mathbb { 1 } [ s _ { j } - \\tilde { s } _ { \\kappa } \\geq 0 ] , \\quad \\forall j \\in \\{ 1 \\ldots m \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            815,
+            635,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\tilde { s } _ { \\kappa }$ is the $\\kappa$ -th largest element in the vector s and $\\mathbb { 1 } [ \\cdot ]$ is the indicator function. Here, for exactly $\\kappa$ connections to be retained, ties can be broken arbitrarily. ",
+        "bbox": [
+            174,
+            837,
+            826,
+            866
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We would like to clarify that the above criterion (Equation 6) is different from the criteria used in early works by Mozer & Smolensky (1989) or Karnin (1990) which do not entirely capture the connection sensitivity. The fundamental idea behind them is to identify elements (e.g. weights or neurons) that least degrade the performance when removed. This means that their saliency criteria (i.e. $- \\partial L / \\partial \\mathbf { w }$ or $- \\partial L / \\partial \\pmb { \\alpha }$ ; $_ { \\pmb { \\alpha } }$ refers to the connectivity of neurons), in fact, depend on the loss value before pruning, which in turn, require the network to be pre-trained and iterative optimization cycles to ensure minimal loss in performance. They also suffer from the same drawbacks as the magnitude and Hessian based methods as discussed in Section 3. In contrast, our saliency criterion (Equation 6) is designed to measure the sensitivity as to how much influence elements have on the loss function regardless of whether it is positive or negative. This criterion alleviates the dependency on the value of the loss, eliminating the need for pre-training. These fundamental differences enable the network to be pruned at single-shot prior to training, which we discuss further in the next section. ",
+        "bbox": [
+            176,
+            872,
+            825,
+            901
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/ba832c82fdeca45ec305823a28416cffe95432383608d5e24276e28ddf126a8e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">Algorithm1 SNIP: Single-shot Network Pruning based on Connection Sensitivity</td></tr><tr><td>Ensure: | w*|lo ≤ κ</td><td>Require: Loss function L, training dataset D, sparsity level K</td><td>Refer Equation 3</td></tr><tr><td></td><td>1:w_← VarianceScalingInitialization</td><td>Refer Section 4.2</td></tr><tr><td></td><td>2:Db={（xi,yi）}=1 ~D</td><td>&gt; Sample a mini-batch of training data</td></tr><tr><td>3:Sj←</td><td>l9j(w;Db) ∑=1l9k(（w;Db)l ， ∀j∈{1...m}</td><td>Connection sensitivity</td></tr><tr><td></td><td>4:s ← SortDescending(s)</td><td></td></tr><tr><td></td><td>5:cj←1[sj-$κ≥0]，∀j∈{1...m}</td><td>&gt;Pruning: choose top-k connections</td></tr><tr><td>7: w* ← c⊙w*</td><td>6: W* ← arg minw∈Rm L(c ③ w;D)</td><td>Regular training</td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            825,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            291,
+            825,
+            431
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 SINGLE-SHOT PRUNING AT INITIALIZATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            452,
+            514,
+            464
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the saliency measure defined in Equation 6 depends on the value of weights w used to evaluate the derivative as well as the dataset $\\mathcal { D }$ and the loss function $L$ . In this section, we discuss the effect of each of them and show that it can be used to prune the network in single-shot with initial weights w. ",
+        "bbox": [
+            174,
+            477,
+            823,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Firstly, in order to minimize the impact of weights on the derivatives $\\partial L / \\partial c _ { j }$ , we need to choose these weights carefully. For instance, if the weights are too large, the activations after the non-linear function (e.g., sigmoid) will be saturated, which would result in uninformative gradients. Therefore, the weights should be within a sensible range. In particular, there is a body of work on neural network initialization (Goodfellow et al. (2016)) that ensures the gradients to be in a reasonable range, and our saliency measure can be used to prune neural networks at any such initialization. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, we are interested in making our saliency measure robust to architecture variations. Note that initializing neural networks is a random process, typically done using normal distribution. However, if the initial weights have a fixed variance, the signal passing through each layer no longer guarantees to have the same variance, as noted by LeCun et al. (1998). This would make the gradient and in turn our saliency measure, to be dependent on the architectural characteristics. Thus, we advocate the use of variance scaling methods (e.g., Glorot & Bengio (2010)) to initialize the weights, such that the variance remains the same throughout the network. By ensuring this, we empirically show that our saliency measure computed at initialization is robust to variations in the architecture. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, since the dataset and the loss function defines the task at hand, by relying on both of them, our saliency criterion in fact discovers the connections in the network that are important to the given task. However, the practitioner needs to make a choice on whether to use the whole training set, or a mini-batch or the validation set to compute the connection saliency. Moreover, in case there are memory limitations (e.g., large model or dataset), one can accumulate the saliency measure over multiple batches or take an exponential moving average. In our experiments, we show that using only one mini-batch of a reasonable number of training examples can lead to effective pruning. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, in contrast to the previous approaches, our criterion for finding redundant connections is simple and directly based on the sensitivity of the connections. This allows us to effectively identify and prune redundant connections in a single step even before training. Then, training can be performed on the resulting pruned (sparse) network. We name our method SNIP for Single-shot Network Pruning, and the complete algorithm is given in Algorithm 1. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3926bf85ac622a47d0b4130ae5dbb2c6cc89a43e80cedae36061229911cdf321.jpg",
+        "image_caption": [
+            "Figure 1: Test errors of LeNets pruned at varying sparsity levels $\\bar { \\kappa }$ , where $\\bar { \\kappa } = 0$ refers to the reference network trained without pruning. Our approach performs as good as the reference network across varying sparsity levels on both the models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            106,
+            782,
+            247
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            330,
+            326,
+            347
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method, SNIP, on MNIST, CIFAR-10 and Tiny-ImageNet classification tasks with a variety of network architectures. Our results show that SNIP yields extremely sparse models with minimal or no loss in accuracy across all tested architectures, while being much simpler than other state-of-the-art alternatives. We also provide clear evidence that our method prunes genuinely explainable connections rather than performing blind pruning. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experiment setup For brevity, we define the sparsity level to be $\\bar { \\kappa } = ( m - \\kappa ) / m \\cdot 1 0 0 ( \\% )$ , where $m$ is the total number of parameters and $\\kappa$ is the desired number of non-zero weights. For a given sparsity level $\\bar { \\kappa }$ , the sensitivity scores are computed using a batch of 100 and 128 examples for MNIST and CIFAR experiments, respectively. After pruning, the pruned network is trained in the standard way. Specifically, we train the models using SGD with momentum of 0.9, batch size of 100 for MNIST and 128 for CIFAR experiments and the weight decay rate of 0.0005, unless stated otherwise. The initial learning rate is set to 0.1 and decayed by 0.1 at every 25k or $3 0 \\mathrm { k }$ iterations for MNIST and CIFAR, respectively. Our algorithm requires no other hyperparameters or complex learning/pruning schedules as in most pruning algorithms. We spare $10 \\%$ of the training data as a validation set and used only $90 \\%$ for training. For CIFAR experiments, we use the standard data augmentation (i.e., random horizontal flip and translation up to 4 pixels) for both the reference and sparse models. The code can be found here: https://github.com/namhoonlee/snip-public. ",
+        "bbox": [
+            174,
+            441,
+            825,
+            608
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 PRUNING LENETS WITH VARYING LEVELS OF SPARSITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            599,
+            643
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first test our approach on two standard networks for pruning, LeNet-300-100 and LeNet-5-Caffe. LeNet-300-100 consists of three fully-connected (fc) layers with $2 6 7 \\mathrm { k }$ parameters and LeNet-5-Caffe consists of two convolutional (conv) layers and two fc layers with 431k parameters. We prune the LeNets for different sparsity levels $\\bar { \\kappa }$ and report the performance in error on the MNIST image classification task. We run the experiment 20 times for each $\\bar { \\kappa }$ by changing random seeds for dataset and network initialization. The results are reported in Figure 1. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The pruned sparse LeNet-300-100 achieves performances similar to the reference $( \\bar { \\kappa } = 0$ ), only with negligible loss at $\\bar { \\kappa } = 9 0$ . For LeNet-5-Caffe, the performance degradation is nearly invisible. Note that our saliency measure does not require the network to be pre-trained and is computed at random initialization. Despite such simplicity, our approach prunes LeNets quickly (single-shot) and effectively (minimal accuracy loss) at varying sparsity levels. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            818
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 COMPARISONS TO EXISTING APPROACHES",
+        "text_level": 1,
+        "bbox": [
+            178,
+            840,
+            504,
+            854
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "What happens if we increase the target sparsity to an extreme level? For example, would a model with only $1 \\%$ of the total parameters still be trainable and perform well? We test our approach for extreme sparsity levels (e.g., up to $9 9 \\%$ sparsity on LeNet-5-Caffe) and compare with various pruning algorithms as follows: LWC (Han et al. (2015)), DNS (Guo et al. (2016)), LC (Carreira-Perpin˜ an & ´ ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5c09ddcf38a7e654111aab6f939c07bb19eb493c1e1176b36e965541c1d4383.jpg",
+        "table_caption": [
+            "Table 1: Pruning results on LeNets and comparisons to other approaches. Here, “many” refers to an arbitrary number often in the order of total learning steps, and “soft” refers to soft pruning in Bayesian based methods. Our approach is capable of pruning up to $98 \\%$ for LeNet-300-100 and $9 9 \\%$ for LeNet-5-Caffe with marginal increases in error from the reference network. Notably, our approach is considerably simpler than other approaches, with no requirements such as pretraining, additional hyperparameters, augmented training objective or architecture dependent constraints. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">Criterion</td><td colspan=\"2\">LeNet-300-100</td><td colspan=\"2\">LeNet-5-Caffe</td><td rowspan=\"2\">Pretrain</td><td rowspan=\"2\">#Prune</td><td rowspan=\"2\">Additional hyperparam.</td><td rowspan=\"2\">Augment objective</td><td rowspan=\"2\">Arch. constraints</td></tr><tr><td>K(%)</td><td>err. (%)</td><td>K(%)</td><td>err. (%)</td></tr><tr><td>Ref.</td><td></td><td></td><td>1.7</td><td>一</td><td>0.9</td><td></td><td>1</td><td>-&gt;</td><td>-xx&gt;</td><td>√</td></tr><tr><td>LWC</td><td>Magnitude</td><td>91.7</td><td>1.6</td><td>91.7</td><td>0.8</td><td></td><td>many</td><td></td><td></td><td></td></tr><tr><td>DNS</td><td>Magnitude</td><td>98.2</td><td>2.0</td><td>99.1</td><td>0.9</td><td></td><td>many</td><td></td><td></td><td>√</td></tr><tr><td>LC</td><td>Magnitude</td><td>99.0</td><td>3.2</td><td>99.0</td><td>1.1</td><td></td><td>many</td><td>√</td><td></td><td>X</td></tr><tr><td>SWS</td><td>Bayesian</td><td>95.6</td><td>1.9</td><td>99.5</td><td>1.0</td><td></td><td>soft</td><td>√</td><td>√</td><td>X</td></tr><tr><td>SVD</td><td>Bayesian</td><td>98.5</td><td>1.9</td><td>99.6</td><td>0.8</td><td>-&gt;&gt;&gt;&gt;&gt;</td><td>soft</td><td>√</td><td>√</td><td>X</td></tr><tr><td>OBD</td><td>Hessian</td><td>92.0</td><td>2.0</td><td>92.0</td><td>2.7</td><td>√</td><td>many</td><td>√</td><td>X</td><td>X</td></tr><tr><td>L-OBS</td><td>Hessian</td><td>98.5</td><td>2.0</td><td>99.0</td><td>2.1</td><td>√</td><td>many</td><td>√</td><td>X</td><td>√</td></tr><tr><td rowspan=\"2\">SNIP (ours)</td><td>Connection</td><td>95.0</td><td>1.6</td><td>98.0</td><td>0.8</td><td>×</td><td></td><td>×</td><td>×</td><td>×</td></tr><tr><td>sensitivity</td><td>98.0</td><td>2.4</td><td>99.0</td><td>1.1</td><td></td><td>1</td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            825,
+            244
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Idelbayev (2018)), SWS (Ullrich et al. (2017)), SVD (Molchanov et al. (2017a)), OBD (LeCun et al.   \n(1990)), L-OBS (Dong et al. (2017)). The results are summarized in Table 1. ",
+        "bbox": [
+            171,
+            366,
+            821,
+            393
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We achieve errors that are comparable to the reference model, degrading approximately $0 . 7 \\%$ and $0 . 3 \\%$ while pruning $98 \\%$ and $9 9 \\%$ of the parameters in LeNet-300-100 and LeNet-5-Caffe respectively. For slightly relaxed sparsities (i.e., $9 5 \\%$ for LeNet-300-100 and $98 \\%$ for LeNet-5-Caffe), the sparse models pruned by SNIP record better performances than the dense reference network. Considering $9 9 \\%$ sparsity, our method efficiently finds $1 \\%$ of the connections even before training, that are sufficient to learn as good as the reference network. Moreover, SNIP is competitive to other methods, yet it is unparalleled in terms of algorithm simplicity. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            498
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To be more specific, we enumerate some key points and non-trivial aspects of other algorithms and highlight the benefit of our approach. First of all, the aforementioned methods require networks to be fully trained (if not partly) before pruning. These approaches typically perform many pruning operations even if the network is well pretrained, and require additional hyperparameters (e.g., pruning frequency in Guo et al. (2016), annealing schedule in Carreira-Perpin˜an & Idelbayev (2018)). Some ´ methods augment the training objective to handle pruning together with training, increasing the complexity of the algorithm (e.g., augmented Lagrangian in Carreira-Perpin˜an & Idelbayev (2018), ´ variational inference in Molchanov et al. (2017a)). Furthermore, there are approaches designed to include architecture dependent constraints (e.g., layer-wise pruning schemes in Dong et al. (2017)). ",
+        "bbox": [
+            174,
+            506,
+            825,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Compared to the above approaches, ours seems to cost almost nothing; it requires no pretraining or additional hyperparameters, and is applied only once at initialization. This means that one can easily plug-in SNIP as a preprocessor before training neural networks. Since SNIP prunes the network at the beginning, we could potentially expedite the training phase by training only the survived parameters (e.g., reduced expected FLOPs in Louizos et al. (2018)). Notice that this is not possible for the aforementioned approaches as they obtain the maximum sparsity at the end of the process. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 VARIOUS MODERN ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            739,
+            464,
+            753
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we show that our approach is generally applicable to more complex modern network architectures including deep convolutional, residual and recurrent ones. Specifically, our method is applied to the following models: ",
+        "bbox": [
+            174,
+            765,
+            821,
+            808
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• AlexNet-s and AlexNet-b: Models similar to Krizhevsky et al. (2012) in terms of the number of layers and size of kernels. We set the size of fc layers to 512 (AlexNet-s) and to 1024 (AlexNet-b) to adapt for CIFAR-10 and use strides of 2 for all conv layers instead of using pooling layers. • VGG-C, VGG-D and VGG-like: Models similar to the original VGG models described in Simonyan & Zisserman (2015). VGG-like (Zagoruyko (2015)) is a popular variant adapted for CIFAR-10 which has one less fc layers. For all VGG models, we set the size of fc layers to 512, remove dropout layers to avoid any effect on sparsification and use batch normalization instead. • WRN-16-8, WRN-16-10 and WRN-22-8: Same models as in Zagoruyko & Komodakis (2016). ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/3fb488c343d9e8ef6995cf22620a1fb59bb2c951a83d7424081ba37e8bd8748b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture</td><td>Model</td><td>Sparsity (%)</td><td># Parameters</td><td>Error (%)</td><td></td><td>△</td></tr><tr><td rowspan=\"5\">Convolutional</td><td>AlexNet-s</td><td>90.0</td><td>5.1m → 507k</td><td>14.12 →</td><td>14.99</td><td>+0.87</td></tr><tr><td>AlexNet-b</td><td>90.0</td><td>8.5m → 849k</td><td>13.92 →</td><td>14.50</td><td>+0.58</td></tr><tr><td>VGG-C</td><td>95.0</td><td>10.5m → 526k</td><td>6.82 →</td><td>7.27</td><td>+0.45</td></tr><tr><td>VGG-D</td><td>95.0</td><td>15.2m → 762k</td><td>6.76 →</td><td>7.09</td><td>+0.33</td></tr><tr><td>VGG-like</td><td>97.0</td><td>15.0m → 449k</td><td>8.26 →</td><td>8.00</td><td>-0.26</td></tr><tr><td rowspan=\"3\">Residual</td><td>WRN-16-8</td><td>95.0</td><td>10.0m → 548k</td><td>6.21 →</td><td>6.63</td><td>+0.42</td></tr><tr><td>WRN-16-10</td><td>95.0</td><td>17.1m → 856k</td><td>5.91 →</td><td>6.43</td><td>+0.52</td></tr><tr><td>WRN-22-8</td><td>95.0</td><td>17.2m → 858k</td><td>6.14 →</td><td>5.85</td><td>-0.29</td></tr><tr><td rowspan=\"4\">Recurrent</td><td>LSTM-s</td><td>95.0</td><td>137k → 6.8k</td><td>1.88 →</td><td>1.57</td><td>-0.31</td></tr><tr><td>LSTM-b</td><td>95.0</td><td>535k → 26.8k</td><td>1.15 →</td><td>1.35</td><td>+0.20</td></tr><tr><td>GRU-s</td><td>95.0</td><td>104k → 5.2k</td><td>1.87 →</td><td>2.41</td><td>+0.54</td></tr><tr><td>GRU-b</td><td>95.0</td><td>404k→ 20.2k</td><td>1.71 →</td><td>1.52</td><td>-0.19</td></tr></table>",
+        "bbox": [
+            199,
+            101,
+            799,
+            294
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Pruning results of the proposed approach on various modern architectures (before after). AlexNets, VGGs and WRNs are evaluated on CIFAR-10, and LSTMs and GRUs are evaluated on the sequential MNIST classification task. The approach is generally applicable regardless of architecture types and models and results in a significant amount of reduction in the number of parameters with minimal or no loss in performance. ",
+        "bbox": [
+            173,
+            303,
+            825,
+            373
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• LSTM-s, LSTM-b, GRU-s, GRU-b: One layer RNN networks with either LSTM (Zaremba et al. (2014)) or GRU (Cho et al. (2014)) cells. We develop two unit sizes for each cell type, 128 and 256 for $\\{ \\cdot \\}$ -s and $\\{ \\cdot \\}$ -b, respectively. The model is adapted for the sequential MNIST classification task, similar to Le et al. (2015). Instead of processing pixel-by-pixel, however, we perform rowby-row processing (i.e., the RNN cell receives each row at a time). ",
+        "bbox": [
+            174,
+            405,
+            823,
+            476
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are summarized in Table 2. Overall, our approach prunes a substantial amount of parameters in a variety of network models with minimal or no loss in accuracy $( < 1 \\% )$ . Our pruning procedure does not need to be modified for specific architectural variations (e.g., recurrent connections), indicating that it is indeed versatile and scalable. Note that prior art that use a saliency criterion based on the weights (i.e., magnitude or Hessian based) would require considerable adjustments in their pruning schedules as per changes in the model. ",
+        "bbox": [
+            174,
+            482,
+            825,
+            566
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We note of a few challenges in directly comparing against others: different network specifications, learning policies, datasets and tasks. Nonetheless, we provide a few comparison points that we found in the literature. On CIFAR-10, SVD prunes $9 7 . 9 \\%$ of the connections in VGG-like with no loss in accuracy (ours: $9 7 \\%$ sparsity) while SWS obtained $9 3 . 4 \\%$ sparsity on WRN-16-4 but with a non-negligible loss in accuracy of $2 \\%$ . There are a couple of works attempting to prune RNNs (e.g., GRU in Narang et al. (2017) and LSTM in See et al. (2016)). Even though these methods are specifically designed for RNNs, none of them are able to obtain extreme sparsity without substantial loss in accuracy reflecting the challenges of pruning RNNs. To the best of our knowledge, we are the first to demonstrate on convolutional, residual and recurrent networks for extreme sparsities without requiring additional hyperparameters or modifying the pruning procedure. ",
+        "bbox": [
+            174,
+            573,
+            825,
+            713
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 UNDERSTANDING WHICH CONNECTIONS ARE BEING PRUNED ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            736,
+            635,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "So far we have shown that our approach can prune a variety of deep neural network architectures for extreme sparsities without losing much on accuracy. However, it is not clear yet which connections are actually being pruned away or whether we are pruning the right (i.e., unimportant) ones. What if we could actually peep through our approach into this inspection? ",
+        "bbox": [
+            174,
+            763,
+            825,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Consider the first layer in LeNet-300-100 parameterized by $\\mathbf { w } _ { l = 1 } ~ \\in ~ \\mathbb { R } ^ { 7 8 4 \\times 3 0 0 }$ . This is a layer fully connected to the input where input images are of size $2 8 \\times 2 8 \\ : = \\ : 7 8 4$ . In order to understand which connections are retained, we can visualize the binary connectivity mask for this layer $\\mathbf { c } _ { l = 1 }$ , by averaging across columns and then reshaping the vector into 2D matrix (i.e., $\\begin{array} { r } { \\mathbf { c } _ { l = 1 } ^ { \\check { } } \\in \\{ \\bar { 0 } , 1 \\} ^ { \\check { } 8 4 \\times 3 0 \\widetilde { 0 } }  \\mathbb { R } ^ { 7 8 4 }  \\mathbb { R } ^ { 2 8 \\times 2 8 } } \\end{array}$ ). Recall that our method computes c using a minibatch of examples. In this experiment, we curate the mini-batch of examples of the same class and see which weights are retained for that mini-batch of data. We repeat this experiment for all classes (i.e., digits for MNIST and fashion items for Fashion-MNIST) with varying sparsity levels $\\bar { \\kappa }$ . The results are displayed in Figure 2 (see Appendix A for more results). ",
+        "bbox": [
+            174,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f4107c55d7dc6d96c089d84572497bc1ec5a1fdb8c53251ac813dd698b02584.jpg",
+        "image_caption": [
+            "Figure 2: Visualizations of pruned parameters of the first layer in LeNet-300-100; the parameters are reshaped to be visualized as an image. Each column represents the visualizations for a particular class obtained using a batch of 100 examples with varying levels of sparsity $\\bar { \\kappa }$ , from 10 (top) to 90 (bottom). Bright pixels indicate that the parameters connected to these region had high importance scores (s) and survived from pruning. As the sparsity increases, the parameters connected to the discriminative part of the image for classification survive and the irrelevant parts get pruned. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            99,
+            797,
+            292
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            417,
+            823,
+            445
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results are significant; important connections seem to reconstruct either the complete image (MNIST) or silhouettes (Fashion-MNIST) of input class. When we use a batch of examples of the digit 0 (i.e., the first column of MNIST results), for example, the parameters connected to the foreground of the digit 0 survive from pruning while the majority of background is removed. Also, one can easily determine the identity of items from Fashion-MNIST results. This clearly indicates that our method indeed prunes the unimportant connections in performing the classification task, receiving signals only from the most discriminative part of the input. This stands in stark contrast to other pruning methods from which carrying out such inspection is not straightforward. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 EFFECTS OF DATA AND WEIGHT INITIALIZATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            583,
+            547,
+            597
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Recall that our connection saliency measure depends on the network weights w as well as the given data $\\mathcal { D }$ (Section 4.2). We study the effect of each of these in this section. ",
+        "bbox": [
+            173,
+            609,
+            823,
+            637
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of data. Our connection saliency measure depends on a mini-batch of train examples $\\mathcal { D } ^ { b }$ (see Algorithm 1). To study the effect of data, we vary the batch size used to compute the saliency $( | \\mathcal { D } ^ { b } | )$ and check which connections are being pruned as well as how much performance change this results in on the corresponding sparse network. We test with LeNet-300-100 to visualize the remaining parameters, and set the sparsity level $\\bar { \\kappa } = 9 0$ . Note that the batch size used for training remains the same as 100 for all cases. The results are displayed in Figure 3. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            728
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of initialization. Our approach prunes a network at a stochastic initialization as discussed. We study the effect of the following initialization methods: 1) RN (random normal), 2) TN (truncated random normal), 3) VS-X (a variance scaling method using Glorot & Bengio (2010)), and 4) VS-H (a variance scaling method He et al. (2015)). We test on LeNets and RNNs on MNIST and run 20 sets of experiments by varying the seed for initialization. We set the sparsity level $\\bar { \\kappa } = 9 0$ , and train with Adam optimizer (Kingma & Ba (2015)) with learning rate of 0.001 without weight decay. Note that for training VS-X initialization is used in all the cases. The results are reported in Figure 3. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For all models, VS-H achieves the best performance. The differences between initializers are marginal on LeNets, however, variance scaling methods indeed turns out to be essential for complex RNN models. This effect is significant especially for GRU where without variance scaling initialization, the pruned networks are unable to achieve good accuracies, even with different optimizers. Overall, initializing with a variance scaling method seems crucial to making our saliency measure reliable and model-agnostic. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/0571d02738677c85bfcc4968a17cec170d1e05716329724896a5e65b46ef5437.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            101,
+            803,
+            212
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/a505a44a37956c2130096a5ae7d1716db983bfb2c703887f7d1cd3760d02587e.jpg",
+        "table_caption": [
+            "Figure 3: The effect of different batch sizes: (top-row) survived parameters in the first layer of LeNet-300-100 from pruning visualized as images; (bottom-row) the performance in errors of the pruned networks. For $| \\mathcal { D } ^ { b } | \\overset { - } { = } 1$ , the sampled example was 8; our pruning precisely retains the valid connections. As $| \\mathcal { D } ^ { b } |$ increases, survived parameters get close to the average of all examples in the train set (last column), and the error decreases. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Init.</td><td>LeNet-300-100</td><td>LeNet-5-Caffe</td><td>LSTM-s</td><td>GRU-s</td></tr><tr><td>RN</td><td>1.90 ± (0.09)</td><td>0.89 ± (0.04)</td><td>2.93 ± (0.20)</td><td>47.61 ± (20.49)</td></tr><tr><td>TN</td><td>1.96 ± (0.11)</td><td>0.87 ± (0.05)</td><td>3.03 ± (0.17)</td><td>46.48± (22.25)</td></tr><tr><td>VS-X</td><td>1.91 ± (0.10)</td><td>0.88 ± (0.07)</td><td>1.48 ± (0.09)</td><td>1.80 ± (0.10)</td></tr><tr><td>VS-H</td><td>1.88 ± (0.10)</td><td>0.85 ± (0.05)</td><td>1.47 ± (0.08)</td><td>1.80 ± (0.14)</td></tr></table>",
+        "bbox": [
+            277,
+            311,
+            720,
+            378
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 3: The effect of initialization on our saliency score. We report the classification errors ( $\\pm$ std).   \nVariance scaling initialization (VS-X, VS-H) improves the performance, especially for RNNs. ",
+        "bbox": [
+            173,
+            388,
+            820,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.6 FITTING RANDOM LABELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            450,
+            398,
+            464
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To further explore the use cases of SNIP, we run the experiment introduced in Zhang et al. (2017) and check whether the sparse network obtained by SNIP memorizes the dataset. Specifically, we train LeNet-5-Caffe for both the reference model and pruned model (with $\\bar { \\kappa } = 9 9 $ ) on MNIST with either true or randomly shuffled labels. To compute the connection sensitivity, always true labels are used. The results are plotted in Figure 4. ",
+        "bbox": [
+            174,
+            479,
+            549,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Given true labels, both the reference (red) and pruned (blue) models quickly reach to almost zero training loss. However, the reference model provided with random labels (green) also reaches to very low training loss, even with an explicit L2 regularizer (purple), indicating that neural networks have enough capacity to memorize completely random data. In contrast, the model pruned by SNIP (orange) fails to fit the random labels (high training error). The potential explanation is that the pruned network does not have sufficient capacity to fit the random labels, but it is able to classify MNIST with true labels, reinforcing the significance of our saliency criterion. It is possible that a similar experiment can be done with other pruning methods (Molchanov et al. (2017a)), however, being simple, SNIP enables such exploration much easier. We provide a further analysis on the effect of varying $\\bar { \\kappa }$ in Appendix B. ",
+        "bbox": [
+            174,
+            598,
+            547,
+            654
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/9a651ab94be553eb9324682211e6a7c4d4dcea5b1a266aa2431d015c01647a2d.jpg",
+        "image_caption": [
+            "Figure 4: The sparse model pruned by SNIP does not fit the random labels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            573,
+            481,
+            803,
+            619
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            654,
+            825,
+            750
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            777,
+            478,
+            792
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have presented a new approach, SNIP, that is simple, versatile and interpretable; it prunes irrelevant connections for a given task at single-shot prior to training and is applicable to a variety of neural network models without modifications. While SNIP results in extremely sparse models, we find that our connection sensitivity measure itself is noteworthy in that it diagnoses important connections in the network from a purely untrained network. We believe that this opens up new possibilities beyond pruning in the topics of understanding of neural network architectures, multi-task transfer learning and structural regularization, to name a few. In addition to these potential directions, we intend to explore the generalization capabilities of sparse networks. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            334,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by the Korean Government Graduate Scholarship, the ERC grant ERC2012-AdG 321162-HELIOS, EPSRC grant Seebibyte EP/M013774/1 and EPSRC/MURI grant EP/N019474/1. We would also like to acknowledge the Royal Academy of Engineering and FiveAI. ",
+        "bbox": [
+            176,
+            127,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            190,
+            287,
+            207
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora, Rong Ge, Behnam Neyshabur, and Yi Zhang. Stronger generalization bounds for deep nets via a compression approach. ICML, 2018. ",
+        "bbox": [
+            174,
+            214,
+            823,
+            243
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Leo Breiman. Better subset regression using the nonnegative garrote. Technometrics, 1995. ",
+        "bbox": [
+            169,
+            252,
+            772,
+            267
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Miguel A. Carreira-Perpi ´ n˜an and Yerlan Idelbayev. “Learning-compression” algorithms for neural ´ net pruning. CVPR, 2018. ",
+        "bbox": [
+            173,
+            277,
+            823,
+            306
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yves Chauvin. A back-propagation algorithm with optimal use of hidden units. NIPS, 1989. ",
+        "bbox": [
+            178,
+            315,
+            781,
+            332
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. EMNLP, 2014. ",
+        "bbox": [
+            176,
+            339,
+            825,
+            382
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xin Dong, Shangyu Chen, and Sinno Pan. Learning to prune deep neural networks via layer-wise optimal brain surgeon. NIPS, 2017. ",
+        "bbox": [
+            171,
+            391,
+            823,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. AISTATS, 2010. ",
+        "bbox": [
+            171,
+            429,
+            823,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yunchao Gong, Liu Liu, Ming Yang, and Lubomir Bourdev. Compressing deep convolutional networks using vector quantization. arXiv preprint arXiv:1412.6115, 2014. ",
+        "bbox": [
+            171,
+            467,
+            823,
+            497
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Yoshua Bengio, Aaron Courville, and Yoshua Bengio. Deep learning. MIT press Cambridge, 2016. ",
+        "bbox": [
+            173,
+            505,
+            823,
+            535
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. NIPS, 2016. ",
+        "bbox": [
+            176,
+            542,
+            823,
+            573
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. ICML, 2015. ",
+        "bbox": [
+            174,
+            580,
+            823,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. NIPS, 2015. ",
+        "bbox": [
+            174,
+            618,
+            823,
+            648
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Babak Hassibi, David G Stork, and Gregory J Wolff. Optimal brain surgeon and general network pruning. Neural Networks, 1993. ",
+        "bbox": [
+            176,
+            656,
+            823,
+            686
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. ICCV, 2015. ",
+        "bbox": [
+            174,
+            694,
+            823,
+            724
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks. NIPS, 2016. ",
+        "bbox": [
+            174,
+            732,
+            823,
+            762
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Masumi Ishikawa. Structural learning with forgetting. Neural Networks, 1996. ",
+        "bbox": [
+            173,
+            771,
+            694,
+            786
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. BMVC, 2014. ",
+        "bbox": [
+            173,
+            795,
+            820,
+            824
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ehud D Karnin. A simple procedure for pruning back-propagation trained neural networks. Neural Networks, 1990. ",
+        "bbox": [
+            174,
+            833,
+            823,
+            862
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015. ",
+        "bbox": [
+            173,
+            871,
+            792,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pang Wei Koh and Percy Liang. Understanding black-box predictions via influence functions. ICML, 2017. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. 2012. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Quoc V Le, Navdeep Jaitly, and Geoffrey E Hinton. A simple way to initialize recurrent networks of rectified linear units. CoRR, 2015. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            169
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. NIPS, 1990. ",
+        "bbox": [
+            174,
+            175,
+            727,
+            190
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Genevieve B. Orr, and Klaus-Robert M ´ uller. Efficient backprop. ¨ Neural Networks: Tricks of the Trade, 1998. ",
+        "bbox": [
+            176,
+            198,
+            823,
+            227
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. ICLR, 2017. ",
+        "bbox": [
+            173,
+            233,
+            823,
+            263
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through $l _ { 0 }$ regularization. ICLR, 2018. ",
+        "bbox": [
+            173,
+            270,
+            821,
+            299
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Decebal Constantin Mocanu, Elena Mocanu, Peter Stone, Phuong H Nguyen, Madeleine Gibescu, and Antonio Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature Communications, 2018. ",
+        "bbox": [
+            174,
+            305,
+            820,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. ICML, 2017a. ",
+        "bbox": [
+            173,
+            356,
+            823,
+            386
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference. ICLR, 2017b. ",
+        "bbox": [
+            173,
+            392,
+            823,
+            421
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michael C Mozer and Paul Smolensky. Skeletonization: A technique for trimming the fat from a network via relevance assessment. NIPS, 1989. ",
+        "bbox": [
+            173,
+            428,
+            823,
+            458
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sharan Narang, Erich Elsen, Gregory Diamos, and Shubho Sengupta. Exploring sparsity in recurrent neural networks. ICLR, 2017. ",
+        "bbox": [
+            176,
+            464,
+            823,
+            493
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander Novikov, Dmitrii Podoprikhin, Anton Osokin, and Dmitry P Vetrov. Tensorizing neural networks. NIPS, 2015. ",
+        "bbox": [
+            174,
+            500,
+            823,
+            530
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Steven J Nowlan and Geoffrey E Hinton. Simplifying neural networks by soft weight-sharing. Neural Computation, 1992. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            565
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ameya Prabhu, Girish Varma, and Anoop Namboodiri. Deep expander networks: Efficient deep networks from graph theory. ECCV, 2018. ",
+        "bbox": [
+            171,
+            571,
+            823,
+            602
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Russell Reed. Pruning algorithms-a survey. Neural Networks, 1993. ",
+        "bbox": [
+            173,
+            608,
+            622,
+            625
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Abigail See, Minh-Thang Luong, and Christopher D Manning. Compression of neural machine translation models via pruning. CoNLL, 2016. ",
+        "bbox": [
+            173,
+            631,
+            818,
+            661
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. ICLR, 2015. ",
+        "bbox": [
+            173,
+            666,
+            823,
+            696
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Ullrich, Edward Meeds, and Max Welling. Soft weight-sharing for neural network compression. ICLR, 2017. ",
+        "bbox": [
+            173,
+            703,
+            823,
+            733
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andreas S Weigend, David E Rumelhart, and Bernardo A Huberman. Generalization by weightelimination with application to forecasting. NIPS, 1991. ",
+        "bbox": [
+            171,
+            739,
+            823,
+            768
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. NIPS, 2016. ",
+        "bbox": [
+            174,
+            775,
+            823,
+            805
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko. $9 2 . 4 5 \\%$ on cifar-10 in torch. Torch Blog, 2015. ",
+        "bbox": [
+            174,
+            811,
+            614,
+            827
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. BMVC, 2016. ",
+        "bbox": [
+            174,
+            834,
+            707,
+            849
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014. ",
+        "bbox": [
+            173,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. ICLR, 2017. ",
+        "bbox": [
+            173,
+            892,
+            823,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/cc69ae2f5789c064a9d7ec25c2cae8be85125a7807f27c075058ab31684ccd3c.jpg",
+        "image_caption": [
+            "Figure 5: Results of pruning with SNIP on inverted (Fashion-)MNIST (i.e., dark and bright regions are swapped). Notably, even if the data is inverted, the results are the same as the ones on the original (Fashion-)MNIST in Figure 2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            138,
+            797,
+            330
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e10adb4cd3b78aa3523f4d7e8ead3c6621045e90fb560498f3758f598063b9e.jpg",
+        "image_caption": [
+            "Figure 6: Results of pruning with $\\partial L / \\partial$ w on the original and inverted (Fashion-)MNIST. Notably, compared to the case of using SNIP (Figures 2 and 5), the results are different: Firstly, the results on the original (Fashion-)MNIST (i.e., (a) and (c) above) are not the same as the ones using SNIP (i.e., (a) and (b) in Figure 2). Moreover, the pruning patterns are inconsistent with different sparsity levels, either intra-class or inter-class. Furthermore, using ${ \\partial L } / { \\partial \\mathbf { w } }$ results in different pruning patterns between the original and inverted data in some cases (e.g., the $2 ^ { \\mathrm { n d } }$ columns between (c) and (d)). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            407,
+            797,
+            791
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/2c60ed92201d216f7acfecb7839cd7dcf12f0266b4e0e0b0daf88b490479c204.jpg",
+        "image_caption": [
+            "Figure 7: The effect of varying sparsity levels $\\left( \\hat { \\kappa } \\right)$ . The lower $\\bar { \\kappa }$ becomes, the lower training loss is recorded, meaning that a network with more parameters is more vulnerable to fitting random labels. Recall, however, that all pruned models are able to learn to perform the classification task without losing much accuracy (see Figure 1). This potentially indicates that the pruned network does not have sufficient capacity to fit the random labels, but it is capable of performing the classification. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            315,
+            146,
+            676,
+            364
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C TINY-IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            491,
+            346,
+            507
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/a890875fcc5d4f00a5d82860fb17b436412cb4053d5263657ca571f91ea9cdab.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture</td><td>Model</td><td>Sparsity (%)</td><td># Parameters</td><td>Error (%)</td><td>△</td></tr><tr><td rowspan=\"5\">Convolutional</td><td>AlexNet-s</td><td>90.0</td><td>5.1m → 507k</td><td>62.52 → 65.27</td><td>+2.75</td></tr><tr><td>AlexNet-b</td><td>90.0</td><td>8.5m → 849k</td><td>62.76 → 65.54</td><td>+2.78</td></tr><tr><td>VGG-C</td><td>95.0</td><td>10.5m → 526k</td><td>56.49 → 57.48</td><td>+0.99</td></tr><tr><td>VGG-D</td><td>95.0</td><td>15.2m → 762k</td><td>56.85 → 57.00</td><td>+0.15</td></tr><tr><td>VGG-like</td><td>95.0</td><td>15.0m → 749k</td><td>54.86 → 55.73</td><td>+0.87</td></tr></table>",
+        "bbox": [
+            209,
+            526,
+            789,
+            618
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Pruning results of SNIP on Tiny-ImageNet (before after). Tiny-ImageNet2 is a subset of the full ImageNet: there are 200 classes in total, each class has 500 and 50 images for training and validation respectively, and each image has the spatial resolution of $6 4 \\times 6 4$ . Compared to CIFAR-10, the resolution is doubled, and to deal with this, the stride of the first convolution in all architectures is doubled, following the standard practice for this dataset. In general, the Tiny-ImageNet classification task is considered much more complex than MNIST or CIFAR-10. Even on Tiny-ImageNet, however, SNIP is still able to prune a large amount of parameters with minimal loss in performance. AlexNet models lose more accuracies than VGGs, which may be attributed to the fact that the first convolution stride for AlexNet is set to be 4 (by its design of no pooling) which is too large and could lead to high loss of information when pruned. ",
+        "bbox": [
+            173,
+            628,
+            826,
+            768
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5b1c3e32d6a5912780b2b0fa9d9c37ee7cb52c76c52ffcb318e5b2010d8f23e.jpg",
+        "table_caption": [
+            "D ARCHITECTURE DETAILS "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=8>Module         Weight         Stride     Bias      BatchNorm  ReLU</td></tr><tr><td rowspan=1 colspan=1>Conv</td><td rowspan=1 colspan=1>[11,11, 3,96]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>[2,2]</td><td rowspan=1 colspan=3>[96]          √</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>Conv</td><td rowspan=1 colspan=1>[5,5,96,256]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2j</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>[256]</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Conv</td><td rowspan=1 colspan=1>[3,3,256,384]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2.2</td><td rowspan=1 colspan=2>[384]</td><td rowspan=1 colspan=2>√</td></tr><tr><td rowspan=1 colspan=1>Conv</td><td rowspan=1 colspan=1>[3,3,384,384]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=5>[384]</td></tr><tr><td rowspan=1 colspan=1>Conv</td><td rowspan=1 colspan=1>[3,3,384,256]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2,2</td><td rowspan=1 colspan=2>[256]</td><td rowspan=1 colspan=2>（</td></tr><tr><td rowspan=1 colspan=1>Linear</td><td rowspan=1 colspan=1>[256,1024 ×k]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>[1024×k]       √</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=3>Linear  [1024 × k,1024 ×k]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>[1024 × k]       √</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=8>Linear       [1024 × k,c]                    [c]           X         X</td></tr></table>",
+        "bbox": [
+            248,
+            136,
+            748,
+            267
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/68cf239c14c0b9bfb6938d081227ddbd93998f5c59b4860fc3ea76177decd0e5.jpg",
+        "table_caption": [
+            "Table 5: AlexNet-s $k = 1 ,$ ) and AlexNet-b $( k = 2 )$ ). In the last layer, $c$ denotes the number of possible classes: $c = 1 0$ for CIFAR-10 and $c = 2 0 0$ for Tiny-ImageNet. The strides in the first convolution layer for Tiny-ImageNet are set [4, 4] instead of [2, 2] to deal with the increase in the image resolution. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Module</td><td>Weight</td><td>Stride</td><td>Bias</td><td>BatchNorm</td><td>ReLU</td></tr><tr><td>Conv</td><td>[3,3,3,64]</td><td>[1,1]</td><td>[64]</td><td></td><td></td></tr><tr><td>Conv</td><td>[3,3, 64, 64]</td><td></td><td>[64]</td><td>广</td><td></td></tr><tr><td>Pool</td><td></td><td></td><td></td><td>×</td><td>&lt;&gt;x&gt;</td></tr><tr><td>Conv</td><td>[3,3,64,128]</td><td>1j</td><td>[128]</td><td>√</td><td></td></tr><tr><td>Conv</td><td>[3,3,128,128]</td><td>1j</td><td>[128]</td><td>√</td><td>√</td></tr><tr><td>Pool</td><td></td><td>18E.83. 2</td><td></td><td>X</td><td>X</td></tr><tr><td>Conv</td><td>[3,3,128,256]</td><td></td><td>[256]</td><td>√</td><td></td></tr><tr><td>Conv</td><td>[3,3,256,256]</td><td>1</td><td>[256]</td><td></td><td></td></tr><tr><td>Conv</td><td>[1/3/3,1/3/3,256,256]</td><td>1j</td><td>[256]</td><td>√</td><td></td></tr><tr><td>Pool</td><td></td><td>2j</td><td></td><td>X</td><td>X</td></tr><tr><td>Conv</td><td>[3,3,256,512]</td><td>1</td><td>[512]</td><td></td><td></td></tr><tr><td>Conv</td><td>[3,3,512, 512]</td><td>1j</td><td>[512]</td><td></td><td></td></tr><tr><td>Conv</td><td>[1/3/3,1/3/3,512,512]</td><td>1j</td><td>[512]</td><td></td><td></td></tr><tr><td>Pool</td><td></td><td>2</td><td></td><td></td><td></td></tr><tr><td>Conv</td><td>[3,3,512, 512]</td><td>1j</td><td>[512]</td><td></td><td></td></tr><tr><td>Conv</td><td>[3,3, 512,512]</td><td>1]</td><td>[512]</td><td></td><td></td></tr><tr><td>Conv</td><td>[1/3/3,1/3/3,512,512]</td><td>1]</td><td>[512]</td><td></td><td></td></tr><tr><td>Pool</td><td></td><td></td><td></td><td>X</td><td></td></tr><tr><td>Linear</td><td>[512, 512]</td><td></td><td>[512]</td><td>√</td><td>√</td></tr><tr><td>Linear</td><td>[512, 512]</td><td></td><td>[512]</td><td>√</td><td>√</td></tr><tr><td>Linear</td><td>[512,c]</td><td></td><td>[c]</td><td>X</td><td>X</td></tr></table>",
+        "bbox": [
+            253,
+            340,
+            743,
+            633
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 6: VGG-C/D/like. In the last layer, $c$ denotes the number of possible classes: $c = 1 0$ for CIFAR10 and $c = 2 0 0$ for Tiny-ImageNet. The strides in the first convolution layer for Tiny-ImageNet are set [2, 2] instead of [1, 1] to deal with the increase in the image resolution. The second Linear layer is only used in VGG-C/D. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            700
+        ],
+        "page_idx": 14
+    }
+]

parse/train/BkmM8Dceg/BkmM8Dceg.md

@@ -0,0 +1,322 @@
+# WARPED CONVOLUTIONS: EFFICIENT INVARIANCE TO SPATIAL TRANSFORMATIONS
+
+João F. Henriques & Andrea Vedaldi   
+Visual Geometry Group   
+University of Oxford   
+{joao,vedaldi}@robots.ox.ac.uk
+
+# ABSTRACT
+
+Convolutional Neural Networks (CNNs) are extremely efficient, since they exploit the inherent translation-invariance of natural images. However, translation is just one of a myriad of useful spatial transformations. Can the same efficiency be attained when considering other spatial invariances? Such generalized convolutions have been considered in the past, but at a high computational cost. We present a construction that is simple and exact, yet has the same computational complexity that standard convolutions enjoy. It consists of a constant image warp followed by a simple convolution, which are standard blocks in deep learning toolboxes. With a carefully crafted warp, the resulting architecture can be made equivariant to a wide range of 2-parameters spatial transformations. We show encouraging results in realistic scenarios, including the estimation of vehicle poses in the Google Earth dataset (rotation and scale), and face poses in Annotated Facial Landmarks in the Wild (3D rotations under perspective).
+
+# 1 INTRODUCTION
+
+A crucial aspect of current deep learning architectures is the encoding of invariances. This fact is epitomized in the success of convolutional neural networks (CNN), where equivariance to image translation is key: translating the input results in a translated output. When invariances are present in the data, encoding them explicitly in an architecture provides an important source of regularization, which allows to reduce the amount of training data required for learning. Invariances may also be used to improve the efficiency of implementations; for instance, a convolutional layer requires orders of magnitude less memory and also less computation compared to an equivalent fully-connected layer.
+
+The success of CNNs indicates that translation invariance is an important property of images. However, this does not explain why translation equivariant operators work well for image understanding. The common interpretation is that such operators are matched to the statistics of natural images, which are well known to be translation invariant (Hyvärinen et al., 2009). However, natural image statistics are also (largely) invariant to other transformations such as isotropic scaling and rotation, which suggests that alternative neural network designs may also work well with images. Furthermore, in specific applications, invariances other than translation may be more appropriate.
+
+Therefore, it is natural to consider generalizing convolutional architectures to other image transformations, and this has been the subject of extensive study (Kanazawa et al., 2014; Bruna et al., 2013; Cohen & Welling, 2016). Unfortunately these approaches do not possess the same memory and speed benefits that CNNs enjoy. The reason is that, ultimately, they have to transform (warp) an image or filter several times (Kanazawa et al., 2014; Marcos et al., 2016; Dieleman et al., 2015), incurring a high computational burden. Another approach is to consider a basis of filters (analogous to eigen-images) encoding the desired invariance (Cohen & Welling, 2014; Bruna et al., 2013; Cohen & Welling, 2016), which requires more storage than a convolutional filter.
+
+Although they are able to handle transformations with many pose parameters, in practice most recent proposals are limited to very coarsely discretized transformations, such as horizontal/vertical flips and $9 0 ^ { \circ }$ rotations (Dieleman et al., 2015; Cohen & Welling, 2014).
+
+In this work we propose a generalization of CNNs that overcomes these disadvantages. Our main result shows that a linear layer with equivariance w.r.t. a large class of 2-parameters transformations can always be implemented efficiently, using a standard convolution in a warped image space. The image warp can be implemented using bilinear resampling, a simple and fast operation that has been popularized by spatial transformer networks (Jaderberg et al., 2015), and is part of most deep learning toolboxes. Unlike previous proposals, the proposed warped convolutions can handle continuous transformations, such as fine rotation and scaling.
+
+This makes generalized convolution easily implementable in neural networks, including using fast convolution algorithms on GPU hardware, such as Winograd (Lavin, 2015) or the Fast Fourier Transform (Lyons, 2010). We present these notions in the simplest possible way (sections 2 to 4), but we note that they can be derived in broader generality from well know concepts of group theory (section 4.2).
+
+# 2 GENERALIZING CONVOLUTION
+
+# 2.1 CONVOLUTIONS OF CONTINUOUS IMAGES
+
+We start by looking at the basic building block of CNNs, i.e. the convolution operator. This operator computes the inner product of an image $\boldsymbol { I } \in \mathbb { R } ^ { m \times n }$ with a translated version of the filter $\boldsymbol { F } \in \mathbb { R } ^ { r \times s }$ , producing a new image as output:
+
+$$
+H _ { j } = \sum _ { k } I _ { k } F _ { k + j } ,
+$$
+
+where $k$ ${ \mathfrak { a } } , { \mathfrak { j } } \in \mathbb { Z } ^ { 2 }$ are two-dimensional vectors of indexes, and the summation ranges inside the extents of both arrays.1 To handle continuous deformations of the input, it is more natural to express eq. 1 as an integral over continuous rather than discrete inputs:
+
+$$
+H ( u ; I ) = \int I ( x ) F ( x + u ) d x ,
+$$
+
+where $I ( x )$ and $F ( x )$ are continuous functions over a bounded 2D region $\Omega \subset \mathbb { R } ^ { 2 }$ , that is: $I , F :$ $\Omega \to \mathbb { R }$ . The real-valued 2D vectors $x \in \Omega$ now play the role of the indexes $k \in  { \mathbb { Z } } ^ { 2 }$ . Equation 2 reduces to the discrete case of eq. 1 if we define $I ( x )$ and $F ( x )$ as the sum of delta functions on grids. Intermediate values can be obtained by interpolation, such as bilinear (which amounts to convolution of the delta functions with a triangle filter (Jaderberg et al., 2015)). Importantly, such continuous images can be deformed by very rich continuous transformations of the input coordinates, whereas strictly discrete operations would be more limiting.
+
+Over the next sections it will be more convenient to translate the image $I$ instead of the filter $F$ . This alternative form of eq. 2 is obtained by replacing $x + u  x$ :
+
+$$
+H ( u ; I ) = \int I ( x - u ) F ( x ) d x .
+$$
+
+# 2.2 BEYOND IMAGE TRANSLATIONS
+
+The standard convolution operator of eq. 3 can be interpreted as applying the filter to translated versions of the image. Translations can be replaced by other transformations as follows (Henriques et al., 2014):
+
+$$
+H ( t ; I ) = \int I ( t ( x ) ) F ( x ) d x , \quad t \in G
+$$
+
+where $G$ is a set of transformation functions $t : \Omega \to \Omega$ (assumed to be invertible). Intuitively, this generalized convolution performs an exhaustive search for a pattern, at many different poses (Henriques et al., 2014; Kanazawa et al., 2014). The interest in this definition lies in the fact that it makes convolution equivariant (Lenc & Vedaldi, 2015):
+
+Lemma 1 (Equivariance). Consider the generalized convolution operator $H ( t ; I )$ of eq. 4. Generalized convolution “commutes” with any transformation $q \in G$ of the image:
+
+$$
+H ( t ; I \circ q ) = H ( q \circ t ; I ) .
+$$
+
+Proof. One has immediately $\begin{array} { r } { H ( t ; I \circ q ) = \int I ( q ( t ( x ) ) ) F ( x ) d x = H ( q \circ t ; I ) . } \end{array}$
+
+A notable case is when transformations have an additive parametrization $t : \Omega \times \mathbb { R } ^ { 2 } \to \Omega$ , with $( x , u ) \mapsto t _ { u } ( x )$ and $t _ { u } \circ t _ { v } = t _ { u + v }$ . In this case, the equivariance relation can be written as
+
+$$
+H ( u ; I \circ t _ { v } ) = H ( v + u ; I ) .
+$$
+
+In particular, standard convolution is obtained when $t _ { u } ( x ) = x - u$ is the translation operator. In this case, the lemma above simply states that any translation of the input of the convolution results in a corresponding translation of the output.
+
+In section 5, we will look in more detail at a few concrete examples of transformations other than translations. Although we will not do so explicitly, in this construction it is also possible to let one or more dimensions of the parameter space $\mathbb { R } ^ { \bar { 2 } }$ be given modulus a period $Q$ , in the sense of replacing $\mathbb { R }$ with $\mathbb { R } / \mathbb { Z } ( Q )$ ; the latter is required to parameterise transformations such as rotation.
+
+# 3 COMPUTATIONAL EFFICIENCY
+
+Unfortunately, what eq. 4 gains us in generality, it loses in both performance and ease of implementation. Most works in computer vision that looked at filtering under generalized transformations (e.g. scale pyramids (Kanazawa et al., 2014) or rotated filter banks (Marcos et al., 2016; Cohen & Welling, 2014; 2016; Henriques et al., 2014)) compute eq. 4 directly by evaluating a large number of transformations $t \in G$ . This entails warping (transforming) either the image or the filter once per transformation $t$ , which can be expensive.
+
+Opting to transform the filter instead of the image can be advantageous, since it is smaller in size. On the other hand, the filter and its domain then become spatially-varying, which foregoes the benefit of the regular, predictable, and local pattern of computations in standard convolution. It precludes the use of fast convolution routines such as Winograd’s algorithm (Lavin, 2015), or the Fast Fourier Transform (Lyons, 2010), which has lower computational complexity than exhaustive search (eq. 3).
+
+In practice, most recent works focus on very coarse transformations that do not change the filter support and can be implemented strictly via permutations, like horizontal/vertical flips and $9 0 ^ { \circ }$ rotations (Dieleman et al., 2015; Cohen & Welling, 2014). Such difficulties explain why generalized convolutions are not as widespread as CNNs.
+
+In section 4 we will show that, for an important class of transformations, including the ones considered in previous works (such as Kanazawa et al. (2014); Cohen & Welling (2014); Marcos et al. (2016)) it is possible to perform generalized convolution by composing a single warp with a standard convolution, instead of several warps. Thus, we are able to take full advantage of modern convolution implementations (Lavin, 2015; Lyons, 2010), including those with lower computational complexity.
+
+# 4 MAIN RESULT
+
+Our main contribution is to show that the generalized convolution operator of eq. 4 can be implemented efficiently by a standard convolution, by pre-warping the input image and filter appropriately. The warp is the same for any image, depending solely on the nature of the relevant transformations, and can be written in closed form. This result, given in theorem 1, allows us to implement very efficient generalized convolutions using simple computational blocks, as shown in section 4.1. We name this method warped convolution.
+
+The strongest assumption is that transformations must have an additive parametrization. By this, we mean that there exists a bijection $t _ { u } : \Omega \to \Omega$ such that, for any $u , v \in \mathbb { R } ^ { 2 }$ , parameters compose additively $t _ { u } \circ t _ { v } = t _ { u + v }$ . The second assumption is that there exists a pivot point $x _ { 0 } \in \Omega$ such that $u \mapsto t _ { u } ( x _ { 0 } )$ defines a bijection $\mathbb { R } ^ { 2 } \to \Omega$ from the parameter space to the real plane. The latter requirements means that any point $x \in \Omega$ can be “reached” by transforming $x _ { 0 }$ under a suitable $t _ { u }$ . We then have that:
+
+Theorem 1. Consider the generalized convolution of eq. 4. Assume that the transformation is additive $( t _ { u } \circ t _ { v } = t _ { u + v . }$ ). Assume also that, for a fixed pivot point $x _ { 0 }$ , the function $u \mapsto t _ { u } ( x _ { 0 } )$ is bijective. Then we can rewrite generalized convolution (eq. 4) as the standard convolution
+
+$$
+H ( u ; I ) = \int \hat { I } ( u + v ) \hat { F } ( v ) d v ,
+$$
+
+where $\hat { I }$ and $\hat { F }$ are the warped image and filter given by:
+
+$$
+\hat { I } ( u ) = I ( t _ { u } ( x _ { 0 } ) ) , \qquad \hat { F } ( u ) = F ( t _ { u } ( x _ { 0 } ) ) \left| \frac { d t _ { u } ( x _ { 0 } ) } { d u } \right| .
+$$
+
+Proof. We use the variable substitution $x = t _ { v } ( x _ { 0 } )$ in eq. 4. Then:
+
+$$
+\begin{array} { l } { H ( u ; I ) = \displaystyle \int I ( t _ { u } ( x ) ) F ( x ) d x } \\ { \displaystyle = \int I ( t _ { u } ( t _ { v } ( x _ { 0 } ) ) ) F ( t _ { v } ( x _ { 0 } ) ) \left| \frac { d t _ { v } ( x _ { 0 } ) } { d v } \right| d v } \\ { \displaystyle = \int \underbrace { I ( t _ { u + v } ( x _ { 0 } ) ) } _ { \hat { I } ( u + v ) } \underbrace { F ( t _ { v } ( x _ { 0 } ) ) \left| \frac { d t _ { v } ( x _ { 0 } ) } { d v } \right| } _ { \hat { F } ( v ) } d v } \\ { \displaystyle = \int \hat { I } ( u + v ) \hat { F } ( v ) d v . } \end{array}
+$$
+
+The warp that is applied to both inputs in eq. 7 can be interpreted as follows. We start with an arbitrary pivot point $x _ { 0 }$ in the image and them sample other points by repeatedly applying the transformation $t _ { u } ( x _ { 0 } )$ to the pivot (by varying $u$ ). When discretized, this sampling is performed over a 2D grid of parameters $u$ . Finally, sampling the input at these points (for example, by bilinear interpolation) yields the warped input.
+
+An illustration is given in fig. 1, for various transformations (each one is discussed in more detail in section 5). The red dot shows the pivot point $x _ { 0 }$ , and the two arrows pointing away from it show the two directions of increasing $u$ values (recall that transformation parameters are two-dimensional). The grids were generated by sampling $u$ at regular intervals. Note that the warp grids are independent of the image contents – they can be computed once offline and then applied to any image.
+
+The last factor in eq. 7 is the determinant of the Jacobian of the image transformation $t$ . It rescales the image values to account for the stretching and shrinking of space due to non-linear warps. It can also be computed offline, and its application amounts to an element-wise product by a constant array. A generalization using group theory is discussed in section 4.2.
+
+# 4.1 PRACTICAL CONSIDERATIONS
+
+There are a few interesting aspects that simplify the use of theorem 1 in practice.
+
+First, since in most applications the filter $F$ is learned, we are free to ignore the constant warp and Jacobian in eq. 7 (which amounts to a simple reparametrization), and learn $\hat { F }$ directly. In practice, this means that we warp only the input image $I$ to obtain $\hat { I }$ , and then perform a standard convolution with a filter $\hat { F }$ . The learned warped filter $\hat { F }$ has a one-to-one correspondence to an image-space filter $F$ by means of eq. 7, although there is no real need to build the latter explicitly.
+
+Second, we can choose either one or two spatial transformations for the generalized convolution (e.g. scale and rotation, simultaneously). The reason is that the input image is 2D, so the parameterspace after warping is also 2D. The choice is not arbitrary though: the two transformations must commute, in order to respect additivity. This will be the case of the pairs we study in section 5.
+
+# Algorithm 1 Warped convolution.
+
+Grid generation (offline)
+
+• Apply the spatial transformation $t$ repeatedly to a pivot point $x _ { 0 }$ , using a 2D grid of parameters $\stackrel { \cdot } { u } = \{ \bar { ( } u _ { 1 } + i \delta _ { 1 } , u _ { 2 } + j \delta _ { 2 } ) : i = 0 , \ldots , m , j = 0 , \bar { \ldots } , n \}$ , obtaining the 2D warp grid $t _ { u } ( x _ { 0 } )$ .
+
+Warped convolution
+
+1. Resample input image $I$ using the warp grid $t _ { u } ( x _ { 0 } )$ , by bilinear interpolation.
+
+2. Convolve the warped image $\hat { I }$ with filter $\hat { F }$ .
+
+By theorem 1, these steps are equivalent to a generalized convolution, which performs an exhaustive search across the pose-space of transformation $t$ , but at a much lower computational cost.
+
+# 4.2 RELATIONSHIP TO GROUP THEORY
+
+This section relates our results, which have been presented using a simple formalism and in a restricted setting, to a more general approach based on group theory (Folland, 1995).
+
+To this end, let $G$ be a group of transformations. Under very mild conditions (the group has to be locally compact and Hausdorff), there exists a unique measure on the group, the Haar measure, which is invariant to the group action, in the sense that, given a measurable function ${ \tilde { I } } : G \to$ $\mathbb { R }$ , then $\begin{array} { r } { \int \tilde { I } ( g ^ { \prime } g ) d g = \int \overline { { \tilde { I } } } ( g ) \dot { } d g } \end{array}$ . Using this measure, one can define generalized convolution as $\begin{array} { r } { ( \tilde { I } * \tilde { F } ) ( t ) = \int _ { G } \tilde { I } ( t g ) \tilde { F } ( g ^ { - 1 } ) d g } \end{array}$ . This resembles our definition (4), although image and filter are defined on the group $G$ instead of the spatial domain $\mathbb { R } ^ { 2 }$ . Lemma 1 translates immediately to this case (Folland, 1995).
+
+In order to extend Theorem 1, we need to make this general but abstract construction concrete. Here one assumes that the group acts transitively on a subset $X \subset \mathbb { R } ^ { 2 }$ (which means that any point $x \in X$ can be written as $x = g x _ { 0 }$ , for a fixed point $x _ { 0 } \in X$ and a suitable transformation $g \in G$ ). Then one can define the image as $\tilde { I } ( g ) = I ( g \bar { ( } x _ { 0 } ) )$ , where $I$ is a function of the spatial domain $X$ instead of the group $G$ , and likewise for the filter. Next, it is necessary to explicitly calculate the integral over $G$ . If the group is an Abelian (commutative) Lie group, then one can show that there exists a map $\exp : V \to G$ , the exponential map, defined on a vector space $V$ . Under commutativity, this map is also additive, in the sense that $\exp ( u ) \exp ( v ) = \exp ( u + v )$ . The structure of $V$ depends on the specific group, but under such restrictive conditions, it is a torus, which allows the calculation of $\textstyle \int { \tilde { I } } ( { \bar { g } } ) d g$ as $\begin{array} { r } { \int \tilde { I } ( \exp ( u ) x _ { 0 } ) d u . } \end{array}$ .
+
+Finally, in order to swap integration over the group parameters with integration over space, one assumes that $x \ = \ \exp ( u ) x _ { 0 }$ defines a smooth bijection $V \  \ X$ , so that it is possible to use the change of variable $\dot { u }  u ( x )$ where $\mathrm { e x p } ( u ( x ) ) x _ { 0 } = x$ . This allows writing the integral as $\begin{array} { r } { \int { \tilde { I } } ( \exp ( u ) x _ { 0 } ) d u = \int I ( x ) \left| d u / d x \right| d x } \end{array}$ . Note that this Jacobian is the inverse of the one found in (1) due to the fact that we started by defining our convolution using $I$ instead of $\tilde { I }$ .
+
+# 5 EXAMPLES OF SPATIAL TRANSFORMATIONS
+
+We now give some concrete examples of pairs of spatial transformations that obey the conditions of theorem 1, and can be useful in practice.
+
+# 5.1 SCALE AND ASPECT RATIO
+
+Detection tasks require predicting the extent of an object as a bounding box. While the location can be found accurately by a standard CNN, which is equivariant to translation, the size prediction could similarly benefit from equivariance to horizontal and vertical scale (equivalently, scale and aspect ratio).
+
+Such a spatial transformation, from which a warp can be constructed, is given by:
+
+![](images/60788d1a003ce7fcae165868e8ad44de46e7af62c507569ccf0f4de9f35dc344.jpg)  
+Figure 1: First row: Sampling grids that define the warps associated with different spatial transformations. Second row: An example image (a) after warping with each grid (b-d). Third row: A small translation is applied to each warped image, which is then mapped back to the original space (by an inverse warp). Translation in one axis of the appropriate warped space is equivalent to (b) horizontal scaling; (c) planar rotation; (d) 3D rotation around the vertical axis.
+
+$$
+t _ { u } ( x ) = { \left[ \begin{array} { l } { x _ { 1 } s ^ { u _ { 1 } } } \\ { x _ { 2 } s ^ { u _ { 2 } } } \end{array} \right] }
+$$
+
+The $s$ constant controls the total degree of scaling applied. Notice that the output must be exponential in the scale parameters $u$ ; this ensures the additive structure required by theorem 1: $t _ { u } ( \bar { t } _ { v } ( x ) ) =$ $t _ { u + v } ( x )$ . The resulting warp grid can be visualized in fig. 1-b. In this case, the domain of the image must be $\Omega \in \mathbb { R } _ { + } ^ { 2 }$ , since a pivot $x _ { 0 }$ in one quadrant cannot reach another quadrant by any amount of (positive) scaling.
+
+# 5.2 SCALE AND ROTATION (LOG-POLAR WARP)
+
+Planar scale and rotation are perhaps the most obvious spatial transformations in images, and are a natural test case for works on spatial transformations (Kanazawa et al., 2014; Marcos et al., 2016). Rotating a point $x$ by $u _ { 1 }$ radians and scaling it by $u _ { 2 }$ , around the origin, can be performed with
+
+$$
+t _ { u } ( x ) = \left[ \begin{array} { l } { s ^ { u _ { 2 } } \left\| x \right\| \cos ( \mathrm { a t a n } _ { 2 } ( x _ { 2 } , x _ { 1 } ) + u _ { 1 } ) } \\ { s ^ { u _ { 2 } } \left\| x \right\| \sin ( \mathrm { a t a n } _ { 2 } ( x _ { 2 } , x _ { 1 } ) + u _ { 1 } ) } \end{array} \right] ,
+$$
+
+where atan $^ 2$ is the standard 4-quadrant inverse tangent function (atan2). The domain in this case must exclude the origin $( \Omega \in \dot { \mathbb { R } } ^ { 2 } \setminus \{ 0 \} )$ , since a pivot $x _ { 0 } = 0$ cannot reach any other points in the image by rotation or scaling.
+
+![](images/411e48b00e252ab8e9ec8948af96a700f5774ade8b1cca75c0faf68a96fea41e.jpg)  
+Figure 2: Equivariant pose estimation strategy used in the experiments (section 6). With an appropriate warp and a standard CNN, the shaded block becomes equivalent to a generalized CNN (by theorem 1), which performs exhaustive searches across pose-space instead of image-space.
+
+The resulting warp grid can be visualized in fig. 1-c. It is interesting to observe that it corresponds exactly to the log-polar domain, which is used in the signal processing literature to perform correlation across scale and rotation (Tzimiropoulos et al., 2010; Reddy & Chatterji, 1996). In fact, it was the source of inspiration for this work, which can be seen as a generalization of the log-polar domain to other spatial transformations.
+
+# 5.3 3D SPHERE ROTATION UNDER PERSPECTIVE
+
+We will now tackle a more difficult spatial transformation, in an attempt to demonstrate the generality of theorem 1. The transformations we will consider are yaw and pitch rotations in 3D space, as seen by a perspective camera. In the experiments (section 6) we will show how to apply it to face pose estimation.
+
+In order to maintain additivity, the rotated 3D points must remain on the surface of a sphere. We consider a simplified camera and world model, whose only hyperparameters are a focal length $f$ , the radius of a sphere $r$ , and its distance from the camera center $d$ . The equations for the spatial transformation corresponding to yaw and pitch rotation under this model are in appendix A.
+
+The corresponding warp grid can be seen in fig. 1-d. It can be observed that the grid corresponds to what we would expect of a 3D rendering of a sphere with a discrete mesh. An intuitive picture of the effect of the warp grid in such cases is that it wraps the 2D image around the surface of the 3D object, so that translation in the warped space corresponds to moving between vertexes of the 3D geometry.
+
+# 6 EXPERIMENTS
+
+# 6.1 ARCHITECTURE
+
+As mentioned in section 2.2, generalized convolution performs an exhaustive search for patterns across spatial transformations, by varying pose parameters. For tasks where invariance to that transformation is important, it is usual to pool the detection responses across all poses (Marcos et al., 2016; Kanazawa et al., 2014).
+
+In the experiments, however, we will test the framework in pose prediction tasks. As such, we do not want to pool the detection responses (e.g. with a max operation) but rather find the pose with the strongest response (i.e., an argmax operation). To perform this operation in a differentiable manner, we implement a soft argmax operation, defined as follows:
+
+$$
+s _ { 1 } ( a ) = \sum _ { i j } ^ { m n } \frac { i } { m } \sigma _ { i j } ( a ) , \qquad s _ { 2 } ( a ) = \sum _ { i j } ^ { m n } \frac { j } { n } \sigma _ { i j } ( a ) ,
+$$
+
+where $\sigma ( a ) \in \mathbb { R } ^ { m \times n }$ is the softmax over all spatial locations, and $\sigma _ { i j } ( a )$ indexes the element at $( i , j )$ . The outputs are the two spatial coordinates of the maximum value, $s ( a ) \in \mathbb { R } ^ { 2 }$ .
+
+Our base architecture then consists of the following blocks, outlined in fig. 2. First, the input image is warped with a pre-generated grid, according to section 4. The warped image is then processed by a standard CNN, which is now equivariant to the spatial transformation that was used to generate the warp grid. A soft argmax (eq. 10) then finds the maximum over pose-space. To ensure the pose prediction is well registered to the reference coordinate system, a learnable scale and bias are applied to the outputs. Training proceeds by minimizing the $L ^ { 1 }$ loss between the predicted pose and ground truth pose.
+
+Table 1: Results of scale and rotation pose estimation of vehicles in the Google Earth dataset.   
+
+<table><tr><td></td><td>CNN+FC</td><td>CNN+softargmax</td><td> Warped CNN</td></tr><tr><td>Rotation error (degrees)</td><td>28.87</td><td>30.6</td><td>26.44</td></tr><tr><td>Scale error (px)</td><td>17.51</td><td>5.783</td><td>5.4</td></tr></table>
+
+![](images/db8ba0448a92bfa2d818168ec5f182ee517f7c3a909c68da0c90758eb10407fb.jpg)  
+Figure 3: Example pose estimates (rotation and scale) on the Google Earth dataset (Section 6.2).
+
+# 6.2 GOOGLE EARTH
+
+For the first task in our experiments, we will consider aerial photos of vehicles, which have been used in several works that deal with rotation invariance (Liu et al., 2014; Schmidt & Roth, 2012; Henriques et al., 2014).
+
+Dataset. The Google Earth dataset (Heitz & Koller, 2008) contains bounding box annotations, supplemented with angle annotations from (Henriques et al., 2014), for 697 vehicles in 15 large images. We use the first 10 for training and the rest for validation. Going beyond these previous works, we focus on the estimation of both rotation and scale parameters. The object scale is taken to be the diagonal length of the bounding box.
+
+Implementation. A $4 8 \times 4 8$ image around each vehicle is cropped and downscaled by $50 \%$ , and then fed to a network for pose prediction. The proposed method, Warped CNN, follows the architecture of section 6.1 (visualized in fig. 2). The CNN block contains 3 convolutional layers with $5 \times 5$ filters, with 20, 50 and 1 output channels respectively. Recall that the output of the CNN block is a single-channel response map over 2D pose-space, which in this case consists of rotation and scale. Between the convolutional layers there are $3 \times 3$ max-pooling operators, with a stride of 2, and a ReLU before the last layer. All networks are trained for 20 epochs with SGD, using hyperparameters chosen by cross-validation.
+
+Baselines and results. The results of the experiments are presented in table 1, which shows angular and scale error in the validation set. Qualitative results are shown in fig. 3. To verify whether the proposed warped convolution is indeed responsible for a boost in performance, rather than other architectural details, we compare it against a number of baselines with different components removed. The first baseline, CNN $^ +$ softargmax, consists of the same architecture but without the warp (section 5.2). This is a standard CNN, with the soft argmax at the end. Since CNNs are equivariant to translation, rather than scale and rotation, we observe a drop in performance. For the second baseline, $\mathrm { C N N + F C }$ , we replace the soft argmax with a fully-connected layer, to allow a prediction that is not equivariant with translation. The FC layer improves the angular error, but not the scale error. The proposed Warped CNN has a similar (slightly lower) capacity to the $\mathrm { C N N + F C }$ baseline, but we see it achieve better performance, since its architectural equivariance seems to be better matched to the data distribution.
+
+Table 2: Results of yaw and pitch pose estimation of faces on the AFLW dataset.   
+
+<table><tr><td></td><td>CNN+FC</td><td>STN+FC</td><td> STN+softargmax</td><td> Warped CNN</td></tr><tr><td>Yaw err. (deg.)</td><td>13.87</td><td>16.92</td><td>15.01</td><td>10.65</td></tr><tr><td>Pitch err. (deg.)</td><td>7.23</td><td>10.17</td><td>6.88</td><td>6.351</td></tr></table>
+
+# 6.3 FACES
+
+We now turn to face pose estimation in unconstrained photos, which requires handling more complex 3D rotations under perspective.
+
+Dataset. For this task we use the Annotated Facial Landmarks in the Wild (AFLW) dataset (Koestinger et al., 2011). It contains about 25K faces found in Flickr photos, and includes yaw (left-right) and pitch (up-down) annotations. We removed 933 faces with yaw larger than 90 degrees (i.e., facing away from the camera), resulting in a set of 24,384 samples. $20 \%$ of the faces were set aside for validation.
+
+Implementation. The region in each face’s bounding box is resized to a $6 4 \times 6 4$ image, which is then processed by the network. Recall that our simplified 3D model of yaw and pitch rotation (section 5.3) assumes a spherical geometry. Although a person’s head roughly follows a spherical shape, the sample images are centered around the face, not the head. As such, we use an affine Spatial Transformer Network (STN) (Jaderberg et al., 2015) as a first step, to center the image correctly. Similarly, because the optimal camera parameters $( f , r$ and $d$ ) are difficult to set by hand, we let the network learn them, by computing their derivatives numerically (which has a low overhead, since they are scalars). The rest of the network follows the same diagram as before (fig. 2). The main CNN has 4 convolutional layers, the first two with $5 \times 5$ filters, the others being $9 \times 9$ . The numbers of output channels are 20, 50, 20 and 1, respectively. A $3 \times 3$ max-pooling with a stride of 2 is performed after the first layer, and there are ReLU non-linearities between the others. As for the STN, it has 3 convolutional layers $\mathrm { ( 5 \times 5 ) }$ , with 20, 50 and 6 output channels respectively, and $3 \times 3$ max-pooling (stride 2) between them.
+
+Baselines and results. The angular error of the proposed equivariant pose estimation, Warped CNN, is shown in table 2, along with a number of baselines. Qualitative results are shown in fig. 4. The goal of these experiments is to demonstrate that it is possible to achieve equivariance to complex 3D rotations. We also wish to disentangle the performance benefits of the warped convolution from the other architectural aspects. The first baseline, $\mathrm { S T N + s }$ oftargmax, is the same as the proposed method, but without the warp. The large performance drop indicates that the spherical model incorporates important domain knowledge, which is ignored by a translation-equivariant STN. To allow nonequivariant models, we also test two other baselines where the softargmax is replaced with a fullyconnected (FC) layer. The $\mathrm { S T N + F C }$ includes an affine Spatial Transformer, while the $\mathrm { C N N + F C }$ does not, corresponding to a standard CNN of equivalent capacity. We observe that neither the FC or the STN components can account up for the performance of the warped convolution, which better exploits the natural 3D rotation equivariance of the data.
+
+# 7 CONCLUSIONS
+
+In this work we show that it is possible to reuse highly optimized convolutional blocks, which are equivariant to image translation, and coax them to exhibit equivariance to other operators, including 3D transformations. This is achieved by a simple warp of the input image, implemented with off-the-shelf components of deep networks, and can be used for image recognition tasks involving a large range of image transformations. Compared to other works, warped convolutions are simpler, relying on highly optimized convolution routines, and can flexibly handle many types of continuous transformations. Studying generalizations that support more than two parameters seems like a fruitful direction for future work. In addition to the practical aspects, our analysis offers some insights into the fundamental relationships between arbitrary image transformations and convolutional architectures.
+
+![](images/fb41b34c37d9d1158c9e5bd2cc84338546aa9a736b99811dd4154caf38a83c9a.jpg)  
+Figure 4: Example pose estimates (yaw and pitch) on the AFLW dataset (Section 6.3).
+
+# REFERENCES
+
+Joan Bruna, Arthur Szlam, and Yann LeCun. Learning stable group invariant representations with convolutional networks. arXiv preprint arXiv:1301.3537, 2013.
+
+Taco Cohen and Max Welling. Learning the Irreducible Representations of Commutative Lie Groups. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), 2014.
+
+Taco Cohen and Max Welling. Group equivariant convolutional networks. In Proceedings of the 33rd International Conference on Machine Learning (ICML-16), 2016.
+
+Sander Dieleman, Kyle W Willett, and Joni Dambre. Rotation-invariant convolutional neural networks for galaxy morphology prediction. Monthly notices of the royal astronomical society, 450 (2):1441–1459, 2015.
+
+Gerald B Folland. A course in abstract harmonic analysis. 1995.
+
+Geremy Heitz and Daphne Koller. Learning spatial context: Using stuff to find things. In European Conference on Computer Vision, pp. 30–43. Springer, 2008.
+
+J. F. Henriques, P. Martins, R. Caseiro, and J. Batista. Fast training of pose detectors in the fourier domain. In Advances in Neural Information Processing Systems, 2014.
+
+Aapo Hyvärinen, Jarmo Hurri, and Patrick O Hoyer. Natural Image Statistics: A Probabilistic Approach to Early Computational Vision., volume 39. Springer Science & Business Media, 2009.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in Neural Information Processing Systems, pp. 2017–2025, 2015.
+
+Angjoo Kanazawa, Abhishek Sharma, and David Jacobs. Locally scale-invariant convolutional neural networks. arXiv preprint arXiv:1412.5104, 2014.
+
+Martin Koestinger, Paul Wohlhart, Peter M. Roth, and Horst Bischof. Annotated facial landmarks in the wild: A large-scale, real-world database for facial landmark localization. In First IEEE International Workshop on Benchmarking Facial Image Analysis Technologies, 2011.
+
+Andrew Lavin. Fast algorithms for convolutional neural networks. arXiv preprint arXiv:1509.09308, 2015.
+
+Karel Lenc and Andrea Vedaldi. Understanding image representations by measuring their equivariance and equivalence. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 991–999, 2015.
+
+Kun Liu, Henrik Skibbe, Thorsten Schmidt, Thomas Blein, Klaus Palme, Thomas Brox, and Olaf Ronneberger. Rotation-Invariant HOG Descriptors Using Fourier Analysis in Polar and Spherical Coordinates. International Journal of Computer Vision, 106(3):342–364, February 2014. ISSN 0920-5691, 1573-1405. doi: 10.1007/s11263-013-0634-z.
+
+Richard G Lyons. Understanding digital signal processing. Pearson Education, 2010.
+
+Diego Marcos, Michele Volpi, and Devis Tuia. Learning rotation invariant convolutional filters for texture classification. arXiv preprint arXiv:1604.06720, 2016.
+
+B. Srinivasa Reddy and Biswanath N. Chatterji. An FFT-based technique for translation, rotation, and scale-invariant image registration. IEEE Transactions on Image Processing, 5(8):1266–1271, 1996.
+
+Uwe Schmidt and Stefan Roth. Learning rotation-aware features: From invariant priors to equivariant descriptors. In Computer Vision and Pattern Recognition (CVPR), 2012 IEEE Conference on, pp. 2050–2057, 2012.
+
+Georgios Tzimiropoulos, Vasileios Argyriou, Stefanos Zafeiriou, and Tania Stathaki. Robust FFTbased scale-invariant image registration with image gradients. IEEE Transactions on Pattern Analysis and Machine Intelligence, 32(10):1899–1906, 2010.
+
+# A SPATIAL TRANSFORMATION FOR 3D SPHERE ROTATION UNDER PERSPECTIVE
+
+Our simplified model consists of a perspective camera with focal length $f$ and all other camera parameters equal to identity, at a distance $d$ from a centered sphere of radius $r$ (see fig. 1-d).
+
+A 2D point $x$ in image-space corresponds to the 3D point
+
+$$
+p = ( x _ { 1 } , x _ { 2 } , f ) .
+$$
+
+Raycasting it along the $z$ axis, it will intersect the sphere surface at the 3D point
+
+$$
+q = { \frac { p } { \| p \| } } \left( k - { \sqrt { k ^ { 2 } - d ^ { 2 } + r ^ { 2 } } } \right) , k = { \frac { f d } { \| p \| } } .
+$$
+
+If the argument of the square-root is negative, the ray does not intersect the sphere and so the point transformation is undefined. This means that the domain of the image $\Omega$ should be restricted to the sphere region. In practice, in such cases we simply leave the point unmodified.
+
+Then, the yaw and pitch coordinates of the point $q$ on the surface of the sphere are
+
+$$
+\phi _ { 1 } = \cos ^ { - 1 } \left( - \frac { q _ { 2 } } { r } \right) , \phi _ { 2 } = \mathrm { a t a n _ { 2 } } \left( - \frac { q _ { 1 } } { d - q _ { 3 } } \right) .
+$$
+
+These polar coordinates are now rotated by the spatial transformation parameters, $\phi ^ { \prime } = \phi + u$
+
+Converting the polar coordinates back to a 3D point $q ^ { \prime }$
+
+$$
+\begin{array} { r } { q ^ { \prime } = \left[ \begin{array} { c } { r \sin \phi _ { 1 } ^ { \prime } \sin \phi _ { 2 } ^ { \prime } } \\ { - r \cos \phi _ { 1 } ^ { \prime } } \\ { r \sin \phi _ { 1 } ^ { \prime } \cos \phi _ { 2 } ^ { \prime } - d } \end{array} \right] . } \end{array}
+$$
+
+Finally, projection of $q ^ { \prime }$ into image-space yields
+
+$$
+t _ { u } ( x ) = - { \frac { f } { q _ { 3 } ^ { \prime } } } \left[ \begin{array} { c } { { q _ { 1 } ^ { \prime } } } \\ { { q _ { 2 } ^ { \prime } } } \end{array} \right] .
+$$

parse/train/BkmM8Dceg/BkmM8Dceg_content_list.json

@@ -0,0 +1,1635 @@
+[
+    {
+        "type": "text",
+        "text": "WARPED CONVOLUTIONS: EFFICIENT INVARIANCE TO SPATIAL TRANSFORMATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "João F. Henriques & Andrea Vedaldi   \nVisual Geometry Group   \nUniversity of Oxford   \n{joao,vedaldi}@robots.ox.ac.uk ",
+        "bbox": [
+            184,
+            169,
+            478,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional Neural Networks (CNNs) are extremely efficient, since they exploit the inherent translation-invariance of natural images. However, translation is just one of a myriad of useful spatial transformations. Can the same efficiency be attained when considering other spatial invariances? Such generalized convolutions have been considered in the past, but at a high computational cost. We present a construction that is simple and exact, yet has the same computational complexity that standard convolutions enjoy. It consists of a constant image warp followed by a simple convolution, which are standard blocks in deep learning toolboxes. With a carefully crafted warp, the resulting architecture can be made equivariant to a wide range of 2-parameters spatial transformations. We show encouraging results in realistic scenarios, including the estimation of vehicle poses in the Google Earth dataset (rotation and scale), and face poses in Annotated Facial Landmarks in the Wild (3D rotations under perspective). ",
+        "bbox": [
+            233,
+            295,
+            764,
+            476
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            507,
+            336,
+            523
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A crucial aspect of current deep learning architectures is the encoding of invariances. This fact is epitomized in the success of convolutional neural networks (CNN), where equivariance to image translation is key: translating the input results in a translated output. When invariances are present in the data, encoding them explicitly in an architecture provides an important source of regularization, which allows to reduce the amount of training data required for learning. Invariances may also be used to improve the efficiency of implementations; for instance, a convolutional layer requires orders of magnitude less memory and also less computation compared to an equivalent fully-connected layer. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            651
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The success of CNNs indicates that translation invariance is an important property of images. However, this does not explain why translation equivariant operators work well for image understanding. The common interpretation is that such operators are matched to the statistics of natural images, which are well known to be translation invariant (Hyvärinen et al., 2009). However, natural image statistics are also (largely) invariant to other transformations such as isotropic scaling and rotation, which suggests that alternative neural network designs may also work well with images. Furthermore, in specific applications, invariances other than translation may be more appropriate. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Therefore, it is natural to consider generalizing convolutional architectures to other image transformations, and this has been the subject of extensive study (Kanazawa et al., 2014; Bruna et al., 2013; Cohen & Welling, 2016). Unfortunately these approaches do not possess the same memory and speed benefits that CNNs enjoy. The reason is that, ultimately, they have to transform (warp) an image or filter several times (Kanazawa et al., 2014; Marcos et al., 2016; Dieleman et al., 2015), incurring a high computational burden. Another approach is to consider a basis of filters (analogous to eigen-images) encoding the desired invariance (Cohen & Welling, 2014; Bruna et al., 2013; Cohen & Welling, 2016), which requires more storage than a convolutional filter. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although they are able to handle transformations with many pose parameters, in practice most recent proposals are limited to very coarsely discretized transformations, such as horizontal/vertical flips and $9 0 ^ { \\circ }$ rotations (Dieleman et al., 2015; Cohen & Welling, 2014). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work we propose a generalization of CNNs that overcomes these disadvantages. Our main result shows that a linear layer with equivariance w.r.t. a large class of 2-parameters transformations can always be implemented efficiently, using a standard convolution in a warped image space. The image warp can be implemented using bilinear resampling, a simple and fast operation that has been popularized by spatial transformer networks (Jaderberg et al., 2015), and is part of most deep learning toolboxes. Unlike previous proposals, the proposed warped convolutions can handle continuous transformations, such as fine rotation and scaling. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This makes generalized convolution easily implementable in neural networks, including using fast convolution algorithms on GPU hardware, such as Winograd (Lavin, 2015) or the Fast Fourier Transform (Lyons, 2010). We present these notions in the simplest possible way (sections 2 to 4), but we note that they can be derived in broader generality from well know concepts of group theory (section 4.2). ",
+        "bbox": [
+            174,
+            208,
+            825,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 GENERALIZING CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            297,
+            464,
+            314
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 CONVOLUTIONS OF CONTINUOUS IMAGES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            329,
+            504,
+            343
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We start by looking at the basic building block of CNNs, i.e. the convolution operator. This operator computes the inner product of an image $\\boldsymbol { I } \\in \\mathbb { R } ^ { m \\times n }$ with a translated version of the filter $\\boldsymbol { F } \\in \\mathbb { R } ^ { r \\times s }$ , producing a new image as output: ",
+        "bbox": [
+            176,
+            354,
+            823,
+            397
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d66687c82b23f584b74fc1586f926c8608ecfcedd91fe2ee364b6171447e398c.jpg",
+        "text": "$$\nH _ { j } = \\sum _ { k } I _ { k } F _ { k + j } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            396,
+            562,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $k$ ${ \\mathfrak { a } } , { \\mathfrak { j } } \\in \\mathbb { Z } ^ { 2 }$ are two-dimensional vectors of indexes, and the summation ranges inside the extents of both arrays.1 To handle continuous deformations of the input, it is more natural to express eq. 1 as an integral over continuous rather than discrete inputs: ",
+        "bbox": [
+            174,
+            433,
+            825,
+            476
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1aac3ddd9e603b228f74471fb49e534750cac869c5ebec337c39afd1194fb627.jpg",
+        "text": "$$\nH ( u ; I ) = \\int I ( x ) F ( x + u ) d x ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            481,
+            607,
+            513
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $I ( x )$ and $F ( x )$ are continuous functions over a bounded 2D region $\\Omega \\subset \\mathbb { R } ^ { 2 }$ , that is: $I , F :$ $\\Omega \\to \\mathbb { R }$ . The real-valued 2D vectors $x \\in \\Omega$ now play the role of the indexes $k \\in  { \\mathbb { Z } } ^ { 2 }$ . Equation 2 reduces to the discrete case of eq. 1 if we define $I ( x )$ and $F ( x )$ as the sum of delta functions on grids. Intermediate values can be obtained by interpolation, such as bilinear (which amounts to convolution of the delta functions with a triangle filter (Jaderberg et al., 2015)). Importantly, such continuous images can be deformed by very rich continuous transformations of the input coordinates, whereas strictly discrete operations would be more limiting. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            619
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Over the next sections it will be more convenient to translate the image $I$ instead of the filter $F$ . This alternative form of eq. 2 is obtained by replacing $x + u  x$ : ",
+        "bbox": [
+            174,
+            625,
+            821,
+            654
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c53784700ff0cd400b5498931f64a21a8843276f3b0dc1f7c736466ccb3b073a.jpg",
+        "text": "$$\nH ( u ; I ) = \\int I ( x - u ) F ( x ) d x .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            660,
+            607,
+            693
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 BEYOND IMAGE TRANSLATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            707,
+            436,
+            720
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The standard convolution operator of eq. 3 can be interpreted as applying the filter to translated versions of the image. Translations can be replaced by other transformations as follows (Henriques et al., 2014): ",
+        "bbox": [
+            174,
+            732,
+            825,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9c58d1ae40c35730ca04373a89d28c133f2745bd59ccf00fcbaaff8a2edf31a.jpg",
+        "text": "$$\nH ( t ; I ) = \\int I ( t ( x ) ) F ( x ) d x , \\quad t \\in G\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            772,
+            632,
+            804
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $G$ is a set of transformation functions $t : \\Omega \\to \\Omega$ (assumed to be invertible). Intuitively, this generalized convolution performs an exhaustive search for a pattern, at many different poses (Henriques et al., 2014; Kanazawa et al., 2014). The interest in this definition lies in the fact that it makes convolution equivariant (Lenc & Vedaldi, 2015): ",
+        "bbox": [
+            174,
+            806,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1 (Equivariance). Consider the generalized convolution operator $H ( t ; I )$ of eq. 4. Generalized convolution “commutes” with any transformation $q \\in G$ of the image: ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/215391eb24c08504dcb2ff688bd3ec840e2bb91efb68e7d7e2e094d96e759c4e.jpg",
+        "text": "$$\nH ( t ; I \\circ q ) = H ( q \\circ t ; I ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            140,
+            584,
+            156
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proof. One has immediately $\\begin{array} { r } { H ( t ; I \\circ q ) = \\int I ( q ( t ( x ) ) ) F ( x ) d x = H ( q \\circ t ; I ) . } \\end{array}$ ",
+        "bbox": [
+            171,
+            171,
+            700,
+            189
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A notable case is when transformations have an additive parametrization $t : \\Omega \\times \\mathbb { R } ^ { 2 } \\to \\Omega$ , with $( x , u ) \\mapsto t _ { u } ( x )$ and $t _ { u } \\circ t _ { v } = t _ { u + v }$ . In this case, the equivariance relation can be written as ",
+        "bbox": [
+            171,
+            205,
+            823,
+            234
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0661afcf0ae6cdffe78a17ebec2cc568e97a6684c79ffdac14e7bb3a10dd40d5.jpg",
+        "text": "$$\nH ( u ; I \\circ t _ { v } ) = H ( v + u ; I ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            242,
+            596,
+            258
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In particular, standard convolution is obtained when $t _ { u } ( x ) = x - u$ is the translation operator. In this case, the lemma above simply states that any translation of the input of the convolution results in a corresponding translation of the output. ",
+        "bbox": [
+            174,
+            266,
+            826,
+            309
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In section 5, we will look in more detail at a few concrete examples of transformations other than translations. Although we will not do so explicitly, in this construction it is also possible to let one or more dimensions of the parameter space $\\mathbb { R } ^ { \\bar { 2 } }$ be given modulus a period $Q$ , in the sense of replacing $\\mathbb { R }$ with $\\mathbb { R } / \\mathbb { Z } ( Q )$ ; the latter is required to parameterise transformations such as rotation. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            372
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 COMPUTATIONAL EFFICIENCY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            392,
+            452,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, what eq. 4 gains us in generality, it loses in both performance and ease of implementation. Most works in computer vision that looked at filtering under generalized transformations (e.g. scale pyramids (Kanazawa et al., 2014) or rotated filter banks (Marcos et al., 2016; Cohen & Welling, 2014; 2016; Henriques et al., 2014)) compute eq. 4 directly by evaluating a large number of transformations $t \\in G$ . This entails warping (transforming) either the image or the filter once per transformation $t$ , which can be expensive. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            508
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Opting to transform the filter instead of the image can be advantageous, since it is smaller in size. On the other hand, the filter and its domain then become spatially-varying, which foregoes the benefit of the regular, predictable, and local pattern of computations in standard convolution. It precludes the use of fast convolution routines such as Winograd’s algorithm (Lavin, 2015), or the Fast Fourier Transform (Lyons, 2010), which has lower computational complexity than exhaustive search (eq. 3). ",
+        "bbox": [
+            174,
+            515,
+            825,
+            584
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In practice, most recent works focus on very coarse transformations that do not change the filter support and can be implemented strictly via permutations, like horizontal/vertical flips and $9 0 ^ { \\circ }$ rotations (Dieleman et al., 2015; Cohen & Welling, 2014). Such difficulties explain why generalized convolutions are not as widespread as CNNs. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In section 4 we will show that, for an important class of transformations, including the ones considered in previous works (such as Kanazawa et al. (2014); Cohen & Welling (2014); Marcos et al. (2016)) it is possible to perform generalized convolution by composing a single warp with a standard convolution, instead of several warps. Thus, we are able to take full advantage of modern convolution implementations (Lavin, 2015; Lyons, 2010), including those with lower computational complexity. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 MAIN RESULT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            758,
+            323,
+            775
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our main contribution is to show that the generalized convolution operator of eq. 4 can be implemented efficiently by a standard convolution, by pre-warping the input image and filter appropriately. The warp is the same for any image, depending solely on the nature of the relevant transformations, and can be written in closed form. This result, given in theorem 1, allows us to implement very efficient generalized convolutions using simple computational blocks, as shown in section 4.1. We name this method warped convolution. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The strongest assumption is that transformations must have an additive parametrization. By this, we mean that there exists a bijection $t _ { u } : \\Omega \\to \\Omega$ such that, for any $u , v \\in \\mathbb { R } ^ { 2 }$ , parameters compose additively $t _ { u } \\circ t _ { v } = t _ { u + v }$ . The second assumption is that there exists a pivot point $x _ { 0 } \\in \\Omega$ such that $u \\mapsto t _ { u } ( x _ { 0 } )$ defines a bijection $\\mathbb { R } ^ { 2 } \\to \\Omega$ from the parameter space to the real plane. The latter requirements means that any point $x \\in \\Omega$ can be “reached” by transforming $x _ { 0 }$ under a suitable $t _ { u }$ . We then have that: ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            102,
+            823,
+            145
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. Consider the generalized convolution of eq. 4. Assume that the transformation is additive $( t _ { u } \\circ t _ { v } = t _ { u + v . }$ ). Assume also that, for a fixed pivot point $x _ { 0 }$ , the function $u \\mapsto t _ { u } ( x _ { 0 } )$ is bijective. Then we can rewrite generalized convolution (eq. 4) as the standard convolution ",
+        "bbox": [
+            173,
+            148,
+            825,
+            191
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/63ea9bdacd1b511cbcc2248b2a9f69d17af3e02ea4e53ea964c348c91ef9e3a1.jpg",
+        "text": "$$\nH ( u ; I ) = \\int \\hat { I } ( u + v ) \\hat { F } ( v ) d v ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            195,
+            604,
+            228
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { I }$ and $\\hat { F }$ are the warped image and filter given by: ",
+        "bbox": [
+            174,
+            233,
+            545,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36c0607d4677e46cf89b622989f83fa21343507de331febd605abe36a9587f7c.jpg",
+        "text": "$$\n\\hat { I } ( u ) = I ( t _ { u } ( x _ { 0 } ) ) , \\qquad \\hat { F } ( u ) = F ( t _ { u } ( x _ { 0 } ) ) \\left| \\frac { d t _ { u } ( x _ { 0 } ) } { d u } \\right| .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            252,
+            681,
+            287
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proof. We use the variable substitution $x = t _ { v } ( x _ { 0 } )$ in eq. 4. Then: ",
+        "bbox": [
+            173,
+            300,
+            611,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f62b9951c65fe6aab37827b2ea6e20108c56f377a9d664ff0d612ef222aa99ff.jpg",
+        "text": "$$\n\\begin{array} { l } { H ( u ; I ) = \\displaystyle \\int I ( t _ { u } ( x ) ) F ( x ) d x } \\\\ { \\displaystyle = \\int I ( t _ { u } ( t _ { v } ( x _ { 0 } ) ) ) F ( t _ { v } ( x _ { 0 } ) ) \\left| \\frac { d t _ { v } ( x _ { 0 } ) } { d v } \\right| d v } \\\\ { \\displaystyle = \\int \\underbrace { I ( t _ { u + v } ( x _ { 0 } ) ) } _ { \\hat { I } ( u + v ) } \\underbrace { F ( t _ { v } ( x _ { 0 } ) ) \\left| \\frac { d t _ { v } ( x _ { 0 } ) } { d v } \\right| } _ { \\hat { F } ( v ) } d v } \\\\ { \\displaystyle = \\int \\hat { I } ( u + v ) \\hat { F } ( v ) d v . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            320,
+            676,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The warp that is applied to both inputs in eq. 7 can be interpreted as follows. We start with an arbitrary pivot point $x _ { 0 }$ in the image and them sample other points by repeatedly applying the transformation $t _ { u } ( x _ { 0 } )$ to the pivot (by varying $u$ ). When discretized, this sampling is performed over a 2D grid of parameters $u$ . Finally, sampling the input at these points (for example, by bilinear interpolation) yields the warped input. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An illustration is given in fig. 1, for various transformations (each one is discussed in more detail in section 5). The red dot shows the pivot point $x _ { 0 }$ , and the two arrows pointing away from it show the two directions of increasing $u$ values (recall that transformation parameters are two-dimensional). The grids were generated by sampling $u$ at regular intervals. Note that the warp grids are independent of the image contents – they can be computed once offline and then applied to any image. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The last factor in eq. 7 is the determinant of the Jacobian of the image transformation $t$ . It rescales the image values to account for the stretching and shrinking of space due to non-linear warps. It can also be computed offline, and its application amounts to an element-wise product by a constant array. A generalization using group theory is discussed in section 4.2. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 PRACTICAL CONSIDERATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            737,
+            421,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "There are a few interesting aspects that simplify the use of theorem 1 in practice. ",
+        "bbox": [
+            176,
+            763,
+            700,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "First, since in most applications the filter $F$ is learned, we are free to ignore the constant warp and Jacobian in eq. 7 (which amounts to a simple reparametrization), and learn $\\hat { F }$ directly. In practice, this means that we warp only the input image $I$ to obtain $\\hat { I }$ , and then perform a standard convolution with a filter $\\hat { F }$ . The learned warped filter $\\hat { F }$ has a one-to-one correspondence to an image-space filter $F$ by means of eq. 7, although there is no real need to build the latter explicitly. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Second, we can choose either one or two spatial transformations for the generalized convolution (e.g. scale and rotation, simultaneously). The reason is that the input image is 2D, so the parameterspace after warping is also 2D. The choice is not arbitrary though: the two transformations must commute, in order to respect additivity. This will be the case of the pairs we study in section 5. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Warped convolution. ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            400,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Grid generation (offline) ",
+        "bbox": [
+            174,
+            128,
+            338,
+            143
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Apply the spatial transformation $t$ repeatedly to a pivot point $x _ { 0 }$ , using a 2D grid of parameters $\\stackrel { \\cdot } { u } = \\{ \\bar { ( } u _ { 1 } + i \\delta _ { 1 } , u _ { 2 } + j \\delta _ { 2 } ) : i = 0 , \\ldots , m , j = 0 , \\bar { \\ldots } , n \\}$ , obtaining the 2D warp grid $t _ { u } ( x _ { 0 } )$ . ",
+        "bbox": [
+            215,
+            148,
+            823,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Warped convolution ",
+        "bbox": [
+            176,
+            194,
+            307,
+            208
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. Resample input image $I$ using the warp grid $t _ { u } ( x _ { 0 } )$ , by bilinear interpolation. ",
+        "bbox": [
+            209,
+            213,
+            738,
+            228
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2. Convolve the warped image $\\hat { I }$ with filter $\\hat { F }$ . ",
+        "bbox": [
+            212,
+            234,
+            519,
+            250
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By theorem 1, these steps are equivalent to a generalized convolution, which performs an exhaustive search across the pose-space of transformation $t$ , but at a much lower computational cost. ",
+        "bbox": [
+            173,
+            253,
+            823,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 RELATIONSHIP TO GROUP THEORY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            314,
+            452,
+            328
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This section relates our results, which have been presented using a simple formalism and in a restricted setting, to a more general approach based on group theory (Folland, 1995). ",
+        "bbox": [
+            171,
+            340,
+            821,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To this end, let $G$ be a group of transformations. Under very mild conditions (the group has to be locally compact and Hausdorff), there exists a unique measure on the group, the Haar measure, which is invariant to the group action, in the sense that, given a measurable function ${ \\tilde { I } } : G \\to$ $\\mathbb { R }$ , then $\\begin{array} { r } { \\int \\tilde { I } ( g ^ { \\prime } g ) d g = \\int \\overline { { \\tilde { I } } } ( g ) \\dot { } d g } \\end{array}$ . Using this measure, one can define generalized convolution as $\\begin{array} { r } { ( \\tilde { I } * \\tilde { F } ) ( t ) = \\int _ { G } \\tilde { I } ( t g ) \\tilde { F } ( g ^ { - 1 } ) d g } \\end{array}$ . This resembles our definition (4), although image and filter are defined on the group $G$ instead of the spatial domain $\\mathbb { R } ^ { 2 }$ . Lemma 1 translates immediately to this case (Folland, 1995). ",
+        "bbox": [
+            173,
+            376,
+            825,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to extend Theorem 1, we need to make this general but abstract construction concrete. Here one assumes that the group acts transitively on a subset $X \\subset \\mathbb { R } ^ { 2 }$ (which means that any point $x \\in X$ can be written as $x = g x _ { 0 }$ , for a fixed point $x _ { 0 } \\in X$ and a suitable transformation $g \\in G$ ). Then one can define the image as $\\tilde { I } ( g ) = I ( g \\bar { ( } x _ { 0 } ) )$ , where $I$ is a function of the spatial domain $X$ instead of the group $G$ , and likewise for the filter. Next, it is necessary to explicitly calculate the integral over $G$ . If the group is an Abelian (commutative) Lie group, then one can show that there exists a map $\\exp : V \\to G$ , the exponential map, defined on a vector space $V$ . Under commutativity, this map is also additive, in the sense that $\\exp ( u ) \\exp ( v ) = \\exp ( u + v )$ . The structure of $V$ depends on the specific group, but under such restrictive conditions, it is a torus, which allows the calculation of $\\textstyle \\int { \\tilde { I } } ( { \\bar { g } } ) d g$ as $\\begin{array} { r } { \\int \\tilde { I } ( \\exp ( u ) x _ { 0 } ) d u . } \\end{array}$ . ",
+        "bbox": [
+            173,
+            488,
+            825,
+            632
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, in order to swap integration over the group parameters with integration over space, one assumes that $x \\ = \\ \\exp ( u ) x _ { 0 }$ defines a smooth bijection $V \\  \\ X$ , so that it is possible to use the change of variable $\\dot { u }  u ( x )$ where $\\mathrm { e x p } ( u ( x ) ) x _ { 0 } = x$ . This allows writing the integral as $\\begin{array} { r } { \\int { \\tilde { I } } ( \\exp ( u ) x _ { 0 } ) d u = \\int I ( x ) \\left| d u / d x \\right| d x } \\end{array}$ . Note that this Jacobian is the inverse of the one found in (1) due to the fact that we started by defining our convolution using $I$ instead of $\\tilde { I }$ . ",
+        "bbox": [
+            174,
+            637,
+            825,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXAMPLES OF SPATIAL TRANSFORMATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            738,
+            570,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now give some concrete examples of pairs of spatial transformations that obey the conditions of theorem 1, and can be useful in practice. ",
+        "bbox": [
+            173,
+            770,
+            823,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 SCALE AND ASPECT RATIO ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            819,
+            400,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Detection tasks require predicting the extent of an object as a bounding box. While the location can be found accurately by a standard CNN, which is equivariant to translation, the size prediction could similarly benefit from equivariance to horizontal and vertical scale (equivalently, scale and aspect ratio). ",
+        "bbox": [
+            174,
+            845,
+            825,
+            902
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Such a spatial transformation, from which a warp can be constructed, is given by: ",
+        "bbox": [
+            171,
+            909,
+            707,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/60788d1a003ce7fcae165868e8ad44de46e7af62c507569ccf0f4de9f35dc344.jpg",
+        "image_caption": [
+            "Figure 1: First row: Sampling grids that define the warps associated with different spatial transformations. Second row: An example image (a) after warping with each grid (b-d). Third row: A small translation is applied to each warped image, which is then mapped back to the original space (by an inverse warp). Translation in one axis of the appropriate warped space is equivalent to (b) horizontal scaling; (c) planar rotation; (d) 3D rotation around the vertical axis. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            98,
+            808,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d30af2a4b23b48bb60e4ef9cc351f77c45fee152af7976aafd5c3c199090dea.jpg",
+        "text": "$$\nt _ { u } ( x ) = { \\left[ \\begin{array} { l } { x _ { 1 } s ^ { u _ { 1 } } } \\\\ { x _ { 2 } s ^ { u _ { 2 } } } \\end{array} \\right] }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            606,
+            566,
+            641
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The $s$ constant controls the total degree of scaling applied. Notice that the output must be exponential in the scale parameters $u$ ; this ensures the additive structure required by theorem 1: $t _ { u } ( \\bar { t } _ { v } ( x ) ) =$ $t _ { u + v } ( x )$ . The resulting warp grid can be visualized in fig. 1-b. In this case, the domain of the image must be $\\Omega \\in \\mathbb { R } _ { + } ^ { 2 }$ , since a pivot $x _ { 0 }$ in one quadrant cannot reach another quadrant by any amount of (positive) scaling. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 SCALE AND ROTATION (LOG-POLAR WARP) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            744,
+            513,
+            758
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Planar scale and rotation are perhaps the most obvious spatial transformations in images, and are a natural test case for works on spatial transformations (Kanazawa et al., 2014; Marcos et al., 2016). Rotating a point $x$ by $u _ { 1 }$ radians and scaling it by $u _ { 2 }$ , around the origin, can be performed with ",
+        "bbox": [
+            174,
+            771,
+            825,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c12bc61daeb8c4068f35af6a7e6dcd729d9df9dbb649a577448644364e368d24.jpg",
+        "text": "$$\nt _ { u } ( x ) = \\left[ \\begin{array} { l } { s ^ { u _ { 2 } } \\left\\| x \\right\\| \\cos ( \\mathrm { a t a n } _ { 2 } ( x _ { 2 } , x _ { 1 } ) + u _ { 1 } ) } \\\\ { s ^ { u _ { 2 } } \\left\\| x \\right\\| \\sin ( \\mathrm { a t a n } _ { 2 } ( x _ { 2 } , x _ { 1 } ) + u _ { 1 } ) } \\end{array} \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            833,
+            656,
+            868
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where atan $^ 2$ is the standard 4-quadrant inverse tangent function (atan2). The domain in this case must exclude the origin $( \\Omega \\in \\dot { \\mathbb { R } } ^ { 2 } \\setminus \\{ 0 \\} )$ , since a pivot $x _ { 0 } = 0$ cannot reach any other points in the image by rotation or scaling. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/411e48b00e252ab8e9ec8948af96a700f5774ade8b1cca75c0faf68a96fea41e.jpg",
+        "image_caption": [
+            "Figure 2: Equivariant pose estimation strategy used in the experiments (section 6). With an appropriate warp and a standard CNN, the shaded block becomes equivalent to a generalized CNN (by theorem 1), which performs exhaustive searches across pose-space instead of image-space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            266,
+            103,
+            735,
+            142
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The resulting warp grid can be visualized in fig. 1-c. It is interesting to observe that it corresponds exactly to the log-polar domain, which is used in the signal processing literature to perform correlation across scale and rotation (Tzimiropoulos et al., 2010; Reddy & Chatterji, 1996). In fact, it was the source of inspiration for this work, which can be seen as a generalization of the log-polar domain to other spatial transformations. ",
+        "bbox": [
+            173,
+            224,
+            825,
+            295
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 3D SPHERE ROTATION UNDER PERSPECTIVE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            315,
+            517,
+            329
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We will now tackle a more difficult spatial transformation, in an attempt to demonstrate the generality of theorem 1. The transformations we will consider are yaw and pitch rotations in 3D space, as seen by a perspective camera. In the experiments (section 6) we will show how to apply it to face pose estimation. ",
+        "bbox": [
+            174,
+            342,
+            825,
+            398
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to maintain additivity, the rotated 3D points must remain on the surface of a sphere. We consider a simplified camera and world model, whose only hyperparameters are a focal length $f$ , the radius of a sphere $r$ , and its distance from the camera center $d$ . The equations for the spatial transformation corresponding to yaw and pitch rotation under this model are in appendix A. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            460
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The corresponding warp grid can be seen in fig. 1-d. It can be observed that the grid corresponds to what we would expect of a 3D rendering of a sphere with a discrete mesh. An intuitive picture of the effect of the warp grid in such cases is that it wraps the 2D image around the surface of the 3D object, so that translation in the warped space corresponds to moving between vertexes of the 3D geometry. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            560,
+            326,
+            577
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.1 ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            593,
+            326,
+            608
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in section 2.2, generalized convolution performs an exhaustive search for patterns across spatial transformations, by varying pose parameters. For tasks where invariance to that transformation is important, it is usual to pool the detection responses across all poses (Marcos et al., 2016; Kanazawa et al., 2014). ",
+        "bbox": [
+            174,
+            621,
+            825,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the experiments, however, we will test the framework in pose prediction tasks. As such, we do not want to pool the detection responses (e.g. with a max operation) but rather find the pose with the strongest response (i.e., an argmax operation). To perform this operation in a differentiable manner, we implement a soft argmax operation, defined as follows: ",
+        "bbox": [
+            174,
+            683,
+            825,
+            739
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/37776009230040da7cad487e5ed5747cc940e28dac129b7bb622cfd1f71dfbd0.jpg",
+        "text": "$$\ns _ { 1 } ( a ) = \\sum _ { i j } ^ { m n } \\frac { i } { m } \\sigma _ { i j } ( a ) , \\qquad s _ { 2 } ( a ) = \\sum _ { i j } ^ { m n } \\frac { j } { n } \\sigma _ { i j } ( a ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            760,
+            665,
+            803
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma ( a ) \\in \\mathbb { R } ^ { m \\times n }$ is the softmax over all spatial locations, and $\\sigma _ { i j } ( a )$ indexes the element at $( i , j )$ . The outputs are the two spatial coordinates of the maximum value, $s ( a ) \\in \\mathbb { R } ^ { 2 }$ . ",
+        "bbox": [
+            173,
+            816,
+            823,
+            848
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our base architecture then consists of the following blocks, outlined in fig. 2. First, the input image is warped with a pre-generated grid, according to section 4. The warped image is then processed by a standard CNN, which is now equivariant to the spatial transformation that was used to generate the warp grid. A soft argmax (eq. 10) then finds the maximum over pose-space. To ensure the pose prediction is well registered to the reference coordinate system, a learnable scale and bias are applied to the outputs. Training proceeds by minimizing the $L ^ { 1 }$ loss between the predicted pose and ground truth pose. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/de34c593ebae9fa31e656d9dcfe4f5a42a84519aa633726a6f1e516f3398bcef.jpg",
+        "table_caption": [
+            "Table 1: Results of scale and rotation pose estimation of vehicles in the Google Earth dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>CNN+FC</td><td>CNN+softargmax</td><td> Warped CNN</td></tr><tr><td>Rotation error (degrees)</td><td>28.87</td><td>30.6</td><td>26.44</td></tr><tr><td>Scale error (px)</td><td>17.51</td><td>5.783</td><td>5.4</td></tr></table>",
+        "bbox": [
+            243,
+            101,
+            750,
+            169
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/db8ba0448a92bfa2d818168ec5f182ee517f7c3a909c68da0c90758eb10407fb.jpg",
+        "image_caption": [
+            "Figure 3: Example pose estimates (rotation and scale) on the Google Earth dataset (Section 6.2). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            210,
+            820,
+            343
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            401,
+            823,
+            430
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.2 GOOGLE EARTH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            450,
+            328,
+            465
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the first task in our experiments, we will consider aerial photos of vehicles, which have been used in several works that deal with rotation invariance (Liu et al., 2014; Schmidt & Roth, 2012; Henriques et al., 2014). ",
+        "bbox": [
+            176,
+            478,
+            823,
+            521
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Dataset. The Google Earth dataset (Heitz & Koller, 2008) contains bounding box annotations, supplemented with angle annotations from (Henriques et al., 2014), for 697 vehicles in 15 large images. We use the first 10 for training and the rest for validation. Going beyond these previous works, we focus on the estimation of both rotation and scale parameters. The object scale is taken to be the diagonal length of the bounding box. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Implementation. A $4 8 \\times 4 8$ image around each vehicle is cropped and downscaled by $50 \\%$ , and then fed to a network for pose prediction. The proposed method, Warped CNN, follows the architecture of section 6.1 (visualized in fig. 2). The CNN block contains 3 convolutional layers with $5 \\times 5$ filters, with 20, 50 and 1 output channels respectively. Recall that the output of the CNN block is a single-channel response map over 2D pose-space, which in this case consists of rotation and scale. Between the convolutional layers there are $3 \\times 3$ max-pooling operators, with a stride of 2, and a ReLU before the last layer. All networks are trained for 20 epochs with SGD, using hyperparameters chosen by cross-validation. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            738
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Baselines and results. The results of the experiments are presented in table 1, which shows angular and scale error in the validation set. Qualitative results are shown in fig. 3. To verify whether the proposed warped convolution is indeed responsible for a boost in performance, rather than other architectural details, we compare it against a number of baselines with different components removed. The first baseline, CNN $^ +$ softargmax, consists of the same architecture but without the warp (section 5.2). This is a standard CNN, with the soft argmax at the end. Since CNNs are equivariant to translation, rather than scale and rotation, we observe a drop in performance. For the second baseline, $\\mathrm { C N N + F C }$ , we replace the soft argmax with a fully-connected layer, to allow a prediction that is not equivariant with translation. The FC layer improves the angular error, but not the scale error. The proposed Warped CNN has a similar (slightly lower) capacity to the $\\mathrm { C N N + F C }$ baseline, but we see it achieve better performance, since its architectural equivariance seems to be better matched to the data distribution. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/bf93d6e3f74a317490197552af8bed33a05296e8f8bcae07c592ca6123689bd4.jpg",
+        "table_caption": [
+            "Table 2: Results of yaw and pitch pose estimation of faces on the AFLW dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>CNN+FC</td><td>STN+FC</td><td> STN+softargmax</td><td> Warped CNN</td></tr><tr><td>Yaw err. (deg.)</td><td>13.87</td><td>16.92</td><td>15.01</td><td>10.65</td></tr><tr><td>Pitch err. (deg.)</td><td>7.23</td><td>10.17</td><td>6.88</td><td>6.351</td></tr></table>",
+        "bbox": [
+            232,
+            101,
+            761,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.3 FACES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            218,
+            261,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We now turn to face pose estimation in unconstrained photos, which requires handling more complex 3D rotations under perspective. ",
+        "bbox": [
+            174,
+            244,
+            823,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dataset. For this task we use the Annotated Facial Landmarks in the Wild (AFLW) dataset (Koestinger et al., 2011). It contains about 25K faces found in Flickr photos, and includes yaw (left-right) and pitch (up-down) annotations. We removed 933 faces with yaw larger than 90 degrees (i.e., facing away from the camera), resulting in a set of 24,384 samples. $20 \\%$ of the faces were set aside for validation. ",
+        "bbox": [
+            174,
+            286,
+            825,
+            357
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Implementation. The region in each face’s bounding box is resized to a $6 4 \\times 6 4$ image, which is then processed by the network. Recall that our simplified 3D model of yaw and pitch rotation (section 5.3) assumes a spherical geometry. Although a person’s head roughly follows a spherical shape, the sample images are centered around the face, not the head. As such, we use an affine Spatial Transformer Network (STN) (Jaderberg et al., 2015) as a first step, to center the image correctly. Similarly, because the optimal camera parameters $( f , r$ and $d$ ) are difficult to set by hand, we let the network learn them, by computing their derivatives numerically (which has a low overhead, since they are scalars). The rest of the network follows the same diagram as before (fig. 2). The main CNN has 4 convolutional layers, the first two with $5 \\times 5$ filters, the others being $9 \\times 9$ . The numbers of output channels are 20, 50, 20 and 1, respectively. A $3 \\times 3$ max-pooling with a stride of 2 is performed after the first layer, and there are ReLU non-linearities between the others. As for the STN, it has 3 convolutional layers $\\mathrm { ( 5 \\times 5 ) }$ , with 20, 50 and 6 output channels respectively, and $3 \\times 3$ max-pooling (stride 2) between them. ",
+        "bbox": [
+            173,
+            371,
+            825,
+            551
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Baselines and results. The angular error of the proposed equivariant pose estimation, Warped CNN, is shown in table 2, along with a number of baselines. Qualitative results are shown in fig. 4. The goal of these experiments is to demonstrate that it is possible to achieve equivariance to complex 3D rotations. We also wish to disentangle the performance benefits of the warped convolution from the other architectural aspects. The first baseline, $\\mathrm { S T N + s }$ oftargmax, is the same as the proposed method, but without the warp. The large performance drop indicates that the spherical model incorporates important domain knowledge, which is ignored by a translation-equivariant STN. To allow nonequivariant models, we also test two other baselines where the softargmax is replaced with a fullyconnected (FC) layer. The $\\mathrm { S T N + F C }$ includes an affine Spatial Transformer, while the $\\mathrm { C N N + F C }$ does not, corresponding to a standard CNN of equivalent capacity. We observe that neither the FC or the STN components can account up for the performance of the warped convolution, which better exploits the natural 3D rotation equivariance of the data. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            733
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            752,
+            328,
+            770
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work we show that it is possible to reuse highly optimized convolutional blocks, which are equivariant to image translation, and coax them to exhibit equivariance to other operators, including 3D transformations. This is achieved by a simple warp of the input image, implemented with off-the-shelf components of deep networks, and can be used for image recognition tasks involving a large range of image transformations. Compared to other works, warped convolutions are simpler, relying on highly optimized convolution routines, and can flexibly handle many types of continuous transformations. Studying generalizations that support more than two parameters seems like a fruitful direction for future work. In addition to the practical aspects, our analysis offers some insights into the fundamental relationships between arbitrary image transformations and convolutional architectures. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb41b34c37d9d1158c9e5bd2cc84338546aa9a736b99811dd4154caf38a83c9a.jpg",
+        "image_caption": [
+            "Figure 4: Example pose estimates (yaw and pitch) on the AFLW dataset (Section 6.3). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            825,
+            255
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            308,
+            287,
+            324
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Arthur Szlam, and Yann LeCun. Learning stable group invariant representations with convolutional networks. arXiv preprint arXiv:1301.3537, 2013. ",
+        "bbox": [
+            174,
+            332,
+            823,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Taco Cohen and Max Welling. Learning the Irreducible Representations of Commutative Lie Groups. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), 2014. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            411
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Taco Cohen and Max Welling. Group equivariant convolutional networks. In Proceedings of the 33rd International Conference on Machine Learning (ICML-16), 2016. ",
+        "bbox": [
+            174,
+            421,
+            821,
+            450
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sander Dieleman, Kyle W Willett, and Joni Dambre. Rotation-invariant convolutional neural networks for galaxy morphology prediction. Monthly notices of the royal astronomical society, 450 (2):1441–1459, 2015. ",
+        "bbox": [
+            173,
+            458,
+            825,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gerald B Folland. A course in abstract harmonic analysis. 1995. ",
+        "bbox": [
+            173,
+            511,
+            598,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geremy Heitz and Daphne Koller. Learning spatial context: Using stuff to find things. In European Conference on Computer Vision, pp. 30–43. Springer, 2008. ",
+        "bbox": [
+            176,
+            535,
+            823,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. F. Henriques, P. Martins, R. Caseiro, and J. Batista. Fast training of pose detectors in the fourier domain. In Advances in Neural Information Processing Systems, 2014. ",
+        "bbox": [
+            173,
+            573,
+            823,
+            603
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aapo Hyvärinen, Jarmo Hurri, and Patrick O Hoyer. Natural Image Statistics: A Probabilistic Approach to Early Computational Vision., volume 39. Springer Science & Business Media, 2009. ",
+        "bbox": [
+            174,
+            611,
+            823,
+            641
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in Neural Information Processing Systems, pp. 2017–2025, 2015. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Angjoo Kanazawa, Abhishek Sharma, and David Jacobs. Locally scale-invariant convolutional neural networks. arXiv preprint arXiv:1412.5104, 2014. ",
+        "bbox": [
+            173,
+            688,
+            823,
+            717
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Koestinger, Paul Wohlhart, Peter M. Roth, and Horst Bischof. Annotated facial landmarks in the wild: A large-scale, real-world database for facial landmark localization. In First IEEE International Workshop on Benchmarking Facial Image Analysis Technologies, 2011. ",
+        "bbox": [
+            176,
+            726,
+            825,
+            768
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Lavin. Fast algorithms for convolutional neural networks. arXiv preprint arXiv:1509.09308, 2015. ",
+        "bbox": [
+            169,
+            777,
+            823,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karel Lenc and Andrea Vedaldi. Understanding image representations by measuring their equivariance and equivalence. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 991–999, 2015. ",
+        "bbox": [
+            174,
+            815,
+            823,
+            858
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kun Liu, Henrik Skibbe, Thorsten Schmidt, Thomas Blein, Klaus Palme, Thomas Brox, and Olaf Ronneberger. Rotation-Invariant HOG Descriptors Using Fourier Analysis in Polar and Spherical Coordinates. International Journal of Computer Vision, 106(3):342–364, February 2014. ISSN 0920-5691, 1573-1405. doi: 10.1007/s11263-013-0634-z. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard G Lyons. Understanding digital signal processing. Pearson Education, 2010. ",
+        "bbox": [
+            171,
+            103,
+            735,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diego Marcos, Michele Volpi, and Devis Tuia. Learning rotation invariant convolutional filters for texture classification. arXiv preprint arXiv:1604.06720, 2016. ",
+        "bbox": [
+            171,
+            127,
+            823,
+            156
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B. Srinivasa Reddy and Biswanath N. Chatterji. An FFT-based technique for translation, rotation, and scale-invariant image registration. IEEE Transactions on Image Processing, 5(8):1266–1271, 1996. ",
+        "bbox": [
+            174,
+            165,
+            823,
+            207
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Uwe Schmidt and Stefan Roth. Learning rotation-aware features: From invariant priors to equivariant descriptors. In Computer Vision and Pattern Recognition (CVPR), 2012 IEEE Conference on, pp. 2050–2057, 2012. ",
+        "bbox": [
+            174,
+            215,
+            823,
+            258
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Georgios Tzimiropoulos, Vasileios Argyriou, Stefanos Zafeiriou, and Tania Stathaki. Robust FFTbased scale-invariant image registration with image gradients. IEEE Transactions on Pattern Analysis and Machine Intelligence, 32(10):1899–1906, 2010. ",
+        "bbox": [
+            174,
+            268,
+            825,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A SPATIAL TRANSFORMATION FOR 3D SPHERE ROTATION UNDER PERSPECTIVE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            732,
+            136
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our simplified model consists of a perspective camera with focal length $f$ and all other camera parameters equal to identity, at a distance $d$ from a centered sphere of radius $r$ (see fig. 1-d). ",
+        "bbox": [
+            174,
+            150,
+            825,
+            180
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A 2D point $x$ in image-space corresponds to the 3D point ",
+        "bbox": [
+            173,
+            185,
+            552,
+            202
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/31b2b0a184906950d991c80ce2aae529f41484f0295cf85ed81183c4f31b7898.jpg",
+        "text": "$$\np = ( x _ { 1 } , x _ { 2 } , f ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            220,
+            553,
+            238
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Raycasting it along the $z$ axis, it will intersect the sphere surface at the 3D point ",
+        "bbox": [
+            171,
+            247,
+            699,
+            263
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65e033401ece94284d9a8c2e47819810b432e434dece1e0248f03118b89e64cd.jpg",
+        "text": "$$\nq = { \\frac { p } { \\| p \\| } } \\left( k - { \\sqrt { k ^ { 2 } - d ^ { 2 } + r ^ { 2 } } } \\right) , k = { \\frac { f d } { \\| p \\| } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            279,
+            645,
+            313
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "If the argument of the square-root is negative, the ray does not intersect the sphere and so the point transformation is undefined. This means that the domain of the image $\\Omega$ should be restricted to the sphere region. In practice, in such cases we simply leave the point unmodified. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            364
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Then, the yaw and pitch coordinates of the point $q$ on the surface of the sphere are ",
+        "bbox": [
+            173,
+            371,
+            712,
+            386
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eef936dd424937eaf2ee8049bccbb30bbd6a80d89ead27a210e329c8de5152f5.jpg",
+        "text": "$$\n\\phi _ { 1 } = \\cos ^ { - 1 } \\left( - \\frac { q _ { 2 } } { r } \\right) , \\phi _ { 2 } = \\mathrm { a t a n _ { 2 } } \\left( - \\frac { q _ { 1 } } { d - q _ { 3 } } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            401,
+            658,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "These polar coordinates are now rotated by the spatial transformation parameters, $\\phi ^ { \\prime } = \\phi + u$ ",
+        "bbox": [
+            173,
+            446,
+            789,
+            463
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Converting the polar coordinates back to a 3D point $q ^ { \\prime }$ ",
+        "bbox": [
+            173,
+            468,
+            532,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c31db84264a5f137aa8076f7b4f5b20fa78965ee3c84fec0a39ee035046b4fa2.jpg",
+        "text": "$$\n\\begin{array} { r } { q ^ { \\prime } = \\left[ \\begin{array} { c } { r \\sin \\phi _ { 1 } ^ { \\prime } \\sin \\phi _ { 2 } ^ { \\prime } } \\\\ { - r \\cos \\phi _ { 1 } ^ { \\prime } } \\\\ { r \\sin \\phi _ { 1 } ^ { \\prime } \\cos \\phi _ { 2 } ^ { \\prime } - d } \\end{array} \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            500,
+            601,
+            545
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Finally, projection of $q ^ { \\prime }$ into image-space yields ",
+        "bbox": [
+            174,
+            555,
+            488,
+            571
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9121d7cb1fbc46d052286b9a607a4800601ac9121a4351b6b000ffc46db5e8eb.jpg",
+        "text": "$$\nt _ { u } ( x ) = - { \\frac { f } { q _ { 3 } ^ { \\prime } } } \\left[ \\begin{array} { c } { { q _ { 1 } ^ { \\prime } } } \\\\ { { q _ { 2 } ^ { \\prime } } } \\end{array} \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            587,
+            575,
+            622
+        ],
+        "page_idx": 11
+    }
+]

parse/train/z-X_PpwaroO/z-X_PpwaroO.md

@@ -0,0 +1,271 @@
+# Computer-Aided Design as Language
+
+Yaroslav Ganin1∗ Sergey Bartunov1 Yujia Li1 Ethan Keller2 Stefano Saliceti1 1DeepMind 2Onshape
+
+# Abstract
+
+Computer-Aided Design (CAD) applications are used in manufacturing to model everything from coffee mugs to sports cars. These programs are complex and require years of training and experience to master. A component of all CAD models particularly difficult to make are the highly structured 2D sketches that lie at the heart of every 3D construction. In this work, we propose a machine learning model capable of automatically generating such sketches. Through this, we pave the way for developing intelligent tools that would help engineers create better designs with less effort. The core of our method is a combination of a generalpurpose language modeling technique alongside an off-the-shelf data serialization protocol. Additionally, we explore several extensions allowing us to gain finer control over the generation process. We show that our approach has enough flexibility to accommodate the complexity of the domain and performs well for both unconditional synthesis and image-to-sketch translation.
+
+# 1 Introduction
+
+Computer-Aided Design (CAD) is used in the production of most manufactured objects: from cars to robots to stents to power plants. CAD has replaced pencil drawings with precise computer sketches, enabling unparalleled precision, flexibility, and speed. Despite these improvements the CAD engineer must still develop, relate and annotate all the minutiae of their designs with the same attention to detail as their draftingtable forebears. CAD productivity might be improved by the careful application of machine learning to automate predictable design tasks and free the engineer to focus on the bigger picture. The flexibility and power of deep learning is uniquely suited to the complexity of design.
+
+Sketches are at the heart of mechanical CAD. They are the skeleton from which three dimensional forms are made. A sketch consists of various geometric entities (e.g., lines, arcs, splines and circles) related by specific constraints such as tangency, perpendicularity and symmetry. Figure 1 illustrates how entities and constraints work in tandem to create well-defined shapes. Geometric entities lie on a single plane and together form enclosed regions used by subsequent construction operations such as lofts and extrusions to generate complex
+
+![](images/801c01a8f7ad74854fddf78e6c8c49c6d66b6df145afc636cd0e89cfc38f010b.jpg)  
+Figure 1: The anatomy of a CAD sketch. Sketches are the main building block of every 3D construction. A sketch consists of entities (e.g., lines and arcs) and constraints (e.g., tangent and mirror). The dotted curve shows what happens if we drop some of the constraints — the design idea is lost.
+
+![](images/768010495993ed4419100a195bad75e3db43476e171ff7bd23282a293c1f8bdc.jpg)  
+Figure 2: Interpreter-guided generation of a sketch. At each point in time, a Transformer [33] outputs a raw value which is fed into an interpreter that decides which field of a Protocol Buffers message this value corresponds to. Once the field is populated the interpreter communicates $( -  )$ its decision back to the Transformer and transitions $( \nrightarrow )$ to the next state.
+
+3D geometry. Well-chosen sketch constraints are essential to properly convey design intent [2] and facilitate the sketch’s resilience to successive parameters modifications which is often understood as a measure of the quality of a design document [8]. The dotted curve in Figure 1 shows what happens when some of the constraints are dropped – the design idea is lost.
+
+The complexities of sketch construction are analogous to those of natural language modeling. Selecting the next constraint or entity in a sketch is like the generation of the next word in a sentence. In both contexts, the selection must function grammatically (form a consistent constraint system in the case of the sketch) and work towards some cohesive meaning (preserve design intent). Luckily, machine learning has proved highly successful in generating natural language — especially the Transformer [33] trained on vast amounts of real-world data [26, 6]. It is therefore a promising choice for adapting to the task of sketch generation. This work is our take at this adaptation.
+
+We make the following contributions: (1) We devise a method for describing structured objects using Protocol Buffers [32] and demonstrate its flexibility on the domain of natural CAD sketches. (2) We propose several techniques for capturing distributions of objects represented as serialized Protocol Buffers. Our approach draws inspiration from recent advances in language modeling while focusing on eliminating data redundancy. (3) We collect a dataset of over $4 . 7 \mathbf { M }$ of carefully preprocessed parametric CAD sketches and use this dataset to validate the proposed generative models. To our knowledge, the experiments presented in this work significantly surpass the scale of those reported in the literature both in terms of the amount of training data and the model capacity.
+
+# 2 Related work
+
+Datasets and generative models for CAD. Until recently there were very few parametric CAD datasets large and varied enough to serve as training data for machine learning. This situation had started to change with the release of the ABC dataset [16] containing a collection of 3D shapes from the Onshape public repository [22]. Unfortunately, the main focus of [16] revolves around meshes and, as a result, the dataset is difficult to use for sketch modeling.
+
+Several works concurrent with ours deal with the symbolic representation of CAD constructions. Seff et al. [31] center their attention on contributing a better dataset of 2D sketches but also provide a proof-of-concept model predicting a selected subset of object attributes. Willis et al. [37] use the dataset from [31] to train a modification of [21] which demonstrates a boost in generation quality but is designed to only work for sketch entities. The latter is addressed in our present work and in a subsequent paper by Para et al. [24]. While [24] employ very similar ideas to ours they do not support certain features of the CAD data and their proposed model is a more direct adaptation of [21] and therefore cannot handle arbitrary orderings of entities and constraints. In Section 5, we show that object ordering has a substantial impact on the performance.
+
+Fusion 360 Gallery [36] attacks CAD data from a different angle. Here, the task is to recover a sequence of extrusion operations that gives rise to a particular target 3D shape. Despite dealing with 3D, this setting is deliberately limited: sketches are assumed to be given and the proposed model only decides on which sketch to extrude and to what extent. [38] considers a more general scenario where extrusion profiles are not provided and need to be synthesized from scratch. Although both of these works make initial steps towards full parametric CAD generation, they rely on significant simplifying assumptions and therefore it is unclear how well they will scale to more real-world scenarios. Our approach, on the other hand, is designed to be flexible and domain-agnostic and is only limited by the data availability.
+
+Vector image generation and inference. Synthesizing CAD sketches bears a lot of similarities with predicting vector graphics. In this field, several recent works Carlier et al. [7] and Reddy et al. [30] using different vector object representations to define generative models of vector images. Egiazarian et al. [13] take a more traditional computer vision approach and propose a multi-stage pipeline for vectorizing technical drawings. All of these methods use highly domain-dependent architectures and, therefore, it would be a non-trivial task to adapt them for generation of complex sketch objects. CAD community has also been concerned with a similar task of image to CAD conversion [20, 34, 10, 11], largely focusing on heuristic object recognition while our work relies more on learning the recognition from data.
+
+Transformers for sequence modeling. In our work, we employ Transfomers [33] as a computational backbone for the proposed approach. Due to its scalability and excellent performance [29, 9, 6, 27], this architecture has become the dominating approach in many sequence modeling applications. Our method can be seen as generalization of PolyGen [21], a Transformer-based generative model for 3D meshes. Similarly to [21], we use Pointer Networks [35] to relate items in the synthesized sequence. Unlike PolyGen, however, our framework can handle non-homogeneous structures of arbitrary complexity. Moreover, we simplify the architecture to use a single neural network to generate the entire object of interest. All these improvements make our approach a good fit for modeling CAD sketches and potentially other components of CAD constructions.
+
+# 3 Data
+
+Formally, a CAD sketch is defined by two collections of objects: entities and constraints. Each object is generally represented as a set of attribute-value pairs where a value can be either primitive (e.g., integer or floating-point) or complex (e.g., an array or another object). Sketches that we use in this work originate from the Onshape platform [22] which provides them in JSON format [25]. As the first step in our processing pipeline we convert JSON messages into Protocol Buffers (PB) [32]. In order to keep the pipeline as domain-agnostic and as widely applicable as possible, we aim to avoid any significant changes to the data and largely retain the original structures of objects. The benefit of converting into PB is twofold: the resulting data occupies less space because unnecessary information is removed, but also, unlike JSON, PB provide a convenient way to define precise specifications for structures of arbitrary complexity.
+
+Listing 1a shows how we represent the line entity and the mirror constraint (see Appendix A for an extensive list of supported objects). The line specification is straightforward: we first need to decide whether our entity should be treated as a construction geometry2 and then provide pairs of coordinates for the beginning and end of the segment. The MirrorConstraint is used to force an arbitrary number of pairs of geometries (i.e., mirrored_pairs) to be symmetrical with respect to some axis (i.e., mirror). Constraints rely on the Pointer data type to specify entities they act upon. In practice, a pointer is simply an index in the table of all the eligible pointees (i.e., entities and their parts).
+
+message LineEntity { bool is_construction $\ c = ~ 1$ ; message Vector $\{ \begin{array} { r l } \end{array}  / / $ 2D coordinate. double $\texttt { x } = \texttt { 1 }$ ; double $\tt { y } = 2$ ; } Vector start $= ~ 2$ ; // Start point. Vector end $\ c = \ 3$ ; // End point.   
+}   
+message MirrorConstraint { Pointer mirror $\ c = ~ 1$ ; // Axis of symmetry. message Pair { // Mirrored objects. Pointer first $\ l = \ 1$ ; Pointer second $= ~ 2$ ; } repeated Pair mirrored_pairs $= ~ 2$ ;   
+}
+
+(a) Entities and constraints have similar structures. Pointers refer to entities that constraints are applied to.
+
+message Entity { oneof kind { LineEntity line $\ l = \ 1$ ; // And other entity types. }   
+}   
+message Object { oneof kind { Entity entity $\ l = \ 1$ ; Constraint constraint $= ~ 2$ ; }   
+}   
+message Constraint { // Defined similarly to Entity.   
+}   
+message Sketch { repeated Object objects $\ c = ~ 1$ ;   
+}
+
+(b) A full sketch is defined as a sequence of objects each of which can be either an entity or a constraint.
+
+Listing 1: Examples of object specifications. We represent objects using Protocol Buffers. Protocol Buffers allow us to easily write specifications for structured objects of varying complexity.
+
+Our ultimate goal is to build a machine learning model of sketch objects. To that end, we process the data even further and represent these objects as sequences of tokens. This allows us to pose sketch generation as language modeling (LM) and take advantage of the recent progress in this area [26, 6]. To achieve this, we pack first collections of entities and constraints into one Protocol Buffer message (see Listing 1b) assuming some ordering of objects. We discuss different orderings in Section 5.
+
+There are a few ways to obtaining a sequence of tokens from a sketch message. Arguably the most intuitive one is to format messages as text. For a line entity connecting (0.0, 0.1) and $( - 0 . 5 , 0 . 2 )$ this will result in:
+
+{ is_construction: true, start { x: 0.0, y: 0.1 }, end { x: -0.5, y: 0.2 } }
+
+Since this format contains both the structure and the content of the data, the resulting sequences end up being prohibitively long. Additionally, the model would have to generate valid syntax, which would take up some portion of the model’s capacity. To overcome these challenges, we work with two flavours of serialized PB messages.
+
+The first one is a sequences of bytes obtained by calling the SerializeToString() method of a message. Such sequences are much shorter since the structure is handled by an external parser automatically generated from the data specification. The parser’s task is to interpret the incoming stream of unstructured bytes and populate the fields of PB messages. However, like the text format, not every sequence of bytes results in a valid PB message.
+
+Going one step further, we can utilize the structure of the sketch format more directly, and build a custom interpreter, that takes as input a sequence of tokens each representing a valid choice at various decision steps [4] in the sketch creation process. We designed this interpreter in such a way that all sequences of tokens in this format lead to valid PB messages. More specifically, we represent a message as a sequence of triplets $( d _ { i } , c _ { i } , f _ { i } )$ where $i$ is an index of the token. The majority of tokens describe basic fields of the sketch objects with each token representing exactly one field. The first two positions in each triplet are allocated for a discrete value and a continuous value respectively. Since each field in a message is either discrete or continuous only one of two positions is active at a time (the other one is set to a default zero value). The third component is a boolean flag signifying the end of a repeated field3 which contains a list of elements of the same type. An example sequence for a sketch containing a line and a point placed at one of its ends is shown in Table 1 (Triplet column).
+
+<table><tr><td>Triplet</td><td>Field</td><td></td><td>Triplet</td><td>Field</td></tr><tr><td>1.</td><td>(0,0.0,False)</td><td>objects.kind</td><td>8. (0,0.0,False)</td><td>objects.kind</td></tr><tr><td>2.</td><td>(0,0.0,False)</td><td>entity.kind</td><td>9. (1, 0.0,False)</td><td>entity.kind</td></tr><tr><td>3.</td><td>(1,0.0,False)</td><td>line.is_constr</td><td>10. (0, 0.0,False)</td><td>Point point.is_const</td></tr><tr><td>4.</td><td>(0, 0.0,False)</td><td>line.start.x</td><td>11. (0, 0.0,False)</td><td>point .x</td></tr><tr><td>5.</td><td>(0,0.1,False)</td><td>line.start.y</td><td>12. (0,0.1,False)</td><td>point.y</td></tr><tr><td>6.</td><td>(0,-0.5,False)</td><td>line.end.x</td><td>13. (0, 0.0, True)</td><td>objects.kind</td></tr><tr><td>7.</td><td>(0, 0.2,False)</td><td>line.end.y</td><td></td><td></td></tr></table>
+
+Table 1: A triplet representation of a simple sketch. The sketch contains and a line and a point. Within each triplet in the left column, the active component (the value that is actually used) is highlighted in bold. The right column shows which field of the object the triplet is associated with.
+
+Given a sequence of such triplets, it is possible to infer which exact field each token corresponds to. Indeed, the very first token $( d _ { 1 } , c _ { 1 } , f _ { 1 } )$ is always associated with objects.kind since it is the first choice that needs to be made to create a Sketch message (see Listing 1b). The second field depends on the concrete value of $d _ { 1 }$ . If $d _ { 1 } = 0$ then the first object is an entity which means that the second token corresponds to entity.kind . The rest of the sequence is associated in a similar fashion. Field identifiers along with their locations within an object form the context of the tokens. We use this contextual information as an additional input for our machine learning models since it makes it easier to interpret the meaning of the triplet values and to be aware of the overall structure of the data.
+
+# 4 Model
+
+In order to estimate the distribution $p _ { \mathrm { d a t a } }$ of 2D sketches in a dataset $\mathcal { D }$ , we decompose the joint distribution over the sequence of tokens [19] $\mathbf { t } = ( t _ { 1 } , \ldots , t _ { N } )$ in an autoregressive fashion, representing each conditional with a neural network parameterized by $\theta$ and pose the estimation of $p _ { \mathrm { d a t a } }$ as maximization of the log-likelihood of $\mathcal { D }$ , i.e.,
+
+$$
+p ( t ; \theta ) = \prod _ { i = 1 } ^ { N } p ( t _ { i } \mid t _ { < i } ; \theta ) , \quad \sum _ { t \in \mathcal { D } } \log p ( t ; \theta ) \to \operatorname* { m a x } _ { \theta } ,
+$$
+
+where $N$ is the length of the sequence and $t _ { < i }$ denotes all the tokens preceding $t _ { i }$ .
+
+More concretely, we employ the Transformer decoder architecture [33] that takes an embedding of the token $\pmb { e } _ { i - 1 } \overset { \cdot } { = } \mathrm { e m b e d } _ { i } ^ { \cdot } ( t _ { i - 1 } ^ { \cdot } ) \in \mathbb { R } ^ { D }$ and maps it into another vector $\boldsymbol { h } _ { i }$ of the same dimensionality. The latter is decoded into parameters of $p ( t _ { i } \mid t _ { < i } )$ by a learned mapping $\mathsf { d i s t } _ { i } ( \cdot )$ .4
+
+Byte representation When dealing with the bytes of a PB message, each token is simply a discrete value in the range $\{ 0 , \dots , 2 5 5 \} \cup \{ \bar { \bf E 0 S } \}$ and therefore $p ( t _ { i } \mid t _ { < i } ; \bar { \theta ( \mathbf { \Sigma } ) }$ can be modeled as a categorical distribution similar to how it’s done in typical LM approaches [5]. In this setting, for each time step $i$ of the sequence we have
+
+$$
+\mathbf { e m b e d } _ { i } ( t _ { i - 1 } ) = V [ t _ { i - 1 } ] + e _ { i } ^ { \mathrm { p o s } } ,
+$$
+
+where $[ \cdot ]$ denotes the lookup operation and $e _ { i } ^ { \mathrm { p o s } }$ is a position embedding for position $i$ . Both $V$ and $e _ { i } ^ { \mathrm { p o s } }$ are learned. Moreover, $\forall i \ \mathtt { d i s t } _ { i }$ is the same linear projection into $\mathbb { R } ^ { 2 5 7 }$ (256 values and EOS) and the output is treated as logits of the distribution.
+
+Triplet representation In case of the triplet representation, we follow a slightly more involved procedure. As outlined in Section 3, tokens can be either discrete or continuous. Additionally, different discrete tokens may have different ranges of values. For example, there are only two possible values for the object.kind token – either to an entity or a constraint. On the other hand, the range of the entity.kind token has cardinality of 4 since we support 4 different types of sketch entities. This means that we can’t naively describe each conditional in Equation 1 using the same template distribution like we did for the bytes. We circumvent this by introducing the notion of token groups.
+
+A token group $\mathcal { G }$ is a collection of related token types that can be handled in a similar fashion. Specifically, we use the same embedding function and the same projection for every $t$ such that
+
+![](images/023d60da6886256697dbccdb13316caf4b192be89fcc2c3abc16679bb42ccf08.jpg)
+
+(a) Unconditional byte model.
+
+(b) Unconditional triplet model.
+
+![](images/6a078adb38e4e5126f04a58c9d202baf6dc4394bfc33aa9ce47e076d2e729d83.jpg)  
+Figure 3: Synthesized sketches and data. (a)–(c) show samples from various proposed models (we use Nucleus Sampling with top- $p = 0 . 9 ,$ ). In (c), the output is rendered in a slightly thicker style. (d) demonstrates samples from the unconditional model after applying predicted constraints (the output is in blue). (e) shows examples from the dataset.
+
+$\mathsf { t y p e } ( t ) \in \mathcal { G }$ . For instance, we might want to group all the tokens associated with coordinates. In the example from Table 1, tokens with indices 4–7 and 11–12 will all end up in the same $\mathcal { G } ^ { 5 }$ . Naturally, we use the same functional form for the output distribution $p ( t _ { i } \mid t _ { < i } ; \boldsymbol { \theta } )$ within each group.
+
+We embed $t _ { i - 1 }$ that belongs to the group $\mathcal { G }$ as (note the difference with Equation 2):
+
+$$
+K [ \mathbf { f i e l d } ( t _ { i - 1 } ) ] + V ^ { \mathcal { G } } [ t _ { i - 1 } ] + e _ { n } ^ { \mathrm { o b j } } + e _ { m } ^ { \mathrm { r e l } } ,
+$$
+
+where field $( t )$ returns the field of $t$ (e.g., objects.kind or line.start. $\mathtt { x }$ ) and $K$ is a collection of learnable embeddings for every possible field type. Unlike in Equation 2, instead of using global position embedding eposi w e describe the location with the index $n$ of the current object as well as the relative position $m$ of $t _ { i - 1 }$ within an object.
+
+We handle the “end” tokens (i.e., $f _ { i } = \mathrm { T r u e } )$ similarly to EOS in Section 4 — the output projection produces an additional logit used to compute the probability of ending the repetition. Since $f _ { i }$ is only expected to be True at particular points in the sequence (i.e., right after tokens forming a whole element of the list) we mask out the extra logit everywhere else. This ensures that the “end” token can’t be predicted prematurely and also eliminates its unnecessary contribution to the optimized objective.
+
+One significant difference between the byte setting and the triplet setting is how we process pointer fields. In the former, pointers do not get any special treatment and are generated just like any other integer field. We rely on the model’s capability to make sense of the entity part index and relate it to the corresponding locations in the sequence via attention weights. This seems to be a viable strategy since Transformers have demonstrated an impressive referencing capacity in recent works [6].
+
+Since the triplet representation provides us with direct access to the semantics of tokens it’s possible to relate pointers to their pointees more explicitly by using Pointer Networks [35]. The approach we are taking here is similar to [21]. In order to compute $p ( t _ { i } \mid t _ { < i } ; \theta )$ , we first project the output of the Transformer $\boldsymbol { h } _ { i }$ into the final pointer vector $p _ { i } = { W _ { \mathrm { p t r } } h _ { i } }$ . The conditional is then obtained as follows:
+
+$$
+\begin{array} { r } { p ( t _ { i } \mathrm { ~ p o i n t s ~ t o ~ } t _ { i k } \mid t _ { < i } ; \theta ) = \mathrm { s o f t m a x } _ { k } ( \pmb { p } _ { i } ^ { T } H _ { i } ) , \quad H _ { i } = [ \pmb { h } _ { i 1 } , \dots , \pmb { h } _ { i k } , \dots , \pmb { h } _ { i M } ] , } \end{array}
+$$
+
+where $\operatorname { s o f t m a x } _ { k }$ is the $k$ -th element of the softmax vector and $\boldsymbol { r } _ { i } = \{ t _ { i 1 } , . . . , t _ { i M } \}$ is the set of tokens that $t _ { i }$ can point to. Naturally, $\mathbf { \nabla } _ { \mathbf { r } _ { i } }$ only contains tokens from $t _ { < i }$ . This is different from [35, 21] where $\textstyle r _ { i } \equiv r$ is external to the predicted sequence and remains immutable throughout the generation process.
+
+In Onshape, constraints can be applied not only to whole entities but also to their subparts (e.g., the center of a circle or the end points of a line segment). To handle this, we introduce special referrable tokens decoupling pointees from the object attribute tokens. Referrables are injected after each entity and have the same identifier within each entity type. In order to let the model distinguish between different subparts, we adjust Equation 3 to use a learnable embedding of a part index instead of $V ^ { \mathcal { G } } [ t _ { i - 1 } ]$ . As referrable tokens do not need to be predicted the respective terms are removed from Equation 1. For the same reason, in Equation 4, $\boldsymbol { h } _ { i k }$ corresponds to the time step where $t _ { i k }$ is the output and not the input. This allows us to avoid having unused Transformer outputs.
+
+Finally, we need to specify how we embed pointers as inputs to the Transformer network. Following [35, 21] we could reuse $h _ { j }$ for tokens that point to $t _ { j }$ . Unfortunately, this creates output-to-input connections which are extremely detrimental to the efficiency of the Transformer architecture — different time steps can no longer be processed in parallel during training. Instead, we opt for a simpler solution and employ the standard embedding scheme for discrete tokens (Equation 3).
+
+Sampling from the model Sampling from the byte model is identical to sampling from any typical Transformer-based LM. The triplet model, on the other hand, requires slightly more bespoke handling. Figure 2 illustrates the procedure. We start by embedding and feeding a special BOS token into the Transformer. The Transformer then outputs a collection of triplets, one for each possible token group. In order to determine which concrete token needs to be emitted, we employ an interpreter (a state machine) automatically generated from the data specification. Knowing the current state allows us to choose the right token group and associate the active component of the triplet with a field in the synthesized object. Once the appropriate field is populated the interpreter transitions to the next state and produces an output token which is then fed back into the model. The process stops when the state machine receives the “end” triplet for the outermost repeated field (i.e., object.kind ).
+
+Conditional generation In addition to the unconditional model described above, we explore a variant that allows us to translate bitmaps into sketches. Here, we simply let the main Transformer cross-attend to the features extracted from the input image by a ViT network [12]. The specific setup is detailed in Appendix C.
+
+# 5 Experiments
+
+We validate our proposed approaches on the data that we obtained from the repository of documents publicly available on the Onshape platform [22]. Following the standard evaluation methodology for autoregressive generative models [23, 21] we use log-likelihood as our primary quantitative metric. Additionally, we provide a variety of random and selected model samples for qualitative assessment (Figure 3).
+
+Dataset Unlike the majority of the existing works dealing with CAD sketch generation [31, 37, 24] we do not rely on SketchGraphs [31]. Instead, we collect the largest to date dataset of engineering sketches addressing the main disadvantage of [31], severe data duplication. The acquisition and the filtering procedures
+
+Table 2: Test likelihoods of various models. The object column is computed as the average number of bits per object in a sketch averaged across test examples. The sketch column is similar except we do not divide by the number of objects.   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2"> Sequence</td><td colspan="2">Average bits per</td></tr><tr><td>object</td><td>sketch</td></tr><tr><td>Uniform</td><td>unord. bytes</td><td>112.23</td><td>3683.56</td></tr><tr><td></td><td>unord. triplets</td><td>25.34</td><td>847.52</td></tr><tr><td>Text</td><td>interleaved</td><td>4.622</td><td>139.687</td></tr><tr><td>Byte</td><td>concatenated</td><td>4.381</td><td>132.621</td></tr><tr><td rowspan="3">Triplet</td><td>interleaved</td><td>4.252</td><td>127.495</td></tr><tr><td>concatenated</td><td>4.218</td><td>127.913</td></tr><tr><td>interleaved</td><td>4.103</td><td>123.213</td></tr><tr><td>Cond.</td><td>interleaved</td><td>1.570</td><td>53.730</td></tr></table>
+
+![](images/2059d907b811a8da4ce130202c27c31b776e49951b3446b4a44e0a7efa04fa39.jpg)  
+Figure 4: Distribution of various sketch statistics for samples drawn from our unconditional models. The top- $p$ parameter for Nucleus Sampling is shown in parentheses.
+
+are detailed in Appendix D. For our experiments we split the dataset randomly into 3 parts: 4,656,607   
+examples for the training set and 50,000 sketches for each the validation and the test set.6
+
+Unconditional generation. In this series of experiments, the goal is to determine how well our models capture the distribution of sketches in the dataset. We use the same network architecture for both the byte and the triplet settings.7 We compare two orderings of objects: in the first one (concatenated), constraints go after the last entity while in the second (interleaved), a constraint object is injected immediately after the entities it operates on. In both cases, the relative orderings within both the sequence of entities and the sequence of constraints are taken directly from the original JSON messages.
+
+Table 2 shows test log-likelihoods obtained by different models. Unsurprisingly, our proposed methods (rows 4–7) significantly outperform the weak baselines (rows 1–2). The difference between the two uniform settings is due to the fact that the byte description of a PB message is usually longer than the triplet one: $2 3 9 \nu s . 4 5 6$ tokens on average with the maximum length of 959 vs. 1987. Additionally, the tokens in the triplet representation tend to have smaller range of values $( i . e . , < 2 5 7 )$ ).
+
+These differences between representations may partially explain why triplet models demonstrate better performance on the hold-out test set. It’s also worth emphasizing that the byte model does not receive any explicit information about the parsing state. This seem to make learning more challenging and as a result compared to the triplet model it takes roughly 3 times more network updates to reach the highest data likelihood on the validation.
+
+Another important factor affecting the performance of the models is the choice of the object ordering. As it is evident from Table 2, the interleaved ordering consistently leads to better results. One explanation for this is that at any point in time, the model has more explicit information about the relations between the sketch entities produced so far.
+
+In the row 3 of Table 2, we also provide the test log-likelihood for a conventional language modeling baseline trained on the text representation of PB messages (see Section 3). Here, we employ the SentencePiece tokenizer [17] with fairly aggressive settings (8000 words in the vocabulary; splitting at whitespaces switched off) to be able to keep the sequences within the budget of 1024 tokens. As can be seen from the table, the resulting Transformer model (of exactly the same architecture as other entries) despite being better than the uniform baselines is still substantially worse than the proposed methods.
+
+In addition to measuring likelihoods, we sampled 10,000 sketches from the best performing byte and triplet models and computed distributions of various high-level statistics (Figure 4 and Figure 6 in the appendix). We repeated this procedure both with and without using Nucleus Sampling (NS) [15]. Both models follow the data distribution closely when we use samples from the unmodified model output. In this setting, however, a significant fraction of sketches is either malformed (e.g., the generated PB message cannot be parsed) or unsolvable: $3 6 \%$ for the byte model and $1 4 \%$ for the triplet model. NS with top- $p = 0 . 9$ skews the sample distribution and seems to have a more pronounced negative effect on the byte model. The upside is that the resulting sketches become “cleaner”: the percentage of invalid samples goes down to $2 5 \%$ and $6 \%$ for the byte and the triplet settings respectively.
+
+![](images/5d620b9ee341dd09d6ee279fd7943e89afcaaee0b870754354379fa1d011f84b.jpg)  
+Figure 5: Entities and constraints sampled from the unconditional (top) and the conditional (bottom) triplet models. The first column of nodes represents different entities (all parts are folded into a single node). The order of nodes (top to bottom) follows the generation order. The second column represents different constraints also ordered by their index in the sequence. Finally, the third column is reserved for constraint types, from the most to the least frequent.
+
+Figures 3a and 3b show renders of random samples from several proposed models. Overall, generated sketches look plausible and exhibit a lot of desired properties: closedness of regions, regularity, symmetry, a non-trivial amount of fine detail. We observe that the byte model produces slightly less complex samples with fewer open arcs but this could be a side effect of a particular top- $p$ value. We also note that the model does not always synthesize sensible sketches — just like any other typical autoregressive model trained with teacher forcing it suffers from not being able to recover from mistakes made early on in the sequence [28]. This can potentially be addressed by fine-tuning using, for example, reinforcement learning.
+
+We show a more detailed sample from the triplet model in Figure 5. While not perfect, the inferred constraints are reasonable most of the time. The model does a good job at connecting entities using Coincident constraints but also successfully detects more complex relations spanning more than two primitives (e.g., Mirror). Having access to constraints gives us opportunity to correct mistakes in entity prediction by applying an external sketch solver (see Figure 3d). Although this aspect of sketching was not the main focus of this work, we believe that a tighter integration between the model and the CAD software will lead to a significant boost in generation quality.
+
+Conditional generation. As discussed in Section 4, we also trained an image-conditional model using the same regime as for the unconditional one. As expected, it achieves a significantly better fit (the last row of Table 2) but at the same time retains a non-trivial amount of uncertainty. The latter is arising, in particular, from the fact that different permutations of entities result in the same rendered image. Image-conditional samples can be found in Figure 3c. The model was able to nearly perfectly reconstruct simpler sketches and mostly made mistakes in the presence of a large number of fine details. Additionally, we compared our system against the nearest neighbour baseline in terms of visual reconstruction error as measured by Chamfer distance. We found that the proposed method reduces the error by $\approx 8 0 \%$ (see Appendix H). In order to test the out-of-distribution performance, we supply the model with several custom-made drawings. Surprisingly, after minor post-processing to account for the short sequence bias the system manages to produce reasonable reconstructions (see the bottom example in Figure 5). We detail this experiment in Appendix I.
+
+# 6 Discussion
+
+In this work, we have demonstrated how a combination of a general-purpose language modeling technique alongside an off-the-shelf data serialization protocol can be used to effectively solve generation of complex structured objects. We showcased the proposed system on the domain of 2D CAD drawings and developed models that can synthesize geometric primitives and relations between them both unconditionally as well as using a bitmap as a reference. These are only initial proof-of-concept experiments and we are hoping to see more applications taking advantage of the flexibility of the developed interface: conditioning on various sketch properties, inferring constraints given entities and automatically completing drawings, to name a few.
+
+Although we focused our attention on a particular dataset we argue that the approach described in this paper is largely domain-agnostic. In order to adapt the system to a new kind of data, the algorithm designer only needs to provide an appropriate Protocol Buffer specification and if the PB language is too restrictive one can always replace it with a more powerful interpreter. As a straightforward direction for future work, we can consider extending the method to handle 3D. In Onshape, 3D operations bear a lot of similarities with sketch constraints — just like constraints, they can be represented as nested messages containing references to the geometries existing in the scene. Thus, most of the ideas from the present work can be taken verbatim to this new setting.
+
+We hope that this work will serve as a stepping stone for further advances in the field of automated CAD but also inspire new ideas and approaches to generative modeling of arbitrary structured data.
+
+# Acknowledgments and Disclosure of Funding
+
+The authors would like to thank Charlie Nash, Georg Ostrovski, and Adam Kosiorek for helping with the manuscript preparation as well as Igor Babuschkin, David Choi, Nate Kushman, Andrew Kimpton, Jake Rosenfeld, Lana Saksonov, John Rousseau, Greg Guarriello, Andy Brock, Francesco Nori, Aäron van den Oord, and Oriol Vinyals for insightful discussions and support.
+
+YG, SB, YL, and SS are funded by DeepMind. EK is funded by PTC.
+
+# References
+
+[1] J. Alakuijala, A. Farruggia, P. Ferragina, E. Kliuchnikov, R. Obryk, Z. Szabadka, and L. Vandevenne. Brotli: A general-purpose data compressor. TOIS, 2018.   
+[2] H. K. Ault. Using geometric constraints to capture design intent. JGG, 1999.   
+[3] H. G. Barrow, J. M. Tenenbaum, R. C. Bolles, and H. C. Wolf. Parametric correspondence and chamfer matching: Two new techniques for image matching. Technical report, SRI INTERNATIONAL MENLO PARK CA ARTIFICIAL INTELLIGENCE CENTER, 1977.   
+[4] R. Bavishi, C. Lemieux, R. Fox, K. Sen, and I. Stoica. AutoPandas: Neural-backed generators for program synthesis. In OOPSLA, 2019.   
+[5] Y. Bengio, R. Ducharme, P. Vincent, and C. Janvin. A neural probabilistic language model. JMLR, 2003.   
+[6] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   
+[7] A. Carlier, M. Danelljan, A. Alahi, and R. Timofte. DeepSVG: A hierarchical generative network for vector graphics animation. arXiv preprint arXiv:2007.11301, 2020.   
+[8] P. Company, F. Naya, M. Contero, and J. Camba. On the role of geometric constraints to support design intent communication and model reusability. Computer-Aided Design and Applications, 2019.   
+[9] P. Dhariwal, H. Jun, C. Payne, J. W. Kim, A. Radford, and I. Sutskever. Jukebox: A generative model for music. arXiv preprint arXiv:2005.00341, 2020.   
+[10] D. Dori and K. Tombre. From engineering drawings to 3d CAD models: are we ready now? Computer-Aided Design, 1995.   
+[11] D. Dori and L. Wenyin. Automated cad conversion with the machine drawing understanding system: concepts, algorithms, and performance. SMC, 1999.   
+[12] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   
+[13] V. Egiazarian, O. Voynov, A. Artemov, D. Volkhonskiy, A. Safin, M. Taktasheva, D. Zorin, and E. Burnaev. Deep vectorization of technical drawings. In ECCV, 2020.   
+[14] Y. Ganin, T. Kulkarni, I. Babuschkin, S. A. Eslami, and O. Vinyals. Synthesizing programs for images using reinforced adversarial learning. In ICML, 2018.   
+[15] A. Holtzman, J. Buys, L. Du, M. Forbes, and Y. Choi. The curious case of neural text degeneration. arXiv preprint arXiv:1904.09751, 2019.   
+[16] S. Koch, A. Matveev, Z. Jiang, F. Williams, A. Artemov, E. Burnaev, M. Alexa, D. Zorin, and D. Panozzo. ABC: A big CAD model dataset for geometric deep learning. In CVPR, 2019.   
+[17] T. Kudo and J. Richardson. Sentencepiece: A simple and language independent subword tokenizer and detokenizer for neural text processing. arXiv preprint arXiv:1808.06226, 2018.   
+[18] A. Meurer, C. P. Smith, M. Paprocki, O. Certík, S. B. Kirpichev, M. Rocklin, A. Kumar, ˇ S. Ivanov, J. K. Moore, S. Singh, et al. SymPy: symbolic computing in Python. PeerJ Computer Science, 2017.   
+[19] T. Mikolov, M. Karafiát, L. Burget, J. Cernock ˇ y, and S. Khudanpur. Recurrent neural network \` based language model. In INTERSPEECH, 2010.   
+[20] V. Nagasamy and N. A. Langrana. Engineering drawing processing and vectorization system. CVGIP, 1990.   
+[21] C. Nash, Y. Ganin, S. A. Eslami, and P. Battaglia. PolyGen: An autoregressive generative model of 3D meshes. In ICML, 2020.   
+[22] Onshape developers. Onshape website. https://www.onshape.com/. Accessed: 2021-03-10.   
+[23] A. v. d. Oord, N. Kalchbrenner, O. Vinyals, L. Espeholt, A. Graves, and K. Kavukcuoglu. Conditional image generation with PixelCNN decoders. arXiv preprint arXiv:1606.05328, 2016.   
+[24] W. R. Para, S. F. Bhat, P. Guerrero, T. Kelly, N. Mitra, L. Guibas, and P. Wonka. SketchGen: Generating constrained CAD sketches. arXiv preprint arXiv:2106.02711, 2021.   
+[25] F. Pezoa, J. L. Reutter, F. Suarez, M. Ugarte, and D. Vrgoc. Foundations of JSON schema. In ˇ WWW, 2016.   
+[26] A. Radford, J. Wu, R. Child, D. Luan, D. Amodei, and I. Sutskever. Language models are unsupervised multitask learners. OpenAI blog, 2019.   
+[27] A. Ramesh, M. Pavlov, G. Goh, S. Gray, C. Voss, A. Radford, M. Chen, and I. Sutskever. Zero-shot text-to-image generation. arXiv preprint arXiv:2102.12092, 2021.   
+[28] M. Ranzato, S. Chopra, M. Auli, and W. Zaremba. Sequence level training with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015.   
+[29] A. Razavi, A. v. d. Oord, and O. Vinyals. Generating diverse high-fidelity images with VQVAE-2. arXiv preprint arXiv:1906.00446, 2019.   
+[30] P. Reddy, M. Gharbi, M. Lukac, and N. J. Mitra. Im2Vec: Synthesizing vector graphics without vector supervision. arXiv preprint arXiv:2102.02798, 2021.   
+[31] A. Seff, Y. Ovadia, W. Zhou, and R. P. Adams. Sketchgraphs: A large-scale dataset for modeling relational geometry in computer-aided design. arXiv preprint arXiv:2007.08506, 2020.   
+[32] K. Varda. Google protocol buffers: Google’s data interchange format. Technical report, 2008.   
+[33] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. arXiv preprint arXiv:1706.03762, 2017.   
+[34] P. Vaxiviere and K. Tombre. Celesstin: CAD conversion of mechanical drawings. Computer, 1992.   
+[35] O. Vinyals, M. Fortunato, and N. Jaitly. Pointer networks. In NeurIPS, 2015.   
+[36] K. D. Willis, Y. Pu, J. Luo, H. Chu, T. Du, J. G. Lambourne, A. Solar-Lezama, and W. Matusik. Fusion 360 gallery: A dataset and environment for programmatic CAD reconstruction. arXiv preprint arXiv:2010.02392, 2020.   
+[37] K. D. Willis, P. K. Jayaraman, J. G. Lambourne, H. Chu, and Y. Pu. Engineering sketch generation for computer-aided design. arXiv preprint arXiv:2104.09621, 2021.   
+[38] R. Wu, C. Xiao, and C. Zheng. DeepCAD: A deep generative network for computer-aided design models. In ICCV, 2021.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [No] The method presented in this work is a general machine learning framework and it is not immediately obvious how it could negatively impact the society.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No] The code is proprietary but may be open-sourced in the future. The dataset will be released shortly.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] The experiments in the paper are expensive to run. Moreover, we did not observe any significant fluctuations in the validation metrics between different training runs with the same hyperparameters.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] We use data coming from a publicly available platform and we give credit to the platform in the paper.   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]
+
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/z-X_PpwaroO/z-X_PpwaroO_content_list.json

@@ -0,0 +1,1228 @@
+[
+    {
+        "type": "text",
+        "text": "Computer-Aided Design as Language ",
+        "text_level": 1,
+        "bbox": [
+            271,
+            122,
+            727,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin1∗ Sergey Bartunov1 Yujia Li1 Ethan Keller2 Stefano Saliceti1 1DeepMind 2Onshape ",
+        "bbox": [
+            197,
+            199,
+            794,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            271,
+            535,
+            287
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Computer-Aided Design (CAD) applications are used in manufacturing to model everything from coffee mugs to sports cars. These programs are complex and require years of training and experience to master. A component of all CAD models particularly difficult to make are the highly structured 2D sketches that lie at the heart of every 3D construction. In this work, we propose a machine learning model capable of automatically generating such sketches. Through this, we pave the way for developing intelligent tools that would help engineers create better designs with less effort. The core of our method is a combination of a generalpurpose language modeling technique alongside an off-the-shelf data serialization protocol. Additionally, we explore several extensions allowing us to gain finer control over the generation process. We show that our approach has enough flexibility to accommodate the complexity of the domain and performs well for both unconditional synthesis and image-to-sketch translation. ",
+        "bbox": [
+            233,
+            303,
+            766,
+            483
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            507,
+            310,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Computer-Aided Design (CAD) is used in the production of most manufactured objects: from cars to robots to stents to power plants. CAD has replaced pencil drawings with precise computer sketches, enabling unparalleled precision, flexibility, and speed. Despite these improvements the CAD engineer must still develop, relate and annotate all the minutiae of their designs with the same attention to detail as their draftingtable forebears. CAD productivity might be improved by the careful application of machine learning to automate predictable design tasks and free the engineer to focus on the bigger picture. The flexibility and power of deep learning is uniquely suited to the complexity of design. ",
+        "bbox": [
+            174,
+            540,
+            531,
+            733
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sketches are at the heart of mechanical CAD. They are the skeleton from which three dimensional forms are made. A sketch consists of various geometric entities (e.g., lines, arcs, splines and circles) related by specific constraints such as tangency, perpendicularity and symmetry. Figure 1 illustrates how entities and constraints work in tandem to create well-defined shapes. Geometric entities lie on a single plane and together form enclosed regions used by subsequent construction operations such as lofts and extrusions to generate complex ",
+        "bbox": [
+            174,
+            739,
+            529,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/801c01a8f7ad74854fddf78e6c8c49c6d66b6df145afc636cd0e89cfc38f010b.jpg",
+        "image_caption": [
+            "Figure 1: The anatomy of a CAD sketch. Sketches are the main building block of every 3D construction. A sketch consists of entities (e.g., lines and arcs) and constraints (e.g., tangent and mirror). The dotted curve shows what happens if we drop some of the constraints — the design idea is lost. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            553,
+            515,
+            812,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/768010495993ed4419100a195bad75e3db43476e171ff7bd23282a293c1f8bdc.jpg",
+        "image_caption": [
+            "Figure 2: Interpreter-guided generation of a sketch. At each point in time, a Transformer [33] outputs a raw value which is fed into an interpreter that decides which field of a Protocol Buffers message this value corresponds to. Once the field is populated the interpreter communicates $( -  )$ its decision back to the Transformer and transitions $( \\nrightarrow )$ to the next state. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            108,
+            828,
+            377
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3D geometry. Well-chosen sketch constraints are essential to properly convey design intent [2] and facilitate the sketch’s resilience to successive parameters modifications which is often understood as a measure of the quality of a design document [8]. The dotted curve in Figure 1 shows what happens when some of the constraints are dropped – the design idea is lost. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            516
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The complexities of sketch construction are analogous to those of natural language modeling. Selecting the next constraint or entity in a sketch is like the generation of the next word in a sentence. In both contexts, the selection must function grammatically (form a consistent constraint system in the case of the sketch) and work towards some cohesive meaning (preserve design intent). Luckily, machine learning has proved highly successful in generating natural language — especially the Transformer [33] trained on vast amounts of real-world data [26, 6]. It is therefore a promising choice for adapting to the task of sketch generation. This work is our take at this adaptation. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            619
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We make the following contributions: (1) We devise a method for describing structured objects using Protocol Buffers [32] and demonstrate its flexibility on the domain of natural CAD sketches. (2) We propose several techniques for capturing distributions of objects represented as serialized Protocol Buffers. Our approach draws inspiration from recent advances in language modeling while focusing on eliminating data redundancy. (3) We collect a dataset of over $4 . 7 \\mathbf { M }$ of carefully preprocessed parametric CAD sketches and use this dataset to validate the proposed generative models. To our knowledge, the experiments presented in this work significantly surpass the scale of those reported in the literature both in terms of the amount of training data and the model capacity. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            737
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            760,
+            316,
+            776
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Datasets and generative models for CAD. Until recently there were very few parametric CAD datasets large and varied enough to serve as training data for machine learning. This situation had started to change with the release of the ABC dataset [16] containing a collection of 3D shapes from the Onshape public repository [22]. Unfortunately, the main focus of [16] revolves around meshes and, as a result, the dataset is difficult to use for sketch modeling. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Several works concurrent with ours deal with the symbolic representation of CAD constructions. Seff et al. [31] center their attention on contributing a better dataset of 2D sketches but also provide a proof-of-concept model predicting a selected subset of object attributes. Willis et al. [37] use the dataset from [31] to train a modification of [21] which demonstrates a boost in generation quality but is designed to only work for sketch entities. The latter is addressed in our present work and in a subsequent paper by Para et al. [24]. While [24] employ very similar ideas to ours they do not support certain features of the CAD data and their proposed model is a more direct adaptation of [21] and therefore cannot handle arbitrary orderings of entities and constraints. In Section 5, we show that object ordering has a substantial impact on the performance. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fusion 360 Gallery [36] attacks CAD data from a different angle. Here, the task is to recover a sequence of extrusion operations that gives rise to a particular target 3D shape. Despite dealing with 3D, this setting is deliberately limited: sketches are assumed to be given and the proposed model only decides on which sketch to extrude and to what extent. [38] considers a more general scenario where extrusion profiles are not provided and need to be synthesized from scratch. Although both of these works make initial steps towards full parametric CAD generation, they rely on significant simplifying assumptions and therefore it is unclear how well they will scale to more real-world scenarios. Our approach, on the other hand, is designed to be flexible and domain-agnostic and is only limited by the data availability. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            305
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Vector image generation and inference. Synthesizing CAD sketches bears a lot of similarities with predicting vector graphics. In this field, several recent works Carlier et al. [7] and Reddy et al. [30] using different vector object representations to define generative models of vector images. Egiazarian et al. [13] take a more traditional computer vision approach and propose a multi-stage pipeline for vectorizing technical drawings. All of these methods use highly domain-dependent architectures and, therefore, it would be a non-trivial task to adapt them for generation of complex sketch objects. CAD community has also been concerned with a similar task of image to CAD conversion [20, 34, 10, 11], largely focusing on heuristic object recognition while our work relies more on learning the recognition from data. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transformers for sequence modeling. In our work, we employ Transfomers [33] as a computational backbone for the proposed approach. Due to its scalability and excellent performance [29, 9, 6, 27], this architecture has become the dominating approach in many sequence modeling applications. Our method can be seen as generalization of PolyGen [21], a Transformer-based generative model for 3D meshes. Similarly to [21], we use Pointer Networks [35] to relate items in the synthesized sequence. Unlike PolyGen, however, our framework can handle non-homogeneous structures of arbitrary complexity. Moreover, we simplify the architecture to use a single neural network to generate the entire object of interest. All these improvements make our approach a good fit for modeling CAD sketches and potentially other components of CAD constructions. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Data ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            602,
+            245,
+            618
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, a CAD sketch is defined by two collections of objects: entities and constraints. Each object is generally represented as a set of attribute-value pairs where a value can be either primitive (e.g., integer or floating-point) or complex (e.g., an array or another object). Sketches that we use in this work originate from the Onshape platform [22] which provides them in JSON format [25]. As the first step in our processing pipeline we convert JSON messages into Protocol Buffers (PB) [32]. In order to keep the pipeline as domain-agnostic and as widely applicable as possible, we aim to avoid any significant changes to the data and largely retain the original structures of objects. The benefit of converting into PB is twofold: the resulting data occupies less space because unnecessary information is removed, but also, unlike JSON, PB provide a convenient way to define precise specifications for structures of arbitrary complexity. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            771
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Listing 1a shows how we represent the line entity and the mirror constraint (see Appendix A for an extensive list of supported objects). The line specification is straightforward: we first need to decide whether our entity should be treated as a construction geometry2 and then provide pairs of coordinates for the beginning and end of the segment. The MirrorConstraint is used to force an arbitrary number of pairs of geometries (i.e., mirrored_pairs) to be symmetrical with respect to some axis (i.e., mirror). Constraints rely on the Pointer data type to specify entities they act upon. In practice, a pointer is simply an index in the table of all the eligible pointees (i.e., entities and their parts). ",
+        "bbox": [
+            174,
+            777,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "message LineEntity { bool is_construction $\\ c = ~ 1$ ; message Vector $\\{ \\begin{array} { r l } \\end{array}  / / $ 2D coordinate. double $\\texttt { x } = \\texttt { 1 }$ ; double $\\tt { y } = 2$ ; } Vector start $= ~ 2$ ; // Start point. Vector end $\\ c = \\ 3$ ; // End point.   \n}   \nmessage MirrorConstraint { Pointer mirror $\\ c = ~ 1$ ; // Axis of symmetry. message Pair { // Mirrored objects. Pointer first $\\ l = \\ 1$ ; Pointer second $= ~ 2$ ; } repeated Pair mirrored_pairs $= ~ 2$ ;   \n} ",
+        "bbox": [
+            173,
+            95,
+            449,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            495,
+            102,
+            820,
+            203
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(a) Entities and constraints have similar structures. Pointers refer to entities that constraints are applied to. ",
+        "bbox": [
+            165,
+            215,
+            823,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "message Entity { oneof kind { LineEntity line $\\ l = \\ 1$ ; // And other entity types. }   \n}   \nmessage Object { oneof kind { Entity entity $\\ l = \\ 1$ ; Constraint constraint $= ~ 2$ ; }   \n}   \nmessage Constraint { // Defined similarly to Entity.   \n}   \nmessage Sketch { repeated Object objects $\\ c = ~ 1$ ;   \n} ",
+        "bbox": [
+            171,
+            237,
+            405,
+            311
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            495,
+            237,
+            730,
+            311
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            325,
+            428,
+            362
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            496,
+            325,
+            730,
+            362
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(b) A full sketch is defined as a sequence of objects each of which can be either an entity or a constraint. ",
+        "bbox": [
+            178,
+            368,
+            805,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Listing 1: Examples of object specifications. We represent objects using Protocol Buffers. Protocol Buffers allow us to easily write specifications for structured objects of varying complexity. ",
+        "bbox": [
+            173,
+            390,
+            823,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our ultimate goal is to build a machine learning model of sketch objects. To that end, we process the data even further and represent these objects as sequences of tokens. This allows us to pose sketch generation as language modeling (LM) and take advantage of the recent progress in this area [26, 6]. To achieve this, we pack first collections of entities and constraints into one Protocol Buffer message (see Listing 1b) assuming some ordering of objects. We discuss different orderings in Section 5. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            505
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "There are a few ways to obtaining a sequence of tokens from a sketch message. Arguably the most intuitive one is to format messages as text. For a line entity connecting (0.0, 0.1) and $( - 0 . 5 , 0 . 2 )$ this will result in: ",
+        "bbox": [
+            174,
+            511,
+            825,
+            553
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "{ is_construction: true, start { x: 0.0, y: 0.1 }, end { x: -0.5, y: 0.2 } } ",
+        "bbox": [
+            173,
+            563,
+            759,
+            578
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since this format contains both the structure and the content of the data, the resulting sequences end up being prohibitively long. Additionally, the model would have to generate valid syntax, which would take up some portion of the model’s capacity. To overcome these challenges, we work with two flavours of serialized PB messages. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The first one is a sequences of bytes obtained by calling the SerializeToString() method of a message. Such sequences are much shorter since the structure is handled by an external parser automatically generated from the data specification. The parser’s task is to interpret the incoming stream of unstructured bytes and populate the fields of PB messages. However, like the text format, not every sequence of bytes results in a valid PB message. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Going one step further, we can utilize the structure of the sketch format more directly, and build a custom interpreter, that takes as input a sequence of tokens each representing a valid choice at various decision steps [4] in the sketch creation process. We designed this interpreter in such a way that all sequences of tokens in this format lead to valid PB messages. More specifically, we represent a message as a sequence of triplets $( d _ { i } , c _ { i } , f _ { i } )$ where $i$ is an index of the token. The majority of tokens describe basic fields of the sketch objects with each token representing exactly one field. The first two positions in each triplet are allocated for a discrete value and a continuous value respectively. Since each field in a message is either discrete or continuous only one of two positions is active at a time (the other one is set to a default zero value). The third component is a boolean flag signifying the end of a repeated field3 which contains a list of elements of the same type. An example sequence for a sketch containing a line and a point placed at one of its ends is shown in Table 1 (Triplet column). ",
+        "bbox": [
+            174,
+            727,
+            825,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/adcfd069a5f960c85bcb146cfc971043babc429a1ecbc2eb31d46ce9af854b1e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Triplet</td><td>Field</td><td></td><td>Triplet</td><td>Field</td></tr><tr><td>1.</td><td>(0,0.0,False)</td><td>objects.kind</td><td>8. (0,0.0,False)</td><td>objects.kind</td></tr><tr><td>2.</td><td>(0,0.0,False)</td><td>entity.kind</td><td>9. (1, 0.0,False)</td><td>entity.kind</td></tr><tr><td>3.</td><td>(1,0.0,False)</td><td>line.is_constr</td><td>10. (0, 0.0,False)</td><td>Point point.is_const</td></tr><tr><td>4.</td><td>(0, 0.0,False)</td><td>line.start.x</td><td>11. (0, 0.0,False)</td><td>point .x</td></tr><tr><td>5.</td><td>(0,0.1,False)</td><td>line.start.y</td><td>12. (0,0.1,False)</td><td>point.y</td></tr><tr><td>6.</td><td>(0,-0.5,False)</td><td>line.end.x</td><td>13. (0, 0.0, True)</td><td>objects.kind</td></tr><tr><td>7.</td><td>(0, 0.2,False)</td><td>line.end.y</td><td></td><td></td></tr></table>",
+        "bbox": [
+            187,
+            87,
+            805,
+            207
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: A triplet representation of a simple sketch. The sketch contains and a line and a point. Within each triplet in the left column, the active component (the value that is actually used) is highlighted in bold. The right column shows which field of the object the triplet is associated with. ",
+        "bbox": [
+            174,
+            213,
+            825,
+            256
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given a sequence of such triplets, it is possible to infer which exact field each token corresponds to. Indeed, the very first token $( d _ { 1 } , c _ { 1 } , f _ { 1 } )$ is always associated with objects.kind since it is the first choice that needs to be made to create a Sketch message (see Listing 1b). The second field depends on the concrete value of $d _ { 1 }$ . If $d _ { 1 } = 0$ then the first object is an entity which means that the second token corresponds to entity.kind . The rest of the sequence is associated in a similar fashion. Field identifiers along with their locations within an object form the context of the tokens. We use this contextual information as an additional input for our machine learning models since it makes it easier to interpret the meaning of the triplet values and to be aware of the overall structure of the data. ",
+        "bbox": [
+            173,
+            265,
+            826,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            396,
+            259,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to estimate the distribution $p _ { \\mathrm { d a t a } }$ of 2D sketches in a dataset $\\mathcal { D }$ , we decompose the joint distribution over the sequence of tokens [19] $\\mathbf { t } = ( t _ { 1 } , \\ldots , t _ { N } )$ in an autoregressive fashion, representing each conditional with a neural network parameterized by $\\theta$ and pose the estimation of $p _ { \\mathrm { d a t a } }$ as maximization of the log-likelihood of $\\mathcal { D }$ , i.e., ",
+        "bbox": [
+            174,
+            426,
+            826,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec608e7217825af4fed5a80aef0f730b0d4ba8b8ae594a7120a0ecbefaf95868.jpg",
+        "text": "$$\np ( t ; \\theta ) = \\prod _ { i = 1 } ^ { N } p ( t _ { i } \\mid t _ { < i } ; \\theta ) , \\quad \\sum _ { t \\in \\mathcal { D } } \\log p ( t ; \\theta ) \\to \\operatorname* { m a x } _ { \\theta } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            489,
+            678,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $N$ is the length of the sequence and $t _ { < i }$ denotes all the tokens preceding $t _ { i }$ . ",
+        "bbox": [
+            173,
+            540,
+            709,
+            555
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "More concretely, we employ the Transformer decoder architecture [33] that takes an embedding of the token $\\pmb { e } _ { i - 1 } \\overset { \\cdot } { = } \\mathrm { e m b e d } _ { i } ^ { \\cdot } ( t _ { i - 1 } ^ { \\cdot } ) \\in \\mathbb { R } ^ { D }$ and maps it into another vector $\\boldsymbol { h } _ { i }$ of the same dimensionality. The latter is decoded into parameters of $p ( t _ { i } \\mid t _ { < i } )$ by a learned mapping $\\mathsf { d i s t } _ { i } ( \\cdot )$ .4 ",
+        "bbox": [
+            174,
+            560,
+            825,
+            603
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Byte representation When dealing with the bytes of a PB message, each token is simply a discrete value in the range $\\{ 0 , \\dots , 2 5 5 \\} \\cup \\{ \\bar { \\bf E 0 S } \\}$ and therefore $p ( t _ { i } \\mid t _ { < i } ; \\bar { \\theta ( \\mathbf { \\Sigma } ) }$ can be modeled as a categorical distribution similar to how it’s done in typical LM approaches [5]. In this setting, for each time step $i$ of the sequence we have ",
+        "bbox": [
+            173,
+            617,
+            825,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fc29416e72b54ccb357d9cd503c309b9320c76706fdd1e30b0d599d9e13d8fd0.jpg",
+        "text": "$$\n\\mathbf { e m b e d } _ { i } ( t _ { i - 1 } ) = V [ t _ { i - 1 } ] + e _ { i } ^ { \\mathrm { p o s } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            671,
+            609,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $[ \\cdot ]$ denotes the lookup operation and $e _ { i } ^ { \\mathrm { p o s } }$ is a position embedding for position $i$ . Both $V$ and $e _ { i } ^ { \\mathrm { p o s } }$ are learned. Moreover, $\\forall i \\ \\mathtt { d i s t } _ { i }$ is the same linear projection into $\\mathbb { R } ^ { 2 5 7 }$ (256 values and EOS) and the output is treated as logits of the distribution. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Triplet representation In case of the triplet representation, we follow a slightly more involved procedure. As outlined in Section 3, tokens can be either discrete or continuous. Additionally, different discrete tokens may have different ranges of values. For example, there are only two possible values for the object.kind token – either to an entity or a constraint. On the other hand, the range of the entity.kind token has cardinality of 4 since we support 4 different types of sketch entities. This means that we can’t naively describe each conditional in Equation 1 using the same template distribution like we did for the bytes. We circumvent this by introducing the notion of token groups. ",
+        "bbox": [
+            173,
+            755,
+            826,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A token group $\\mathcal { G }$ is a collection of related token types that can be handled in a similar fashion. Specifically, we use the same embedding function and the same projection for every $t$ such that ",
+        "bbox": [
+            174,
+            859,
+            825,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/023d60da6886256697dbccdb13316caf4b192be89fcc2c3abc16679bb42ccf08.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            87,
+            812,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(a) Unconditional byte model. ",
+        "bbox": [
+            243,
+            250,
+            428,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(b) Unconditional triplet model. ",
+        "bbox": [
+            560,
+            250,
+            759,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/6a078adb38e4e5126f04a58c9d202baf6dc4394bfc33aa9ce47e076d2e729d83.jpg",
+        "image_caption": [
+            "Figure 3: Synthesized sketches and data. (a)–(c) show samples from various proposed models (we use Nucleus Sampling with top- $p = 0 . 9 ,$ ). In (c), the output is rendered in a slightly thicker style. (d) demonstrates samples from the unconditional model after applying predicted constraints (the output is in blue). (e) shows examples from the dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            275,
+            803,
+            452
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$\\mathsf { t y p e } ( t ) \\in \\mathcal { G }$ . For instance, we might want to group all the tokens associated with coordinates. In the example from Table 1, tokens with indices 4–7 and 11–12 will all end up in the same $\\mathcal { G } ^ { 5 }$ . Naturally, we use the same functional form for the output distribution $p ( t _ { i } \\mid t _ { < i } ; \\boldsymbol { \\theta } )$ within each group. ",
+        "bbox": [
+            174,
+            529,
+            823,
+            571
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We embed $t _ { i - 1 }$ that belongs to the group $\\mathcal { G }$ as (note the difference with Equation 2): ",
+        "bbox": [
+            176,
+            577,
+            725,
+            593
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6187811b2facd16f51c3ced7cc3f023802faef96c81beb2f67c43a83b0629102.jpg",
+        "text": "$$\nK [ \\mathbf { f i e l d } ( t _ { i - 1 } ) ] + V ^ { \\mathcal { G } } [ t _ { i - 1 } ] + e _ { n } ^ { \\mathrm { o b j } } + e _ { m } ^ { \\mathrm { r e l } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            599,
+            643,
+            621
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where field $( t )$ returns the field of $t$ (e.g., objects.kind or line.start. $\\mathtt { x }$ ) and $K$ is a collection of learnable embeddings for every possible field type. Unlike in Equation 2, instead of using global position embedding eposi w e describe the location with the index $n$ of the current object as well as the relative position $m$ of $t _ { i - 1 }$ within an object. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            686
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We handle the “end” tokens (i.e., $f _ { i } = \\mathrm { T r u e } )$ similarly to EOS in Section 4 — the output projection produces an additional logit used to compute the probability of ending the repetition. Since $f _ { i }$ is only expected to be True at particular points in the sequence (i.e., right after tokens forming a whole element of the list) we mask out the extra logit everywhere else. This ensures that the “end” token can’t be predicted prematurely and also eliminates its unnecessary contribution to the optimized objective. ",
+        "bbox": [
+            173,
+            690,
+            825,
+            775
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "One significant difference between the byte setting and the triplet setting is how we process pointer fields. In the former, pointers do not get any special treatment and are generated just like any other integer field. We rely on the model’s capability to make sense of the entity part index and relate it to the corresponding locations in the sequence via attention weights. This seems to be a viable strategy since Transformers have demonstrated an impressive referencing capacity in recent works [6]. ",
+        "bbox": [
+            174,
+            781,
+            825,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since the triplet representation provides us with direct access to the semantics of tokens it’s possible to relate pointers to their pointees more explicitly by using Pointer Networks [35]. The approach we are taking here is similar to [21]. In order to compute $p ( t _ { i } \\mid t _ { < i } ; \\theta )$ , we first project the output of the Transformer $\\boldsymbol { h } _ { i }$ into the final pointer vector $p _ { i } = { W _ { \\mathrm { p t r } } h _ { i } }$ . The conditional is then obtained as follows: ",
+        "bbox": [
+            178,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9ac78d8e1391073d825dc80ed6a0c040b7b3d2ab49408020279bca3188d51aef.jpg",
+        "text": "$$\n\\begin{array} { r } { p ( t _ { i } \\mathrm { ~ p o i n t s ~ t o ~ } t _ { i k } \\mid t _ { < i } ; \\theta ) = \\mathrm { s o f t m a x } _ { k } ( \\pmb { p } _ { i } ^ { T } H _ { i } ) , \\quad H _ { i } = [ \\pmb { h } _ { i 1 } , \\dots , \\pmb { h } _ { i k } , \\dots , \\pmb { h } _ { i M } ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            135,
+            766,
+            154
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\operatorname { s o f t m a x } _ { k }$ is the $k$ -th element of the softmax vector and $\\boldsymbol { r } _ { i } = \\{ t _ { i 1 } , . . . , t _ { i M } \\}$ is the set of tokens that $t _ { i }$ can point to. Naturally, $\\mathbf { \\nabla } _ { \\mathbf { r } _ { i } }$ only contains tokens from $t _ { < i }$ . This is different from [35, 21] where $\\textstyle r _ { i } \\equiv r$ is external to the predicted sequence and remains immutable throughout the generation process. ",
+        "bbox": [
+            174,
+            155,
+            825,
+            210
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Onshape, constraints can be applied not only to whole entities but also to their subparts (e.g., the center of a circle or the end points of a line segment). To handle this, we introduce special referrable tokens decoupling pointees from the object attribute tokens. Referrables are injected after each entity and have the same identifier within each entity type. In order to let the model distinguish between different subparts, we adjust Equation 3 to use a learnable embedding of a part index instead of $V ^ { \\mathcal { G } } [ t _ { i - 1 } ]$ . As referrable tokens do not need to be predicted the respective terms are removed from Equation 1. For the same reason, in Equation 4, $\\boldsymbol { h } _ { i k }$ corresponds to the time step where $t _ { i k }$ is the output and not the input. This allows us to avoid having unused Transformer outputs. ",
+        "bbox": [
+            173,
+            217,
+            825,
+            329
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we need to specify how we embed pointers as inputs to the Transformer network. Following [35, 21] we could reuse $h _ { j }$ for tokens that point to $t _ { j }$ . Unfortunately, this creates output-to-input connections which are extremely detrimental to the efficiency of the Transformer architecture — different time steps can no longer be processed in parallel during training. Instead, we opt for a simpler solution and employ the standard embedding scheme for discrete tokens (Equation 3). ",
+        "bbox": [
+            174,
+            334,
+            825,
+            405
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Sampling from the model Sampling from the byte model is identical to sampling from any typical Transformer-based LM. The triplet model, on the other hand, requires slightly more bespoke handling. Figure 2 illustrates the procedure. We start by embedding and feeding a special BOS token into the Transformer. The Transformer then outputs a collection of triplets, one for each possible token group. In order to determine which concrete token needs to be emitted, we employ an interpreter (a state machine) automatically generated from the data specification. Knowing the current state allows us to choose the right token group and associate the active component of the triplet with a field in the synthesized object. Once the appropriate field is populated the interpreter transitions to the next state and produces an output token which is then fed back into the model. The process stops when the state machine receives the “end” triplet for the outermost repeated field (i.e., object.kind ). ",
+        "bbox": [
+            174,
+            417,
+            826,
+            556
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Conditional generation In addition to the unconditional model described above, we explore a variant that allows us to translate bitmaps into sketches. Here, we simply let the main Transformer cross-attend to the features extracted from the input image by a ViT network [12]. The specific setup is detailed in Appendix C. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            626
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            645,
+            312,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We validate our proposed approaches on the data that we obtained from the repository of documents publicly available on the Onshape platform [22]. Following the standard evaluation methodology for autoregressive generative models [23, 21] we use log-likelihood as our primary quantitative metric. Additionally, we provide a variety of random and selected model samples for qualitative assessment (Figure 3). ",
+        "bbox": [
+            174,
+            675,
+            485,
+            800
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dataset Unlike the majority of the existing works dealing with CAD sketch generation [31, 37, 24] we do not rely on SketchGraphs [31]. Instead, we collect the largest to date dataset of engineering sketches addressing the main disadvantage of [31], severe data duplication. The acquisition and the filtering procedures ",
+        "bbox": [
+            174,
+            814,
+            485,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/5a1941415669c09e1aee337475dc0e5a8eb38b2c564fb3b3ad2734d5a4aa2c1a.jpg",
+        "table_caption": [
+            "Table 2: Test likelihoods of various models. The object column is computed as the average number of bits per object in a sketch averaged across test examples. The sketch column is similar except we do not divide by the number of objects. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\"> Sequence</td><td colspan=\"2\">Average bits per</td></tr><tr><td>object</td><td>sketch</td></tr><tr><td>Uniform</td><td>unord. bytes</td><td>112.23</td><td>3683.56</td></tr><tr><td></td><td>unord. triplets</td><td>25.34</td><td>847.52</td></tr><tr><td>Text</td><td>interleaved</td><td>4.622</td><td>139.687</td></tr><tr><td>Byte</td><td>concatenated</td><td>4.381</td><td>132.621</td></tr><tr><td rowspan=\"3\">Triplet</td><td>interleaved</td><td>4.252</td><td>127.495</td></tr><tr><td>concatenated</td><td>4.218</td><td>127.913</td></tr><tr><td>interleaved</td><td>4.103</td><td>123.213</td></tr><tr><td>Cond.</td><td>interleaved</td><td>1.570</td><td>53.730</td></tr></table>",
+        "bbox": [
+            500,
+            650,
+            821,
+            832
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/2059d907b811a8da4ce130202c27c31b776e49951b3446b4a44e0a7efa04fa39.jpg",
+        "image_caption": [
+            "Figure 4: Distribution of various sketch statistics for samples drawn from our unconditional models. The top- $p$ parameter for Nucleus Sampling is shown in parentheses. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            92,
+            816,
+            208
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "are detailed in Appendix D. For our experiments we split the dataset randomly into 3 parts: 4,656,607   \nexamples for the training set and 50,000 sketches for each the validation and the test set.6 ",
+        "bbox": [
+            176,
+            261,
+            825,
+            289
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Unconditional generation. In this series of experiments, the goal is to determine how well our models capture the distribution of sketches in the dataset. We use the same network architecture for both the byte and the triplet settings.7 We compare two orderings of objects: in the first one (concatenated), constraints go after the last entity while in the second (interleaved), a constraint object is injected immediately after the entities it operates on. In both cases, the relative orderings within both the sequence of entities and the sequence of constraints are taken directly from the original JSON messages. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            405
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows test log-likelihoods obtained by different models. Unsurprisingly, our proposed methods (rows 4–7) significantly outperform the weak baselines (rows 1–2). The difference between the two uniform settings is due to the fact that the byte description of a PB message is usually longer than the triplet one: $2 3 9 \\nu s . 4 5 6$ tokens on average with the maximum length of 959 vs. 1987. Additionally, the tokens in the triplet representation tend to have smaller range of values $( i . e . , < 2 5 7 )$ ). ",
+        "bbox": [
+            174,
+            410,
+            825,
+            481
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "These differences between representations may partially explain why triplet models demonstrate better performance on the hold-out test set. It’s also worth emphasizing that the byte model does not receive any explicit information about the parsing state. This seem to make learning more challenging and as a result compared to the triplet model it takes roughly 3 times more network updates to reach the highest data likelihood on the validation. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            556
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another important factor affecting the performance of the models is the choice of the object ordering. As it is evident from Table 2, the interleaved ordering consistently leads to better results. One explanation for this is that at any point in time, the model has more explicit information about the relations between the sketch entities produced so far. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            617
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the row 3 of Table 2, we also provide the test log-likelihood for a conventional language modeling baseline trained on the text representation of PB messages (see Section 3). Here, we employ the SentencePiece tokenizer [17] with fairly aggressive settings (8000 words in the vocabulary; splitting at whitespaces switched off) to be able to keep the sequences within the budget of 1024 tokens. As can be seen from the table, the resulting Transformer model (of exactly the same architecture as other entries) despite being better than the uniform baselines is still substantially worse than the proposed methods. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            720
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In addition to measuring likelihoods, we sampled 10,000 sketches from the best performing byte and triplet models and computed distributions of various high-level statistics (Figure 4 and Figure 6 in the appendix). We repeated this procedure both with and without using Nucleus Sampling (NS) [15]. Both models follow the data distribution closely when we use samples from the unmodified model output. In this setting, however, a significant fraction of sketches is either malformed (e.g., the generated PB message cannot be parsed) or unsolvable: $3 6 \\%$ for the byte model and $1 4 \\%$ for the triplet model. NS with top- $p = 0 . 9$ skews the sample distribution and seems to have a more pronounced negative effect on the byte model. The upside is that the resulting sketches become “cleaner”: the percentage of invalid samples goes down to $2 5 \\%$ and $6 \\%$ for the byte and the triplet settings respectively. ",
+        "bbox": [
+            173,
+            728,
+            826,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/5d620b9ee341dd09d6ee279fd7943e89afcaaee0b870754354379fa1d011f84b.jpg",
+        "image_caption": [
+            "Figure 5: Entities and constraints sampled from the unconditional (top) and the conditional (bottom) triplet models. The first column of nodes represents different entities (all parts are folded into a single node). The order of nodes (top to bottom) follows the generation order. The second column represents different constraints also ordered by their index in the sequence. Finally, the third column is reserved for constraint types, from the most to the least frequent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            89,
+            813,
+            386
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figures 3a and 3b show renders of random samples from several proposed models. Overall, generated sketches look plausible and exhibit a lot of desired properties: closedness of regions, regularity, symmetry, a non-trivial amount of fine detail. We observe that the byte model produces slightly less complex samples with fewer open arcs but this could be a side effect of a particular top- $p$ value. We also note that the model does not always synthesize sensible sketches — just like any other typical autoregressive model trained with teacher forcing it suffers from not being able to recover from mistakes made early on in the sequence [28]. This can potentially be addressed by fine-tuning using, for example, reinforcement learning. ",
+        "bbox": [
+            173,
+            496,
+            825,
+            608
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We show a more detailed sample from the triplet model in Figure 5. While not perfect, the inferred constraints are reasonable most of the time. The model does a good job at connecting entities using Coincident constraints but also successfully detects more complex relations spanning more than two primitives (e.g., Mirror). Having access to constraints gives us opportunity to correct mistakes in entity prediction by applying an external sketch solver (see Figure 3d). Although this aspect of sketching was not the main focus of this work, we believe that a tighter integration between the model and the CAD software will lead to a significant boost in generation quality. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            710
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Conditional generation. As discussed in Section 4, we also trained an image-conditional model using the same regime as for the unconditional one. As expected, it achieves a significantly better fit (the last row of Table 2) but at the same time retains a non-trivial amount of uncertainty. The latter is arising, in particular, from the fact that different permutations of entities result in the same rendered image. Image-conditional samples can be found in Figure 3c. The model was able to nearly perfectly reconstruct simpler sketches and mostly made mistakes in the presence of a large number of fine details. Additionally, we compared our system against the nearest neighbour baseline in terms of visual reconstruction error as measured by Chamfer distance. We found that the proposed method reduces the error by $\\approx 8 0 \\%$ (see Appendix H). In order to test the out-of-distribution performance, we supply the model with several custom-made drawings. Surprisingly, after minor post-processing to account for the short sequence bias the system manages to produce reasonable reconstructions (see the bottom example in Figure 5). We detail this experiment in Appendix I. ",
+        "bbox": [
+            173,
+            744,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            89,
+            294,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have demonstrated how a combination of a general-purpose language modeling technique alongside an off-the-shelf data serialization protocol can be used to effectively solve generation of complex structured objects. We showcased the proposed system on the domain of 2D CAD drawings and developed models that can synthesize geometric primitives and relations between them both unconditionally as well as using a bitmap as a reference. These are only initial proof-of-concept experiments and we are hoping to see more applications taking advantage of the flexibility of the developed interface: conditioning on various sketch properties, inferring constraints given entities and automatically completing drawings, to name a few. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Although we focused our attention on a particular dataset we argue that the approach described in this paper is largely domain-agnostic. In order to adapt the system to a new kind of data, the algorithm designer only needs to provide an appropriate Protocol Buffer specification and if the PB language is too restrictive one can always replace it with a more powerful interpreter. As a straightforward direction for future work, we can consider extending the method to handle 3D. In Onshape, 3D operations bear a lot of similarities with sketch constraints — just like constraints, they can be represented as nested messages containing references to the geometries existing in the scene. Thus, most of the ideas from the present work can be taken verbatim to this new setting. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We hope that this work will serve as a stepping stone for further advances in the field of automated CAD but also inspire new ideas and approaches to generative modeling of arbitrary structured data. ",
+        "bbox": [
+            173,
+            354,
+            823,
+            383
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            401,
+            553,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank Charlie Nash, Georg Ostrovski, and Adam Kosiorek for helping with the manuscript preparation as well as Igor Babuschkin, David Choi, Nate Kushman, Andrew Kimpton, Jake Rosenfeld, Lana Saksonov, John Rousseau, Greg Guarriello, Andy Brock, Francesco Nori, Aäron van den Oord, and Oriol Vinyals for insightful discussions and support. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "YG, SB, YL, and SS are funded by DeepMind. EK is funded by PTC. ",
+        "bbox": [
+            174,
+            494,
+            630,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            530,
+            266,
+            546
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] J. Alakuijala, A. Farruggia, P. Ferragina, E. Kliuchnikov, R. Obryk, Z. Szabadka, and L. Vandevenne. Brotli: A general-purpose data compressor. TOIS, 2018.   \n[2] H. K. Ault. Using geometric constraints to capture design intent. JGG, 1999.   \n[3] H. G. Barrow, J. M. Tenenbaum, R. C. Bolles, and H. C. Wolf. Parametric correspondence and chamfer matching: Two new techniques for image matching. Technical report, SRI INTERNATIONAL MENLO PARK CA ARTIFICIAL INTELLIGENCE CENTER, 1977.   \n[4] R. Bavishi, C. Lemieux, R. Fox, K. Sen, and I. Stoica. AutoPandas: Neural-backed generators for program synthesis. In OOPSLA, 2019.   \n[5] Y. Bengio, R. Ducharme, P. Vincent, and C. Janvin. A neural probabilistic language model. JMLR, 2003.   \n[6] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   \n[7] A. Carlier, M. Danelljan, A. Alahi, and R. Timofte. DeepSVG: A hierarchical generative network for vector graphics animation. arXiv preprint arXiv:2007.11301, 2020.   \n[8] P. Company, F. Naya, M. Contero, and J. Camba. On the role of geometric constraints to support design intent communication and model reusability. Computer-Aided Design and Applications, 2019.   \n[9] P. Dhariwal, H. Jun, C. Payne, J. W. Kim, A. Radford, and I. Sutskever. Jukebox: A generative model for music. arXiv preprint arXiv:2005.00341, 2020.   \n[10] D. Dori and K. Tombre. From engineering drawings to 3d CAD models: are we ready now? Computer-Aided Design, 1995.   \n[11] D. Dori and L. Wenyin. Automated cad conversion with the machine drawing understanding system: concepts, algorithms, and performance. SMC, 1999.   \n[12] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   \n[13] V. Egiazarian, O. Voynov, A. Artemov, D. Volkhonskiy, A. Safin, M. Taktasheva, D. Zorin, and E. Burnaev. Deep vectorization of technical drawings. In ECCV, 2020.   \n[14] Y. Ganin, T. Kulkarni, I. Babuschkin, S. A. Eslami, and O. Vinyals. Synthesizing programs for images using reinforced adversarial learning. In ICML, 2018.   \n[15] A. Holtzman, J. Buys, L. Du, M. Forbes, and Y. Choi. The curious case of neural text degeneration. arXiv preprint arXiv:1904.09751, 2019.   \n[16] S. Koch, A. Matveev, Z. Jiang, F. Williams, A. Artemov, E. Burnaev, M. Alexa, D. Zorin, and D. Panozzo. ABC: A big CAD model dataset for geometric deep learning. In CVPR, 2019.   \n[17] T. Kudo and J. Richardson. Sentencepiece: A simple and language independent subword tokenizer and detokenizer for neural text processing. arXiv preprint arXiv:1808.06226, 2018.   \n[18] A. Meurer, C. P. Smith, M. Paprocki, O. Certík, S. B. Kirpichev, M. Rocklin, A. Kumar, ˇ S. Ivanov, J. K. Moore, S. Singh, et al. SymPy: symbolic computing in Python. PeerJ Computer Science, 2017.   \n[19] T. Mikolov, M. Karafiát, L. Burget, J. Cernock ˇ y, and S. Khudanpur. Recurrent neural network \\` based language model. In INTERSPEECH, 2010.   \n[20] V. Nagasamy and N. A. Langrana. Engineering drawing processing and vectorization system. CVGIP, 1990.   \n[21] C. Nash, Y. Ganin, S. A. Eslami, and P. Battaglia. PolyGen: An autoregressive generative model of 3D meshes. In ICML, 2020.   \n[22] Onshape developers. Onshape website. https://www.onshape.com/. Accessed: 2021-03-10.   \n[23] A. v. d. Oord, N. Kalchbrenner, O. Vinyals, L. Espeholt, A. Graves, and K. Kavukcuoglu. Conditional image generation with PixelCNN decoders. arXiv preprint arXiv:1606.05328, 2016.   \n[24] W. R. Para, S. F. Bhat, P. Guerrero, T. Kelly, N. Mitra, L. Guibas, and P. Wonka. SketchGen: Generating constrained CAD sketches. arXiv preprint arXiv:2106.02711, 2021.   \n[25] F. Pezoa, J. L. Reutter, F. Suarez, M. Ugarte, and D. Vrgoc. Foundations of JSON schema. In ˇ WWW, 2016.   \n[26] A. Radford, J. Wu, R. Child, D. Luan, D. Amodei, and I. Sutskever. Language models are unsupervised multitask learners. OpenAI blog, 2019.   \n[27] A. Ramesh, M. Pavlov, G. Goh, S. Gray, C. Voss, A. Radford, M. Chen, and I. Sutskever. Zero-shot text-to-image generation. arXiv preprint arXiv:2102.12092, 2021.   \n[28] M. Ranzato, S. Chopra, M. Auli, and W. Zaremba. Sequence level training with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015.   \n[29] A. Razavi, A. v. d. Oord, and O. Vinyals. Generating diverse high-fidelity images with VQVAE-2. arXiv preprint arXiv:1906.00446, 2019.   \n[30] P. Reddy, M. Gharbi, M. Lukac, and N. J. Mitra. Im2Vec: Synthesizing vector graphics without vector supervision. arXiv preprint arXiv:2102.02798, 2021.   \n[31] A. Seff, Y. Ovadia, W. Zhou, and R. P. Adams. Sketchgraphs: A large-scale dataset for modeling relational geometry in computer-aided design. arXiv preprint arXiv:2007.08506, 2020.   \n[32] K. Varda. Google protocol buffers: Google’s data interchange format. Technical report, 2008.   \n[33] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. arXiv preprint arXiv:1706.03762, 2017.   \n[34] P. Vaxiviere and K. Tombre. Celesstin: CAD conversion of mechanical drawings. Computer, 1992.   \n[35] O. Vinyals, M. Fortunato, and N. Jaitly. Pointer networks. In NeurIPS, 2015.   \n[36] K. D. Willis, Y. Pu, J. Luo, H. Chu, T. Du, J. G. Lambourne, A. Solar-Lezama, and W. Matusik. Fusion 360 gallery: A dataset and environment for programmatic CAD reconstruction. arXiv preprint arXiv:2010.02392, 2020.   \n[37] K. D. Willis, P. K. Jayaraman, J. G. Lambourne, H. Chu, and Y. Pu. Engineering sketch generation for computer-aided design. arXiv preprint arXiv:2104.09621, 2021.   \n[38] R. Wu, C. Xiao, and C. Zheng. DeepCAD: A deep generative network for computer-aided design models. In ICCV, 2021. ",
+        "bbox": [
+            179,
+            554,
+            828,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            55,
+            828,
+            914
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            371
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            396,
+            254,
+            412
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            422,
+            339,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [No] The method presented in this work is a general machine learning framework and it is not immediately obvious how it could negatively impact the society.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            441,
+            825,
+            560
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            564,
+            493,
+            579
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            583,
+            738,
+            614
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            618,
+            393,
+            632
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No] The code is proprietary but may be open-sourced in the future. The dataset will be released shortly.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] The experiments in the paper are expensive to run. Moreover, we did not observe any significant fluctuations in the validation metrics between different training runs with the same hyperparameters.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            637,
+            825,
+            797
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            218,
+            801,
+            823,
+            816
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We use data coming from a publicly available platform and we give credit to the platform in the paper.   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] ",
+        "bbox": [
+            238,
+            820,
+            825,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            236,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            123,
+            705,
+            138
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            142,
+            826,
+            232
+        ],
+        "page_idx": 12
+    }
+]