Add files using upload-large-folder tool

parse/train/-QxT4mJdijq/-QxT4mJdijq.md

@@ -0,0 +1,439 @@
+# META-LEARNING SYMMETRIES BY REPARAMETERIZATION
+
+Allan Zhou, Tom Knowles, Chelsea Finn Dept of Computer Science, Stanford University {ayz,tknowles,cbfinn}@stanford.edu
+
+# ABSTRACT
+
+Many successful deep learning architectures are equivariant to certain transformations in order to conserve parameters and improve generalization: most famously, convolution layers are equivariant to shifts of the input. This approach only works when practitioners know the symmetries of the task and can manually construct an architecture with the corresponding equivariances. Our goal is an approach for learning equivariances from data, without needing to design custom task-specific architectures. We present a method for learning and encoding equivariances into networks by learning corresponding parameter sharing patterns from data. Our method can provably represent equivariance-inducing parameter sharing for any finite group of symmetry transformations. Our experiments suggest that it can automatically learn to encode equivariances to common transformations used in image processing tasks. We provide our experiment code at https: //github.com/AllanYangZhou/metalearning-symmetries.
+
+# 1 INTRODUCTION
+
+In deep learning, the convolutional neural network (CNN) (LeCun et al., 1998) is a prime example of exploiting equivariance to a symmetry transformation to conserve parameters and improve generalization. In image classification (Russakovsky et al., 2015; Krizhevsky et al., 2012) and audio processing (Graves and Jaitly, 2014; Hannun et al., 2014) tasks, we may expect the layers of a deep network to learn feature detectors that are translation equivariant: if we translate the input, the output feature map is also translated. Convolution layers satisfy translation equivariance by definition, and produce remarkable results on these tasks. The success of convolution’s “built in” inductive bias suggests that we can similarly exploit other equivariances to solve machine learning problems.
+
+However, there are substantial challenges with building in inductive biases. Identifying the correct biases to build in is challenging, and even if we do know the correct biases, it is often difficult to build them into a neural network. Practitioners commonly avoid this issue by “training in” desired equivariances (usually the special case of invariances) using data augmentation. However, data augmentation can be challenging in many problem settings and we would prefer to build the equivariance into the network itself. For example, robotics sim2real transfer approaches train agents that are robust to varying conditions by varying the simulated environment dynamics (Song et al., 2020). But this type of augmentation is not possible once the agent leaves the simulator and is trying to learn or adapt to a new task in the real world. Additionally, building in incorrect biases may actually be detrimental to final performance (Liu et al., 2018b).
+
+In this work we aim for an approach that can automatically learn and encode equivariances into a neural network. This would free practitioners from having to design custom equivariant architectures for each task, and allow them to transfer any learned equivariances to new tasks. Neural network layers can achieve various equivariances through parameter sharing patterns, such as the spatial parameter sharing of standard convolutions. In this paper we reparameterize network layers to learnably represent sharing patterns. We leverage meta-learning to learn the sharing patterns that help a model generalize on new tasks.
+
+The primary contribution of this paper is an approach to automatically learn equivariance-inducing parameter sharing, instead of using custom designed equivariant architectures. We show theoretically that reparameterization can represent networks equivariant to any finite symmetry group. Our experiments show that meta-learning can recover various convolutional architectures from data, and learn invariances to common data augmentation transformations.
+
+# 2 RELATED WORK
+
+A number of works have studied designing layers with equivariances to certain transformations such as permutation, rotation, reflection, and scaling (Gens and Domingos, 2014; Cohen and Welling, 2016; Zaheer et al., 2017; Worrall et al., 2017; Cohen et al., 2019; Weiler and Cesa, 2019; Worrall and Welling, 2019). These approaches focus on manually constructing layers analagous to standard convolution, but for other symmetry groups. Rather than building symmetries into the architecture, data augmentation (Beymer and Poggio, 1995; Niyogi et al., 1998) trains a network to satisfy them. Diaconu and Worrall (2019) use a hybrid approach that pre-trains a basis of rotated filters in order to define roto-translation equivariant convolution. Unlike these works, we aim to automatically build in symmetries by acquiring them from data.
+
+Our approach is motivated in part by theoretical work characterizing the nature of equivariant layers for various symmetry groups. In particular, the analysis of our method as learning a certain kind of convolution is inspired by Kondor and Trivedi (2018), who show that under certain conditions all linear equivariant layers are (generalized) convolutions. Shawe-Taylor (1989) and Ravanbakhsh et al. (2017) analyze the relationship between desired symmetries in a layer and symmetries of the weight matrix. Ravanbakhsh et al. (2017) show that we can make a layer equivariant to the permutation representation of any discrete group through a corresponding parameter sharing pattern in the weight matrix. From this perspective, our reparameterization is a way of representing possible parameter sharing patterns, and the training procedure aims to learn the correct parameter sharing pattern that achieves a desired equivariance.
+
+Prior work on automatically learning symmetries include methods for learning invariances in Gaussian processes (van der Wilk et al., 2018) and learning symmetries of physical systems (Greydanus et al., 2019; Cranmer et al., 2020). Another very recent line of work has shown that more general Transformer (Vaswani et al., 2017) style architectures can match or outperform traditional CNNs on image tasks, without baking in translation symmetry (Dosovitskiy et al., 2020). Their results suggest that Transformer architectures can automatically learn symmetries and other inductive biases from data, but typically only with very large training datasets. One can also consider automatic data augmentation strategies (Cubuk et al., 2018; Lorraine et al., 2019) as a way of learning symmetries, though the symmetries are not embedded into the network in a transferable way. Concurrent work by Benton et al. (2020) aims to learn invariances from data by learning distributions over transformations of the input, similar to learned data augmentation. Our method aims to learn parameter sharing of the layer weights which induces equivariance. Additionally, our objective for learning symmetries is driven directly by generalization error (in a meta-learning framework), while the objective in Benton et al. (2020) adds a regularizer to the training loss to encourage symmetry learning.
+
+Our work is related to neural architecture search (Zoph and Le, 2016; Brock et al., 2017; Liu et al., 2018a; Elsken et al., 2018), which also aims to automate part of the model design process. Although architecture search methods are varied, they are generally not designed to exploit symmetry or learn equivariances. Evolutionary methods for learning both network weights and topology (Stanley and Miikkulainen, 2002; Stanley et al., 2009) are also not motivated by symmetry considerations.
+
+Our method learns to exploit symmetries that are shared by a collection of tasks, a form of metalearning (Thrun and Pratt, 2012; Schmidhuber, 1987; Bengio et al., 1992; Hochreiter et al., 2001). We extend gradient based meta-learning (Finn et al., 2017; Li et al., 2017; Antoniou et al., 2018) to separately learn parameter sharing patterns (which enforce equivariance) and actual parameter values. Separately representing network weights in terms of a sharing pattern and parameter values is a form of reparameterization. Prior work has used weight reparameterization in order to “warp” the loss surface (Lee and Choi, 2018; Flennerhag et al., 2019) and to learn good latent spaces (Rusu et al., 2018) for optimization, rather than to encode equivariance. HyperNetworks (Ha et al., 2016; Schmidhuber, 1992) generate network layer weights using a separate smaller network, which can be viewed as a nonlinear reparameterization, albeit not one that encourages learning equivariances. Modular meta-learning (Alet et al., 2018) is a related technique that aims to achieve combinatorial generalization on new tasks by stacking meta-learned “modules,” each of which is a neural network.
+
+This can be seen as parameter sharing by re-using and combining modules, rather than using our layerwise reparameterization.
+
+# 3 PRELIMINARIES
+
+In Sec. 3.1, we review gradient based meta-learning, which underlies our algorithm. Sections 3.2 and 3.3 build up a formal definition of equivariance and group convolution (Cohen and Welling, 2016), a generalization of standard convolution which defines equivariant operations for other groups such as rotation and reflection. These concepts are important for a theoretical understanding of our work as a method for learning group convolutions in Sec. 4.2.
+
+# 3.1 GRADIENT BASED META-LEARNING
+
+Our method is a gradient-based meta-learning algorithm that extends MAML (Finn et al., 2017), which we briefly review here. Suppose we have some task distribution $p ( \mathcal { T } )$ , where each task dataset is split into training and validation datasets $\{ \mathcal { D } _ { i } ^ { t r } , \mathcal { D } _ { i } ^ { v a l } \}$ . For a model with parameters $\theta$ , loss $\mathcal { L }$ , and learning rate $\alpha$ , the “inner loop” updates $\theta$ on the task’s training data: $\theta ^ { \prime } = \theta - \alpha \nabla _ { \theta } \mathcal { L } ( \theta , \mathcal { D } ^ { t r } )$ . In the “outer loop,” MAML meta-learns a good initialization $\theta$ by minimizing the loss of $\theta ^ { \prime }$ on the task’s validation data, with updates of the form meta-learning the inner loop initialization $\theta \gets \theta - \eta \frac { \mathrm { d } } { \mathrm { d } \theta } \mathcal { L } ( \theta ^ { \prime } , \mathcal { D } ^ { v a l } )$ . Although MAML focuses ona to meta-learning other things $\theta$   
+such as the inner learning rate $\alpha$ . In our method, we meta-learn a parameter sharing pattern at each layer that maximizes performance across the task distribution.
+
+# 3.2 GROUPS AND GROUP ACTIONS
+
+Symmetry and equivariance is usually studied in the context of groups and their actions on sets; refer to Dummit and Foote (2004) for more comprehensive coverage. A group $G$ is a set closed under some associative binary operation, where there is an identity element and each element has an inverse. Consider the group $( \mathbb { Z } , + )$ (the set of integers with addition): we can add any two integers to obtain another, each integer has an additive inverse, and 0 is the additive identity.
+
+A group $G$ can act on a set $X$ through some action $\rho : G \to \operatorname { A u t } ( X )$ which maps each $g \in G$ to some transformation on $X$ . $\rho$ must be a homomorphism, i.e. $\rho ( g h ) ~ = ~ \rho ( g ) \rho ( h )$ for all $g , h \in G$ , and $\operatorname { A u t } ( X )$ is the set of automorphisms on $X$ (bijective homomorphisms from $X$ to itself). As a shorthand we write $g x : = \rho ( g ) ( x )$ for any $x \in X$ . Any group can act on itself by letting $X = G$ : for $( \mathbb { Z } , + )$ , we define the action $g x = g + x$ for any $g , x \in \mathbb { Z }$ .
+
+The action of a group $G$ on a vector space $V$ is called a representation, which we denote $\pi : G \to G L ( V )$ . Recall $G L ( V )$ is the set of invertible linear maps on $V$ . Assume the vectors $v \in V$ are discrete, with components $v [ i ]$ . If we already have $G$ ’s action on the indices, a natural corresponding representation is defined $( \pi ( g ) v ) [ i ] : = { \overset { } { v } } [ g ^ { - 1 } i ]$ . As a concrete example,
+
+![](images/effd2e35cb9a3dff094ba1649c9b9484edf2eb8acf1801850584c77ad0069917.jpg)  
+Figure 1: Convolution as translating filters. Left: Standard 1-D convolution slides a filter $w$ along the length of input $x$ . This operation is translation equivariant: translating $x$ will translate $y$ . Right: Standard convolution is equivalent to a fully connected layer with a parameter sharing pattern: each row contains translated copies of the filter. Other equivariant layers will have their own sharing patterns.
+
+consider the representation of $G = ( \mathbb { Z } , + )$ for infinite length vectors. The indices are also integers, so the group is acting on itself as defined above. Then $\tilde { ( \pi ( g ) v ) } [ i ] = v [ g ^ { - 1 } i ] = v [ i - g ]$ for any $g , i \in \mathbb { Z }$ . Hence this representation of $\mathbb { Z }$ shifts vectors by translating their indices by $g$ spaces.
+
+# 3.3 EQUIVARIANCE AND CONVOLUTION
+
+A function (like a neural network layer) is equivariant to some transformation if transforming the function’s input is the same as transforming its output. To be more precise, we must define what those transformations of the input and output are. Consider a neural network layer $\phi : \mathbb { R } ^ { n }  \mathbb { R } ^ { m }$ .
+
+Assume we have two representations $\pi _ { 1 } , \pi _ { 2 }$ of group $G$ on $\mathbb { R } ^ { n }$ and $\mathbb { R } ^ { m }$ , respectively. For each $g \in G$ , $\pi _ { 1 } ( g )$ transforms the input vectors, while $\pi _ { 2 } ( g )$ transforms the output vectors. The layer $\phi$ is $G$ -equivariant with respect to these transformations if $\phi ( \pi _ { 1 } ( g ) v ) = \bar { \pi _ { 2 } } ( g ) \phi ( v )$ , for any $g \in$ $G , v \in \mathbb { R } ^ { n }$ . If we choose $\pi _ { 2 } \equiv i d$ we get $\phi ( \pi _ { 1 } ( g ) v ) = \phi ( v )$ , showing that invariance is a type of equivariance.
+
+Deep networks contain many layers, but function composition preserves equivariance. So if we achieve equivariance in each individual layer, the whole network will be equivariant. Pointwise nonlinearities such as ReLU and sigmoid are already equivariant to any permutation of the input and output indices, which includes translation, reflection, and rotation. Hence we are primarily focused on enforcing equivariance in the linear layers.
+
+Prior work (Kondor and Trivedi, 2018) has shown that a linear layer $\phi$ is equivariant to the action of some group if and only if it is a group convolution, which generalizes standard convolutions to arbitrary groups. For a specific $G$ , we call the corresponding group convolution “ $G$ -convolution” to distinguish it from standard convolution. Intuitively, $G$ -convolution transforms a filter according to each $g ~ \in ~ G$ , then computes a dot product between the transformed filter and the input. In standard convolution, the filter transformations correspond to translation (Fig. 1). $G$ -equivariant layers convolve an input $v \in \mathbb { R } ^ { n }$ with a filter $\psi \in \mathbb { R } ^ { n }$ . Assume the group $G = \{ g _ { 1 } , \cdots , g _ { m } \}$ is finite:
+
+$$
+\phi ( v ) [ j ] = ( v \star \psi ) [ j ] = \sum _ { i } v [ i ] ( \pi ( g _ { j } ) \psi ) [ i ] = \sum _ { i } v [ i ] \psi [ g _ { j } ^ { - 1 } i ]
+$$
+
+In this work, we present a method that represents and learns parameter sharing patterns for existing layers, such as fully connected layers. These sharing patterns can force the layer to implement various group convolutions, and hence equivariant layers.
+
+# 4 ENCODING AND LEARNING EQUIVARIANCE
+
+To learn equivariances automatically, our method introduces a flexible representation that can encode possible equivariances, and an algorithm for learning which equivariances to encode. Here we describe this method, which we call Meta-learning Symmetries by Reparameterization (MSR).
+
+# 4.1 LEARNABLE PARAMETER SHARING
+
+As Fig. 1 shows, a fully connected layer can implement standard convolution if its weight matrix is constrained with a particular sharing pattern, where each row contains a translated copy of the same underlying filter parameters. This idea generalizes to equivariant layers for other transformations like rotation and reflection, but the sharing pattern depends on the transformation. Since we do not know the sharing pattern a priori, we “reparameterize” fully connected weight matrices to represent them in a general and flexible fashion. A fully connected layer $\phi : \mathbb { R } ^ { n }  \mathbb { R } ^ { m }$ with weight matrix $W \in \mathbb { R } ^ { m \times n }$ is defined for input $x$ by $\phi ( x ) \ : = \ : W x$ . We can optionally incorporate biases by appending a dimension with value “1” to the input $x$ . We factorize $W$ as the product of a “symmetry matrix” $U$ and a vector $v$ of $k$ “filter parameters”:
+
+$$
+\operatorname { v e c } ( W ) = U v , \quad v \in \mathbb { R } ^ { k } , U \in \mathbb { R } ^ { m n \times k }
+$$
+
+For fully connected layers, we reshape1 the vector $\operatorname { v e c } ( W ) \in \mathbb { R } ^ { m n }$ into a weight matrix $W \in \mathbb { R } ^ { m \times n }$ . Intuitively, $U$ encodes the pattern by which the weights $W$ will “share” the filter parameters $v$ . Crucially, we can now separate the problem of learning the sharing pattern (learning $U$ ) from the problem of learning the filter parameters $v$ . In Sec. 4.3, we discuss how to learn $U$ from data.
+
+The symmetry matrix for each layer has mnk entries, which can become too expensive in larger layers. Kronecker factorization is a common approach for approximating a very large matrix with smaller ones (Martens and Grosse, 2015; Park and Oliva, 2019). In Appendix A we describe how we apply Kronecker approximation to Eq. 2, and analyze memory and computation efficiency.
+
+In practice, there are certain equivariances that are expensive to meta-learn, but that we know to be useful: for example, standard 2D convolutions for image data. However, there may be still other symmetries of the data (i.e., rotation, scaling, reflection, etc.) that we still wish to learn
+
+$$
+\underbrace { \left( \begin{array} { l } { \pi ( \mathrm { e } ) } \\ { \pi ( \mathrm { g } ) } \\ { \rho ^ { \prime } } \\ { \sigma ^ { \prime } } \end{array} \right) } _ { \mathrm { g r o u p } } \underbrace { \left( \begin{array} { l } { 1 } \\ { 0 } \\ { 0 } \\ { 1 } \\ { 1 } \end{array} \right) } _ { \mathrm { s y m m e t r y } } \underbrace { \left( \begin{array} { l } { \equiv } \\ { \left\{ \begin{array} { l } { \overline { { \mathbf { \ } } } } \\ { \overline { { \mathbf { \ } } } } \\ { \mathbf { \mu } } \end{array} \right\} } \\ { \mathrm { p a r a m e t e r s } } \end{array} \right) } _ { \mathrm { m a t r i x } } = \underbrace { \left( \begin{array} { l } { \overline { { \mathbf { \mu } } } } \\ { \overline { { \mathbf { \mu } } } } \\ { \overline { { \mathbf { \mu } } } } \end{array} \right) } _ { \mathrm { m ~ \mu } } \xrightarrow { \mathrm { r e s h a p e } } \underbrace { \left( \underbrace { \left\{ \begin{array} { l } { \mathbf { \mu } } \\ { \mathbf { \mu } } \\ { \mathbf { \mu } } \\ { \mathrm { \mu } } \end{array} \right\} } _ { \mathrm { l o y e r } } \right) } _ { \mathrm { w e i g h t s } }
+$$
+
+Figure 2: We reparameterize the weights of each layer in terms of a symmetry matrix $U$ that can enforce equivariant sharing patterns of the filter parameters $v$ . Here we show a $U$ that enforces permutation equivariance. More technically, the layer implements group convolution on the permutation group $S _ { 2 }$ : $U$ ’s block submatrices $\pi ( e ) , \pi ( g )$ define the action of each permutation on filter $v$ . Note that $U$ need not be binary in general.
+
+![](images/cb0678ed8a88a0f45082a325fabd83a7b02420696ff29181ba0d7eb73ae5aeaf.jpg)  
+Figure 3: For each task, the inner loop updates the filter parameters $v$ to the task using the inner loop loss. Note that the symmetry matrix $U$ does not change in the inner loop, and is only updated by the outer loop.
+
+# Algorithm 1: MSR: Meta-Training
+
+input: $\{ \mathcal { T } _ { j } \} _ { j = 1 } ^ { N } \sim p ( \mathcal { T } )$ : Meta-training tasks   
+input: $\{ \mathbf { U } , { \dot { \mathbf { v } } } \}$ : Randomly initialized symmetry matrices and filters.   
+input: $\alpha , \eta$ : Inner and outer loop step sizes.   
+while not done do sample minibatch $\{ \mathcal { T } _ { i } \} _ { i = 1 } ^ { n } \sim \{ \mathcal { T } _ { j } \} _ { j = 1 } ^ { N }$ ; forall $\mathcal { T } _ { i } \in \{ \mathcal { T } _ { i } \} _ { i = 1 } ^ { n } \mathbf { d }$ o $\{ \mathcal { D } _ { i } ^ { t r } , \mathcal { D } _ { i } ^ { v a l } \}  \mathcal { T } _ { i }$ ; // task data $\pmb { \delta } _ { i } \gets \nabla _ { \mathbf { v } } \mathcal { L } ( \mathbf { U } , \mathbf { v } , \mathcal { D } _ { i } ^ { t r } ) ;$ $\mathbf { v } ^ { \prime }  \mathbf { v } - \alpha \pmb { \delta } _ { i }$ ; // inner step /\* outer gradient $\star /$ $\begin{array} { r } { \mathbf { G } _ { i }  \frac { \mathrm { d } } { \mathrm { d } \mathbf { U } } \mathcal { L } ( \mathbf { U } , \mathbf { v } ^ { \prime } , \mathcal { D } _ { i } ^ { v a l } ) } \end{array}$ ; /\* outer step \*/ U ← U − η P G i ; i
+
+automatically. This suggests a “hybrid” approach, where we bake-in equivariances we know to be useful, and learn the others. Indeed, we can directly reparameterize a standard convolution layer by reshaping $\mathrm { v e c } ( W )$ into a convolution filter bank rather than a weight matrix. By doing so we bake in translational equivariance, but we can still learn things like rotation equivariance from data.
+
+# 4.2 PARAMETER SHARING AND GROUP CONVOLUTION
+
+By properly choosing the symmetry matrix $U$ of Eq. 2, we can force the layer to implement arbitrary group convolutions (Eq. 1) by filter $v$ . Recall that group convolutions generalize standard convolution to define operations that are equivariant to other transformations, such as rotation. Hence by choosing $U$ properly we can enforce various equivariances, which will be preserved regardless of the value of $v$ .
+
+Proposition 1 Suppose $G$ is a finite group $\{ g _ { 1 } , \dotsc , g _ { m } \}$ . There exists a $U ^ { G } \in \mathbb { R } ^ { m n \times n }$ such that for any $v \in \mathbb { R } ^ { n }$ , the layer with weights $\nu e c ( W ) = U ^ { G } v$ implements $G$ -convolution on input $x \in \mathbb { R } ^ { n }$ . Moreover, with this fixed choice of $U ^ { G }$ , any $G$ -convolution can be represented by a weight matrix $\nu e c ( W ) = U ^ { G } v$ for some $v \in \mathbb { R } ^ { n }$ .
+
+Intuitively, $U$ can store the symmetry transformations $\pi ( g )$ for each $g \in G$ , thus capturing how the filters should transform during $G$ -convolution. For example, Fig. 2 shows how $U$ can implement convolution on the permutation group $S _ { 2 }$ . We present a proof in Appendix B.
+
+Subject to having a correct $U ^ { G }$ , $v$ is precisely the convolution filter in a $G$ -convolution. This will motivate the notion of separately learning the convolution filter $v$ and the symmetry structure $U$ in the inner and outer loops of a meta-learning process, respectively.
+
+<table><tr><td colspan="8">Synthetic Problems MSE (lower is better)</td></tr><tr><td rowspan="2">Method</td><td colspan="3">Small train dataset</td><td colspan="4">Large train dataset</td></tr><tr><td>k=1</td><td>k=2</td><td>k=5</td><td>k=1</td><td></td><td>k=2</td><td>k=5</td></tr><tr><td>MAML-FC</td><td>3.4±.60</td><td>2.1± .35</td><td>1.0±.10</td><td>3.4±.49</td><td>2.0±.27</td><td></td><td>1.1 ± .11</td></tr><tr><td>MAML-LC</td><td>2.9 ± .53</td><td>1.8 ± .24</td><td>.87±.08</td><td>2.9 ±.42</td><td>1.6 ± .23</td><td></td><td>.89±.08</td></tr><tr><td>MAML-Conv</td><td>.00± .00</td><td>.43 ± .09</td><td>.41 ± .04</td><td>.00 ± .00</td><td>.53 ± .08</td><td></td><td>.49 ± .04</td></tr><tr><td>MTSR-FC (Ours)</td><td>3.2±.49</td><td>1.4 ± .17</td><td>.86± .06</td><td>.12 ± .03</td><td>.07 ± .02</td><td></td><td>.07 ± .01</td></tr><tr><td>MSR-Joint-FC (Ours)</td><td>.25± .16</td><td>.12 ± .04</td><td>.21 ± .03</td><td>.01± .00</td><td>.08±.02</td><td></td><td>.12 ± .02</td></tr><tr><td>MSR-FC (Ours)</td><td>.07±.02</td><td>.07± .02</td><td>.16 ± .02</td><td>.00± .00</td><td>.05 ± .01</td><td></td><td>.09 ±.01</td></tr></table>
+
+Table 1: Meta-test MSE of different methods on synthetic data with (partial) translation symmetry. “Small” vs “large” train dataset refers to the number of examples per training task. Among methods with non-convolutional architectures, MSR-FC is closest to matching actual convolution (MAML-Conv) performance on translation equivariant $k = 1 \mathrm { \cdot }$ ) data. On data with less symmetry $k = 2 , 5$ ), MSR-FC outperforms MAML-Conv and other MAML approaches. MSR-Joint is an ablation of MSR where both $U$ and $v$ of Eq. 2 are updated on task train data, rather than just $v$ . MTSR is an ablation of MSR where we train the reparameterization using multi-task learning, rather than meta-learning. Results are shown with $9 5 \%$ confidence intervals over test tasks.
+
+# 4.3 META-LEARNING EQUIVARIANCES
+
+Meta-learning generally applies when we want to learn and exploit some shared structure in a distribution of tasks $p ( \mathcal T )$ . In this case, we assume the task distribution has some common underlying symmetry: i.e., models trained for each task should satisfy some set of shared equivariances. We extend gradient based meta-learning to automatically learn those equivariances.
+
+Suppose we have an $L$ -layer network. We collect each layer’s symmetry matrix and filter parameters: $\mathbf { U } , { \bf { \dot { v } } } \gets \{ U ^ { 1 } , \cdots , U ^ { L } \} , \{ v ^ { 1 } , \cdot \cdot \cdot , v ^ { L } \}$ . Since we aim to learn equivariances that are shared across $p ( \mathcal { T } )$ ,the symmetry matrices should not change with the task. Hence, for any $\mathcal { T } _ { i } \sim p ( \mathcal { T } )$ the inner loop fixes $\mathbf { U }$ and only updates $\mathbf { v }$ using the task training data:
+
+$$
+\mathbf { v } ^ { \prime }  \mathbf { v } - \alpha \nabla _ { \mathbf { v } } \mathcal { L } ( \mathbf { U } , \mathbf { v } , \mathcal { D } _ { i } ^ { t r } )
+$$
+
+where $\mathcal { L }$ is simply the supervised learning loss, and $\alpha$ is the inner loop step size. During metatraining, the outer loop updates $\mathbf { U }$ by computing the loss on the task’s validation data using $\mathbf { v } ^ { \prime }$ :
+
+$$
+\mathbf { U } \gets \mathbf { U } - \eta \frac { \mathrm { d } } { \mathrm { d } \mathbf { U } } \mathcal { L } ( \mathbf { U } , \mathbf { v } ^ { \prime } , \mathcal { D } _ { i } ^ { v a l } )
+$$
+
+We illustrate the inner and outer loop updates in Fig. 3. Note that in addition to meta-learning the symmetry matrices, we can also still meta-learn the filter initialization $\mathbf { v }$ as in prior work. In practice we also take outer updates averaged over mini-batches of tasks, as we describe in Alg. 1.
+
+After meta-training is complete, we freeze the symmetry matrices U. On a new test task $\mathcal { T } _ { k } \sim p ( \mathcal { T } )$ , we use the inner loop (Eq. 3) to update only the filter $\mathbf { v }$ . The frozen $\mathbf { U }$ enforces meta-learned parameter sharing in each layer, which improves generalization by reducing the number of taskspecific inner loop parameters. For example, the sharing pattern of standard convolution makes the weight matrix constant along any diagonal, reducing the number of per-task parameters (see Fig. 1).
+
+# 5 CAN WE RECOVER CONVOLUTIONAL STRUCTURE?
+
+We now introduce a series of synthetic meta-learning problems, where each problem contains regression tasks that are guaranteed to have some symmetries, such as translation, rotation, or reflection. We combine meta-learning methods with general architectures not designed with these symmetries in mind to see whether each method can automatically meta-learn these equivariances.
+
+# 5.1 LEARNING (PARTIAL) TRANSLATION SYMMETRY
+
+Our first batch of synthetic problems contains tasks with translational symmetry: we generate outputs by feeding random input vectors through a 1-D locally connected (LC) layer with filter size 3 and no bias. Each task corresponds to different values of the LC filter, and the meta-learner must minimize mean squared error (MSE) after observing a single input-output pair. For each problem we constrain the LC filter weights with a rank $\bar { k \in \ \{ 1 , 2 , 5 \} }$ factorization, resulting in partial translation symmetry (Elsayed et al., 2020). In the case where rank $k = 1$ , the LC layer is equivalent to convolution (ignoring the biases) and thus generates exactly translation equivariant task data. We apply both MSR and MAML to this problem using a single fully connected layer (MSR-FC and MAML-FC), so these models have no translation equivariance built in and must meta-learn it to solve the tasks efficiently. For comparison, we also train convolutional and locally connected models with MAML (MAML-Conv and MAML-LC). Since MAML-Conv has built in translation equivariance, we expect it to at least perform well on the rank $k = 1$ problem.
+
+We also ran two ablations of MSR that use the same reparameterization (Eq. 2) but vary the training procedure. In MSRJoint, we allow $U$ and $v$ to be jointly updated in the inner loop, instead of only updating $v$ in the inner loop. Hence MSRJoint is trained identically to MAML, but with reparameterized weights. MTSR is an ablation of MSR that trains using multi-task learning instead of meta-learning. Given data from training task $\mathcal { T } _ { i }$ , MTSR jointly optimizes $U$ (shared symmetry matrix) and $v ^ { ( i ) }$ (task specific filter parameters) using the MSE loss. For a new test task we freeze the optimized $U$ and optimize a newly initialized filter $v$ using the test task’s training data, then evaluate MSE on held out data. Even though the true filter that generates the data has width 3, for MSR and MTSR we initialize the learned filter $v$ to be the same size as the input, per Prop. 1. In principle, these methods should automatically meta-learn that the true filter is sparse, and to ignore the extra dimensions in $v$ . Appendix D.1 further explains the experimental setup.
+
+![](images/54f6352f774a074f950f8a54ab5510b26f1df97b07052bfc3ec162c4a8b409cb.jpg)  
+Figure 4: After observing translation equivariant data, MSR enforces convolutional parameter sharing on the weight matrix. An example weight matrix is shown above.
+
+Table 1 shows how each method performs on each of the synthetic problems, with columns denoting the rank $k$ of the problem’s data. The “small vs large train dataset” results differ only in that the latter contains 5 or 10 times more examples per training task, depending on $k$ . On fully translation equivariant data $k = 1$ ), MAML-Conv performs best due to its architecture having built in translation equivariance. MSR-FC is the only non-convolutional architecture to perform comparably to MAML-Conv for $k = 1$ . Fig. 4 shows that MSR-FC has learned to produce weight matrices with convolutional parameter sharing structure, indicating it has “learned convolution” from the data. Appendix C.1 visualizes the meta-learned $U$ , which we find implements convolution as Sec. 4.2 predicted. Meanwhile, MAML-FC and MAML-LC perform significantly worse as they are unable to meta-learn this structure. On partially symmetric data $k = 2$ , $k = 5$ ), MSR-FC performs well due to its ability to flexibly meta-learn even partial symmetries. MAML-Conv performs worse here since the convolution assumption is overly restrictive, while MAML-FC and MAML-LC are not able to meta-learn much structure. MSR-Joint-FC performs comparably to or worse than MSR-FC across the board. Note that following prior work (Li et al., 2017), all methods use meta-learned inner learning rates on parameters that change in the inner loop. For MSR-Joint-FC we observe that the meta-learned inner loop learning rates corresponding to $U$ are significantly smaller than the inner learning rates corresponding to $v$ , suggesting that $U$ is changing relatively little in the inner loop (see Appendix Table 4). MTSR-FC performs significantly worse than MSR-FC with small training datasets, but performs comparably with large datasets. This indicates that although our reparameterization can be trained by either multi-task learning or meta-learning, the meta-learning approach (Alg. 1) is more efficient at learning from less data.
+
+# 5.2 LEARNING EQUIVARIANCE TO ROTATIONS AND FLIPS
+
+We also created synthetic problems with 2-D synthetic image inputs and outputs, in order to study rotation and flip equivariance. We generate task data by passing randomly generated inputs through a single layer E(2)-equivariant steerable CNN (Weiler and Cesa, 2019) configured to be equivariant to combinations of translations, discrete rotations by increments of $4 5 ^ { \circ }$ , and reflections. Hence our synthetic task data contains rotation and reflection in addition to translation symmetry. Each task corresponds to different values of the data-generating network’s weights. We apply MSR and MAML to a single standard con
+
+<table><tr><td rowspan=1 colspan=3>Rotation/Flip Equivariance MSE</td></tr><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Rot</td><td rowspan=1 colspan=1>Rot+Flip</td></tr><tr><td rowspan=1 colspan=1>MAML-ConvMSR-Conv (Ours)</td><td rowspan=1 colspan=1>.504.004</td><td rowspan=1 colspan=1>.507.001</td></tr></table>
+
+Table 2: MSR learns rotation and flip equivariant parameter sharing on top of a standard convolution model, and thus achieves much better generalization error on meta-test tasks compared to MAML on rotation and flip equivariant data.
+
+volution layer, which guarantees translation equivariance.
+
+Each method must still meta-learn rotation and reflection (flip) equivariance from the data. Table 2 shows that MSR easily learns rotation and rotation+reflection equivariance on top of the convolutional model’s built in translational equivariance. Appendix C.2 visualizes the filters MSR produces, which we see are rotated and/or flipped versions of the same filter.
+
+# 6 CAN WE LEARN INVARIANCES FROM AUGMENTED DATA?
+
+Practitioners commonly use data augmentation to train their models to have certain invariances. Since invariance is a special case of equivariance, we can also view data augmentation as a way of learning equivariant models. The downside is that we need augmented data for each task. While augmentation is often possible during meta-training, there are many situations where it is impractical at meta-test time. For example, in robotics we may meta-train a robot in simulation and then deploy (meta-test) in the real world, a kind of sim2real transfer strategy (Song et al., 2020). During meta-training we can augment data using the simulated environ
+
+# Algorithm 2: Augmentation Meta-Training
+
+input: $\{ \mathcal { T } _ { i } \} _ { i = 1 } ^ { N }$ : Meta-training tasks   
+input: META-TRAIN: Any meta-learner   
+input: AUGMENT: Data augmenter   
+forall $\mathcal { T } _ { i } \in \{ \mathcal { T } _ { i } \} _ { i = 1 } ^ { N }$ do $\{ \mathcal { D } _ { i } ^ { t r } , \mathcal { D } _ { i } ^ { v a l } \}  \mathcal { T } _ { i }$ ; // task data split   
+$\begin{array} { r l } & { \hat { \mathcal { D } } _ { i } ^ { v a l } \gets \mathrm { A U G M E N T } \big ( \mathcal { D } ^ { v a l } \big ) ; } \\ & { \hat { \mathcal { T } } _ { i } \gets \{ \mathcal { D } ^ { t r } , \hat { \mathcal { D } } _ { i } ^ { v a l } \} } \\ & { \mathbf { M } \mathrm { E T A - T R A I N } \Big ( \{ \hat { \mathcal { T } } _ { i } \} _ { i = 1 } ^ { N } \Big ) } \end{array}$
+
+ment, but we cannot do the same at meta-test time in the real world. Can we instead use MSR to learn equivariances from data augmentation at training time, and encode those learned equivariances into the network itself? This way, the network would preserve learned equivariances on new meta-test tasks without needing any additional data augmentation.
+
+Alg. 2 describes our approach for meta-learning invariances from data augmentation, which wraps around any meta-learning algorithm using generic data augmentation procedures. Recall that each task is split into training and validation data $\mathcal { T } _ { i } = \{ \mathcal { D } _ { i } ^ { t r } , \mathcal { D } _ { i } ^ { v a l } \}$ . We use the data augmentation procedure to only modify the validation data, producing a new validation dataset $\hat { \mathcal { D } } _ { i } ^ { v a l }$ for each task. We re-assemble each modified task $\hat { \mathcal { T } } _ { i } \gets \{ \mathcal { D } _ { i } ^ { t r } , \hat { \mathcal { D } } _ { i } ^ { v a l } \}$ . So for each task, the meta-learner observes unaugmented training data, but must generalize to augmented validation data. This forces the model to be invariant to the augmentation transforms without actually seeing any augmented training data.
+
+We apply this augmentation strategy to Omniglot (Lake et al., 2015) and MiniImagenet (Vinyals et al., 2016) few shot classification to create the Aug-Omniglot and Aug-MiniImagenet benchmarks. Our data augmentation function contains a combination of random rotations, flips, and resizes (rescaling), which we only apply to task validation data as described above. The problem is set up analogous to (Finn et al., 2017): for each task, the model must classify images into one of either 5 or 20 classes ( $\cdot n$ -way) and receives either 1 or 5 examples of each class in the task training data ( $k$ -shot). Unlike Finn et al. (2017) our Aug-Omniglot and Aug-MiniImagenet benchmarks contain transformed task validation data.
+
+We tried combining Alg. 2 with our MSR method and three other meta-learning algorithms: MAML (Finn et al., 2017), ANIL (Raghu et al., 2019), and Prototypical Networks (ProtoNets) (Snell et al., 2017). While the latter three methods all have the potential to learn equivariant features through Alg. 2, we hypothesize that since MSR enforces learned equivariance through its symmetry matrices it should outperform these feature-metalearning methods. We also paired MAML with a model that has built in equivariance to the group D8 $4 5 ^ { \circ }$ -increment rotation and reflections) using the E2-CNN library (Weiler and Cesa, 2019). We call this baseline “MAML $+ \mathrm { D } 8 ^ { \circ }$ . Appendix D.3 describes the experimental setup and methods implementations in more detail.
+
+Table 3 shows each method’s meta-test accuracies on both benchmarks. Across different settings MSR performs either comparably to the best method, or the best. MAML and ANIL perform similarly to each other, and usually worse than MSR, suggesting that learning equivariant or invariant features is not as helpful as learning equivariant layer structures. ProtoNets perform well on the easier Aug-Omniglot benchmark, but evidently struggle with learning a transformation invariant metric space on the harder Aug-MiniImagenet problems. MSR even outperforms the architecture with built in rotation and reflection symmetry (MAML $+ \mathrm { D 8 }$ ) across the board. MSR’s advantage may be due to the additional presence of scaling transformations in the image data; we are not aware of architectures that build in rotation, reflection, and scaling equivariance at the time of writing. Note that MSR’s reparameterization increases the number of meta-learned parameters at each layer, so MSR models contain more total parameters than corresponding MAML models. The “MAML (Big)” results show MAML performance with very large models containing more total parameters than the corresponding MSR models. The results show that MSR also outperforms these larger MAML models despite having fewer total parameters.
+
+Table 3: Meta-test accuracies on Aug-Omniglot and Aug-MiniImagenet few-shot classification. These benchmarks test generalization to augmented validation data from un-augmented training data. MSR performs comparably to or better than other methods under this augmented regime. Results are shown with $9 5 \%$ confidence intervals over test tasks.   
+
+<table><tr><td></td><td colspan="4">Aug-Omniglot</td><td colspan="2">Aug-MiniImagenet</td></tr><tr><td>Method</td><td colspan="2">5 way</td><td colspan="2">20 way</td><td colspan="2">5 way</td></tr><tr><td></td><td>1-shot</td><td>5-shot</td><td>1-shot</td><td>5-shot</td><td>1-shot</td><td>5-shot</td></tr><tr><td>MAML</td><td>87.3± 0.5</td><td>93.6± 0.3</td><td>67.0± 0.4</td><td>79.9 ± 0.3</td><td>42.5 ± 1.1</td><td>61.5 ± 1.0</td></tr><tr><td>MAML (Big)</td><td>89.3 ±0.4</td><td>94.8± 0.3</td><td>69.6±0.4</td><td>83.2 ± 0.3</td><td>37.2 ± 1.1</td><td>63.2 ± 1.0</td></tr><tr><td>ANIL</td><td>86.4±0.5</td><td>93.2 ± 0.3</td><td>67.5 ± 3.5</td><td>79.8 ± 0.3</td><td>43.0 ± 1.1</td><td>62.3 ±1.0</td></tr><tr><td>ProtoNets</td><td>92.9 ± 0.4</td><td>97.4±0.2</td><td>85.1 ± 0.3</td><td>94.3 ± 0.2</td><td>34.6± 0.5</td><td>54.5 ± 0.6</td></tr><tr><td>MAML + D8</td><td>94.6± 0.4</td><td>96.4± 0.3</td><td>82.6 ± 0.3</td><td>85.1 ± 0.3</td><td>44.9 ± 1.2</td><td>56.8 ±1.1</td></tr><tr><td>MSR (Ours)</td><td>95.3 ± 0.3</td><td>97.7 ± 0.2</td><td>84.3± 0.2</td><td>92.6± 0.2</td><td>45.5 ± 1.1</td><td>65.2 ± 1.0</td></tr></table>
+
+# 7 DISCUSSION AND FUTURE WORK
+
+We introduce a method for automatically meta-learning equivariances in neural network models, by encoding learned equivariance-inducing parameter sharing patterns in each layer. On new tasks, these sharing patterns reduce the number of task-specific parameters and improve generalization. Our experiments show that this method can improve few-shot generalization on task distributions with shared underlying symmetries. We also introduce a strategy for meta-training invariances into networks using data augmentation, and show that it works well with our method. By encoding equivariances into the network as a parameter sharing pattern, our method has the benefit of preserving learned equivariances on new tasks so it can learn more efficiently.
+
+Machine learning thus far has benefited from exploiting human knowledge of problem symmetries, and we believe this work presents a step towards learning and exploiting symmetries automatically. This work leads to numerous directions for future investigation. In addition to generalization benefits, standard convolution is practical since it exploits the parameter sharing structure to improve computational efficiency, relative to a fully connected layer of the same input/output dimensions. While MSR we can improve computational efficiency by reparameterizing standard convolution layers, it does not exploit learned structure to further optimize its computation. Can we automatically learn or find efficient implementations of these more structured operations? Additionally, MSR is focused on learning finite symmetry groups, while approximating infinite ones (e.g., learning $4 5 ^ { \circ }$ - increment rotation symmetry as an approximation to continuous rotation symmetry). Unfortunately, the number of parameters increases with the resolution of the approximation, so further research would be useful in discovering more scalable methods of approximating and learning continuous symmetries. Finally, our method is best for learning symmetries which are shared across a distribution of tasks. Further research on quickly discovering symmetries which are particular to a single task would make deep learning methods significantly more useful on many difficult real world problems.
+
+# ACKNOWLEDGEMENTS
+
+We would like to thank Sam Greydanus, Archit Sharma, and Yiding Jiang for reviewing and critiquing earlier drafts of this paper. This work was supported in part by Google. CF is a CIFAR Fellow.
+
+REFERENCES   
+F. Alet, T. Lozano-Perez, and L. P. Kaelbling. Modular meta-learning. ´ arXiv preprint arXiv:1806.10166, 2018.   
+A. Antoniou, H. Edwards, and A. Storkey. How to train your maml. arXiv preprint arXiv:1810.09502, 2018.   
+S. Bengio, Y. Bengio, J. Cloutier, and J. Gecsei. On the optimization of a synaptic learning rule. In Preprints Conf. Optimality in Artificial and Biological Neural Networks, volume 2. Univ. of Texas, 1992.   
+G. Benton, M. Finzi, P. Izmailov, and A. G. Wilson. Learning invariances in neural networks. arXiv preprint arXiv:2010.11882, 2020.   
+D. Beymer and T. Poggio. Face recognition from one example view. In Proceedings of IEEE International Conference on Computer Vision, pages 500–507. IEEE, 1995.   
+A. Brock, T. Lim, J. M. Ritchie, and N. Weston. Smash: one-shot model architecture search through hypernetworks. arXiv preprint arXiv:1708.05344, 2017.   
+T. Cohen and M. Welling. Group equivariant convolutional networks. In International conference on machine learning, pages 2990–2999, 2016.   
+T. S. Cohen, M. Weiler, B. Kicanaoglu, and M. Welling. Gauge equivariant convolutional networks and the icosahedral cnn. arXiv preprint arXiv:1902.04615, 2019.   
+M. Cranmer, S. Greydanus, S. Hoyer, P. Battaglia, D. Spergel, and S. Ho. Lagrangian neural networks. arXiv preprint arXiv:2003.04630, 2020.   
+E. D. Cubuk, B. Zoph, D. Mane, V. Vasudevan, and Q. V. Le. Autoaugment: Learning augmentation ´ policies from data. corr abs/1805.09501 (2018). arXiv preprint arXiv:1805.09501, 2018.   
+T. Deleu, T. Wurfl, M. Samiei, J. P. Cohen, and Y. Bengio. Torchmeta: A Meta-Learning li- ¨ brary for PyTorch, 2019. URL https://arxiv.org/abs/1909.06576. Available at: https://github.com/tristandeleu/pytorch-meta.   
+N. Diaconu and D. E. Worrall. Learning to convolve: A generalized weight-tying approach. arXiv preprint arXiv:1905.04663, 2019.   
+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.   
+D. S. Dummit and R. M. Foote. Abstract algebra, volume 3. Wiley Hoboken, 2004.   
+G. F. Elsayed, P. Ramachandran, J. Shlens, and S. Kornblith. Revisiting spatial invariance with low-rank local connectivity. arXiv preprint arXiv:2002.02959, 2020.   
+T. Elsken, J. H. Metzen, and F. Hutter. Neural architecture search: A survey. arXiv preprint arXiv:1808.05377, 2018.   
+C. Finn, P. Abbeel, and S. Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1126–1135. JMLR. org, 2017.   
+S. Flennerhag, A. A. Rusu, R. Pascanu, H. Yin, and R. Hadsell. Meta-learning with warped gradient descent. arXiv preprint arXiv:1909.00025, 2019.   
+R. Gens and P. M. Domingos. Deep symmetry networks. In Advances in neural information processing systems, pages 2537–2545, 2014.   
+A. Graves and N. Jaitly. Towards end-to-end speech recognition with recurrent neural networks. In International conference on machine learning, pages 1764–1772, 2014.   
+E. Grefenstette, B. Amos, D. Yarats, P. M. Htut, A. Molchanov, F. Meier, D. Kiela, K. Cho, and S. Chintala. Generalized inner loop meta-learning. arXiv preprint arXiv:1910.01727, 2019.   
+S. Greydanus, M. Dzamba, and J. Yosinski. Hamiltonian neural networks. In Advances in Neural Information Processing Systems, pages 15353–15363, 2019.   
+D. Ha, A. Dai, and Q. V. Le. Hypernetworks. arXiv preprint arXiv:1609.09106, 2016.   
+A. Hannun, C. Case, J. Casper, B. Catanzaro, G. Diamos, E. Elsen, R. Prenger, S. Satheesh, S. Sengupta, A. Coates, et al. Deep speech: Scaling up end-to-end speech recognition. arXiv preprint arXiv:1412.5567, 2014.   
+S. Hochreiter, A. S. Younger, and P. R. Conwell. Learning to learn using gradient descent. In International Conference on Artificial Neural Networks, pages 87–94. Springer, 2001.   
+D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+T. G. Kolda and B. W. Bader. Tensor decompositions and applications. SIAM review, 51(3):455–500, 2009.   
+R. Kondor and S. Trivedi. On the generalization of equivariance and convolution in neural networks to the action of compact groups, 2018.   
+A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pages 1097–1105, 2012.   
+B. M. Lake, R. Salakhutdinov, and J. B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015.   
+Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   
+Y. Lee and S. Choi. Gradient-based meta-learning with learned layerwise metric and subspace. arXiv preprint arXiv:1801.05558, 2018.   
+Z. Li, F. Zhou, F. Chen, and H. Li. Meta-sgd: Learning to learn quickly for few-shot learning. arXiv preprint arXiv:1707.09835, 2017.   
+H. Liu, K. Simonyan, and Y. Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018a.   
+R. Liu, J. Lehman, P. Molino, F. P. Such, E. Frank, A. Sergeev, and J. Yosinski. An intriguing failing of convolutional neural networks and the coordconv solution. In Advances in Neural Information Processing Systems, pages 9605–9616, 2018b.   
+J. Lorraine, P. Vicol, and D. Duvenaud. Optimizing millions of hyperparameters by implicit differentiation. arXiv preprint arXiv:1911.02590, 2019.   
+J. Martens and R. Grosse. Optimizing neural networks with kronecker-factored approximate curvature. In International conference on machine learning, pages 2408–2417, 2015.   
+P. Niyogi, F. Girosi, and T. Poggio. Incorporating prior information in machine learning by creating virtual examples. Proceedings of the IEEE, 86(11):2196–2209, 1998.   
+E. Park and J. B. Oliva. Meta-curvature. In Advances in Neural Information Processing Systems, pages 3309–3319, 2019.   
+A. Raghu, M. Raghu, S. Bengio, and O. Vinyals. Rapid learning or feature reuse? towards understanding the effectiveness of maml. arXiv preprint arXiv:1909.09157, 2019.   
+S. Ravanbakhsh, J. Schneider, and B. Poczos. Equivariance through parameter-sharing. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 2892–2901. JMLR. org, 2017.   
+O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.   
+A. A. Rusu, D. Rao, J. Sygnowski, O. Vinyals, R. Pascanu, S. Osindero, and R. Hadsell. Metalearning with latent embedding optimization. arXiv preprint arXiv:1807.05960, 2018.   
+J. Schmidhuber. Evolutionary principles in self-referential learning. On learning how to learn: The meta-meta-... hook.) Diploma thesis, Institut f. Informatik, Tech. Univ. Munich, 1:2, 1987.   
+J. Schmidhuber. Learning to control fast-weight memories: An alternative to dynamic recurrent networks. Neural Computation, 4(1):131–139, 1992.   
+J. Shawe-Taylor. Building symmetries into feedforward networks. In 1989 First IEE International Conference on Artificial Neural Networks,(Conf. Publ. No. 313), pages 158–162. IET, 1989.   
+J. Snell, K. Swersky, and R. Zemel. Prototypical networks for few-shot learning. In Advances in neural information processing systems, pages 4077–4087, 2017.   
+X. Song, Y. Yang, K. Choromanski, K. Caluwaerts, W. Gao, C. Finn, and J. Tan. Rapidly adaptable legged robots via evolutionary meta-learning. arXiv preprint arXiv:2003.01239, 2020.   
+K. O. Stanley and R. Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.   
+K. O. Stanley, D. B. D’Ambrosio, and J. Gauci. A hypercube-based encoding for evolving largescale neural networks. Artificial life, 15(2):185–212, 2009.   
+S. Thrun and L. Pratt. Learning to learn. Springer Science & Business Media, 2012.   
+M. van der Wilk, M. Bauer, S. John, and J. Hensman. Learning invariances using the marginal likelihood. In Advances in Neural Information Processing Systems, pages 9938–9948, 2018.   
+A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017.   
+O. Vinyals, C. Blundell, T. Lillicrap, D. Wierstra, et al. Matching networks for one shot learning. In Advances in neural information processing systems, pages 3630–3638, 2016.   
+M. Weiler and G. Cesa. General e (2)-equivariant steerable cnns. In Advances in Neural Information Processing Systems, pages 14334–14345, 2019.   
+D. Worrall and M. Welling. Deep scale-spaces: Equivariance over scale. In Advances in Neural Information Processing Systems, pages 7364–7376, 2019.   
+D. E. Worrall, S. J. Garbin, D. Turmukhambetov, and G. J. Brostow. Harmonic networks: Deep translation and rotation equivariance. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5028–5037, 2017.   
+M. Zaheer, S. Kottur, S. Ravanbakhsh, B. Poczos, R. R. Salakhutdinov, and A. J. Smola. Deep sets. In Advances in neural information processing systems, pages 3391–3401, 2017.   
+B. Zoph and Q. V. Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+# A APPROXIMATION AND TRACTABILITY
+
+# A.1 FULLY CONNECTED
+
+From Eq. 2 we see that for a layer with $m$ output units, $n$ input units, and $k$ filter parameters the symmetry matrix $U$ has mnk entries. This is too expensive for larger layers, so in practice, we need a factorized reparameterization to reduce memory and compute requirements when $k$ is larger.
+
+For fully connected layers, we use a Kronecker factorization to scalably reparameterize each layer. First, we assume that the filter parameters $v \in \mathbb { R } ^ { k l }$ can be arranged in a matrix $V \in \mathbb { R } ^ { k \times l }$ . Then we reparameterize each layer’s weight matrix $W$ similar to Eq. 2, but assume the symmetry matrix is the Kronecker product of two smaller matrices:
+
+$$
+\begin{array} { r } { \mathbf { v e c } ( W ) = ( U _ { 1 } \otimes U _ { 2 } ) \mathbf { v e c } ( V ) , \quad U _ { 1 } \in \mathbb { R } ^ { n \times l } , U _ { 2 } \in \mathbb { R } ^ { m \times k } } \end{array}
+$$
+
+Since we only store the two Kronecker factors $U _ { 1 }$ and $U _ { 2 }$ , we reduce the memory requirements of $U$ from mnkl to $m k + n l$ . In our experiments we generally choose $V \in \mathbb { R } ^ { m \times n }$ so $U _ { 1 } \in \mathbb { R } ^ { n \times n }$ and $U _ { 2 } \in \mathbb { R } ^ { m \times m }$ . Then the actual memory cost of each reparameterized layer (including both $U$ and $v$ ) is $m ^ { 2 } + n ^ { 2 } + m n$ , compared to mn for a standard fully connected layer. So in the case where $m \approx n$ , MSR increases memory cost by roughly a constant factor of 3.
+
+After approximation MSR also increases computation time (forward and backward passes) by roughly a constant factor of 3 compared to MAML. A standard fully connected layer requires a single matrix-matrix multiply $Y = W X$ in the forward pass (here $Y$ and $X$ are matrices since inputs and outputs are in batches). Applying the Kronecker-vec trick to Eq. 5 gives:
+
+$$
+W = U _ { 1 } V U _ { 2 } ^ { T } \iff \operatorname { v e c } ( W ) = ( U _ { 1 } \otimes U _ { 2 } ) \mathbf { v e c } ( V )
+$$
+
+So rather than actually forming the (possibly large) symmetry matrix $U _ { 1 } \otimes U _ { 2 }$ , we can directly construct $W$ simply using 2 additional matrix-matrix multiplies $W = U _ { 1 } V U _ { 2 } ^ { T }$ . Again assuming $V \in \mathbb { R } ^ { m \times n }$ and $m \approx n$ , each matrix in the preceding expression is approximately the same size as $W$ .
+
+# A.2 2D CONVOLUTION
+
+When reparameterizing 2-D convolutions, we need to produce a filter (a rank-4 tensor $W \in$ $\mathbb { R } ^ { C _ { o } \times C _ { i } \times \mathbf { \bar { H } } \times W } )$ . We assume the filter parameters are stored in a rank 3 tensor $V \in \mathbb { R } ^ { p \times q \times s }$ , and factorize the symmetry matrix $U$ into three separate matrices $U _ { 1 } \in \mathbb { R } ^ { C _ { o } \times p } , U _ { 2 } \in \mathbb { R } ^ { C _ { i } \times q }$ and $U _ { 3 } \in \mathbb { R } ^ { H W \times s }$ . A similar Kronecker product approximation gives:
+
+$$
+\begin{array} { r } { \tilde { W } = V \times _ { 1 } U _ { 1 } \times _ { 2 } U _ { 2 } \times _ { 3 } U _ { 3 } , \quad \tilde { W } \in \mathbb { R } ^ { C _ { o } \times C _ { i } \times H W } } \\ { W = \mathrm { r e s h a p e } ( \tilde { W } ) , \quad W \in \mathbb { R } ^ { C _ { i } \times C _ { i } \times H \times W } } \end{array}
+$$
+
+where $\times _ { n }$ represents $n$ -mode tensor multiplication (Kolda and Bader, 2009). Just as in the fully connected case, this convolution reparameterization is equivalent to a Kronecker factorization of the symmetry matrix $U$ .
+
+An analysis of the memory and computation requirements of reparameterized convolution layers proceeds similarly to the above analysis for the fully connected case. As we describe below, in our augmented experiments using convolutional models each MSR outer step takes roughly $3 0 \% - 4 0 \%$ longer than a MAML outer step.
+
+In practice, for any experiment where we reparameterize a standard 2-D convolution with weights $\boldsymbol { W } ^ { \bullet } \in \mathbb { R } ^ { C _ { o } \times C _ { i } \times H \times W }$ , we choose $p = C _ { o } , q = C _ { i }$ , and $s = H W$ . Equivalently, we choose $V \in$ $\mathbb { R } ^ { C _ { o } \times C _ { i } \times H W }$ . Although not necessary, this choice conveniently makes the matrices $U _ { 1 } , U _ { 2 }$ and $U _ { 3 }$ into square matrices, which we can initialize to identity matrices at the start of meta-learning.
+
+# B PROOF OF PROPOSITION 1
+
+To show the connection with the existing literature, we first present a slightly generalised definition of $G$ -convolution that is more common in the existing literature. We instead model an input signal as a function $f : X \to \mathbb { R }$ on some underlying space $X$ . We then consider a finite group $G =$ $\{ g _ { 1 } , \ldots , g _ { n } \}$ of symmetries acting transitively on $X$ , over which we desire $G$ -equivariance. Many (but not all) of the groups discussed in (Weiler and Cesa, 2019) are finite groups of this form.
+
+It is proven by (Kondor and Trivedi, 2018) that a function $\phi$ is equivariant to $G$ if and only if it is a $G$ -convolution on this space. In the domain of finite groups, we can consider a slight simplification of this notion: a finite “ $\cdot _ { G }$ cross-correlation” of $f$ with a filter $\psi : X \to \mathbb { R }$ . This is defined by (Cohen and Welling, 2016) as:
+
+$$
+[ \phi ( f ) ] ( g ) = ( f \star \psi ) ( g ) = \sum _ { x \in X } f ( x ) \psi ( g ^ { - 1 } x ) . ^ { 2 }
+$$
+
+We can now connect this notion with the linear layer, as described in our paper. First, in order for a fully connected layer’s weight matrix $W$ to act on function $f$ , we must first assume that $f$ has finite support $\{ x _ { 1 } , \ldots , x _ { s } \}$ —i.e. $f ( x )$ is only non-zero at these $s$ points within $X$ . This means that $f$ can be represented as a “dual” vector $\overline { { f } } \in \mathbb R ^ { s }$ given by ${ \overline { { f } } } _ { i } = f ( x _ { i } )$ , on which $W$ can act.3
+
+We aim to show a certain value of $U ^ { G } \in \mathbb { R } ^ { n s \times s }$ allows arbitrary $G$ cross-correlations—and only $G$ cross-correlations—to be represented by fully connected layers with weight matrices of the form
+
+$$
+\mathrm { v e c } ( W ) = U ^ { G } v ,
+$$
+
+where $v \in \mathbb { R } ^ { s }$ is any arbitrary vector of appropriate dimension. The reshape specifically gives $W \in \mathbb { R } ^ { n \times s }$ , which transforms the vector $\overline { { f } } \in \mathbb R ^ { s }$ .
+
+With this in mind, we first use that the action of the group can be represented as a matrix transformation on this vector space, using the matrix representation $\pi$ :
+
+$$
+[ \pi ( g ) \overline { { f } } ] _ { i } = f ( g ^ { - 1 } x _ { i } )
+$$
+
+where notably $\pi ( g ) \in \mathbb { R } ^ { s \times s }$ .
+
+![](images/cb216c7240d0a8c8c61d6f76e58889ba8cd3666236583915375caf6607d7ae9a.jpg)  
+Figure 5: The theoretical convolutional weight symmetry matrix for the group $\langle g \rangle \ \cong$ $C _ { 4 }$ , where $g$ is a $\frac { N \pi } { 2 }$ -radian rotation of a 3x3 image $N \in$ $\{ 0 , 1 , 2 , 3 \}$ . Notice that the image is flattened into a length 9 vector. The matrix $\pi ( g )$ describes the action of a $\frac { N \pi } { 2 }$ radian rotation on this image.
+
+We consider $U ^ { G } \in \mathbb { R } ^ { n s \times s }$ , and $v \in \mathbb { R } ^ { s }$ . Since $v \in \mathbb { R } ^ { s }$ , we can also treat $v$ as a the “dual” vector of a function ${ \hat { v } } : X \to \mathbb { R }$ with support $\{ x _ { 1 } , \ldots , x _ { s } \}$ , described by $\hat { v } ( x _ { i } ) = v _ { i }$ . We can interpret $\hat { v }$
+
+as a convolutional filter, just like $\psi$ in Eq. 9. $W$ then acts on $v$ just as it acts on $\overline { { f } }$ , namely:
+
+$$
+[ \pi ( g ) v ] _ { i } = \hat { v } ( g ^ { - 1 } x _ { i } ) .
+$$
+
+Now, we define $U ^ { G }$ by stacking the matrix representations of $g _ { i } \in G$
+
+$$
+U ^ { G } = \left[ \overbrace { \begin{array} { c } { \vdots } \\ { \pi ( g _ { n } ) } \end{array} } ^ { \pi ( g _ { 1 } ) } \right]
+$$
+
+which implies the following value of $W$ :
+
+$$
+W = { \mathrm { r e s h a p e } } ( U ^ { G } v ) = { \mathrm { r e s h a p e } } \left( { \left[ \begin{array} { l } { \qquad | } \\ { \pi ( g _ { 1 } ) v } \\ { \qquad | } \\ { \qquad \vdots } \\ { \pi ( g _ { n } ) v } \\ { \qquad | } \end{array} \right] } \right) = { \left[ \begin{array} { l l l } { \qquad - } & { \pi ( g _ { 1 } ) v } & { - } \\ { \qquad \vdots } & { \qquad \vdots } \\ { \qquad \pi ( g _ { n } ) v } & { - } \end{array} \right] }
+$$
+
+<table><tr><td colspan="7">Meta-learned LRs on synthetic problems</td></tr><tr><td rowspan="2">Variable</td><td colspan="3">Small traindataset</td><td colspan="3">Large train dataset</td></tr><tr><td>k=1</td><td>k=2</td><td>k=5</td><td>k=1</td><td>k=2</td><td>k=5</td></tr><tr><td>U</td><td>-0.017</td><td>-0.011</td><td>-0.052</td><td>-0.009</td><td>-0.021</td><td>-0.039</td></tr><tr><td>U</td><td>+0.241</td><td>+0.326</td><td>+0.401</td><td>+0.241</td><td>+0.307</td><td>+0.312</td></tr></table>
+
+Table 4: In the ablation “MSR-Joint-FC” of Sec. 4 we jointly updated $U$ and $v$ in the inner loop with metalearned inner loop learning rates for each. This is in contrast with standard MSR, where only $v$ is updated in the inner loop (also with a meta-learned learning rate), and $U$ is only updated in the outer loop. The inner learning rates were initialized at 0.02 for all variables. The table shows the inner loop learning rates at the end of training. The relative magnitudes suggest that $v$ is being updated significantly more than $U$ in the inner loop.
+
+This then grants that the output of the fully connected layer with weights $W$ is:
+
+$$
+( W \overline { { { f } } } ) _ { i } = \sum _ { j = 1 } ^ { s } ( \pi ( g _ { i } ) v ) _ { j } \overline { { { f } } } _ { j } .
+$$
+
+Using that $f$ has finite support $\{ x _ { 1 } , \ldots , x _ { s } \}$ , and that $( \pi ( g _ { i } ) v ) _ { j } = \hat { v } ( g _ { i } ^ { - 1 } x _ { j } )$ , we have that:
+
+$$
+( W \overline { { { f } } } ) _ { i } = \sum _ { j = 1 } ^ { s } \hat { v } ( g _ { i } ^ { - 1 } x _ { j } ) f ( x _ { j } ) = \sum _ { x \in X } \hat { v } ( g _ { i } ^ { - 1 } x ) f ( x ) .
+$$
+
+Lastly, we can interpret $W _ { G } { \overline { { f } } }$ as a function $\phi ^ { G } ( f )$ mapping each $g _ { i } \in G$ to its $i ^ { \mathrm { { t h } } }$ component:
+
+$$
+[ \phi ^ { G } ( f ) ] ( g _ { i } ) = ( W \overline { { f } } ) _ { i } = \sum _ { x \in X } \hat { v } ( g _ { i } ^ { - 1 } x ) f ( x )
+$$
+
+which is precisely the cross-correlation as described in Eq. 9 with filter $\psi = \hat { v }$ . This implies that φG must be equivariant with respect to $G$ . Moreover, all such $G$ -equivariant functions are $G$ crosscorrelations parameterized by $v$ , so with $U ^ { G }$ fixed as in Eq.-13, we have that $W = U ^ { G } v$ can represent all $G$ -equivariant functions.
+
+This means that if $v$ is chosen to have the same dimension as the input, and the weight symmetry matrix is sufficiently large, any equivariance to a finite group can be meta-learned using this approach. Moreover, in this case the symmetry matrix has a very natural and interpretable structure, containing a representation of the group in block submatrices—this structure is seen in practice in our synthetic experiments. Lastly, notice that $v$ corresponds (dually) to the convolutional filter, justifying the notion that we learn the convolutional filter in the inner loop, and the group action in the outer group.
+
+In the above proof, we’ve used the original definition of group convolution (Cohen and Welling, 2016) for the sake of simplicity. It is useful to note that a slight generalization of the proof applies for more general equivariance between representations, as defined in equation (3.3)—(i.e. the case when $\pi ( g )$ is an arbitrary linear transformation, and not necessarily of the form $\pi ( g ) f ( x ) = f ( g ^ { - 1 } x ) .$ ) This is subject to a unitarity condition on the group representation (Worrall and Welling, 2019).
+
+Without any modification to the method, arbitrary linear approximations to group convolution can be learnt when the representation is not a permutation of the indices. For example, non axis-aligned rotations can be easily approximated through both bilinear and bicubic interpolation, whereby the value of a pixel $x$ after rotation is a linear interpolation of the 4 or 16 pixels nearest to the “true” value of this pixel before rotation $g ^ { - 1 } x$ . Practically, this allows us to approximate equivariance to 45 degree rotations of 2D images, for which there don’t exist representations of the form in Eq. 12.
+
+# C FURTHER SYNTHETIC EXPERIMENT RESULTS
+
+# C.1 VISUALIZING TRANSLATION EQUIVARIANT SYMMETRY MATRICES
+
+Fig. 6 visualizes the actual symmetry matrix $U$ that MSR-FC meta-learns from translation equivariant data. Each column is one of the submatrices $\pi ( i )$ corresponding to the action of the discrete translation group element $i \in \mathbb Z$ on the filter $v$ . In other words, MSR automatically meta-learned $U$ to contain these submatrices $\pi ( i )$ such that each $\pi ( i )$ translates the filter by $i$ spaces, effectively meta-learning standard convolution! In the actual symmetry matrix the submatrices are stacked on top of each other as in Eq. 13, but we display each submatrix side-by-side for easy visualization. The figure is also cropped for space: there are a total of 68 submatrices but we show only the first 20, and each submatrix is cropped from $7 0 \times 3$ to $2 2 \times 3$ .
+
+![](images/ecb7acfd893d04352769cdb775abb7d8d42845248ab3f2264aaf152c86fb6f91.jpg)  
+Meta-learned symmetry matrix representations   
+Figure 6: The submatrices of the meta-learned symmetry matrix of MSR-FC on the translation equivariant problem (Sec. 5.1). Intensity corresponds to each entry’s absolute value. We see that the symmetry matrix has been meta-learned to implement standard convolution: each $\pi ( i )$ translates the size filter $v \in \mathbb { R } ^ { 3 }$ by $i$ spaces. Note that in actuality the submatrices are stacked on top of each other in $U$ as in Eq. 13, but we display them side-by-side for visualization.
+
+Table 5: The amount of training and test data provided to each method in the synthetic experiments of Table 1 and Table 2. The last row indicates that on the test tasks,, all methods were expected to solve each problem using a single example from that task.   
+
+<table><tr><td colspan="6">Synthetic problem data quantity</td></tr><tr><td></td><td>k=1</td><td>k=2</td><td>k=5</td><td>Rot</td><td>Rot+flip</td></tr><tr><td>No.train tasks</td><td>400</td><td>800</td><td>800</td><td>8000</td><td>8000</td></tr><tr><td>No. test tasks</td><td>100</td><td>200</td><td>200</td><td>2000</td><td>2000</td></tr><tr><td>Examples/train task (Small)</td><td>2</td><td>2</td><td>4</td><td>20</td><td>20</td></tr><tr><td>Examples/train task (Large)</td><td>20</td><td>20</td><td>20</td><td>1</td><td>1</td></tr><tr><td>Train examples/test task</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td></tr></table>
+
+# C.2 VISUALIZING ROTATION AND FLIP EQUIVARIANT FILTERS
+
+In Sec. 5.2 we ran three experiments reparameterizing convolution layers to meta-learn $9 0 °$ rotation, $4 5 ^ { \circ }$ rotation, and $4 5 ^ { \circ }$ rotation+flip equivariance, respectively. Figure 7 shows that MSR produces rotated and flipped versions of filters in order to make the convolution layers equivariant to the corresponding rotation or flip transformations.
+
+# D EXPERIMENTAL DETAILS
+
+Throughout this work we implemented all gradient based meta-learning algorithms in PyTorch using the Higher (Grefenstette et al., 2019) library.
+
+# D.1 TRANSLATION SYMMETRY SYNTHETIC PROBLEMS
+
+For the (partial) translation symmetry problems we generated regression data using a single locally connected layer. Each task corresponds to different weights of the data generating network, whose entries we sample independently from a standard normal distribution. For rank $k$ locally connected filters we sampled $k$ width-3 filters and then set the filter value at each spatial location to be a random linear combination of those $k$ filters. Table 5 shows how many distinct training and test tasks we generated data for. For each particular task, we generated data points by randomly sampling the entries of the input vector from a standard normal distribution, passing the input vector into the data generating network, and saving the input and output as a pair.
+
+MSR and MAML training: During meta-training we trained each method for 1, 000 outer steps on task batches of size 32, enough for the training loss to converge for every method in every problem. We used the Adam (Kingma and Ba, 2014) optimizer in the outer loop with learning rate .0005. Like most meta-learning methods, MAML and MSR split each task’s examples into a support set (task training data) and a query set (task validation data). On training tasks MAML and MSR used 3 SGD steps on the support data before computing the meta-training objective on the query data, while using 9 SGD steps on the support data of test tasks. We also used meta-learned per-layer learning rates initialized to 0.02. At meta-test time we evaluated average performance and error bars on held-out tasks.
+
+MTSR training: We reparameterize fully connected layers into symmetry matrix $U$ and filter $v$ , similar to MSR. MTSR maintains single shared $U$ , but initializes a separate filter $v ^ { ( i ) }$ for each training task $\mathcal { T } _ { i }$ . Given example data $\mathcal { D } _ { i }$ from $\mathcal { T } _ { i }$ , we jointly optimize $\{ U , v ^ { ( i ) } \}$ using the loss $\mathcal { L } ( U , v ^ { ( i ) } , \mathcal { D } _ { i } )$ . In practice each update step updates $U$ and all $\{ v ^ { ( i ) } \}$ in parallel using the full batch of training tasks. Given a test task we initialize a new filter $v$ alongside our already trained $U$ . We then update $v$ on training examples from the test task before evaluating on held out examples from the test task. We use 500 gradient steps for each task at both training and test time, again using the Adam optimizer with learning rate 0.001.
+
+We ran all experiments on a single machine with a single NVidia RTX 2080Ti GPU. Our MSR-FC experiments took about 9.5 (outer loop) steps per second, while our MSR-Conv experiments took about 2.8 (outer loop) steps per second.
+
+# D.2 ROTATION $^ +$ FLIP SYMMETRY SYNTHETIC PROBLEMS
+
+The setup of the rotation and rotation $^ +$ flip symmetry problems is very similar to that of the translation symmetry problems. Here we generated regression data using a single E(2)-steerable (Weiler and Cesa, 2019) layer. Each task again corresponds to a particular setting of the weights of this data generating network, whose entries are sampled from a standard normal distribution for each task. We generate examples for each task similarly to above, and Table 5 shows the quantity of data available for training and test tasks.
+
+MAML and MSR training setups here are similar to the translation setups, but we reparameterize the filter of a standard convolution layer to build in translation symmetry and focus on learning rotation/flip symmetry. Unlike the translation experiments, here we use 1 SGD step in the inner loop for both train and test tasks, and initialize the learned learning rates to 0.1.
+
+# D.3 AUGMENTATION EXPERIMENTS
+
+To create Aug-Omniglot and Aug-MiniImagenet, we extended the Omniglot and MiniImagenet benchmarks from TorchMeta (Deleu et al., 2019). Each task in these benchmarks is split into support (train) and query (validation) datasets. For the augmented benchmarks we applied data augmentation to only the query dataset of each task, which consisted of randomly resized crops, reflections, and rotations by up to $3 0 ^ { \circ }$ . Using the torchvision library, the augmentation function is:
+
+# D a t a a u g m e n t a t i o n a p p l i e d t o ONLY t h e q u e r y s e t . s i z e $\ c = \ 2 8$ # O m n i g l o t i m a g e s i z e . 84 f o r M i n i I m a g e n e t . a u g m e n t f n $=$ Compose (
+
+RandomResizedC rop ( 2 8 $, \quad \mathrm { ~ s ~ c ~ a ~ l ~ e ~ = ( ~ 0 ~ . ~ 8 ~ , ~ } \quad 1 . 0 ) )$ , R a n d o m V e r t i c a l F l i p ( $\mathtt { p } = 0 . 5 )$ , R a n d o m H o r i z o n t a l F l i p $\cdot { \bf p } { = } 0 . 5 )$ , R a n d o m R o t a t i o n ( 3 0 , r e s a m p l e $=$ I ma ge . BILINEAR ) , )
+
+For the augmented Omniglot and MiniImagenet 1-shot experiments, MAML used exactly the same convolutional architecture (same number of layers, number of channels, filter sizes, etc.) as prior work on Omniglot and MiniImagenet (Vinyals et al., 2016; Finn et al., 2017). For MSR we reparameterize each layer’s weight matrix or convolutional filter using the Kronecker approximation (Appendix A) such that the reparameterized layer has the same number of input and output neurons as the corresponding layer in the MAML model.
+
+For MiniImagenet 5-shot, we experimented with increasing architecture size via more channels and/or larger filters, which yielded better accuracies on meta-validation tasks. For MSR, MAML, and ANIL we increased the number of output channels from 32 to 128 and increased the kernel size from 3 to 5 in the first 3 convolution layers. We then inserted a $1 \times 1$ convolution layer with 64 output channels right before the linear output layer. For the ProtoNet architecture we similarly increased the output channels at each layer from 32 to 128, but found that keeping the kernel size at 3 worked best.
+
+For “MAML (Big)” experiments we increased the architecture size of the MAML model to exceed the number of meta-parameters (symmetry matrices $^ +$ filter parameters) in the corresponding MSR model. For MiniImagenet 5-Shot we inserted an additional linear layer with 3840 output units before the final linear layer. For MiniImagenet 1-Shot we increased the number of output channels at each of the 3 convolution layers from 32 to 64, then inserted an additional linear layer with 1920 output units before the final linear layer. For the Omniglot experiments we increased the number of output channels at each of the 3 convolution layers to 150.
+
+For all experiments and gradient based methods we trained for 60, 000 (outer) steps using the Adam optimizer with learning rate .0005 for MiniImagenet 5-shot and .001 for all other experiments. In the inner loop we used SGD with meta-learned per-layer learning rates initialized to 0.4 for Omniglot and .05 for MiniImagenet. We meta-trained using a single inner loop step in all experiments, and used 3 inner loop steps at meta-test time. Although MAML originally meta-trained with 5 inner loop steps on MiniImagenet, we found that this destabilized meta-training on our augmented version. We hypothesize that this is due to the discrepancy between support and query data in our augmented problems. During meta-training we used a task batch size of 32 for Omniglot and 10 for MiniImagenet. At meta-test time we evaluated average performance and error bars using 1000 held-out meta-test tasks.
+
+We ran all experiments on a machine with a single NVidia Titan RTX GPU. For our Aug-Omniglot, we ran two experiments at simultaneously on the same machine, which likely slowed each invididual experiment down. Our MSR method took about 0.6 steps per second, whereas the MAML baseline took about 0.86 steps per second. For Aug-Miniimagenet we ran one experiment per machine. MSR took 4.2 steps per second, while MAML took 5.6 steps per second on these experiments.
+
+![](images/153dca76ce1cbb30d8daae071dc7a59a683b38fc3437174d1fd2becea451d56a.jpg)  
+Figure 7: MSR produced convolution filters, after meta-learning $9 0 ^ { \circ }$ rotation, $4 5 ^ { \circ }$ rotation, and $4 5 ^ { \circ }$ rotation+flip equivariance in the Sec. 5.2 experiments. Notice that MSR learns to achieve the corresponding equivariance by producing rotated/flipped versions of the same filter.

parse/train/8jFiomKUnaT/8jFiomKUnaT.md

@@ -0,0 +1,542 @@
+# Revisiting Multi-Codebook Quantization
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Multi-Codebook Quantization (MCQ) is a generalized version of existing codebook  
+2 based quantizations for Approximate Nearest Neighbor (ANN) search. Therefore,   
+3 MCQ theoretically has the potential to achieve the best performance because so  
+4 lutions of other codebook-based quantization methods are all covered by MCQ’s   
+5 solution space under the same codebook size setting. However, finding the opti  
+6 mal solution to MCQ is proved to be NP-hard due to its encoding process, i.e.,   
+7 converting an input vector to a binary code. To tackle this, researchers apply   
+8 constraints to it to find near-optimal solutions, or employ heuristic algorithms   
+9 which are still time-consuming for encoding. Different from previous approaches,   
+10 this paper takes the first attempt to find a deep solution to MCQ. The encoding   
+11 network is designed to be as simple as possible, so the very complex encoding   
+12 problem becomes simply a feed-forward. Compared with other methods on three   
+13 datasets, our method shows state-of-the-art performance. Notably, our method   
+14 is $1 1 \times - 3 8 \times$ faster than heuristic algorithms for encoding, which makes it more   
+15 practical for real scenery of large-scale retrieval. Our code is publicly available:   
+16 https://github.com/DeepMCQ/DeepQ.
+
+# 17 1 Introduction
+
+18 Rapidly increasing multimedia contents in recent years raise an urgent request for retrieval in a   
+19 short time. Unlike the exhaustive routine [31, 20], Approximate Nearest Neighbor (ANN) search   
+20 significantly reduces retrieval time while preserving high recall. It has been widely applied to various   
+21 scenarios, such as database indexing, fast image retrieval, and recommender systems.   
+22 As a typical approach, vector quantization (VQ) [7] is at first developed as a compression technique,   
+23 which uses a codebook to approximate vectors. People further find the power of VQ to preserve   
+24 similarities between quantized features and enable VQ to perform ANN search. In order to achieve   
+25 low quantization errors with limited codebook size, a multi-codebook structure is introduced. The   
+26 proposal of the Multi-Codebook Quantization (MCQ) [2] describes the approach as a combination   
+27 of one codeword for each sub-codebook, and previous methods [9, 6, 19, 30, 10, 3] are summarized   
+28 as exceptional cases of MCQ or constrained MCQs. The quantization codes are designed to be   
+29 compacted, which results in negligible storage cost and high-quality results.   
+30 However, the optimization of MCQ without any constraints is formally NP-hard. [14] models   
+31 it as the minimization on several fully-connected Markov Random Fields (MRFs). As a result,   
+32 current researches aim at solving MCQ under acceptable computational costs. Other than applying   
+33 constraints on it [34, 4, 15], another approach designs algorithms in a heuristic way [2, 14, 16]. The   
+34 latter achieves better performance but suffers from slow encoding.   
+35 There are chances to employ neural networks’ power to solve MCQ, where people expect to obtain   
+36 higher performance and encoding efficiency than previous methods. [11, 5, 28, 33, 27] already give   
+37 the way to treat codebook as network parameter and update it by gradient-descent, but they are   
+38 all still under constraints that hinder performance. Morozov and Babenko [18] and Sablayrolles et   
+39 al. [22] map datapoints to learned space, which are not flexible, especially when performing the   
+40 reconstruction. Therefore in this paper, we give our first attempt to solve MCQ in a deep learning   
+41 approach, without constraints and work-arounds. Our contributions can be summarized as three-folds:   
+42 • Our novel approach, Deep Multi-Codebook Quantization (DeepQ), fully considers encoding   
+43 difficulty and time complexity in MCQ. With the high efficient and parallelized encoding networks,   
+44 our method significantly reduces encoding time.   
+45 To tackle the NP-hard encoding problem and non-differentiable gradient estimation, we employ and   
+46 further revise a policy gradient method. Value-Corrected Proximal Policy Optimization (VC-PPO)   
+47 is proposed to speed up convergence in the training phase.   
+48 Experiments conducted on a benchmark dataset validate our proposed method. Furthermore, to   
+49 evaluate the scalability of the method, it is tested on million-scale datasets to show the effectiveness   
+50 of our proposed algorithm.
+
+# 51 2 Related Works
+
+52 Vector quantization is a routine to approximate vectors by a codebook. Typical applications include   
+53 clustering, compression, and Approximate Nearest Neighbor (ANN) search. The famous proposal   
+54 $k$ -means [7], also known as Lloyd’s algorithm [13], clusters the dataset into uniformly sized convex   
+55 cells. When it is applied to ANN search, datapoints from the base set are quantized into their   
+56 nearest centriods and represented by indices. The distance from a given query to any datapoint   
+57 is approximated by the distance from the query to the datapoint’s centriod, which is effectively   
+58 pre-computed and stored in a lookup table. To perform fine-grained clustering as well as reducing the   
+59 space and time complexity, they [9, 6, 19, 10, 30] divide the feature space orthogonally by performing   
+60 $k$ -means in each subspace concurrently. Meanwhile, the introduced sub-codebook structure reveals   
+61 the prototype of MCQ. Formally, [2] gives a well definition of MCQ, and previous works are all   
+62 summarized into constrained MCQs. Specifically, subspace $k$ -means must keep orthogonality among   
+63 sub-codebooks. Zhang et al. [34] loosens the orthogonality constraint, but sub-codebooks are still   
+64 weakly-orthogonal. Chen et al. [4] and Martinez et al. [15] propose hierarchical $k$ -means, where   
+65 vectors are quantized coarse-to-fine. If constraints are moved, MCQ is not easy to solve. Current   
+66 state-of-the-art methods develop heuristic algorithms to help to encode. Specifically, Babenko and   
+67 Lempitsky [2] employs beam search, Martinez et al. [14, 16] give algorithm based on Iterated   
+68 Conditional Modes (ICM). However, the above methods do not achieve satisfied time complexity in   
+69 encoding yet.   
+70 When neural networks and gradient descent become a fashion, a few attempts to integrate quantization   
+71 into deep retrieval networks are proposed. Klein and Wolf [11] and Song et al. [5] propose Deep   
+72 Product Quantization (DPQ) and Deep Progressive Quantization $\mathrm { ( D P g Q ) }$ which update codebook by   
+73 soft relaxation, but they are still under the same constraints as [9, 15]. Sablayrolles et al. [22] and   
+74 Morozov and Babenko [18] give pipelines to encode compact representations for compressed-domain   
+75 search, but they do not strictly follow the paradigm of MCQ.
+
+# 76 3 Preliminaries
+
+77 Given a vector $\pmb { x } \in \mathbb { R } ^ { D }$ , its quantized vector $\tilde { \pmb { x } }$ are composed by several codewords in a codebook   
+78 $C$ . More Specifically, $C = ( \bar { C } _ { m } )$ , $C _ { m } \in \mathbb { R } ^ { K \times D }$ , $1 \leq m \leq M$ contains $M$ sub-codebooks and $K$   
+79 codewords for each. Quantization codes are formed by $\pmb { b } = ( \pmb { b } _ { m } )$ , $\pmb { b _ { m } } \in \{ 1 , 2 , \cdots , K \}$ , $1 \leq m \leq$   
+80 $M$ , which indicates the picked codeword in each sub-codebook. For the whole training set $X = \{ x \}$   
+81 with $N$ datapoints, MCQ aims at finding the optimal quantization codes ${ \boldsymbol { B } } = \{ { \boldsymbol { b } } \}$ and codebook $C$   
+82 to minimize following objective:
+
+$$
+\underset { C , B } { \operatorname* { m i n } } \ \underset { { \bf { x } } \in { \cal { X } } } { \mathbb { E } } \operatorname { Q } \left( { \bf { x } } , { \bf { b } } , C \right) = \underset { C , B } { \operatorname* { m i n } } \ \underset { { \bf { x } } \in { \cal { X } } } { \mathbb { E } } \left\| { \bf { x } } - \sum _ { m = 1 } ^ { M } C _ { m b _ { m } } \right\| _ { 2 }
+$$
+
+83 where $C _ { m { \pmb b } _ { m } } \in \mathbb { R } ^ { D }$ is the $b _ { m }$ -th codeword of the $m$ -th sub-codebook. The sum of picked codewords   
+84 $\sum C _ { m { \pmb b } _ { m } }$ tries to approximate $_ { \textbf { \em x } }$ . $C$ and $^ { b }$ are stored for further retrieval. Some of the previously   
+85 mentioned methods [9, 6, 4, 15, 34] are treated as constrained MCQs, as they are all represented   
+86 as special cases of (1). Specifically, when $M = 1$ , (1) becomes VQ. Or if any two sub-codebooks   
+87 $C _ { i } , C _ { j }$ are orthogonal, it will be PQ or OPQ.   
+88 The optimization of (1) without any constraints is proved to be NP-hard [14]. To tackle this, we   
+89 propose a Expectation-Maximization style solution. Following sections will explain the deep neural   
+90 network for encoding $^ { b }$ (Section 4.1), the way to solve $C$ (Section 4.2), and how to conduct retrieval   
+91 (Section 4.3), respectively.
+
+# 92 4 Methodology
+
+# 93 4.1 Expectation: Encoding $\textbf {  { B } }$ with neural networks
+
+94 Our first step, is to find a potential code $^ { b }$ by given $_ { \textbf { \em x } }$ and   
+95 a fixed $C$ . A policy $\pi$ parameterized by $\theta$ is employed to   
+96 take possible solution of $^ { b }$ by feeding $_ { \textbf { \em x } }$ :
+
+$$
+\pi = \left( \pi _ { m } \right) = \pi \left( \pmb { x } \mid \theta _ { m } \right) , 1 \leq m \leq M .
+$$
+
+97 More specifically, $\pi$ produces $M$ Categorical distribu  
+98 tions Categorical $( K , \pmb { p } _ { m 1 } , \cdots , \pmb { p } _ { m K } )$ , where $\pmb { p } _ { m j }$ is   
+99 the probability to pick the $j$ -th codeword in the $m$ -th   
+100 sub-codebook. A potential encoding $\boldsymbol { b } _ { m }$ is generated by   
+101 drawing samples from $\pi _ { m }$ , which then helps us to pick   
+102 codeword $C _ { m b _ { m } }$ . Therefore:
+
+$$
+\pmb { b _ { m } } \sim \pi _ { m } \left( \pmb { x } \mid \theta _ { m } \right) = \operatorname { C a t e g o r i c a l } ( K , \pmb { p _ { m } } ) .
+$$
+
+103 Since the independence among different sub-codebooks   
+104 is a prerequisite of MCQ, $\boldsymbol { b } _ { m }$ should be drawn from $\pi _ { m }$   
+105 independently. Intuitively, the probability of $^ { b }$ to be a   
+106 specific ${ \pmb { b } } ^ { \star }$ is derived by conditional independence:
+
+$$
+\operatorname* { P r } \left( \boldsymbol { b } = \boldsymbol { b } ^ { \star } \right) = \prod _ { m = 1 } ^ { M } \operatorname* { P r } \left( \boldsymbol { b } _ { m } = \boldsymbol { b } _ { m } ^ { \star } \right) = \prod _ { m = 1 } ^ { M } p _ { m \boldsymbol { b } _ { m } ^ { \star } } .
+$$
+
+107 We adopt the power of neural networks to model   
+108 $\pi _ { m }$ . Specifically, $\theta _ { m }$ produces $K$ unnormalized log  
+109 probabilities $\ell _ { m }$ and $\pmb { p } _ { m j }$ is obtained by Softmax. To   
+110 keep the independence, $\dot { \theta _ { m } }$ will not share parameters with   
+111 each other.   
+112 Therefore, $\theta$ , or our proposed IndepNet is illustrated in   
+113 Figure 1. We first build a basic structure called IndepBlock and duplicate this block for $M$ times as   
+114 $\theta _ { 1 } , \theta _ { 2 } , \cdots , \theta _ { M }$ . We try to keep the basic structure really simple to achieve high efficiency during   
+115 training and encoding. As the figure shows, IndepBlock is an hourglass network contains 6 layer  
+116 groups (consists of a linear layer with ReLU activation and layer-normalization) with skip-connections.   
+117 The last three outputs are concatenated and further fed into a final linear layer with $K$ outputs as   
+118 $\ell _ { m } = ( \ell _ { m 1 } , \cdot \cdot \cdot , \bar { \ell } _ { m K } )$ , and therefore:
+
+![](images/b6f11e48f5dde3ac69f93081e039972bb0654b233b1a3a45b23d641592ccfc34.jpg)  
+Figure 1: Our proposed IndepNet for producing probabilities of choosing each codeword. IndepBlock is duplicated for $M$ times without shared parameters, in order to keep independence between different IndepBlocks. Categorical distribution is built upon output from the IndepBlock. Then, quantization code $b _ { m }$ associated with sub-codebook $C _ { m }$ is sampled from distribution.
+
+$$
+\pmb { p } _ { m j } = \mathrm { S o f t m a x } \left( \pmb { \ell } _ { m } \right) _ { j } , \ w h e r e \ \pmb { \ell } _ { m } = \theta _ { m } \left( \pmb { x } \right) .
+$$
+
+# 119 4.1.1 Gradient estimation
+
+120 The objective of training $\theta$ is formed as:
+
+$$
+\operatorname* { m i n } _ { \pmb { \pi } } \operatorname* { \mathbb { E } } _ { \pmb { x } \in \pmb { X } } \mathrm { Q } \left( \pmb { x } , \pmb { b } , \pmb { C } \right) .
+$$
+
+121 However, the optimization faces two problems: 1) The encoding of $^ { b }$ involves sampling from discrete   
+122 distributions, which is non-differentiable, 2) All possible encoding of $^ { b }$ is $\mathcal { O } \left( \overset { \bullet } { K } { } ^ { M } \right)$ . Exhaustive   
+123 search becomes impracticable.   
+124 Therefore, gradient estimation over discrete, stochastic computation graph is required to train $\theta$ .   
+125 Mainstream methods [23, 32, 17] include score function gradient estimator, pathwise gradient   
+126 estimator, etc. Meanwhile, minimizing (6) is also faced with the high-variance problem during   
+127 gradient estimation. To tackle this, the advantage function is introduced [12, 25]. Specifically in   
+128 our work, a value network called QENet parameterized by $\tau$ is proposed to model a value function   
+129 $v = \mathrm { V } \left( \cdot \mid \tau \right)$ . It performs a regression task to minimize the following objectives:
+
+$$
+\operatorname* { m i n } _ { \tau } \underset { \pmb { x } \in \pmb { X } } { \mathbb { E } } \| \mathrm { Q } \left( \pmb { x } , \pmb { b } , \pmb { C } \right) - \mathrm { V } \left( \pmb { x } , \pmb { b } , \pmb { C } \mid \tau \right) \| _ { 2 } .
+$$
+
+Advantages 130 $\hat { A }$ is then estimated by
+
+$$
+\hat { A } = \operatorname { Q } \left( \mathbf { { x } } , \boldsymbol { b } , \boldsymbol { C } \right) - \operatorname { V } \left( \mathbf { { x } } , \boldsymbol { b } , \boldsymbol { C } \mid \tau \right) .
+$$
+
+131 The detailed architecture of QENet is shown in Figure 2.   
+132 We reuse the IndepBlock to generate $v$ by $M + 1$ blocks:   
+133 $\boldsymbol { \tau } = \left( \tau _ { 1 } , \cdot \cdot \cdot , \tau _ { M } , \tau _ { x } \right)$ . Specifically, latent representation   
+134 for each selected-codeword $C _ { m b _ { m } }$ is obtained by:
+
+$$
+\pmb { \iota } _ { m } = \tau _ { m } ( C _ { m { \pmb b } _ { m } } ) .
+$$
+
+135 The last IndepBlock $\tau _ { x }$ is introduced to transform $_ { \textbf { \em x } }$ . Then,   
+136 all the outputs from IndepBlocks are summed up to get   
+137 scalar value $v$ (denoted as “reduce-sum”):
+
+$$
+v = { \mathrm { s u m } } ( \iota _ { 1 } , \cdot \cdot \cdot , \iota _ { M } , \iota _ { x } ) .
+$$
+
+![](images/7d1a762b0aaa3ad7a080abf2fa63c21a54cc7025884a767faccb3fb522015eaa.jpg)  
+Figure 2: Our proposed QENet for advantage estimation. First $M$ IndepBlocks are fed by $M$ selected codewords and the last one is fed by $_ { \textbf { \em x } }$ . Outputs are summed up to get scalar value $v$ .
+
+138 Value-corrected proximal policy optimization We   
+139 propose a variant of score function gradient estimator   
+140 called Value Corrected Proximal Policy Optimization (VC  
+141 PPO) based on PPO to get simple but efficient Trust Re  
+142 gion updates [26, 24]. In the real scenario of large-scale   
+143 ANN search, the training size $N$ is usually larger than $1 0 k$ . Conventional PPO still does not satisfy   
+144 us due to the speed of convergence. Therefore, we revise and propose the Value-Corrected PPO   
+145 (VC-PPO) to achieve fast training. Firstly in the sampling stage, $b _ { o }$ and $v _ { o }$ is produced from datapoint   
+146 $_ { \textbf { \em x } }$ over whole training set $\boldsymbol { X }$ by freezing current policy network and value network as $\theta _ { o } , \tau _ { o }$ :
+
+$$
+\begin{array} { r l } & { b _ { o } \sim \pi \left( \pmb { x } \mid \theta _ { o } \right) , } \\ & { v _ { o } = \mathrm { V } \left( \pmb { x } , b _ { o } , C \mid \tau _ { o } \right) . } \end{array}
+$$
+
+147 The probability of producing the sampled $b _ { o }$ is denoted as $p _ { o } = \operatorname* { P r } \left( \pmb { b } _ { o } \mid \pmb { x } , \pmb { \theta } _ { o } \right)$ , calculated by   
+148 equation (4). Finally, our surrogate objectives of VC-PPO is defined as [8]:
+
+149
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \theta } = \operatorname* { m i n } \left( \frac { \operatorname* { P r } \left( b _ { o } \mid \boldsymbol { x } , \theta \right) } { \operatorname* { P r } \left( b _ { o } \mid \boldsymbol { x } , \theta _ { o } \right) } \hat { A } , \right. } \\ & { \qquad \left. \mathrm { c l i p } _ { 1 - \epsilon } ^ { 1 + \epsilon } \left( \frac { \operatorname* { P r } \left( b _ { o } \mid \boldsymbol { x } , \theta \right) } { \operatorname* { P r } \left( b _ { o } \mid \boldsymbol { x } , \theta _ { o } \right) } \right) \hat { A } \right) , } \\ & { \mathcal { L } _ { \tau } = \operatorname* { m a x } \left( \left( \operatorname { Q } \left( \boldsymbol { x } , b _ { o } , C \right) - \mathrm { V } \left( \boldsymbol { x } , b _ { o } , C \mid \tau \right) \right) ^ { 2 } , \right. } \\ & { \qquad \left. \left( \mathrm { Q } \left( \boldsymbol { x } , b _ { o } , C \right) - \boldsymbol { v } _ { o } - \mathrm { c l i p } _ { - \epsilon } ^ { + \epsilon } \left( \mathrm { V } \left( \boldsymbol { x } , b _ { o } , C \mid \tau \right) - \boldsymbol { v } _ { o } \right) \right) ^ { 2 } \right) . } \end{array}
+$$
+
+150 Here, The $\mathrm { c l i p } \left( \cdot \right)$ forces the policy and value to be not too far from old ones and $\epsilon$ is the clip-range.   
+151 In both equations, it prevents a large update ratio leading to an unstable policy. The key difference   
+152 between the original PPO and our VC-PPO is, we use $\mathrm { V } \left( \boldsymbol { x } , \boldsymbol { b _ { o } } , \boldsymbol { C } \mid \tau \right)$ other than the recorded old   
+153 value $v _ { o }$ from sampling stage to estimate advantage. This modification is treated as a value-correction   
+154 process. Correcting value leads to a precise estimation on advantage, which is based on two reasons:   
+155 a) Biases are introduced into advantage estimation if we use $v _ { o }$ , since the policy is getting better and   
+156 better during training but $\tau _ { o }$ is froze, and 2) The calculation of $\mathrm { V } \left( \boldsymbol { x } , \boldsymbol { b _ { o } } , \boldsymbol { C } \mid \tau \right)$ can be done instantly   
+157 without introducing significant computational overhead. To further encourage the network choose   
+158 codewords uniformly, a regularization is applied to $\theta$ to maximize the entropy of $\pi$ :
+
+$$
+e _ { \theta } = - \sum _ { m = 1 } ^ { M } \sum _ { j = 1 } ^ { K } p _ { m j } \log { p _ { m j } }
+$$
+
+159 which forces network to try more codeword combinations.
+
+# 60 4.2 Maximization: Solve $C$ by least-squares
+
+161 To give the closed-form derivation of solving $C$ by given $\boldsymbol { X }$ and $\textbf {  { B } }$ , We will firstly rewrite Equation   
+162 (1) to a matrix formulation. Since $\pmb { b } = ( \pmb { b } _ { 1 } , \pmb { b } _ { 2 } , \pmb { \cdot \cdot \cdot } , \pmb { b } _ { M } )$ and ${ \pmb b } _ { m } \in \{ 1 , 2 , \cdots \dot { K } \}$ is the index of   
+163 selected codeword in the $i$ -th sub-codebook, a one-hot encoding and a concatenation on each $b _ { m }$ :   
+164 $\pmb { b } _ { m } ^ { \prime } = \mathrm { o n e - h o t } ( \pmb { b } _ { m } )$ , $\pmb { b } ^ { \prime } = ( \pmb { b } _ { 1 } ^ { \prime } , \cdots , \pmb { b } _ { m } ^ { \prime } )$ will convert the quantization code to a $M$ -hot vector i.e. a   
+165 vector that contains $M$ segments, and each segment contains exactly one 1 and remaining 0, where   
+1 is the entry of picked codeword. Correspondingly, a reshape is applied to 166 $C \colon C ^ { \prime } = \left( \begin{array} { c } { { C _ { 1 } } } \\ { { C _ { 2 } } } \\ { { \vdots } } \\ { { C _ { M } } } \end{array} \right) \in$
+
+$\mathbb { R } ^ { ( M \times K ) \times D }$ . (1) will become:
+
+$$
+\operatorname* { m i n } _ { \boldsymbol { C ^ { \prime } } } \left\| \boldsymbol { X } - \boldsymbol { B ^ { \prime } } \boldsymbol { C ^ { \prime } } \right\| _ { 2 } ^ { 2 } .
+$$
+
+168 This equation is formally a linear least-squares regression, where $\pmb { { B } } ^ { \prime } \in \{ 0 , 1 \} ^ { N \times ( M \times K ) }$ is known   
+169 and $\boldsymbol { X }$ is target. Although there is a bunch of algorithms to solve it, we finally choose gelsy [1],   
+170 which in our experiments shows the best results. The solution is to first apply a QR factorization with   
+171 column permutation on $B ^ { \prime }$ :
+
+$$
+B ^ { \prime } = Q \left( \begin{array} { c c } { { R _ { 1 1 } } } & { { R _ { 1 2 } } } \\ { { 0 } } & { { R _ { 2 2 } } } \end{array} \right) P ^ { \intercal }
+$$
+
+where 172 $Q$ and $\pmb { R } = \left( \begin{array} { c c } { R _ { 1 1 } } & { R _ { 1 2 } } \\ { 0 } & { R _ { 2 2 } } \end{array} \right)$ is the factorization matrix and $_ { r }$ is an orthogonal matrix that 173 permutes columns of $B ^ { \prime }$ until $\pmb { R } _ { 1 1 }$ is well-conditioned (its estimated condition number approaches 174 0). With the permutation, $ { R _ { 2 2 } }$ becomes negligible. Moreover, $\mathbf { R } _ { 1 2 }$ is erased by another orthogonal 175 transformation:
+
+$$
+\begin{array} { r l } { \bigg ( R _ { 1 1 } } & { { } R _ { 1 2 } \bigg )  \bigg ( R _ { 1 1 } \quad R _ { 1 2 } \bigg ) = \bigg ( T _ { 1 1 } \quad 0 \bigg ) Z } \\ { 0 } & { { } R _ { 2 2 } \bigg )  \bigg ( T _ { 0 } \qquad 0 \bigg ) = \bigg ( T _ { 0 } \quad 0 \bigg ) Z } \end{array}
+$$
+
+where 176 $\mathbf { T }$ and $z$ are from the orthogonal transformation of $\pmb { R }$ . Then, $C ^ { \prime }$ is derived by:
+
+$$
+\begin{array} { r } { B ^ { \prime } = Q \left( \begin{array} { c c } { T _ { 1 1 } } & { 0 } \\ { 0 } & { 0 } \end{array} \right) Z P ^ { \intercal } , } \\ { C \gets C ^ { \prime } \gets P Z ^ { \intercal } \left( \begin{array} { c c } { T _ { 1 1 } ^ { - 1 } Q _ { 1 } ^ { \intercal } X } \\ { 0 } \end{array} \right) } \end{array}
+$$
+
+where 177 $Q _ { 1 }$ is the top $\mathrm { r a n k } ( B ^ { \prime } )$ columns of $Q$ .
+
+178 In brief, our overall training approach is summarized into algorithm 1.
+
+# 4.3 Fast retrieval
+
+80 After training, we are able to encode the base set for retrieval. Other than sampling from $\pi$ , codewords   
+81 are simply rolled out by greedy assignments:
+
+$$
+\pmb { b } _ { m } ^ { g } = \arg \operatorname* { m a x } \theta _ { m } ( \pmb { x } ) .
+$$
+
+182 We firstly use the greedy roll-out strategy to obtain $\textbf {  { B } }$ in the training set in order to solve the final   
+183 codebook. Then, we employ the same strategy to encode the base set.   
+184 To further refine assignments, we add an extra step that randomly selects and alters $b _ { i }$ while fixing   
+185 others:
+
+$$
+\begin{array} { l } { { b _ { i } ^ { g }  \underset { b _ { i } ^ { g } } { \operatorname { a r g m i n } } \mathrm { Q } ( x , b ^ { g } , C ) , } } \\ { { \quad i \sim \mathcal { U } [ 1 , M ] . } } \end{array}
+$$
+
+186 Since this refinement only causes negligible overhead referred to the implementation by [14], in   
+187 practice, we benefit from it not only to get lower quantization error but also to obtain acceptable   
+188 performance from a fast training, i.e., training within a very few steps before the network is converged.   
+189 The encoded and refined base set, combined with the codebook, is finally employed for retrieval. The   
+90 LSQ-style lookup table [14] is utilized to speed up similarity search.
+
+# 191 4.4 Discussion
+
+Our work aims at solving Multi-Codebook Quantization via neural networks. Similar works include Unsupervised Neural Quantization (UNQ) [18] and Spreading Vectors [22]. But ours has several key advantages compared to previous works: 1) Unlike UNQ, which reconstructs features by an encoderdecoder structure, we follow the paradigm of MCQ to directly give binary codes and codebooks for the benefit of speed and storage, for UNQ needs an extra decoding stage during retrieval. 2) UNQ and Spreading Vectors both project original features into a learned space. Although similarities between features are preserved, they still have biases in quantized results. This causes several issues, especially when we want to perform a reconstruction to approximate original features, e.g. data compression.
+
+208 Compared to LSQ [14], the state-of-the-art heuris  
+209 tic algorithm, our work is the first to tackle MCQ in   
+210 a deep learning fashion. The policy network is de  
+211 signed to be very simple to get fast encoding speed   
+212 and comparable retrieval performance.
+
+# Algorithm 1: VC-PPO for Training
+
+Inputs: Training set $\boldsymbol { X }$ , max step $T$ , hyper  
+parameters $\alpha$ , , learning rates $\eta _ { 1 } , \eta _ { 2 }$ .   
+Outputs: Policy $\pi$ .   
+Initialize codebook $C$ , parameters $\theta$ and $\tau$ ;   
+$i \gets 0$ ;   
+while $i < T$ do $^ { \prime * }$ Training loop $^ { * / }$ for $_ { \textbf { \em x } }$ in $\boldsymbol { X }$ do $^ { \prime * }$ Sampling stage $^ { * / }$ Sample $\ b { b _ { o } } \sim \pi \left( \pmb { x } \mid \theta _ { o } \right)$ into $\textbf {  { B } }$ ; Compute $v _ { o } , p _ { o }$ into $V$ , $_ { r }$ ; end for $x , b _ { o } , v _ { o } , p _ { o }$ in $X , B , V , P r$ do $^ { \prime * }$ Updating stage $^ { * / }$ $\tau  \tau - \eta _ { 1 } \nabla _ { \tau } { \mathcal { L } } _ { \tau }$ ; Compute $\hat { A }$ by (8); $\theta  \theta + \eta _ { 2 } \nabla _ { \theta } ( \mathcal { L } _ { \theta } + \alpha \cdot e _ { \theta } ) ;$ end C ← Solved by (15) ∼ (18); $i \gets i + 1$ ;   
+end   
+return π (· | θ)
+
+# 5 Experiments
+
+214 Our proposed Deep Multi-Codebook Quantization (DeepQ) is compared against the state-of-the-arts   
+215 on a visual-feature dataset (LabelMe22K) to evaluate retrieval performance and encoding speed.   
+216 Then, we scale up to make comparisons on commonly used large-scale datasets (SIFT1M and   
+217 DEEP1M), whose base sets include 1 million vectors for retrieval. Furthermore, ablation study on   
+218 SIFT1M investigates the effectiveness of each component in our proposed pipeline.
+
+# 5.1 Datasets and evaluation metrics
+
+LabelMe22K [29]: This dataset collects images by the LabelMe annotation tool1 and uses Convolutional Neural Network (CNN) to extract them into 512-d features. It has 22, 019 vectors for training and 2, 000 vectors for test.
+
+SIFT1M2 and DEEP1M3: Both datasets contain $1 0 ^ { 4 }$ , $1 0 ^ { 5 }$ , $1 0 ^ { 6 }$ vectors in query, training and base set, respectively. Vectors from SIFT1M is extracted by Scale-Invariant Feature Transform (128-d) while DEEP1M contains 96-d vectors from outputs of a CNN.
+
+226 Recall $ @ \{ 1 , 1 0 , 1 0 0 \}$ and quantization error are adopted as evaluation metrics. These two metrics   
+227 indicate not only the retrieval performance but also the reconstruction accuracy. Because LabelMe22K   
+228 does not have a base set, its training set is adopted as a base set. We train on the training set, and then   
+229 encode the base set for evaluations with queries. When calculating recall, groundtruth is defined as   
+230 the nearest neighbor of each query in the base set (sorted by l2 distance). As for quantization error,   
+231 the average value of $\wr ( { \pmb x } , { \pmb b } , { \pmb C } )$ is reported over all $_ { \textbf { \em x } }$ in the base set.
+
+We compare our proposal with both shallow and deep methods, including three classic quantization: OPQ [6], SQ [15] and $\mathbf { L S Q + + }$ [14, 16] (denoted as LSQ for simplicity. Also, these two in our experiments have similar performance), as well as three graident-based methods: DPQ [11], $\mathbf { D P g Q }$ [5] and DRQ [28]. DPQ and PQNet [33] have basically the same architecture that extend PQ with gradient-descent, so we only report the performance of DPQ. Additionally, UNQ [18] is also included, although they introduce an extra decoder and re-ranking trick for retrieval.
+
+# 5.2 Implementation details
+
+Our method is implemented with PyTorch,4 the popular deep learning package in Python. Codebook $C$ is solved by Intel MKL that has been fully optimized for speed. As for network training, we adopt Adam optimizer with AMSGrad [21] and hyperparameters are tuned by grid search. Specifically, learning rates $\eta _ { 1 } = \eta _ { 2 } =$ $2 \times 1 0 ^ { - 4 }$ , with an exponetial learning rate decay $\gamma = 0 . 9 9 9 9$ . Batch-size in updating stage is 2000, while other hyper-parameters $\epsilon = 0 . 2$ , $\alpha = 0 . 0 5$ . Additionally, during training, we insert dropout layers after every layernormalization in all layer-groups to tackle overfitting. More detailed settings as well as specifications of $I n$ - depNet $\theta$ and QENet $\tau$ on each dataset
+
+<table><tr><td rowspan="3">Method</td><td colspan="6">LabelMe22K</td></tr><tr><td rowspan="2">R@1</td><td>32 bits</td><td rowspan="2">R@100</td><td rowspan="2">R@1</td><td rowspan="2">64 bits R@10</td><td rowspan="2">R@100</td></tr><tr><td>R@10</td></tr><tr><td>OPQ</td><td>18.70</td><td>57.25</td><td>90.10</td><td>32.30</td><td>80.40</td><td>98.00</td></tr><tr><td>SQ</td><td>18.45</td><td>57.60</td><td>90.85</td><td>32.65</td><td>82.05</td><td>99.05</td></tr><tr><td>LSQ</td><td>21.20</td><td>60.85</td><td>94.35</td><td>36.45</td><td>86.25</td><td>99.15</td></tr><tr><td>DPQ</td><td>8.60</td><td>32.80</td><td>77.50</td><td>15.35</td><td>48.75</td><td>90.75</td></tr><tr><td>DPgQ</td><td>19.85</td><td>57.80</td><td>90.70</td><td>35.05</td><td>84.10</td><td>98.90</td></tr><tr><td>DRQ</td><td>9.65</td><td>34.15</td><td>80.15</td><td>30.75</td><td>77.35</td><td>97.10</td></tr><tr><td>UNQ</td><td>22.25</td><td>61.20</td><td>89.30</td><td>37.10</td><td>85.55</td><td>98.80</td></tr><tr><td>Ours</td><td>24.45</td><td>69.05</td><td>97.65</td><td>39.60</td><td>87.60</td><td>99.80</td></tr></table>
+
+Table 1: Recall(R $) @ \{ 1 , 1 0 , 1 0 0 \}$ on LabelMe22K dataset $( \% )$ . Ours outperforms state-of-the-arts by at least $2 . 2 0 \%$ $7 . 8 5 \%$ , $3 . 3 0 \%$ (32 bits), and $2 . 7 0 \%$ , $1 . 4 5 \%$ , $0 . 6 5 \%$ (64 bits), respectively.
+
+(LabelMe22K, SIFT1M, DEEP1M) can be found in supplementary material.
+
+As for quantization code-lengths, $K = 2 5 6$ codewords for each sub-codebook and $M = \{ 4 , 8 \}$ sub-codebooks are employed in total. We follow [2] to report “effective” code-lengths (additional code-length for storing $\lVert \boldsymbol { x } \rVert$ for lookup table is ignored). Therefore code-lengths become $\{ 3 2 , 6 4 \}$ bits, respectively.
+
+For a fair comparison, experiments are conducted on a single machine, equipped with Intel Xeon E5-2678v3 CPU, 256 GiB RAM, and NVIDIA RTX 3090 GPU. For other methods, we re-run on all datasets under unified settings with implementations provided by the authors.
+
+# 5.3 Comparisons with state-of-the-arts
+
+Under the small training set and base set settings on LabelMe22K, we get the results placed in Table 1. Our method takes the highest recall on this dataset, outperforming the state-of-the-art by $2 . 2 0 \%$ , $7 . 8 5 \%$ , $3 . 3 0 \%$ on 32 bits for $\mathbf { R } \ @ 1$ , $\mathrm { R @ 1 0 }$ and $\mathbf { R } @ \mathbf { 1 } 0 0$ . It also outperforms the best competitor by $2 . 7 0 \%$ , $1 . 4 5 \%$ , $0 . 6 5 \%$ on 64 bits. In brief, All methods except for UNQ are generally split into three styles: 1) PQ-like: OPQ and DPQ. 2) SQ-like: SQ, $\mathrm { D P g Q }$ and DRQ. 3) MCQ: LSQ and ours. Generally, DPQ, $\mathrm { D P g Q }$ , and DRQ achieve similar results compared to their shallow versions. However, since they are still constrained MCQs, they show worse performances than 3). The performance of LSQ is worse than ours, shows the effectiveness of neural networks for modeling the MCQ encoding problem. As for UNQ, it takes several extra tricks i.e., another network for decoding and re-ranking in retrieval. Although it beats LSQ, our network still shows the power of MCQ to win the competition.
+
+<table><tr><td rowspan="3">Method</td><td colspan="6">SIFT1M</td><td colspan="6">DEEP1M</td></tr><tr><td></td><td>32 bits</td><td></td><td></td><td>64 bits</td><td></td><td></td><td>32 bits</td><td></td><td></td><td>64 bits</td><td></td></tr><tr><td>R@1</td><td>R@10</td><td>R@100</td><td>R@1</td><td>R@10</td><td>R@100</td><td>R@1</td><td>R@10</td><td>R@100</td><td>R@1</td><td>R@10</td><td>R@100</td></tr><tr><td>OPQ</td><td>5.34</td><td>22.03</td><td>56.72</td><td>22.84</td><td>60.27</td><td>92.19</td><td>3.07</td><td>15.39</td><td>48.40</td><td>15.34</td><td>50.06</td><td>87.96</td></tr><tr><td>sQ</td><td>9.45</td><td>34.88</td><td>70.07</td><td>24.41</td><td>65.48</td><td>93.17</td><td>6.41</td><td>26.79</td><td>70.25</td><td>19.95</td><td>56.31</td><td>91.27</td></tr><tr><td>LSQ</td><td>11.43</td><td>40.48</td><td>80.52</td><td>33.23</td><td>78.37</td><td>98.72</td><td>7.29</td><td>28.96</td><td>72.93</td><td>21.12</td><td>61.47</td><td>93.98</td></tr><tr><td>DPQ</td><td>5.41</td><td>22.97</td><td>58.57</td><td>21.87</td><td>59.39</td><td>91.66</td><td>1.59</td><td>8.96</td><td>33.09</td><td>9.53</td><td>33.45</td><td>72.80</td></tr><tr><td>DPgQ</td><td>9.71</td><td>35.03</td><td>74.19</td><td>27.96</td><td>69.98</td><td>96.04</td><td>6.36</td><td>26.16</td><td>70.02</td><td>18.98</td><td>55.80</td><td>90.95</td></tr><tr><td>DRQ</td><td>1.40</td><td>8.87</td><td>35.27</td><td>18.56</td><td>53.06</td><td>88.45</td><td>4.48</td><td>22.46</td><td>62.57</td><td>16.10</td><td>52.76</td><td>89.31</td></tr><tr><td>UNQ</td><td>10.01</td><td>33.92</td><td>73.39</td><td>28.37</td><td>69.15</td><td>95.99</td><td>5.19</td><td>23.55</td><td>65.09</td><td>16.12</td><td>52.06</td><td>90.10</td></tr><tr><td>Ours</td><td>11.02</td><td>37.73</td><td>76.79</td><td>28.02</td><td>70.22</td><td>96.43</td><td>7.43</td><td>30.03</td><td>72.48</td><td>20.87</td><td>62.06</td><td>94.07</td></tr></table>
+
+Table 2: Quantitative comparisons with state-of-the-arts on SIFT1M and DEEP1M datasets. $\operatorname { R e c a l l } ( \mathbf { R } ) @ \left\{ 1 , 1 0 , 1 0 0 \right\}$ are reported $( \% )$ . Ours shows comparable performance with staet-of-the-arts on SIFT1M, while achieving the highest recall in most cases on DEEP1M.
+
+# 78 5.3.1 Large-scale retrieval performance
+
+Our evaluations on SIFT1M and DEEP1M datasets is presented in Table 2. The training set and base set are scaled up, and retrievals on these datasets become more difficult. We observe expected results on two datasets. Compared to our main competitor, LSQ, our method achieves comparable performance on SIFT1M, and outperforms LSQ on DEEP1M in most cases. Our method achieves higher recall on DEEP1M than SIFT1M. A potential reason is that DEEP1M is under a nearly normal distribution that, in practice, is easier to converge than SIFT1M, which has a larger variance between datapoints. The performance of UNQ in our experiments is lower than expected, possibly due to different dataset settings.
+
+Another key advantage of our method is that, different from shallow methods, which are hand-crafted algorithms that find possible solutions manually or with constraints, our DeepQ encodes vectors by only a feed-forward.
+
+# 5.3.2 Encoding efficiency
+
+In order to verify the encoding efficiency of our method, evaluations of encoding time on SIFT1M with the $1 0 ^ { 6 }$ base set are conducted by checking the total time spent. All of them are run under GPU-acceleration. Additionally, we evaluate the time with and without the extra codewords refinement that introduced in section 4.3 (128 bits results are simulated). As Figure 3 shows, our network is significantly faster than LSQ since it needs to perform local search iteratively for 25 or even 100 rounds. Specifically, to encode SIFT1M base set, LSQ takes 52.84s, 96.99s, 256.86s and 639.18s for 16, 32, 64 and 128 bits respectively. By contrast, our method takes 4.46s, 5.46s, 8.26s and 16.64s, which is $1 1 . 8 \times$ , $1 7 . 8 \times$ , $3 1 . 1 \times$ and $3 8 . 4 \times$ faster than LSQ. Moreover, our method is even faster than most of the constrained MCQs. We also notice that the refinement takes negligible overhead. Although UNQ takes the fastest encoding speed, it still needs to decode and re-rank during retrieval, which slows down its retrieval speed.
+
+# 5.3.3 Reconstruction accuracy
+
+![](images/706b3a3a6fdaf44b799211fd57ada61964058b8ee1e1aa34549a4cb8bcfc5924.jpg)  
+Figure 3: Total encoding time w.r.t. code-length on SIFT1M dataset. For 128 bits, we illustrate the simulated results. The variant Ours\* removes extra refinement step to show its overhead. Our two variants are significantly faster than LSQ while achieving similar performance. Furthermore, our method is slightly faster than most of the constrained MCQs. Our method achieves high performance as well as superior encoding efficiency. UNQ has the shortest time to encode the whole set, however during retrieval, they still need to decode and re-rank that slow down the speed.
+
+315 datasets are stated in Table 3. Basically, when the quantization error gets lower, recall will be higher.
+
+Table 3: Comparisons of quantization error with state-of-the-arts on three datasets (lower is better). Ours achieves the lowest quantization error in most cases. This gives us benefits of feature reconstruction. Observe that UNQ performs poorly, we believe it focuses more on ranking and similarity preservation, other than reconstruction.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">SIFT1M</td><td colspan="2">DEEP1M</td><td colspan="2">LabelMe22K</td></tr><tr><td>32 bits</td><td>64 bits</td><td>32 bits</td><td>64 bits</td><td>32 bits</td><td>64 bits</td></tr><tr><td>OPQ</td><td>4.03×104</td><td>2.51×104</td><td>4.25×10-1</td><td>2.70×10-1</td><td>1.25×10-1</td><td>9.25×10-2</td></tr><tr><td>sQ</td><td>3.42 ×104</td><td>2.13×104</td><td>3.24×10-1</td><td>2.10×10-1</td><td>1.25 × 10-1</td><td>9.10 ×10-2</td></tr><tr><td>LSQ</td><td>2.90 ×104</td><td>1.12 × 104</td><td>3.04× 10-1</td><td>1.99 ×10-1</td><td>1.21 ×10-1</td><td>8.57×10-2</td></tr><tr><td>DPQ</td><td>4.01×104</td><td>2.48×104</td><td>4.58×10-1</td><td>3.54×10-1</td><td>1.77 × 10-1</td><td>1.60×10-1</td></tr><tr><td>DPgQ</td><td>3.30×104</td><td>2.10×104</td><td>3.29 ×10-1</td><td>2.12 ×10-1</td><td>1.31 × 10-1</td><td>8.74×10-2</td></tr><tr><td>DRQ</td><td>4.75×104</td><td>2.88×104</td><td>3.52 ×10-1</td><td>2.54×10-1</td><td>1.61 × 10-1</td><td>1.01 × 10-1</td></tr><tr><td>UNQ</td><td>4.14×104</td><td>2.33×104</td><td>3.52 ×10-1</td><td>2.39 ×10-1</td><td>1.48 ×10-1</td><td>1.08×10-1</td></tr><tr><td>Ours</td><td>2.92×104</td><td>1.91 × 104</td><td>2.92×10-1</td><td>1.93×10-1</td><td>1.02×10-1</td><td>6.72×10-2</td></tr></table>
+
+316 Ours get the 2nd place on SIFT1M, and the lowest on remaining datasets in most cases. Quantization   
+317 error indicates reconstruction accuracy and further shows the quality of codebook generation and   
+318 quantization codes selection. Notably, ours significantly outperforms UNQ, which has a strong bias   
+319 on the reconstruction task. This is because they focus more on ranking, not the quantization error.   
+320 The result shows that our method can be applied to other areas, e.g. vector compression.
+
+# 5.4 Ablation study
+
+Our ablation study is conducted on the SIFT1M dataset, with the code-length of 32 bits, which in our experiments is sufficient to show how does each component affects our model. We choose the following variants to perform ablation:
+
+w/o regularization: which removes $e _ { \theta }$ in the losses, and the output distributions will not be forced to be uniform.
+
+w/o return-norm: which does not normalize $R$ , and therefor advantage is computed by $R$ other than $\bar { R }$ .
+
+<table><tr><td rowspan="2">Method</td><td colspan="4">SIFT1M@32 bits</td></tr><tr><td>QE</td><td>R@1</td><td>R@10</td><td>R@100</td></tr><tr><td>w/o regularization</td><td>3.38×104</td><td>7.60</td><td>29.96</td><td>68.73</td></tr><tr><td>w/o return-norm</td><td>3.06×104</td><td>10.57</td><td>36.44</td><td>76.04</td></tr><tr><td>w/o correction</td><td>3.10×104</td><td>10.09</td><td>35.30</td><td>75.16</td></tr><tr><td>w/o refinement</td><td>3.17 ×104</td><td>9.91</td><td>30.39</td><td>68.28</td></tr><tr><td>DeepQ</td><td>2.92×104</td><td>11.02</td><td>37.73</td><td>76.79</td></tr></table>
+
+w/o correction: which removes value correction. So our VC-PPO falls back to the original PPO.
+
+Table 4: Ablation study conducted on SIFT1M with 32 bits code-length. Entropy regularization forces network to try more codeword combinations, which help to jump out of local-optima. Return normalization and value correction help for fast convergence. The extra refinement leads to low quantization error and high recall with negligible costs.
+
+w/o refinement: which directly encode the base set without extra refinement.
+
+Quantization error and recall are evaluated and placed in Table 4. We report the best value they ever met during the training procedure. Specifically, when regularization is removed, it seems that the network is trapped in local-optima and the performance drops. Meanwhile, although return normalization and value correction give us only subtle improvements, we find they help the network to converge quickly. The extra refinement gives us lower quantization error and higher recall, specially when we want to perform fast training before the network is converged.
+
+# 43 6 Conclusion and Future Work
+
+In this paper, we first review previous works of constrained MCQs, and investigate solutions to unconstrained ones. Since finding the global-optima of MCQ is NP-hard, researchers apply constraints to find near-optimal solutions or employ heuristic algorithms that are still time-consuming. This paper takes the first attempt to find a deep solution to MCQ. The proposed IndepNet is designed to be simple enough to encode vectors extremely fast. Furthermore, our network shows state-of-the-art performance in retrieval and reconstruction tasks. Our method is slow to converge in a large dataset, which hinders our performance. So, our future work will focus on training speedup.
+
+# 351 References
+
+353 Demmel, J., Bischof, C. H., and Sorensen, D. C. (1990). LAPACK: a portable linear algebra library for   
+354 high-performance computers. In SC, pages 2–11.   
+355 [2] Babenko, A. and Lempitsky, V. (2014). Additive quantization for extreme vector compression. In CVPR,   
+356 pages 931–938.   
+357 [3] Babenko, A. and Lempitsky, V. (2015). Tree quantization for large-scale similarity search and classification.   
+358 In CVPR, pages 4240–4248.   
+359 [4] Chen, Y., Guan, T., and Wang, C. (2010). Approximate nearest neighbor search by residual vector   
+360 quantization. Sensors, 10(12):11259–11273.   
+361 [5] Gao, L., Zhu, X., Song, J., Zhao, Z., and Shen, H. T. (2019). Beyond product quantization: Deep progressive   
+362 quantization for image retrieval. In IJCAI, pages 723–729.   
+363 [6] Ge, T., He, K., Ke, Q., and Sun, J. (2013). Optimized product quantization for approximate nearest neighbor   
+364 search. In CVPR, pages 2946–2953.   
+365 [7] Gray, R. (1984). Vector quantization. IEEE Assp Magazine, 1(2):4–29.   
+366 [8] Ilyas, A., Engstrom, L., Santurkar, S., Tsipras, D., Janoos, F., Rudolph, L., and Madry, A. (2020). A closer   
+367 look at deep policy gradients. In ICLR.   
+368 [9] Jégou, H., Douze, M., and Schmid, C. (2010). Product quantization for nearest neighbor search. IEEE Trans.   
+369 Pattern Anal. Mach. Intell., 33(1):117–128.   
+370 [10] Kalantidis, Y. and Avrithis, Y. (2014). Locally optimized product quantization for approximate nearest   
+371 neighbor search. In CVPR, pages 2329–2336.   
+372 [11] Klein, B. and Wolf, L. (2019). End-to-end supervised product quantization for image search and retrieval.   
+373 In CVPR, pages 5041–5050.   
+374 [12] Konda, V. R. and Tsitsiklis, J. N. (2000). Actor-critic algorithms. In NeurIPS, pages 1008–1014.   
+375 [13] Lloyd, S. (1982). Least squares quantization in pcm. IEEE transactions on information theory, 28(2):129–   
+376 137.   
+377 [14] Martinez, J., Clement, J., Hoos, H. H., and Little, J. J. (2016). Revisiting additive quantization. In ECCV,   
+378 pages 137–153. Springer.   
+379 [15] Martinez, J., Hoos, H. H., and Little, J. J. (2014). Stacked quantizers for compositional vector compression.   
+380 arXiv preprint arXiv:1411.2173.   
+381 [16] Martinez, J., Zakhmi, S., Hoos, H. H., and Little, J. J. (2018). Lsq $^ { + + }$ : Lower running time and higher   
+382 recall in multi-codebook quantization. In ECCV, pages 491–506.   
+383 [17] Mohamed, S., Rosca, M., Figurnov, M., and Mnih, A. (2020). Monte carlo gradient estimation in machine   
+384 learning. J. Mach. Learn. Res., 21:132:1–132:62.   
+385 [18] Morozov, S. and Babenko, A. (2019). Unsupervised neural quantization for compressed-domain similarity   
+386 search. In ICCV, pages 3036–3045.   
+387 [19] Norouzi, M. and Fleet, D. J. (2013). Cartesian k-means. In CVPR, pages 3017–3024.   
+388 [20] Radenovic, F., Iscen, A., Tolias, G., Avrithis, Y., and Chum, O. (2018). Revisiting oxford and paris:   
+389 Large-scale image retrieval benchmarking. In CVPR, pages 5706–5715.   
+390 [21] Reddi, S. J., Kale, S., and Kumar, S. (2018). On the convergence of adam and beyond. In ICLR.   
+391 [22] Sablayrolles, A., Douze, M., Schmid, C., and Jégou, H. (2019). Spreading vectors for similarity search. In   
+392 ICLR.   
+393 [23] Schulman, J., Heess, N., Weber, T., and Abbeel, P. (2015a). Gradient estimation using stochastic computa  
+394 tion graphs. In NeurIPS, pages 3528–3536.   
+395 [24] Schulman, J., Levine, S., Abbeel, P., Jordan, M. I., and Moritz, P. (2015b). Trust region policy optimization.   
+396 In ICML, pages 1889–1897.   
+397 [25] Schulman, J., Moritz, P., Levine, S., Jordan, M. I., and Abbeel, P. (2016). High-dimensional continuous   
+398 control using generalized advantage estimation. In ICLR.   
+399 [26] Schulman, J., Wolski, F., Dhariwal, P., Radford, A., and Klimov, O. (2017). Proximal policy optimization   
+400 algorithms. arXiv preprint arXiv:1707.06347.   
+401 [27] Song, J., Lang, R., Zhu, X., Xu, X., Gao, L., and Shen, H. T. (2020). 3d self-attention for unsupervised   
+402 video quantization. In ACM SIGIR, pages 1061–1070.   
+403 [28] Song, J., Zhu, X., Gao, L., Xu, X.-S., Liu, W., and Shen, H. T. (2019). Deep recurrent quantization for   
+404 generating sequential binary codes. In IJCAI, pages 912–918.   
+405 [29] Torralba, A., Fergus, R., and Weiss, Y. (2008). Small codes and large image databases for recognition. In   
+406 CVPR, pages 1–8. IEEE.   
+407 [30] Wang, J., Wang, J., Song, J., Xu, X., Shen, H. T., and Li, S. (2015). Optimized cartesian k-means. IEEE   
+408 Transactions on Knowledge and Data Engineering, 27(1):180–192.   
+409 [31] Weyand, T., Araujo, A., Cao, B., and Sim, J. (2020). Google landmarks dataset v2 - A large-scale   
+410 benchmark for instance-level recognition and retrieval. In CVPR, pages 2572–2581.   
+411 [32] Williams, R. J. (1992). Simple statistical gradient-following algorithms for connectionist reinforcement   
+412 learning. Machine learning, 8(3-4):229–256.   
+413 [33] Yu, T., Yuan, J., Fang, C., and Jin, H. (2018). Product quantization network for fast image retrieval. In   
+414 ECCV, pages 186–201.   
+415 [34] Zhang, T., Du, C., and Wang, J. (2014). Composite quantization for approximate nearest neighbor search.   
+416 In ICML, volume 2, page 3.
+
+# 417 Checklist
+
+418 The checklist follows the references. Please read the checklist guidelines carefully for information on   
+419 how to answer these questions. For each question, change the default [TODO] to [Yes] , [No] , or   
+420 [N/A] . You are strongly encouraged to include a justification to your answer, either by referencing   
+421 the appropriate section of your paper or providing a brief inline description. For example:
+
+• Did you include the license to the code and datasets? [Yes] See Section ??. • Did you include the license to the code and datasets? [No] The code and the data are proprietary. • Did you include the license to the code and datasets? [N/A]
+
+425 Please do not modify the questions and only use the provided macros for your answers. Note that the   
+426 Checklist section does not count towards the page limit. In your paper, please delete this instructions   
+427 block and only keep the Checklist section heading above along with the questions/answers below.
+
+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] See Section 6.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(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)? [Yes] See https://github.com/ DeepMCQ/DeepQ.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 5 and supplementary materials.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No]   
+(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] See Section 5.
+
+48 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] See Section 5.   
+(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? [Yes] See https://github.com/DeepMCQ/DeepQ.   
+(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/8jFiomKUnaT/8jFiomKUnaT_content_list.json

@@ -0,0 +1,1587 @@
+[
+    {
+        "type": "text",
+        "text": "Revisiting Multi-Codebook Quantization ",
+        "text_level": 1,
+        "bbox": [
+            250,
+            122,
+            748,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            200,
+            580,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            292,
+            535,
+            309
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Multi-Codebook Quantization (MCQ) is a generalized version of existing codebook  \n2 based quantizations for Approximate Nearest Neighbor (ANN) search. Therefore,   \n3 MCQ theoretically has the potential to achieve the best performance because so  \n4 lutions of other codebook-based quantization methods are all covered by MCQ’s   \n5 solution space under the same codebook size setting. However, finding the opti  \n6 mal solution to MCQ is proved to be NP-hard due to its encoding process, i.e.,   \n7 converting an input vector to a binary code. To tackle this, researchers apply   \n8 constraints to it to find near-optimal solutions, or employ heuristic algorithms   \n9 which are still time-consuming for encoding. Different from previous approaches,   \n10 this paper takes the first attempt to find a deep solution to MCQ. The encoding   \n11 network is designed to be as simple as possible, so the very complex encoding   \n12 problem becomes simply a feed-forward. Compared with other methods on three   \n13 datasets, our method shows state-of-the-art performance. Notably, our method   \n14 is $1 1 \\times - 3 8 \\times$ faster than heuristic algorithms for encoding, which makes it more   \n15 practical for real scenery of large-scale retrieval. Our code is publicly available:   \n16 https://github.com/DeepMCQ/DeepQ. ",
+        "bbox": [
+            148,
+            324,
+            766,
+            545
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "17 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            571,
+            312,
+            589
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "18 Rapidly increasing multimedia contents in recent years raise an urgent request for retrieval in a   \n19 short time. Unlike the exhaustive routine [31, 20], Approximate Nearest Neighbor (ANN) search   \n20 significantly reduces retrieval time while preserving high recall. It has been widely applied to various   \n21 scenarios, such as database indexing, fast image retrieval, and recommender systems.   \n22 As a typical approach, vector quantization (VQ) [7] is at first developed as a compression technique,   \n23 which uses a codebook to approximate vectors. People further find the power of VQ to preserve   \n24 similarities between quantized features and enable VQ to perform ANN search. In order to achieve   \n25 low quantization errors with limited codebook size, a multi-codebook structure is introduced. The   \n26 proposal of the Multi-Codebook Quantization (MCQ) [2] describes the approach as a combination   \n27 of one codeword for each sub-codebook, and previous methods [9, 6, 19, 30, 10, 3] are summarized   \n28 as exceptional cases of MCQ or constrained MCQs. The quantization codes are designed to be   \n29 compacted, which results in negligible storage cost and high-quality results.   \n30 However, the optimization of MCQ without any constraints is formally NP-hard. [14] models   \n31 it as the minimization on several fully-connected Markov Random Fields (MRFs). As a result,   \n32 current researches aim at solving MCQ under acceptable computational costs. Other than applying   \n33 constraints on it [34, 4, 15], another approach designs algorithms in a heuristic way [2, 14, 16]. The   \n34 latter achieves better performance but suffers from slow encoding.   \n35 There are chances to employ neural networks’ power to solve MCQ, where people expect to obtain   \n36 higher performance and encoding efficiency than previous methods. [11, 5, 28, 33, 27] already give   \n37 the way to treat codebook as network parameter and update it by gradient-descent, but they are   \n38 all still under constraints that hinder performance. Morozov and Babenko [18] and Sablayrolles et   \n39 al. [22] map datapoints to learned space, which are not flexible, especially when performing the   \n40 reconstruction. Therefore in this paper, we give our first attempt to solve MCQ in a deep learning   \n41 approach, without constraints and work-arounds. Our contributions can be summarized as three-folds:   \n42 • Our novel approach, Deep Multi-Codebook Quantization (DeepQ), fully considers encoding   \n43 difficulty and time complexity in MCQ. With the high efficient and parallelized encoding networks,   \n44 our method significantly reduces encoding time.   \n45 To tackle the NP-hard encoding problem and non-differentiable gradient estimation, we employ and   \n46 further revise a policy gradient method. Value-Corrected Proximal Policy Optimization (VC-PPO)   \n47 is proposed to speed up convergence in the training phase.   \n48 Experiments conducted on a benchmark dataset validate our proposed method. Furthermore, to   \n49 evaluate the scalability of the method, it is tested on million-scale datasets to show the effectiveness   \n50 of our proposed algorithm. ",
+        "bbox": [
+            147,
+            603,
+            823,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            665,
+            825,
+            776
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            782,
+            825,
+            852
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            858,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            152,
+            826,
+            287
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "51 2 Related Works ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            306,
+            330,
+            324
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "52 Vector quantization is a routine to approximate vectors by a codebook. Typical applications include   \n53 clustering, compression, and Approximate Nearest Neighbor (ANN) search. The famous proposal   \n54 $k$ -means [7], also known as Lloyd’s algorithm [13], clusters the dataset into uniformly sized convex   \n55 cells. When it is applied to ANN search, datapoints from the base set are quantized into their   \n56 nearest centriods and represented by indices. The distance from a given query to any datapoint   \n57 is approximated by the distance from the query to the datapoint’s centriod, which is effectively   \n58 pre-computed and stored in a lookup table. To perform fine-grained clustering as well as reducing the   \n59 space and time complexity, they [9, 6, 19, 10, 30] divide the feature space orthogonally by performing   \n60 $k$ -means in each subspace concurrently. Meanwhile, the introduced sub-codebook structure reveals   \n61 the prototype of MCQ. Formally, [2] gives a well definition of MCQ, and previous works are all   \n62 summarized into constrained MCQs. Specifically, subspace $k$ -means must keep orthogonality among   \n63 sub-codebooks. Zhang et al. [34] loosens the orthogonality constraint, but sub-codebooks are still   \n64 weakly-orthogonal. Chen et al. [4] and Martinez et al. [15] propose hierarchical $k$ -means, where   \n65 vectors are quantized coarse-to-fine. If constraints are moved, MCQ is not easy to solve. Current   \n66 state-of-the-art methods develop heuristic algorithms to help to encode. Specifically, Babenko and   \n67 Lempitsky [2] employs beam search, Martinez et al. [14, 16] give algorithm based on Iterated   \n68 Conditional Modes (ICM). However, the above methods do not achieve satisfied time complexity in   \n69 encoding yet.   \n70 When neural networks and gradient descent become a fashion, a few attempts to integrate quantization   \n71 into deep retrieval networks are proposed. Klein and Wolf [11] and Song et al. [5] propose Deep   \n72 Product Quantization (DPQ) and Deep Progressive Quantization $\\mathrm { ( D P g Q ) }$ which update codebook by   \n73 soft relaxation, but they are still under the same constraints as [9, 15]. Sablayrolles et al. [22] and   \n74 Morozov and Babenko [18] give pipelines to encode compact representations for compressed-domain   \n75 search, but they do not strictly follow the paradigm of MCQ. ",
+        "bbox": [
+            145,
+            337,
+            825,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            593,
+            825,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "76 3 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            695,
+            318,
+            713
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "77 Given a vector $\\pmb { x } \\in \\mathbb { R } ^ { D }$ , its quantized vector $\\tilde { \\pmb { x } }$ are composed by several codewords in a codebook   \n78 $C$ . More Specifically, $C = ( \\bar { C } _ { m } )$ , $C _ { m } \\in \\mathbb { R } ^ { K \\times D }$ , $1 \\leq m \\leq M$ contains $M$ sub-codebooks and $K$   \n79 codewords for each. Quantization codes are formed by $\\pmb { b } = ( \\pmb { b } _ { m } )$ , $\\pmb { b _ { m } } \\in \\{ 1 , 2 , \\cdots , K \\}$ , $1 \\leq m \\leq$   \n80 $M$ , which indicates the picked codeword in each sub-codebook. For the whole training set $X = \\{ x \\}$   \n81 with $N$ datapoints, MCQ aims at finding the optimal quantization codes ${ \\boldsymbol { B } } = \\{ { \\boldsymbol { b } } \\}$ and codebook $C$   \n82 to minimize following objective: ",
+        "bbox": [
+            147,
+            726,
+            825,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49b04dc37c65702fbf56ecf6dd2ea3e2f241ff72ba65a7feeecdf14f6d3261e8.jpg",
+        "text": "$$\n\\underset { C , B } { \\operatorname* { m i n } } \\ \\underset { { \\bf { x } } \\in { \\cal { X } } } { \\mathbb { E } } \\operatorname { Q } \\left( { \\bf { x } } , { \\bf { b } } , C \\right) = \\underset { C , B } { \\operatorname* { m i n } } \\ \\underset { { \\bf { x } } \\in { \\cal { X } } } { \\mathbb { E } } \\left\\| { \\bf { x } } - \\sum _ { m = 1 } ^ { M } C _ { m b _ { m } } \\right\\| _ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            816,
+            674,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "83 where $C _ { m { \\pmb b } _ { m } } \\in \\mathbb { R } ^ { D }$ is the $b _ { m }$ -th codeword of the $m$ -th sub-codebook. The sum of picked codewords   \n84 $\\sum C _ { m { \\pmb b } _ { m } }$ tries to approximate $_ { \\textbf { \\em x } }$ . $C$ and $^ { b }$ are stored for further retrieval. Some of the previously   \n85 mentioned methods [9, 6, 4, 15, 34] are treated as constrained MCQs, as they are all represented   \n86 as special cases of (1). Specifically, when $M = 1$ , (1) becomes VQ. Or if any two sub-codebooks   \n87 $C _ { i } , C _ { j }$ are orthogonal, it will be PQ or OPQ.   \n88 The optimization of (1) without any constraints is proved to be NP-hard [14]. To tackle this, we   \n89 propose a Expectation-Maximization style solution. Following sections will explain the deep neural   \n90 network for encoding $^ { b }$ (Section 4.1), the way to solve $C$ (Section 4.2), and how to conduct retrieval   \n91 (Section 4.3), respectively. ",
+        "bbox": [
+            147,
+            868,
+            825,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            126,
+            825,
+            181
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "92 4 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            153,
+            200,
+            313,
+            218
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "93 4.1 Expectation: Encoding $\\textbf {  { B } }$ with neural networks ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            232,
+            545,
+            247
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "94 Our first step, is to find a potential code $^ { b }$ by given $_ { \\textbf { \\em x } }$ and   \n95 a fixed $C$ . A policy $\\pi$ parameterized by $\\theta$ is employed to   \n96 take possible solution of $^ { b }$ by feeding $_ { \\textbf { \\em x } }$ : ",
+        "bbox": [
+            147,
+            257,
+            549,
+            300
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6aa15a957df05570571a28a7a91f94cdbb003ce8a6c642d180e814dbce6a717b.jpg",
+        "text": "$$\n\\pi = \\left( \\pi _ { m } \\right) = \\pi \\left( \\pmb { x } \\mid \\theta _ { m } \\right) , 1 \\leq m \\leq M .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            306,
+            493,
+            324
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "97 More specifically, $\\pi$ produces $M$ Categorical distribu  \n98 tions Categorical $( K , \\pmb { p } _ { m 1 } , \\cdots , \\pmb { p } _ { m K } )$ , where $\\pmb { p } _ { m j }$ is   \n99 the probability to pick the $j$ -th codeword in the $m$ -th   \n100 sub-codebook. A potential encoding $\\boldsymbol { b } _ { m }$ is generated by   \n101 drawing samples from $\\pi _ { m }$ , which then helps us to pick   \n102 codeword $C _ { m b _ { m } }$ . Therefore: ",
+        "bbox": [
+            143,
+            330,
+            550,
+            415
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3c459d93988ed32b76be0d5e7b9e438df9eb14e580e420fbb6a715e8eb4ad0d5.jpg",
+        "text": "$$\n\\pmb { b _ { m } } \\sim \\pi _ { m } \\left( \\pmb { x } \\mid \\theta _ { m } \\right) = \\operatorname { C a t e g o r i c a l } ( K , \\pmb { p _ { m } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            420,
+            508,
+            439
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "103 Since the independence among different sub-codebooks   \n104 is a prerequisite of MCQ, $\\boldsymbol { b } _ { m }$ should be drawn from $\\pi _ { m }$   \n105 independently. Intuitively, the probability of $^ { b }$ to be a   \n106 specific ${ \\pmb { b } } ^ { \\star }$ is derived by conditional independence: ",
+        "bbox": [
+            140,
+            452,
+            547,
+            508
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a62b960589644e691d94f19299f13f2a5c21ce1e0c75dd15d239fedbc74ad5c1.jpg",
+        "text": "$$\n\\operatorname* { P r } \\left( \\boldsymbol { b } = \\boldsymbol { b } ^ { \\star } \\right) = \\prod _ { m = 1 } ^ { M } \\operatorname* { P r } \\left( \\boldsymbol { b } _ { m } = \\boldsymbol { b } _ { m } ^ { \\star } \\right) = \\prod _ { m = 1 } ^ { M } p _ { m \\boldsymbol { b } _ { m } ^ { \\star } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            513,
+            511,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "107 We adopt the power of neural networks to model   \n108 $\\pi _ { m }$ . Specifically, $\\theta _ { m }$ produces $K$ unnormalized log  \n109 probabilities $\\ell _ { m }$ and $\\pmb { p } _ { m j }$ is obtained by Softmax. To   \n110 keep the independence, $\\dot { \\theta _ { m } }$ will not share parameters with   \n111 each other.   \n112 Therefore, $\\theta$ , or our proposed IndepNet is illustrated in   \n113 Figure 1. We first build a basic structure called IndepBlock and duplicate this block for $M$ times as   \n114 $\\theta _ { 1 } , \\theta _ { 2 } , \\cdots , \\theta _ { M }$ . We try to keep the basic structure really simple to achieve high efficiency during   \n115 training and encoding. As the figure shows, IndepBlock is an hourglass network contains 6 layer  \n116 groups (consists of a linear layer with ReLU activation and layer-normalization) with skip-connections.   \n117 The last three outputs are concatenated and further fed into a final linear layer with $K$ outputs as   \n118 $\\ell _ { m } = ( \\ell _ { m 1 } , \\cdot \\cdot \\cdot , \\bar { \\ell } _ { m K } )$ , and therefore: ",
+        "bbox": [
+            140,
+            570,
+            550,
+            640
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b6f11e48f5dde3ac69f93081e039972bb0654b233b1a3a45b23d641592ccfc34.jpg",
+        "image_caption": [
+            "Figure 1: Our proposed IndepNet for producing probabilities of choosing each codeword. IndepBlock is duplicated for $M$ times without shared parameters, in order to keep independence between different IndepBlocks. Categorical distribution is built upon output from the IndepBlock. Then, quantization code $b _ { m }$ associated with sub-codebook $C _ { m }$ is sampled from distribution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            562,
+            215,
+            823,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            646,
+            826,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/961efebbfae0b006f8d58171160a962b71c54f713c0e10166c09a413d72841ab.jpg",
+        "text": "$$\n\\pmb { p } _ { m j } = \\mathrm { S o f t m a x } \\left( \\pmb { \\ell } _ { m } \\right) _ { j } , \\ w h e r e \\ \\pmb { \\ell } _ { m } = \\theta _ { m } \\left( \\pmb { x } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            751,
+            653,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "119 4.1.1 Gradient estimation ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            784,
+            366,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "120 The objective of training $\\theta$ is formed as: ",
+        "bbox": [
+            143,
+            806,
+            437,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c7d9cc96b99782d4d6763024734cab95a67f875e991af32a6310bc0e4d6e4cfb.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\pmb { \\pi } } \\operatorname* { \\mathbb { E } } _ { \\pmb { x } \\in \\pmb { X } } \\mathrm { Q } \\left( \\pmb { x } , \\pmb { b } , \\pmb { C } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            828,
+            584,
+            862
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "121 However, the optimization faces two problems: 1) The encoding of $^ { b }$ involves sampling from discrete   \n122 distributions, which is non-differentiable, 2) All possible encoding of $^ { b }$ is $\\mathcal { O } \\left( \\overset { \\bullet } { K } { } ^ { M } \\right)$ . Exhaustive   \n123 search becomes impracticable.   \n124 Therefore, gradient estimation over discrete, stochastic computation graph is required to train $\\theta$ .   \n125 Mainstream methods [23, 32, 17] include score function gradient estimator, pathwise gradient   \n126 estimator, etc. Meanwhile, minimizing (6) is also faced with the high-variance problem during   \n127 gradient estimation. To tackle this, the advantage function is introduced [12, 25]. Specifically in   \n128 our work, a value network called QENet parameterized by $\\tau$ is proposed to model a value function   \n129 $v = \\mathrm { V } \\left( \\cdot \\mid \\tau \\right)$ . It performs a regression task to minimize the following objectives: ",
+        "bbox": [
+            142,
+            868,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            826,
+            175
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61a7b474f4aa3bbb9029fcf6b97a53dc5c978349829fffde7631e49d407d0889.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\tau } \\underset { \\pmb { x } \\in \\pmb { X } } { \\mathbb { E } } \\| \\mathrm { Q } \\left( \\pmb { x } , \\pmb { b } , \\pmb { C } \\right) - \\mathrm { V } \\left( \\pmb { x } , \\pmb { b } , \\pmb { C } \\mid \\tau \\right) \\| _ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            181,
+            656,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Advantages 130 $\\hat { A }$ is then estimated by ",
+        "bbox": [
+            142,
+            231,
+            403,
+            247
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de141b5cf1a36fc877726b5931dccd18fcbd9a7f893c1f51b055a87c1f45a7ec.jpg",
+        "text": "$$\n\\hat { A } = \\operatorname { Q } \\left( \\mathbf { { x } } , \\boldsymbol { b } , \\boldsymbol { C } \\right) - \\operatorname { V } \\left( \\mathbf { { x } } , \\boldsymbol { b } , \\boldsymbol { C } \\mid \\tau \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            253,
+            480,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "131 The detailed architecture of QENet is shown in Figure 2.   \n132 We reuse the IndepBlock to generate $v$ by $M + 1$ blocks:   \n133 $\\boldsymbol { \\tau } = \\left( \\tau _ { 1 } , \\cdot \\cdot \\cdot , \\tau _ { M } , \\tau _ { x } \\right)$ . Specifically, latent representation   \n134 for each selected-codeword $C _ { m b _ { m } }$ is obtained by: ",
+        "bbox": [
+            140,
+            287,
+            550,
+            343
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0a7877792fdd8d6f0b3c351d17f5df444e91be0571a05754cb5379a9d680ef63.jpg",
+        "text": "$$\n\\pmb { \\iota } _ { m } = \\tau _ { m } ( C _ { m { \\pmb b } _ { m } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            351,
+            424,
+            367
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "135 The last IndepBlock $\\tau _ { x }$ is introduced to transform $_ { \\textbf { \\em x } }$ . Then,   \n136 all the outputs from IndepBlocks are summed up to get   \n137 scalar value $v$ (denoted as “reduce-sum”): ",
+        "bbox": [
+            140,
+            375,
+            549,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/191a27a45eeb34ad88403685a62c75336635c072b5219704927cf4fb3366f952.jpg",
+        "text": "$$\nv = { \\mathrm { s u m } } ( \\iota _ { 1 } , \\cdot \\cdot \\cdot , \\iota _ { M } , \\iota _ { x } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            424,
+            449,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/7d1a762b0aaa3ad7a080abf2fa63c21a54cc7025884a767faccb3fb522015eaa.jpg",
+        "image_caption": [
+            "Figure 2: Our proposed QENet for advantage estimation. First $M$ IndepBlocks are fed by $M$ selected codewords and the last one is fed by $_ { \\textbf { \\em x } }$ . Outputs are summed up to get scalar value $v$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            565,
+            248,
+            823,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "138 Value-corrected proximal policy optimization We   \n139 propose a variant of score function gradient estimator   \n140 called Value Corrected Proximal Policy Optimization (VC  \n141 PPO) based on PPO to get simple but efficient Trust Re  \n142 gion updates [26, 24]. In the real scenario of large-scale   \n143 ANN search, the training size $N$ is usually larger than $1 0 k$ . Conventional PPO still does not satisfy   \n144 us due to the speed of convergence. Therefore, we revise and propose the Value-Corrected PPO   \n145 (VC-PPO) to achieve fast training. Firstly in the sampling stage, $b _ { o }$ and $v _ { o }$ is produced from datapoint   \n146 $_ { \\textbf { \\em x } }$ over whole training set $\\boldsymbol { X }$ by freezing current policy network and value network as $\\theta _ { o } , \\tau _ { o }$ : ",
+        "bbox": [
+            140,
+            454,
+            560,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            525,
+            826,
+            580
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2a5f54dd318140f00307c9f0c496f35885d7fbc41ed0459f9ecf0955ef389ea.jpg",
+        "text": "$$\n\\begin{array} { r l } & { b _ { o } \\sim \\pi \\left( \\pmb { x } \\mid \\theta _ { o } \\right) , } \\\\ & { v _ { o } = \\mathrm { V } \\left( \\pmb { x } , b _ { o } , C \\mid \\tau _ { o } \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            585,
+            578,
+            623
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "147 The probability of producing the sampled $b _ { o }$ is denoted as $p _ { o } = \\operatorname* { P r } \\left( \\pmb { b } _ { o } \\mid \\pmb { x } , \\pmb { \\theta } _ { o } \\right)$ , calculated by   \n148 equation (4). Finally, our surrogate objectives of VC-PPO is defined as [8]: ",
+        "bbox": [
+            140,
+            636,
+            828,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "149 ",
+        "bbox": [
+            142,
+            742,
+            161,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/22e348067959e332c2ca5f6f7710c8f767247a1bf7a3e7d76885211f108b77da.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\theta } = \\operatorname* { m i n } \\left( \\frac { \\operatorname* { P r } \\left( b _ { o } \\mid \\boldsymbol { x } , \\theta \\right) } { \\operatorname* { P r } \\left( b _ { o } \\mid \\boldsymbol { x } , \\theta _ { o } \\right) } \\hat { A } , \\right. } \\\\ & { \\qquad \\left. \\mathrm { c l i p } _ { 1 - \\epsilon } ^ { 1 + \\epsilon } \\left( \\frac { \\operatorname* { P r } \\left( b _ { o } \\mid \\boldsymbol { x } , \\theta \\right) } { \\operatorname* { P r } \\left( b _ { o } \\mid \\boldsymbol { x } , \\theta _ { o } \\right) } \\right) \\hat { A } \\right) , } \\\\ & { \\mathcal { L } _ { \\tau } = \\operatorname* { m a x } \\left( \\left( \\operatorname { Q } \\left( \\boldsymbol { x } , b _ { o } , C \\right) - \\mathrm { V } \\left( \\boldsymbol { x } , b _ { o } , C \\mid \\tau \\right) \\right) ^ { 2 } , \\right. } \\\\ & { \\qquad \\left. \\left( \\mathrm { Q } \\left( \\boldsymbol { x } , b _ { o } , C \\right) - \\boldsymbol { v } _ { o } - \\mathrm { c l i p } _ { - \\epsilon } ^ { + \\epsilon } \\left( \\mathrm { V } \\left( \\boldsymbol { x } , b _ { o } , C \\mid \\tau \\right) - \\boldsymbol { v } _ { o } \\right) \\right) ^ { 2 } \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            670,
+            699,
+            805
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "150 Here, The $\\mathrm { c l i p } \\left( \\cdot \\right)$ forces the policy and value to be not too far from old ones and $\\epsilon$ is the clip-range.   \n151 In both equations, it prevents a large update ratio leading to an unstable policy. The key difference   \n152 between the original PPO and our VC-PPO is, we use $\\mathrm { V } \\left( \\boldsymbol { x } , \\boldsymbol { b _ { o } } , \\boldsymbol { C } \\mid \\tau \\right)$ other than the recorded old   \n153 value $v _ { o }$ from sampling stage to estimate advantage. This modification is treated as a value-correction   \n154 process. Correcting value leads to a precise estimation on advantage, which is based on two reasons:   \n155 a) Biases are introduced into advantage estimation if we use $v _ { o }$ , since the policy is getting better and   \n156 better during training but $\\tau _ { o }$ is froze, and 2) The calculation of $\\mathrm { V } \\left( \\boldsymbol { x } , \\boldsymbol { b _ { o } } , \\boldsymbol { C } \\mid \\tau \\right)$ can be done instantly   \n157 without introducing significant computational overhead. To further encourage the network choose   \n158 codewords uniformly, a regularization is applied to $\\theta$ to maximize the entropy of $\\pi$ : ",
+        "bbox": [
+            140,
+            814,
+            826,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2600f134d6a39bc36fd27d1596b221f5435bebb40f7c67130a041fb5da375978.jpg",
+        "text": "$$\ne _ { \\theta } = - \\sum _ { m = 1 } ^ { M } \\sum _ { j = 1 } ^ { K } p _ { m j } \\log { p _ { m j } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            127,
+            596,
+            172
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "159 which forces network to try more codeword combinations. ",
+        "bbox": [
+            142,
+            179,
+            557,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "60 4.2 Maximization: Solve $C$ by least-squares ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            210,
+            491,
+            227
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "161 To give the closed-form derivation of solving $C$ by given $\\boldsymbol { X }$ and $\\textbf {  { B } }$ , We will firstly rewrite Equation   \n162 (1) to a matrix formulation. Since $\\pmb { b } = ( \\pmb { b } _ { 1 } , \\pmb { b } _ { 2 } , \\pmb { \\cdot \\cdot \\cdot } , \\pmb { b } _ { M } )$ and ${ \\pmb b } _ { m } \\in \\{ 1 , 2 , \\cdots \\dot { K } \\}$ is the index of   \n163 selected codeword in the $i$ -th sub-codebook, a one-hot encoding and a concatenation on each $b _ { m }$ :   \n164 $\\pmb { b } _ { m } ^ { \\prime } = \\mathrm { o n e - h o t } ( \\pmb { b } _ { m } )$ , $\\pmb { b } ^ { \\prime } = ( \\pmb { b } _ { 1 } ^ { \\prime } , \\cdots , \\pmb { b } _ { m } ^ { \\prime } )$ will convert the quantization code to a $M$ -hot vector i.e. a   \n165 vector that contains $M$ segments, and each segment contains exactly one 1 and remaining 0, where   \n1 is the entry of picked codeword. Correspondingly, a reshape is applied to 166 $C \\colon C ^ { \\prime } = \\left( \\begin{array} { c } { { C _ { 1 } } } \\\\ { { C _ { 2 } } } \\\\ { { \\vdots } } \\\\ { { C _ { M } } } \\end{array} \\right) \\in$ ",
+        "bbox": [
+            138,
+            236,
+            828,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbb { R } ^ { ( M \\times K ) \\times D }$ . (1) will become: ",
+        "bbox": [
+            163,
+            372,
+            372,
+            388
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92203fb75cdfb88648c18e1251b72658fffc964587d6172a3b34588b94445a89.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\boldsymbol { C ^ { \\prime } } } \\left\\| \\boldsymbol { X } - \\boldsymbol { B ^ { \\prime } } \\boldsymbol { C ^ { \\prime } } \\right\\| _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            387,
+            568,
+            414
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "168 This equation is formally a linear least-squares regression, where $\\pmb { { B } } ^ { \\prime } \\in \\{ 0 , 1 \\} ^ { N \\times ( M \\times K ) }$ is known   \n169 and $\\boldsymbol { X }$ is target. Although there is a bunch of algorithms to solve it, we finally choose gelsy [1],   \n170 which in our experiments shows the best results. The solution is to first apply a QR factorization with   \n171 column permutation on $B ^ { \\prime }$ : ",
+        "bbox": [
+            140,
+            426,
+            826,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/02e6374ce5a25b6bc52b26e948de6f86f82fb6e3dcefa1d1e8aff09ea3cf2ea8.jpg",
+        "text": "$$\nB ^ { \\prime } = Q \\left( \\begin{array} { c c } { { R _ { 1 1 } } } & { { R _ { 1 2 } } } \\\\ { { 0 } } & { { R _ { 2 2 } } } \\end{array} \\right) P ^ { \\intercal }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            483,
+            591,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where 172 $Q$ and $\\pmb { R } = \\left( \\begin{array} { c c } { R _ { 1 1 } } & { R _ { 1 2 } } \\\\ { 0 } & { R _ { 2 2 } } \\end{array} \\right)$ is the factorization matrix and $_ { r }$ is an orthogonal matrix that 173 permutes columns of $B ^ { \\prime }$ until $\\pmb { R } _ { 1 1 }$ is well-conditioned (its estimated condition number approaches 174 0). With the permutation, $ { R _ { 2 2 } }$ becomes negligible. Moreover, $\\mathbf { R } _ { 1 2 }$ is erased by another orthogonal 175 transformation: ",
+        "bbox": [
+            140,
+            523,
+            825,
+            595
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b134d9efca723d4c9dfe1b620958e639fc0e93d5c53af02c3e03d1195ce292f.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\bigg ( R _ { 1 1 } } & { { } R _ { 1 2 } \\bigg )  \\bigg ( R _ { 1 1 } \\quad R _ { 1 2 } \\bigg ) = \\bigg ( T _ { 1 1 } \\quad 0 \\bigg ) Z } \\\\ { 0 } & { { } R _ { 2 2 } \\bigg )  \\bigg ( T _ { 0 } \\qquad 0 \\bigg ) = \\bigg ( T _ { 0 } \\quad 0 \\bigg ) Z } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            594,
+            668,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where 176 $\\mathbf { T }$ and $z$ are from the orthogonal transformation of $\\pmb { R }$ . Then, $C ^ { \\prime }$ is derived by: ",
+        "bbox": [
+            142,
+            635,
+            735,
+            650
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8c6ec043e2ff760713295bca760de5b8497f6229e375967916e38dd50aa97254.jpg",
+        "text": "$$\n\\begin{array} { r } { B ^ { \\prime } = Q \\left( \\begin{array} { c c } { T _ { 1 1 } } & { 0 } \\\\ { 0 } & { 0 } \\end{array} \\right) Z P ^ { \\intercal } , } \\\\ { C \\gets C ^ { \\prime } \\gets P Z ^ { \\intercal } \\left( \\begin{array} { c c } { T _ { 1 1 } ^ { - 1 } Q _ { 1 } ^ { \\intercal } X } \\\\ { 0 } \\end{array} \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            656,
+            609,
+            728
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where 177 $Q _ { 1 }$ is the top $\\mathrm { r a n k } ( B ^ { \\prime } )$ columns of $Q$ . ",
+        "bbox": [
+            142,
+            734,
+            473,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "178 In brief, our overall training approach is summarized into algorithm 1. ",
+        "bbox": [
+            145,
+            756,
+            633,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 Fast retrieval ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            789,
+            307,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "80 After training, we are able to encode the base set for retrieval. Other than sampling from $\\pi$ , codewords   \n81 are simply rolled out by greedy assignments: ",
+        "bbox": [
+            156,
+            814,
+            825,
+            843
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b517b3fe7194dc1d9aa4a6c19d7455a08f48cfc9aa8b943117ffc6e4790e6776.jpg",
+        "text": "$$\n\\pmb { b } _ { m } ^ { g } = \\arg \\operatorname* { m a x } \\theta _ { m } ( \\pmb { x } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            851,
+            576,
+            868
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "182 We firstly use the greedy roll-out strategy to obtain $\\textbf {  { B } }$ in the training set in order to solve the final   \n183 codebook. Then, we employ the same strategy to encode the base set.   \n184 To further refine assignments, we add an extra step that randomly selects and alters $b _ { i }$ while fixing   \n185 others: ",
+        "bbox": [
+            138,
+            882,
+            826,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93256c486a65bba72c2946046f8aa289280081e2f60e83fb05a7887976df91c5.jpg",
+        "text": "$$\n\\begin{array} { l } { { b _ { i } ^ { g }  \\underset { b _ { i } ^ { g } } { \\operatorname { a r g m i n } } \\mathrm { Q } ( x , b ^ { g } , C ) , } } \\\\ { { \\quad i \\sim \\mathcal { U } [ 1 , M ] . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            123,
+            594,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "186 Since this refinement only causes negligible overhead referred to the implementation by [14], in   \n187 practice, we benefit from it not only to get lower quantization error but also to obtain acceptable   \n188 performance from a fast training, i.e., training within a very few steps before the network is converged.   \n189 The encoded and refined base set, combined with the codebook, is finally employed for retrieval. The   \n90 LSQ-style lookup table [14] is utilized to speed up similarity search. ",
+        "bbox": [
+            142,
+            186,
+            825,
+            228
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            234,
+            828,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "191 4.4 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            280,
+            285,
+            295
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our work aims at solving Multi-Codebook Quantization via neural networks. Similar works include Unsupervised Neural Quantization (UNQ) [18] and Spreading Vectors [22]. But ours has several key advantages compared to previous works: 1) Unlike UNQ, which reconstructs features by an encoderdecoder structure, we follow the paradigm of MCQ to directly give binary codes and codebooks for the benefit of speed and storage, for UNQ needs an extra decoding stage during retrieval. 2) UNQ and Spreading Vectors both project original features into a learned space. Although similarities between features are preserved, they still have biases in quantized results. This causes several issues, especially when we want to perform a reconstruction to approximate original features, e.g. data compression. ",
+        "bbox": [
+            161,
+            308,
+            503,
+            526
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "208 Compared to LSQ [14], the state-of-the-art heuris  \n209 tic algorithm, our work is the first to tackle MCQ in   \n210 a deep learning fashion. The policy network is de  \n211 signed to be very simple to get fast encoding speed   \n212 and comparable retrieval performance. ",
+        "bbox": [
+            145,
+            534,
+            504,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: VC-PPO for Training ",
+        "text_level": 1,
+        "bbox": [
+            517,
+            286,
+            753,
+            301
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inputs: Training set $\\boldsymbol { X }$ , max step $T$ , hyper  \nparameters $\\alpha$ , \u000f, learning rates $\\eta _ { 1 } , \\eta _ { 2 }$ .   \nOutputs: Policy $\\pi$ .   \nInitialize codebook $C$ , parameters $\\theta$ and $\\tau$ ;   \n$i \\gets 0$ ;   \nwhile $i < T$ do $^ { \\prime * }$ Training loop $^ { * / }$ for $_ { \\textbf { \\em x } }$ in $\\boldsymbol { X }$ do $^ { \\prime * }$ Sampling stage $^ { * / }$ Sample $\\ b { b _ { o } } \\sim \\pi \\left( \\pmb { x } \\mid \\theta _ { o } \\right)$ into $\\textbf {  { B } }$ ; Compute $v _ { o } , p _ { o }$ into $V$ , $_ { r }$ ; end for $x , b _ { o } , v _ { o } , p _ { o }$ in $X , B , V , P r$ do $^ { \\prime * }$ Updating stage $^ { * / }$ $\\tau  \\tau - \\eta _ { 1 } \\nabla _ { \\tau } { \\mathcal { L } } _ { \\tau }$ ; Compute $\\hat { A }$ by (8); $\\theta  \\theta + \\eta _ { 2 } \\nabla _ { \\theta } ( \\mathcal { L } _ { \\theta } + \\alpha \\cdot e _ { \\theta } ) ;$ end C ← Solved by (15) ∼ (18); $i \\gets i + 1$ ;   \nend   \nreturn π (· | θ) ",
+        "bbox": [
+            514,
+            304,
+            812,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            623,
+            312,
+            640
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "214 Our proposed Deep Multi-Codebook Quantization (DeepQ) is compared against the state-of-the-arts   \n215 on a visual-feature dataset (LabelMe22K) to evaluate retrieval performance and encoding speed.   \n216 Then, we scale up to make comparisons on commonly used large-scale datasets (SIFT1M and   \n217 DEEP1M), whose base sets include 1 million vectors for retrieval. Furthermore, ablation study on   \n218 SIFT1M investigates the effectiveness of each component in our proposed pipeline. ",
+        "bbox": [
+            147,
+            655,
+            825,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Datasets and evaluation metrics ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            742,
+            434,
+            757
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "LabelMe22K [29]: This dataset collects images by the LabelMe annotation tool1 and uses Convolutional Neural Network (CNN) to extract them into 512-d features. It has 22, 019 vectors for training and 2, 000 vectors for test. ",
+        "bbox": [
+            171,
+            767,
+            825,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "SIFT1M2 and DEEP1M3: Both datasets contain $1 0 ^ { 4 }$ , $1 0 ^ { 5 }$ , $1 0 ^ { 6 }$ vectors in query, training and base set, respectively. Vectors from SIFT1M is extracted by Scale-Invariant Feature Transform (128-d) while DEEP1M contains 96-d vectors from outputs of a CNN. ",
+        "bbox": [
+            166,
+            815,
+            823,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "226 Recall $ @ \\{ 1 , 1 0 , 1 0 0 \\}$ and quantization error are adopted as evaluation metrics. These two metrics   \n227 indicate not only the retrieval performance but also the reconstruction accuracy. Because LabelMe22K   \n228 does not have a base set, its training set is adopted as a base set. We train on the training set, and then   \n229 encode the base set for evaluations with queries. When calculating recall, groundtruth is defined as   \n230 the nearest neighbor of each query in the base set (sorted by l2 distance). As for quantization error,   \n231 the average value of $\\wr ( { \\pmb x } , { \\pmb b } , { \\pmb C } )$ is reported over all $_ { \\textbf { \\em x } }$ in the base set. ",
+        "bbox": [
+            140,
+            92,
+            825,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare our proposal with both shallow and deep methods, including three classic quantization: OPQ [6], SQ [15] and $\\mathbf { L S Q + + }$ [14, 16] (denoted as LSQ for simplicity. Also, these two in our experiments have similar performance), as well as three graident-based methods: DPQ [11], $\\mathbf { D P g Q }$ [5] and DRQ [28]. DPQ and PQNet [33] have basically the same architecture that extend PQ with gradient-descent, so we only report the performance of DPQ. Additionally, UNQ [18] is also included, although they introduce an extra decoder and re-ranking trick for retrieval. ",
+        "bbox": [
+            169,
+            181,
+            825,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 Implementation details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            281,
+            372,
+            295
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our method is implemented with PyTorch,4 the popular deep learning package in Python. Codebook $C$ is solved by Intel MKL that has been fully optimized for speed. As for network training, we adopt Adam optimizer with AMSGrad [21] and hyperparameters are tuned by grid search. Specifically, learning rates $\\eta _ { 1 } = \\eta _ { 2 } =$ $2 \\times 1 0 ^ { - 4 }$ , with an exponetial learning rate decay $\\gamma = 0 . 9 9 9 9$ . Batch-size in updating stage is 2000, while other hyper-parameters $\\epsilon = 0 . 2$ , $\\alpha = 0 . 0 5$ . Additionally, during training, we insert dropout layers after every layernormalization in all layer-groups to tackle overfitting. More detailed settings as well as specifications of $I n$ - depNet $\\theta$ and QENet $\\tau$ on each dataset ",
+        "bbox": [
+            173,
+            306,
+            421,
+            566
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9b43679453b4e6c934cd6a1249740aafecd7ad6bc1df7092e58cd2fc42ad93be.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Method</td><td colspan=\"6\">LabelMe22K</td></tr><tr><td rowspan=\"2\">R@1</td><td>32 bits</td><td rowspan=\"2\">R@100</td><td rowspan=\"2\">R@1</td><td rowspan=\"2\">64 bits R@10</td><td rowspan=\"2\">R@100</td></tr><tr><td>R@10</td></tr><tr><td>OPQ</td><td>18.70</td><td>57.25</td><td>90.10</td><td>32.30</td><td>80.40</td><td>98.00</td></tr><tr><td>SQ</td><td>18.45</td><td>57.60</td><td>90.85</td><td>32.65</td><td>82.05</td><td>99.05</td></tr><tr><td>LSQ</td><td>21.20</td><td>60.85</td><td>94.35</td><td>36.45</td><td>86.25</td><td>99.15</td></tr><tr><td>DPQ</td><td>8.60</td><td>32.80</td><td>77.50</td><td>15.35</td><td>48.75</td><td>90.75</td></tr><tr><td>DPgQ</td><td>19.85</td><td>57.80</td><td>90.70</td><td>35.05</td><td>84.10</td><td>98.90</td></tr><tr><td>DRQ</td><td>9.65</td><td>34.15</td><td>80.15</td><td>30.75</td><td>77.35</td><td>97.10</td></tr><tr><td>UNQ</td><td>22.25</td><td>61.20</td><td>89.30</td><td>37.10</td><td>85.55</td><td>98.80</td></tr><tr><td>Ours</td><td>24.45</td><td>69.05</td><td>97.65</td><td>39.60</td><td>87.60</td><td>99.80</td></tr></table>",
+        "bbox": [
+            434,
+            323,
+            821,
+            489
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Recall(R $) @ \\{ 1 , 1 0 , 1 0 0 \\}$ on LabelMe22K dataset $( \\% )$ . Ours outperforms state-of-the-arts by at least $2 . 2 0 \\%$ $7 . 8 5 \\%$ , $3 . 3 0 \\%$ (32 bits), and $2 . 7 0 \\%$ , $1 . 4 5 \\%$ , $0 . 6 5 \\%$ (64 bits), respectively. ",
+        "bbox": [
+            431,
+            497,
+            823,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(LabelMe22K, SIFT1M, DEEP1M) can be found in supplementary material. ",
+        "bbox": [
+            163,
+            568,
+            674,
+            582
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As for quantization code-lengths, $K = 2 5 6$ codewords for each sub-codebook and $M = \\{ 4 , 8 \\}$ sub-codebooks are employed in total. We follow [2] to report “effective” code-lengths (additional code-length for storing $\\lVert \\boldsymbol { x } \\rVert$ for lookup table is ignored). Therefore code-lengths become $\\{ 3 2 , 6 4 \\}$ bits, respectively. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            645
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For a fair comparison, experiments are conducted on a single machine, equipped with Intel Xeon E5-2678v3 CPU, 256 GiB RAM, and NVIDIA RTX 3090 GPU. For other methods, we re-run on all datasets under unified settings with implementations provided by the authors. ",
+        "bbox": [
+            176,
+            651,
+            823,
+            693
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 Comparisons with state-of-the-arts ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            709,
+            455,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Under the small training set and base set settings on LabelMe22K, we get the results placed in Table 1. Our method takes the highest recall on this dataset, outperforming the state-of-the-art by $2 . 2 0 \\%$ , $7 . 8 5 \\%$ , $3 . 3 0 \\%$ on 32 bits for $\\mathbf { R } \\ @ 1$ , $\\mathrm { R @ 1 0 }$ and $\\mathbf { R } @ \\mathbf { 1 } 0 0$ . It also outperforms the best competitor by $2 . 7 0 \\%$ , $1 . 4 5 \\%$ , $0 . 6 5 \\%$ on 64 bits. In brief, All methods except for UNQ are generally split into three styles: 1) PQ-like: OPQ and DPQ. 2) SQ-like: SQ, $\\mathrm { D P g Q }$ and DRQ. 3) MCQ: LSQ and ours. Generally, DPQ, $\\mathrm { D P g Q }$ , and DRQ achieve similar results compared to their shallow versions. However, since they are still constrained MCQs, they show worse performances than 3). The performance of LSQ is worse than ours, shows the effectiveness of neural networks for modeling the MCQ encoding problem. As for UNQ, it takes several extra tricks i.e., another network for decoding and re-ranking in retrieval. Although it beats LSQ, our network still shows the power of MCQ to win the competition. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2d29c59c2ed53fba3e7ebc3047c4a5874b881d5af5c32f8351b1bb1d3165bd47.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Quantitative comparisons with state-of-the-arts on SIFT1M and DEEP1M datasets. $\\operatorname { R e c a l l } ( \\mathbf { R } ) @ \\left\\{ 1 , 1 0 , 1 0 0 \\right\\}$ are reported $( \\% )$ . Ours shows comparable performance with staet-of-the-arts on SIFT1M, while achieving the highest recall in most cases on DEEP1M. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"3\">Method</td><td colspan=\"6\">SIFT1M</td><td colspan=\"6\">DEEP1M</td></tr><tr><td></td><td>32 bits</td><td></td><td></td><td>64 bits</td><td></td><td></td><td>32 bits</td><td></td><td></td><td>64 bits</td><td></td></tr><tr><td>R@1</td><td>R@10</td><td>R@100</td><td>R@1</td><td>R@10</td><td>R@100</td><td>R@1</td><td>R@10</td><td>R@100</td><td>R@1</td><td>R@10</td><td>R@100</td></tr><tr><td>OPQ</td><td>5.34</td><td>22.03</td><td>56.72</td><td>22.84</td><td>60.27</td><td>92.19</td><td>3.07</td><td>15.39</td><td>48.40</td><td>15.34</td><td>50.06</td><td>87.96</td></tr><tr><td>sQ</td><td>9.45</td><td>34.88</td><td>70.07</td><td>24.41</td><td>65.48</td><td>93.17</td><td>6.41</td><td>26.79</td><td>70.25</td><td>19.95</td><td>56.31</td><td>91.27</td></tr><tr><td>LSQ</td><td>11.43</td><td>40.48</td><td>80.52</td><td>33.23</td><td>78.37</td><td>98.72</td><td>7.29</td><td>28.96</td><td>72.93</td><td>21.12</td><td>61.47</td><td>93.98</td></tr><tr><td>DPQ</td><td>5.41</td><td>22.97</td><td>58.57</td><td>21.87</td><td>59.39</td><td>91.66</td><td>1.59</td><td>8.96</td><td>33.09</td><td>9.53</td><td>33.45</td><td>72.80</td></tr><tr><td>DPgQ</td><td>9.71</td><td>35.03</td><td>74.19</td><td>27.96</td><td>69.98</td><td>96.04</td><td>6.36</td><td>26.16</td><td>70.02</td><td>18.98</td><td>55.80</td><td>90.95</td></tr><tr><td>DRQ</td><td>1.40</td><td>8.87</td><td>35.27</td><td>18.56</td><td>53.06</td><td>88.45</td><td>4.48</td><td>22.46</td><td>62.57</td><td>16.10</td><td>52.76</td><td>89.31</td></tr><tr><td>UNQ</td><td>10.01</td><td>33.92</td><td>73.39</td><td>28.37</td><td>69.15</td><td>95.99</td><td>5.19</td><td>23.55</td><td>65.09</td><td>16.12</td><td>52.06</td><td>90.10</td></tr><tr><td>Ours</td><td>11.02</td><td>37.73</td><td>76.79</td><td>28.02</td><td>70.22</td><td>96.43</td><td>7.43</td><td>30.03</td><td>72.48</td><td>20.87</td><td>62.06</td><td>94.07</td></tr></table>",
+        "bbox": [
+            173,
+            88,
+            823,
+            239
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "78 5.3.1 Large-scale retrieval performance ",
+        "text_level": 1,
+        "bbox": [
+            155,
+            315,
+            460,
+            330
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our evaluations on SIFT1M and DEEP1M datasets is presented in Table 2. The training set and base set are scaled up, and retrievals on these datasets become more difficult. We observe expected results on two datasets. Compared to our main competitor, LSQ, our method achieves comparable performance on SIFT1M, and outperforms LSQ on DEEP1M in most cases. Our method achieves higher recall on DEEP1M than SIFT1M. A potential reason is that DEEP1M is under a nearly normal distribution that, in practice, is easier to converge than SIFT1M, which has a larger variance between datapoints. The performance of UNQ in our experiments is lower than expected, possibly due to different dataset settings. ",
+        "bbox": [
+            173,
+            339,
+            825,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another key advantage of our method is that, different from shallow methods, which are hand-crafted algorithms that find possible solutions manually or with constraints, our DeepQ encodes vectors by only a feed-forward. ",
+        "bbox": [
+            176,
+            457,
+            825,
+            498
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3.2 Encoding efficiency ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            515,
+            359,
+            530
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to verify the encoding efficiency of our method, evaluations of encoding time on SIFT1M with the $1 0 ^ { 6 }$ base set are conducted by checking the total time spent. All of them are run under GPU-acceleration. Additionally, we evaluate the time with and without the extra codewords refinement that introduced in section 4.3 (128 bits results are simulated). As Figure 3 shows, our network is significantly faster than LSQ since it needs to perform local search iteratively for 25 or even 100 rounds. Specifically, to encode SIFT1M base set, LSQ takes 52.84s, 96.99s, 256.86s and 639.18s for 16, 32, 64 and 128 bits respectively. By contrast, our method takes 4.46s, 5.46s, 8.26s and 16.64s, which is $1 1 . 8 \\times$ , $1 7 . 8 \\times$ , $3 1 . 1 \\times$ and $3 8 . 4 \\times$ faster than LSQ. Moreover, our method is even faster than most of the constrained MCQs. We also notice that the refinement takes negligible overhead. Although UNQ takes the fastest encoding speed, it still needs to decode and re-rank during retrieval, which slows down its retrieval speed. ",
+        "bbox": [
+            173,
+            539,
+            485,
+            842
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3.3 Reconstruction accuracy ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            859,
+            397,
+            873
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/706b3a3a6fdaf44b799211fd57ada61964058b8ee1e1aa34549a4cb8bcfc5924.jpg",
+        "image_caption": [
+            "Figure 3: Total encoding time w.r.t. code-length on SIFT1M dataset. For 128 bits, we illustrate the simulated results. The variant Ours\\* removes extra refinement step to show its overhead. Our two variants are significantly faster than LSQ while achieving similar performance. Furthermore, our method is slightly faster than most of the constrained MCQs. Our method achieves high performance as well as superior encoding efficiency. UNQ has the shortest time to encode the whole set, however during retrieval, they still need to decode and re-rank that slow down the speed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            508,
+            823,
+            699
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "315 datasets are stated in Table 3. Basically, when the quantization error gets lower, recall will be higher. ",
+        "bbox": [
+            148,
+            897,
+            826,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e9e91a5492899ec798bba4382e3d03b8a74c0c1625ee5d63fc74bc05438c206.jpg",
+        "table_caption": [
+            "Table 3: Comparisons of quantization error with state-of-the-arts on three datasets (lower is better). Ours achieves the lowest quantization error in most cases. This gives us benefits of feature reconstruction. Observe that UNQ performs poorly, we believe it focuses more on ranking and similarity preservation, other than reconstruction. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">SIFT1M</td><td colspan=\"2\">DEEP1M</td><td colspan=\"2\">LabelMe22K</td></tr><tr><td>32 bits</td><td>64 bits</td><td>32 bits</td><td>64 bits</td><td>32 bits</td><td>64 bits</td></tr><tr><td>OPQ</td><td>4.03×104</td><td>2.51×104</td><td>4.25×10-1</td><td>2.70×10-1</td><td>1.25×10-1</td><td>9.25×10-2</td></tr><tr><td>sQ</td><td>3.42 ×104</td><td>2.13×104</td><td>3.24×10-1</td><td>2.10×10-1</td><td>1.25 × 10-1</td><td>9.10 ×10-2</td></tr><tr><td>LSQ</td><td>2.90 ×104</td><td>1.12 × 104</td><td>3.04× 10-1</td><td>1.99 ×10-1</td><td>1.21 ×10-1</td><td>8.57×10-2</td></tr><tr><td>DPQ</td><td>4.01×104</td><td>2.48×104</td><td>4.58×10-1</td><td>3.54×10-1</td><td>1.77 × 10-1</td><td>1.60×10-1</td></tr><tr><td>DPgQ</td><td>3.30×104</td><td>2.10×104</td><td>3.29 ×10-1</td><td>2.12 ×10-1</td><td>1.31 × 10-1</td><td>8.74×10-2</td></tr><tr><td>DRQ</td><td>4.75×104</td><td>2.88×104</td><td>3.52 ×10-1</td><td>2.54×10-1</td><td>1.61 × 10-1</td><td>1.01 × 10-1</td></tr><tr><td>UNQ</td><td>4.14×104</td><td>2.33×104</td><td>3.52 ×10-1</td><td>2.39 ×10-1</td><td>1.48 ×10-1</td><td>1.08×10-1</td></tr><tr><td>Ours</td><td>2.92×104</td><td>1.91 × 104</td><td>2.92×10-1</td><td>1.93×10-1</td><td>1.02×10-1</td><td>6.72×10-2</td></tr></table>",
+        "bbox": [
+            173,
+            88,
+            825,
+            232
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "316 Ours get the 2nd place on SIFT1M, and the lowest on remaining datasets in most cases. Quantization   \n317 error indicates reconstruction accuracy and further shows the quality of codebook generation and   \n318 quantization codes selection. Notably, ours significantly outperforms UNQ, which has a strong bias   \n319 on the reconstruction task. This is because they focus more on ranking, not the quantization error.   \n320 The result shows that our method can be applied to other areas, e.g. vector compression. ",
+        "bbox": [
+            140,
+            319,
+            825,
+            388
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 Ablation study ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            405,
+            313,
+            419
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our ablation study is conducted on the SIFT1M dataset, with the code-length of 32 bits, which in our experiments is sufficient to show how does each component affects our model. We choose the following variants to perform ablation: ",
+        "bbox": [
+            173,
+            430,
+            452,
+            512
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "w/o regularization: which removes $e _ { \\theta }$ in the losses, and the output distributions will not be forced to be uniform. ",
+        "bbox": [
+            174,
+            520,
+            450,
+            560
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "w/o return-norm: which does not normalize $R$ , and therefor advantage is computed by $R$ other than $\\bar { R }$ . ",
+        "bbox": [
+            173,
+            568,
+            450,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/d9e8fc7d2d4f1e89b83389fee6027acdf1012132fa06e52b848439b318d7b586.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"4\">SIFT1M@32 bits</td></tr><tr><td>QE</td><td>R@1</td><td>R@10</td><td>R@100</td></tr><tr><td>w/o regularization</td><td>3.38×104</td><td>7.60</td><td>29.96</td><td>68.73</td></tr><tr><td>w/o return-norm</td><td>3.06×104</td><td>10.57</td><td>36.44</td><td>76.04</td></tr><tr><td>w/o correction</td><td>3.10×104</td><td>10.09</td><td>35.30</td><td>75.16</td></tr><tr><td>w/o refinement</td><td>3.17 ×104</td><td>9.91</td><td>30.39</td><td>68.28</td></tr><tr><td>DeepQ</td><td>2.92×104</td><td>11.02</td><td>37.73</td><td>76.79</td></tr></table>",
+        "bbox": [
+            464,
+            404,
+            825,
+            516
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "w/o correction: which removes value correction. So our VC-PPO falls back to the original PPO. ",
+        "bbox": [
+            169,
+            617,
+            534,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Ablation study conducted on SIFT1M with 32 bits code-length. Entropy regularization forces network to try more codeword combinations, which help to jump out of local-optima. Return normalization and value correction help for fast convergence. The extra refinement leads to low quantization error and high recall with negligible costs. ",
+        "bbox": [
+            465,
+            522,
+            825,
+            619
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "w/o refinement: which directly encode the base set without extra refinement. ",
+        "bbox": [
+            171,
+            650,
+            678,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Quantization error and recall are evaluated and placed in Table 4. We report the best value they ever met during the training procedure. Specifically, when regularization is removed, it seems that the network is trapped in local-optima and the performance drops. Meanwhile, although return normalization and value correction give us only subtle improvements, we find they help the network to converge quickly. The extra refinement gives us lower quantization error and higher recall, specially when we want to perform fast training before the network is converged. ",
+        "bbox": [
+            173,
+            671,
+            825,
+            755
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "43 6 Conclusion and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            153,
+            773,
+            449,
+            790
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we first review previous works of constrained MCQs, and investigate solutions to unconstrained ones. Since finding the global-optima of MCQ is NP-hard, researchers apply constraints to find near-optimal solutions or employ heuristic algorithms that are still time-consuming. This paper takes the first attempt to find a deep solution to MCQ. The proposed IndepNet is designed to be simple enough to encode vectors extremely fast. Furthermore, our network shows state-of-the-art performance in retrieval and reconstruction tasks. Our method is slow to converge in a large dataset, which hinders our performance. So, our future work will focus on training speedup. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            902
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "351 References ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            89,
+            267,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "353 Demmel, J., Bischof, C. H., and Sorensen, D. C. (1990). LAPACK: a portable linear algebra library for   \n354 high-performance computers. In SC, pages 2–11.   \n355 [2] Babenko, A. and Lempitsky, V. (2014). Additive quantization for extreme vector compression. In CVPR,   \n356 pages 931–938.   \n357 [3] Babenko, A. and Lempitsky, V. (2015). Tree quantization for large-scale similarity search and classification.   \n358 In CVPR, pages 4240–4248.   \n359 [4] Chen, Y., Guan, T., and Wang, C. (2010). Approximate nearest neighbor search by residual vector   \n360 quantization. Sensors, 10(12):11259–11273.   \n361 [5] Gao, L., Zhu, X., Song, J., Zhao, Z., and Shen, H. T. (2019). Beyond product quantization: Deep progressive   \n362 quantization for image retrieval. In IJCAI, pages 723–729.   \n363 [6] Ge, T., He, K., Ke, Q., and Sun, J. (2013). Optimized product quantization for approximate nearest neighbor   \n364 search. In CVPR, pages 2946–2953.   \n365 [7] Gray, R. (1984). Vector quantization. IEEE Assp Magazine, 1(2):4–29.   \n366 [8] Ilyas, A., Engstrom, L., Santurkar, S., Tsipras, D., Janoos, F., Rudolph, L., and Madry, A. (2020). A closer   \n367 look at deep policy gradients. In ICLR.   \n368 [9] Jégou, H., Douze, M., and Schmid, C. (2010). Product quantization for nearest neighbor search. IEEE Trans.   \n369 Pattern Anal. Mach. Intell., 33(1):117–128.   \n370 [10] Kalantidis, Y. and Avrithis, Y. (2014). Locally optimized product quantization for approximate nearest   \n371 neighbor search. In CVPR, pages 2329–2336.   \n372 [11] Klein, B. and Wolf, L. (2019). End-to-end supervised product quantization for image search and retrieval.   \n373 In CVPR, pages 5041–5050.   \n374 [12] Konda, V. R. and Tsitsiklis, J. N. (2000). Actor-critic algorithms. In NeurIPS, pages 1008–1014.   \n375 [13] Lloyd, S. (1982). Least squares quantization in pcm. IEEE transactions on information theory, 28(2):129–   \n376 137.   \n377 [14] Martinez, J., Clement, J., Hoos, H. H., and Little, J. J. (2016). Revisiting additive quantization. In ECCV,   \n378 pages 137–153. Springer.   \n379 [15] Martinez, J., Hoos, H. H., and Little, J. J. (2014). Stacked quantizers for compositional vector compression.   \n380 arXiv preprint arXiv:1411.2173.   \n381 [16] Martinez, J., Zakhmi, S., Hoos, H. H., and Little, J. J. (2018). Lsq $^ { + + }$ : Lower running time and higher   \n382 recall in multi-codebook quantization. In ECCV, pages 491–506.   \n383 [17] Mohamed, S., Rosca, M., Figurnov, M., and Mnih, A. (2020). Monte carlo gradient estimation in machine   \n384 learning. J. Mach. Learn. Res., 21:132:1–132:62.   \n385 [18] Morozov, S. and Babenko, A. (2019). Unsupervised neural quantization for compressed-domain similarity   \n386 search. In ICCV, pages 3036–3045.   \n387 [19] Norouzi, M. and Fleet, D. J. (2013). Cartesian k-means. In CVPR, pages 3017–3024.   \n388 [20] Radenovic, F., Iscen, A., Tolias, G., Avrithis, Y., and Chum, O. (2018). Revisiting oxford and paris:   \n389 Large-scale image retrieval benchmarking. In CVPR, pages 5706–5715.   \n390 [21] Reddi, S. J., Kale, S., and Kumar, S. (2018). On the convergence of adam and beyond. In ICLR.   \n391 [22] Sablayrolles, A., Douze, M., Schmid, C., and Jégou, H. (2019). Spreading vectors for similarity search. In   \n392 ICLR.   \n393 [23] Schulman, J., Heess, N., Weber, T., and Abbeel, P. (2015a). Gradient estimation using stochastic computa  \n394 tion graphs. In NeurIPS, pages 3528–3536.   \n395 [24] Schulman, J., Levine, S., Abbeel, P., Jordan, M. I., and Moritz, P. (2015b). Trust region policy optimization.   \n396 In ICML, pages 1889–1897.   \n397 [25] Schulman, J., Moritz, P., Levine, S., Jordan, M. I., and Abbeel, P. (2016). High-dimensional continuous   \n398 control using generalized advantage estimation. In ICLR.   \n399 [26] Schulman, J., Wolski, F., Dhariwal, P., Radford, A., and Klimov, O. (2017). Proximal policy optimization   \n400 algorithms. arXiv preprint arXiv:1707.06347.   \n401 [27] Song, J., Lang, R., Zhu, X., Xu, X., Gao, L., and Shen, H. T. (2020). 3d self-attention for unsupervised   \n402 video quantization. In ACM SIGIR, pages 1061–1070.   \n403 [28] Song, J., Zhu, X., Gao, L., Xu, X.-S., Liu, W., and Shen, H. T. (2019). Deep recurrent quantization for   \n404 generating sequential binary codes. In IJCAI, pages 912–918.   \n405 [29] Torralba, A., Fergus, R., and Weiss, Y. (2008). Small codes and large image databases for recognition. In   \n406 CVPR, pages 1–8. IEEE.   \n407 [30] Wang, J., Wang, J., Song, J., Xu, X., Shen, H. T., and Li, S. (2015). Optimized cartesian k-means. IEEE   \n408 Transactions on Knowledge and Data Engineering, 27(1):180–192.   \n409 [31] Weyand, T., Araujo, A., Cao, B., and Sim, J. (2020). Google landmarks dataset v2 - A large-scale   \n410 benchmark for instance-level recognition and retrieval. In CVPR, pages 2572–2581.   \n411 [32] Williams, R. J. (1992). Simple statistical gradient-following algorithms for connectionist reinforcement   \n412 learning. Machine learning, 8(3-4):229–256.   \n413 [33] Yu, T., Yuan, J., Fang, C., and Jin, H. (2018). Product quantization network for fast image retrieval. In   \n414 ECCV, pages 186–201.   \n415 [34] Zhang, T., Du, C., and Wang, J. (2014). Composite quantization for approximate nearest neighbor search.   \n416 In ICML, volume 2, page 3. ",
+        "bbox": [
+            137,
+            122,
+            828,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            92,
+            826,
+            268
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "417 Checklist ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            292,
+            254,
+            309
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "418 The checklist follows the references. Please read the checklist guidelines carefully for information on   \n419 how to answer these questions. For each question, change the default [TODO] to [Yes] , [No] , or   \n420 [N/A] . You are strongly encouraged to include a justification to your answer, either by referencing   \n421 the appropriate section of your paper or providing a brief inline description. For example: ",
+        "bbox": [
+            142,
+            324,
+            825,
+            380
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• Did you include the license to the code and datasets? [Yes] See Section ??. • Did you include the license to the code and datasets? [No] The code and the data are proprietary. • Did you include the license to the code and datasets? [N/A] ",
+        "bbox": [
+            169,
+            385,
+            823,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "425 Please do not modify the questions and only use the provided macros for your answers. Note that the   \n426 Checklist section does not count towards the page limit. In your paper, please delete this instructions   \n427 block and only keep the Checklist section heading above along with the questions/answers below. ",
+        "bbox": [
+            143,
+            443,
+            825,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            173,
+            493,
+            302,
+            507
+        ],
+        "page_idx": 10
+    },
+    {
+        "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] See Section 6.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            197,
+            508,
+            826,
+            599
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            166,
+            603,
+            455,
+            617
+        ],
+        "page_idx": 10
+    },
+    {
+        "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": [
+            197,
+            619,
+            699,
+            650
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            176,
+            655,
+            354,
+            669
+        ],
+        "page_idx": 10
+    },
+    {
+        "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)? [Yes] See https://github.com/ DeepMCQ/DeepQ.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 5 and supplementary materials.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No]   \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] See Section 5. ",
+        "bbox": [
+            197,
+            670,
+            826,
+            801
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "48 4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            155,
+            805,
+            784,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] See Section 5.   \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? [Yes] See https://github.com/DeepMCQ/DeepQ.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] ",
+        "bbox": [
+            197,
+            821,
+            825,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            187,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            169,
+            123,
+            669,
+            138
+        ],
+        "page_idx": 11
+    },
+    {
+        "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": [
+            197,
+            140,
+            826,
+            229
+        ],
+        "page_idx": 11
+    }
+]

parse/train/B1gdkxHFDH/B1gdkxHFDH.md

@@ -0,0 +1,628 @@
+# TRAINING INDIVIDUALLY FAIR ML MODELS WITH SENSITIVE SUBSPACE ROBUSTNESS
+
+Mikhail Yurochkin   
+IBM Research   
+MIT-IBM Watson AI Lab   
+mikhail.yurochkin@ibm.com   
+Amanda Bower†, Yuekai Sun‡   
+Department of Mathematics†   
+Department of Statistics‡   
+University of Michigan   
+{amandarg,yuekai}@umich.edu
+
+# ABSTRACT
+
+We consider training machine learning models that are fair in the sense that their performance is invariant under certain sensitive perturbations to the inputs. For example, the performance of a resume screening system should be invariant under changes to the gender and/or ethnicity of the applicant. We formalize this notion of algorithmic fairness as a variant of individual fairness and develop a distributionally robust optimization approach to enforce it during training. We also demonstrate the effectiveness of the approach on two ML tasks that are susceptible to gender and racial biases.
+
+# 1 INTRODUCTION
+
+Machine learning (ML) models are gradually replacing humans in high-stakes decision making roles. For example, in Philadelphia, an ML model classifies probationers as high or low-risk (Metz & Satariano, 2020). In North Carolina, “analytics” is used to report suspicious activity and fraud by Medicaid patients and providers (Metz & Satariano, 2020). Although ML models appear to eliminate the biases of a human decision maker, they may perpetuate or even exacerbate biases in the training data (Barocas & Selbst, 2016). Such biases are especially objectionable when it adversely affects underprivileged groups of users (Barocas & Selbst, 2016).
+
+In response, the scientific community has proposed many mathematical definitions of algorithmic fairness and approaches to ensure ML models satisfy the definitions. Unfortunately, this abundance of definitions, many of which are incompatible (Kleinberg et al., 2016; Chouldechova, 2017), has hindered the adoption of this work by practitioners. There are two types of formal definitions of algorithmic fairness: group fairness and individual fairness. Most recent work on algorithmic fairness considers group fairness because it is more amenable to statistical analysis (Ritov et al., 2017). Despite their prevalence, group notions of algorithmic fairness suffer from certain shortcomings. One of the most troubling is there are many scenarios in which an algorithm satisfies group fairness, but its output is blatantly unfair from the point of view of individual users (Dwork et al., 2011).
+
+In this paper, we consider individual fairness instead of group fairness. Intuitively, an individually fair ML model treats similar users similarly. Formally, an ML model is a map $h : \mathcal { X } \to \mathcal { Y }$ , where $\mathcal { X }$ and $\mathcal { V }$ are the input and output spaces. The leading notion of individual fairness is metric fairness (Dwork et al., 2011); it requires
+
+$$
+d _ { y } ( h ( x _ { 1 } ) , h ( x _ { 2 } ) ) \leq L d _ { x } ( x _ { 1 } , x _ { 2 } ) { \mathrm { ~ f o r ~ a l l ~ } } x _ { 1 } , x _ { 2 } \in \mathcal { X } ,
+$$
+
+where $d _ { x }$ and $d _ { y }$ are metrics on the input and output spaces and $L \ge 0$ is a Lipschitz constant. The fair metric $d _ { x }$ encodes our intuition of which samples should be treated similarly by the ML model. We emphasize that $d _ { x } ( x _ { 1 } , x _ { 2 } )$ being small does not imply $x _ { 1 }$ and $x _ { 2 }$ are similar in all respects. Even if $d _ { x } ( x _ { 1 } , x _ { 2 } )$ is small, $x _ { 1 }$ and $x _ { 2 }$ may differ in certain problematic ways, e.g. in their protected/sensitive attributes. This is why we refer to pairs of samples $x _ { 1 }$ and $x _ { 2 }$ such that $d _ { x } ( x _ { 1 } , x _ { 2 } )$ is small as comparable instead of similar.
+
+Despite its benefits, individual fairness was dismissed as impractical because there is no widely accepted fair metric for many ML tasks. Fortunately, there is a line of recent work on learning the fair metric from data (Ilvento, 2019; Wang et al., 2019). In this paper, we consider two data-driven choices of the fair metric: one for problems in which the sensitive attribute is reliably observed, and another for problems in which the sensitive attribute is unobserved (see Appendix B).
+
+The rest of this paper is organized as follows. In Section 2, we cast individual fairness as a form of robustness: robustness to certain sensitive perturbations to the inputs of an ML model. This allows us to leverage recent advances in adversarial ML to train individually fair ML models. More concretely, we develop an approach to audit ML models for violations of individual fairness that is similar to adversarial attacks (Goodfellow et al., 2014) and an approach to train ML models that passes such audits (akin to adversarial training (Madry et al., 2017)). We justify the approach theoretically (see Section 3) and empirically (see Section 4).
+
+# 2 FAIRNESS THROUGH (DISTRIBUTIONAL) ROBUSTNESS
+
+To motivate our approach, imagine an auditor investigating an ML model for unfairness. The auditor collects a set of audit data and compares the output of the ML model on comparable samples in the audit data. For example, to investigate whether a resume screening system is fair, the auditor may collect a stack of resumes and change the names on the resumes of Caucasian applicants to names more common among the African-American population. If the system performs worse on the edited resumes, then the auditor may conclude the model treats African-American applicants unfairly. Such investigations are known as correspondence studies, and a prominent example is Bertrand & Mullainathan’s celebrated investigation of racial discrimination in the labor market. In a correspondence study, the investigator looks for inputs that are comparable to the training examples (the edited resumes in the resume screening example) on which the ML model performs poorly. In the rest of this section, we formulate an optimization problem to find such inputs.
+
+# 2.1 FAIR WASSERSTEIN DISTANCES
+
+Recall $\mathcal { X }$ and $\mathcal { V }$ are the spaces of inputs and outputs. To keep things simple, we assume that the ML task at hand is a classification task, so $\mathcal { V }$ is discrete. We also assume that we have a fair metric $d _ { x }$ of the form
+
+$$
+d _ { x } ( x _ { 1 } , x _ { 2 } ) ^ { 2 } \triangleq \langle x _ { 1 } - x _ { 2 } , \Sigma ( x _ { 1 } - x _ { 2 } ) \rangle ^ { \frac { 1 } { 2 } } ,
+$$
+
+where $\boldsymbol { \Sigma } \in \mathbf { S } _ { \neq } ^ { d \times d }$ . For example, suppose we are given a set of $K$ “sensitive” directions that we wish the metric to ignore; i.e. $d ( x _ { 1 } , x _ { 2 } ) \ll 1$ for any $x _ { 1 }$ and $x _ { 2 }$ such that $x _ { 1 } - x _ { 2 }$ falls in the span of the sensitive directions. These directions may be provided by a domain expert or learned from data (see Section 4 and Appendix B). In this case, we may choose $\Sigma$ as the orthogonal complement projector of the span of the sensitive directions. We equip $\mathcal { X }$ with the fair metric and ${ \mathcal { Z } } \triangleq \chi \times \qquad $ with
+
+$$
+d _ { z } ( ( x _ { 1 } , y _ { 1 } ) , ( x _ { 2 } , y _ { 2 } ) ) \triangleq d _ { x } ( x _ { 1 } , x _ { 2 } ) + \infty \cdot { \bf 1 } \{ y _ { 1 } \neq y _ { 2 } \} .
+$$
+
+We consider $d _ { z } ^ { 2 }$ as a transport cost function on $\mathcal { Z }$ . This cost function encodes our intuition of which samples are comparable for the ML task at hand. We equip the space of probability distributions on $\mathcal { Z }$ with the fair Wasserstein distance
+
+$$
+\begin{array} { r } { W ( P , Q ) = \operatorname* { i n f } _ { \Pi \in \mathcal { C } ( P , Q ) } \int _ { \mathcal { Z } \times \mathcal { Z } } c ( z _ { 1 } , z _ { 2 } ) d \Pi ( z _ { 1 } , z _ { 2 } ) , } \end{array}
+$$
+
+where ${ \mathcal { C } } ( P , Q )$ is the set of couplings between $P$ and $Q$ . The fair Wasserstein distance inherits our intuition of which samples are comparable through the cost function; i.e. the fair Wasserstein distance between two probability distributions is small if they are supported on comparable areas of the sample space.
+
+# 2.2 AUDITING ML MODELS FOR ALGORITHMIC BIAS
+
+To investigate whether an ML model performs disparately on comparable samples, the auditor collects a set of audit data $\{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n }$ and solves the optimization problem
+
+$$
+\begin{array} { r } { \operatorname* { m a x } _ { P : W ( P , P _ { n } ) \leq \epsilon } \int _ { \mathcal { Z } } \ell ( z , h ) d P ( z ) , } \end{array}
+$$
+
+where $\ell : \mathcal { Z } \times \mathcal { H }  \mathbf { R } _ { + }$ is a loss function, $h$ is the ML model, $P _ { n }$ is the empirical distribution of the audit data, and $\epsilon > 0$ is a small tolerance parameter. We interpret $\epsilon$ as a moving budget that the auditor may expend to discover discrepancies in the performance of the ML model. This budget forces the auditor to avoid moving samples to incomparable areas of the sample space. We emphasize that equation 2.1 detects aggregate violations of individual fairness. In other words, although the violations that the auditor’s problem detects are individual in nature, the auditor’s problem is only able to detect aggregate violations. We summarize the implicit notion of fairness in equation 2.1 in a definition.
+
+Definition 2.1 (distributionally robustly fair (DRF)). An ML model $h \ : \ \mathcal { X } \ \to \ \mathcal { Y }$ is $( \epsilon , \delta )$ - distributionally robustly fair (DRF) WRT the fair metric $d _ { x }$ iff
+
+$$
+\begin{array} { r } { \operatorname* { m a x } _ { P : W ( P , P _ { n } ) \leq \epsilon } \int _ { \mathcal { Z } } \ell ( z , h ) d P ( z ) \leq \delta . } \end{array}
+$$
+
+Although equation 2.1 is an infinite-dimensional optimization problem, it is possible to solve it exactly by appealing to duality. Blanchet & Murthy showed that the dual of equation 2.1 is
+
+$$
+\begin{array} { r l r } & { } & { \operatorname* { s u p } _ { P : W ( P , P _ { n } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , h ) \big ] = \operatorname* { i n f } _ { \lambda \geq 0 } \{ \lambda \epsilon + \mathbb { E } _ { P _ { n } } \big [ \ell _ { \lambda } ^ { c } ( Z , h ) \big ] \} , } \\ & { } & { \ell _ { \lambda } ^ { c } ( ( x _ { i } , y _ { i } ) , h ) \triangleq \operatorname* { s u p } _ { x \in \mathcal { X } } \ell ( ( x , y _ { i } ) , \theta ) - \lambda d _ { x } ( x , x _ { i } ) . } \end{array}
+$$
+
+This is a univariate optimization problem, and it is amenable to stochastic optimization. We describe a stochastic approximation algorithm for equation 2.3 in Algorithm 1. Inspecting the algorithm, we see that it is similar to the PGD algorithm for adversarial attack.
+
+# Algorithm 1 stochastic gradient method for equation 2.3
+
+Require: starting point $\hat { \lambda } _ { 1 }$ , step sizes $\alpha _ { t } > 0$
+
+1: repeat   
+2: draw mini-batch $( x _ { t _ { 1 } } , y _ { t _ { 1 } } ) , \dots , ( x _ { t _ { B } } , y _ { t _ { B } } ) \sim P _ { n }$   
+3: $\begin{array} { r } { x _ { t _ { b } } ^ { * } \gets \arg \operatorname* { m a x } _ { x \in \mathcal { X } } \ell ( ( x , y _ { t _ { b } } ) , h ) - \lambda d _ { x } ( x _ { t _ { b } } , x ) , } \end{array}$ b ∈ [B]   
+4: $\begin{array} { r } { \hat { \lambda } _ { t + 1 } \gets \operatorname* { m a x } \{ 0 , \hat { \lambda } _ { t } - \alpha _ { t } ( \epsilon - \frac { 1 } { B } \sum _ { b = 1 } ^ { B } d _ { x } ( x _ { t _ { b } } , x _ { t _ { b } } ^ { * } ) ) \} } \end{array}$   
+5: until converged
+
+It is known that the optimal point of equation 2.1 is the discrete measure $\textstyle { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } \delta _ { ( T _ { \lambda } ( x _ { i } ) , y _ { i } ) }$ , where $T _ { \lambda } : \mathcal { X } \to \mathcal { X }$ is the unfair map
+
+$$
+\begin{array} { r } { T _ { \lambda } ( x _ { i } ) \gets \arg \operatorname* { m a x } _ { x \in \mathcal { X } } \ell ( ( x , y _ { i } ) , h ) - \lambda d _ { x } ^ { 2 } ( x , x _ { i } ) . } \end{array}
+$$
+
+We call $T _ { \lambda }$ an unfair map because it reveals unfairness in the ML model by mapping samples in the audit data to comparable areas of the sample space that the system performs poorly on. We note that $T _ { \lambda }$ may map samples in the audit data to areas of the sample space that are not represented in the audit data, thereby revealing disparate treatment in the ML model not visible in the audit data alone. We emphasize that $T _ { \lambda }$ more than reveals disparate treatment in the ML model; it localizes the unfairness to certain areas of the sample space.
+
+We present a simple example to illustrating fairness through robustness (a similar example appeared in Hashimoto et al. (2018)). Consider the binary classification dataset shown in Figure 1. There are two subgroups of observations in this dataset, and (sub)group membership is the protected attribute (e.g. the smaller group contains observations from a minority subgroup). In Figure 1a we see the decision heatmap of a vanilla logistic regression, which performs poorly on the blue minority subgroup. The two subgroups are separated in the horizontal direction, so the horizontal direction is the sensitive direction. Figure 1b shows that such classifier is unfair with respect to the corresponding fair metric, i.e. the unfair map equation 2.4 leads to significant loss increase by transporting mass along the horizontal direction with very minor change of the vertical coordinate.
+
+Comparison with metric fairness Before moving on to training individually fair ML models, we compare DRF with metric fairness equation 1.1. Although we concentrate on the differences between the two definitions here, they are more similar than different: both formalize the intuition that the outputs of a fair ML model should perform similarly on comparable inputs. That said, there are two main differences between the two definitions. First, instead of requiring the output of the ML model to be similar on all inputs comparable to a training example, we require the output to be similar to the training label. Thus DRF not only enforces similarity of the output on comparable inputs, but also accuracy of the ML model on the training data. Second, DRF considers differences between datasets instead of samples by replacing the fair metric on inputs with the fair Wasserstein distance induced by the fair metric. The main benefits of this modifications are (i) it is possible to optimize equation 2.1 efficiently, (ii) we can show this modified notion of individual fairness generalizes.
+
+![](images/ae1244dc0b49d9c729c2eafc402ee7143ef1ace7ecda688185539c0b9332d346.jpg)  
+Figure 1: Figure (a) depicts a binary classification dataset in which the minority group shown on the right of the plot is underrepresented. This tilts the logistic regression decision boundary in favor of the majority group on the left. Figure (b) shows the unfair map of the logistic regression decision boundary. It maps samples in the minority group towards the majority group. Figure (c) shows an algorithmically fair classifier that treats the majority and minority groups identically.
+
+# 2.3 FAIR TRAINING WITH SENSITIVE SUBSPACE ROBUSTNESS
+
+We cast the fair training problem as training supervised learning systems that are robust to sensitive perturbations. We propose solving the minimax problem
+
+$$
+\operatorname* { i n f } _ { h \in \mathcal { H } } \operatorname* { s u p } _ { P : W ( P , P _ { n } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , h ) \big ] = \operatorname* { i n f } _ { h \in \mathcal { H } } \operatorname* { i n f } _ { \lambda \geq 0 } \lambda \epsilon + \mathbb { E } _ { P _ { n } } \big [ \ell _ { \lambda } ^ { c } ( Z , h ) \big ] ,
+$$
+
+where $\ell _ { \lambda } ^ { c }$ is defined in equation 2.3. This is an instance of a distributionally robust optimization (DRO) problem, and it inherits some of the statistical properties of DRO. To see why equation 2.5 encourages individual fairness, recall the loss function is a measure of the performance of the ML model. By assessing the performance of an ML model by its worse-case performance on hypothetical populations of users with perturbed sensitive attributes, minimizing equation 2.5 ensures the system performs well on all such populations. In our toy example, minimizing equation 2.5 implies learning a classifier that is insensitive to perturbations along the horizontal (i.e. sensitive) direction. In Figure 1c this is achieved by the algorithm we describe next.
+
+To keep things simple, we assume the hypothesis class is parametrized by $\theta \in \Theta \subset \mathbf { R } ^ { d }$ and replace the minimization with respect to $\mathcal { H }$ by minimization with respect to $\theta$ . In light of the similarities between the DRO objective function and adversarial training, we borrow algorithms for adversarial training (Madry et al., 2017) to solve equation 2.5 (see Algorithm 2).
+
+# Algorithm 2 Sensitive Subspace Robustness (SenSR)
+
+Require: starting point $\widehat { \theta } _ { 1 }$ , step sizes $\alpha _ { t } , \beta _ { t } > 0$
+
+1: repeat   
+2: sample mini-batch $( x _ { 1 } , y _ { 1 } ) , \dotsc , ( x _ { B } , y _ { B } ) \sim P _ { n }$   
+3: $\begin{array} { r } { x _ { t _ { b } } ^ { * } \gets \arg \operatorname* { m a x } _ { x \in \mathcal { X } } \ell ( ( x , y _ { t _ { b } } ) , \theta ) - \hat { \lambda } _ { t } d _ { x } ( x _ { t _ { b } } , x ) , b } \end{array}$ ∈ [B]   
+4: $\begin{array} { r } { \hat { \lambda } _ { t + 1 } \gets \operatorname* { m a x } \{ 0 , \hat { \lambda } _ { t } - \alpha _ { t } ( \epsilon - \frac { 1 } { B } \sum _ { b = 1 } ^ { B } d _ { x } ( x _ { t _ { b } } , x _ { t _ { b } } ^ { * } ) ) \} } \end{array}$   
+5: $\begin{array} { r } { \hat { \theta } _ { t + 1 } \gets \hat { \theta } _ { t } - \frac { \beta _ { t } } { B } \sum _ { b = 1 } ^ { B } \partial _ { \theta } \ell ( ( x _ { t _ { b } } ^ { * } , y _ { t _ { b } } ) , \hat { \theta } _ { t } ) } \end{array}$   
+6: until converged
+
+Related work Our approach to fair training is an instance of distributionally robust optimization (DRO). In DRO, the usual sample-average approximation of the expected cost function is replaced by $\widehat { L } _ { \mathrm { D R O } } ( \theta ) \triangleq \operatorname* { s u p } _ { P \in { \mathcal U } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ]$ , where $\mathcal { U }$ is a (data dependent) uncertainty set of probability distributions. The uncertainty set may be defined by moment or support constraints (Chen et al., 2007; Delage & Ye, 2010; Goh & Sim, 2010), $f$ -divergences (Ben-Tal et al., 2012; Lam & Zhou,
+
+2015; Miyato et al., 2015; Namkoong & Duchi, 2016), and Wasserstein distances (ShafieezadehAbadeh et al., 2015; Blanchet et al., 2016; Esfahani & Kuhn, 2015; Lee & Raginsky, 2017; Sinha et al., 2017). Most similar to our work is Hashimoto et al. (2018): they show that DRO with a $\chi ^ { 2 }$ -neighborhood of the training data prevents representation disparity, i.e. minority groups tend to suffer higher losses because the training algorithm ignores them. One advantage of picking a Wasserstein uncertainty set is the set depends on the geometry of the sample space. This allows us to encode the correct notion of individual fairness for the ML task at hand in the Wasserstein distance.
+
+Our approach to fair training is also similar to adversarial training (Madry et al., 2017), which hardens ML models against adversarial attacks by minimizing adversarial losses of the form ${ \mathrm { s u p } } _ { u \in \mathcal { U } } \ell ( z + u , \theta )$ , where $\mathcal { U }$ is a set of allowable perturbations (Szegedy et al., 2013; Goodfellow et al., 2014; Papernot et al., 2015; Carlini & Wagner, 2016; Kurakin et al., 2016). Typically, $\mathcal { U }$ is a scaled $\ell _ { p }$ -norm ball: $\mathcal { U } = \{ u : \| u \| _ { p } \leq \epsilon \}$ . Most similar to our work is Sinha et al. (2017): they consider an uncertainty set that is a Wasserstein neighborhood of the training data.
+
+There are a few papers that consider adversarial approaches to algorithmic fairness. Zhang et al. (2018) propose an adversarial learning method that enforces equalized odds in which the adversary learns to predict the protected attribute from the output of the classifier. Edwards & Storkey (2015) propose an adversarial method for learning classifiers that satisfy demographic parity. Madras et al. (2018) generalize their method to learn classifiers that satisfy other (group) notions of algorithmic fairness. Garg et al. (2019) propose to use adversarial logit pairing (Kannan et al., 2018) to achieve fairness in text classification using a pre-specified list of counterfactual tokens.
+
+# 3 SENSR TRAINS INDIVIDUALLY FAIR ML MODELS
+
+One of the main benefits of our approach is it provably trains individually fair ML models. Further, it is possible for the learner to certify that an ML model is individually fair a posteriori. As we shall see, both are consequences of uniform convergence results for the DR loss class. More concretely, we study how quickly the uniform convergence error
+
+$$
+\begin{array} { r } { \delta _ { n } \triangleq \operatorname* { s u p } _ { \theta \in \Theta } \left\{ \left| \operatorname* { s u p } _ { P : W _ { * } ( P , P _ { n } ) \leq \epsilon } \mathbb { E } _ { P } \left[ \ell ( Z , \theta ) \right] - \operatorname* { s u p } _ { P : W ( P , P _ { n } ) \leq \epsilon } \mathbb { E } _ { P } \left[ \ell ( Z , \theta ) \right] \right| \right\} , } \end{array}
+$$
+
+where $W _ { * }$ is the Wasserstein distance on $\Delta ( \mathcal { Z } )$ with a transportation cost function $c _ { * }$ that is possibly different from $c$ , vanishes. We permit some discrepancy in the (transportation) cost function to study the effect of a data-driven choice of $c$ . In the rest of this section, we regard $c _ { * }$ as the exact cost function and $c$ as a cost function learned from human supervision. We start by stating our assumptions on the ML task:
+
+(A1) the feature space $\mathcal { X }$ is bounded: $D \triangleq \operatorname* { m a x } \{ \mathsf { d i a m } ( \boldsymbol { \mathcal { X } } ) , \mathsf { d i a m } _ { * } ( \boldsymbol { \mathcal { X } } ) \} < \infty ;$   
+(A2) the functions in the loss class $\mathcal { L } = \{ \ell ( \cdot , \theta ) : \theta \in \Theta \}$ are non-negative and bounded: $0 \leq \ell ( z , \theta ) \leq M$ for all $z \in { \mathcal { Z } }$ and $\theta \in \Theta$ , and $L$ -Lipschitz with respect to $d _ { x }$ : $\begin{array} { r } { \operatorname* { s u p } _ { \theta \in \Theta } \{ \operatorname* { s u p } _ { ( x _ { 1 } , y ) , ( x _ { 2 } , y ) \in \mathbb { Z } } \vert \ell ( ( x _ { 1 } , y ) , \theta ) - \ell ( ( x _ { 2 } , y ) , \theta ) \vert \} \leq L d _ { x } ( x _ { 1 } , x _ { 2 } ) ; } \end{array}$
+
+(A3) the discrepancy in the (transportation) cost function is uniformly bounded:
+
+$$
+\begin{array} { r } { \operatorname* { s u p } _ { ( x _ { 1 } , y ) , ( x _ { 2 } , y ) \in \mathcal { Z } } \left| c ( ( x _ { 1 } , y ) , ( x _ { 2 } , y ) ) - c _ { * } ( ( x _ { 1 } , y ) , ( x _ { 2 } , y ) ) \right| \le \delta _ { c } D ^ { 2 } . } \end{array}
+$$
+
+Assumptions A1 and A2 are standard (see (Lee & Raginsky, 2017, Assumption 1, 2, 3)) in the DRO literature. We emphasize that the constant $L$ in Assumption A2 is not the constant $L$ in the definition of metric fairness; it may be much larger. Thus most models that satisfy the conditions of the loss class are not individually fair in a meaningful sense.
+
+Assumption A3 deserves further comment. Under A1, A3 is mild. For example, if the exact fair metric is
+
+$$
+d _ { x } ( x _ { 1 } , x _ { 2 } ) = ( x _ { 1 } - x _ { 2 } ) ^ { T } \Sigma _ { * } ( x _ { 1 } - x _ { 2 } ) ^ { \frac { 1 } { 2 } } ,
+$$
+
+then the error in the transportation cost function is at most
+
+$$
+\begin{array} { r l } & { | c ( ( x _ { 1 } , y ) , ( x _ { 2 } , y ) ) - c _ { * } ( ( x _ { 1 } , y ) , ( x _ { 2 } , y ) ) | } \\ & { \quad = | ( x _ { 1 } - x _ { 2 } ) ^ { T } \Sigma ( x _ { 1 } - x _ { 2 } ) - ( x _ { 1 } - x _ { 2 } ) ^ { T } \Sigma _ { * } ( x _ { 1 } - x _ { 2 } ) | } \\ & { \quad \leq D ^ { 2 } \frac { \| \Sigma - \Sigma _ { * } \| _ { 2 } } { \lambda _ { \operatorname* { m i n } } ( \Sigma _ { * } ) } , } \end{array}
+$$
+
+We see that the error in the transportation cost function vanishes in the large-sample limit as long as $\Sigma$ is a consistent estimator of $\Sigma _ { * }$ .
+
+We state the uniform convergence result in terms of the entropy integral of the loss class: ${ \mathfrak { C } } ( { \mathcal { L } } ) =$ $\begin{array} { r } { \int _ { 0 } ^ { \infty } \sqrt { \log N _ { \infty } ( \mathcal { F } , r ) } d r } \end{array}$ , where egral is $N _ { \infty } ( \mathcal { L } , r )$ as the  of the $r$ -covering number of the loss class in the uniformmplexity of the loss class.
+
+Proposition 3.1 (uniform convergence). Under Assumptions A1–A3, equation 3.1 satisfies
+
+$$
+\delta _ { n } \leq \frac { 4 8 \mathfrak { C } ( \mathcal { L } ) } { \sqrt { n } } + \frac { 4 8 L D ^ { 2 } } { \sqrt { n \epsilon } } + \frac { L \delta _ { c } D ^ { 2 } } { \sqrt { \epsilon } } + M ( \frac { \log \frac { 2 } { t } } { 2 n } ) ^ { \frac { 1 } { 2 } }
+$$
+
+with probability at least $1 - t$
+
+We note that Proposition 3.1 is similar to the generalization error bounds by Lee & Raginsky (2017). The main novelty in Proposition 3.1 is allowing error in the transportation cost function. We see that the discrepancy in the transportation cost function may affect the rate at which the uniform convergence error vanishes: it affects the rate if $\delta _ { c }$ is $\omega _ { P } ( \frac { 1 } { \sqrt { n } } )$ .
+
+A consequence of uniform convergence is SenSR trains individually fair classifiers (if there are such classifiers in the hypothesis class). By individually fair ML model, we mean an ML model that has a small gap
+
+$$
+\begin{array} { r } { \operatorname* { s u p } _ { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { * } } \big [ \ell ( Z , \theta ) \big ] , } \end{array}
+$$
+
+The gap is the difference between the optimal value of the auditor’s optimization problem equation 2.1 and the (non-robust) risk. A small gap implies the auditor cannot significantly increase the loss by moving samples from $P _ { * }$ to comparable samples.
+
+Proposition 3.2. Under the assumptions $A I { - } A 3$ , as long as there is $\bar { \theta } \in \Theta$ such that
+
+$$
+\begin{array} { r } { \operatorname* { s u p } _ { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , \bar { \theta } ) \big ] \leq \delta ^ { * } } \end{array}
+$$
+
+for some $\delta ^ { * } > 0$ , $\begin{array} { r } { \widehat { \theta } \in \arg \operatorname* { m i n } _ { \theta \in \Theta } \operatorname* { s u p } _ { P : W ( P , P _ { n } ) \leq \epsilon } \mathbb { E } _ { P } \left[ \ell ( Z , h ) \right] } \end{array}$ satisfies
+
+$$
+\begin{array} { r } { \operatorname* { s u p } _ { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } \mathbb { E } _ { P } \left[ \ell ( Z , \hat { \theta } ) \right] - \mathbb { E } _ { P _ { * } } \left[ \ell ( Z , \hat { \theta } ) \right] \leq \delta ^ { * } + 2 \delta _ { n } , } \end{array}
+$$
+
+where $\delta _ { n }$ is the uniform convergence error equation 3.1.
+
+Proposition 3.2 guarantees Algorithm 2 trains an individually fair ML model. More precisely, if there are models in $\mathcal { H }$ that are (i) individually fair and (ii) achieve small test error, then Algorithm 2 trains such a model. It is possible to replace equation 3.4 with other conditions, but a condition to its effect cannot be dispensed with entirely. If there are no individually fair models in $\mathcal { H }$ , then it is not possible for equation 2.5 to learn an individually fair model. If there are individually fair models in $\mathcal { H }$ , but they all perform poorly, then the goal of learning an individually fair model is futile.
+
+Another consequence of uniform convergence is equation 3.3 is close to its empirical counterpart
+
+$$
+\begin{array} { r } { \operatorname* { s u p } _ { P : W ( P , P _ { n } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { n } } \big [ \ell ( Z , \theta ) \big ] . } \end{array}
+$$
+
+In other words, the gap generalizes. This implies equation 3.5 is a certificate of individual fairness; i.e. it is possible for practitioners to check whether an ML model is individually fair by evaluating equation 3.5.
+
+Proposition 3.3. Under the assumptions A1–A3, for any $\epsilon > 0$ ,
+
+$$
+\begin{array} { r } { \operatorname* { s u p } _ { \theta \in \Theta } \Big \{ \operatorname* { s u p } _ { P : W ( P , P _ { n } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { n } } \big [ \ell ( Z , \theta ) \big ] - ( \operatorname* { s u p } _ { P : W ( P , P _ { * } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { * } } \big [ \ell ( Z , \theta ) \big ] \Big \} = \mathbb { E } _ { P _ { * } } \big [ \ell ( Z , \theta ) \big ] . } \end{array}
+$$
+
+# 4 COMPUTATIONAL RESULTS
+
+In this section, we present results from using SenSR to train individually fair ML models for two tasks: sentiment analysis and income prediction. We pick these two tasks to demonstrate the efficacy of SenSR on problems with structured (income prediction) and unstructured (sentiment analysis) inputs and in which the sensitive attribute (income prediction) is observed and unobserved (sentiment analysis). We refer to Appendix C and D for the implementation details.
+
+Table 1: Sentiment prediction experiments over 10 restarts   
+
+<table><tr><td></td><td>Acc.,%</td><td>Race gap</td><td>Gend. gap</td><td>Cuis. gap</td></tr><tr><td>SenSR</td><td>94±1</td><td>0.30±.05</td><td>0.19±.03</td><td>0.23±.05</td></tr><tr><td>SenSR-E</td><td>93±1</td><td>0.11±.04</td><td>0.04±.03</td><td>1.11±.15</td></tr><tr><td>Baseline</td><td>95±1</td><td>7.01±.44</td><td>5.59±.37</td><td>4.10±.44</td></tr><tr><td>Project</td><td>94±1</td><td>1.00±.56</td><td>1.99±.58</td><td>1.70±.41</td></tr><tr><td>Sinha+ Bolukb.+</td><td>94±1 94±1</td><td>3.88±.26 6.85±.53</td><td>1.42±.29 4.33±.46</td><td>1.33±.18 3.44±.29</td></tr></table>
+
+![](images/27de42a242ec99e65002261933c0302e83555aff8662d6645bfbf3200ea079aa.jpg)  
+Figure 2: Box-plots of sentiment scores
+
+# 4.1 FAIR SENTIMENT PREDICTION WITH WORD EMBEDDINGS
+
+Problem formulation We study the problem of classifying the sentiment of words using positive (e.g. ‘smart’) and negative (e.g. ‘anxiety’) words compiled by Hu & Liu (2004). We embed words using 300-dimensional GloVe (Pennington et al., 2014) and train a one layer neural network with 1000 hidden units. Such classifier achieves $9 5 \%$ test accuracy, however it entails major individual fairness violation. Consider an application of this sentiment classifier to summarizing customer reviews, tweets or news articles. Human names are typical in such texts and should not affect the sentiment score, hence we consider fair metric between any pair of names to be 0. Then sentiment score for all names should be the same to satisfy the individual fairness. To make a connection to group fairness, following the study of Caliskan et al. (2017) that reveals the biases in word embeddings, we evaluate the fairness of our sentiment classifier using male and female names typical for Caucasian and African-American ethnic groups. We emphasize that to satisfy individual fairness, the sentiment of any name should be the same.
+
+Comparison metrics To evaluate the gap between two groups of names, $\mathcal { N } _ { 0 }$ for Caucasian (or female) and $\mathcal { N } _ { 1 }$ for African-American (or male), we report $\begin{array} { r } { \frac { 1 } { | \mathcal { N } _ { 0 } | } \sum _ { n \in \mathcal { N } _ { 0 } } ( h ( n ) _ { 1 } - h ( n ) _ { 0 } ) \ - } \end{array}$ $\begin{array} { r } { \frac { 1 } { | \mathcal { N } _ { 1 } | } \sum _ { n \in \mathcal { N } _ { 1 } } ( h ( n ) _ { 1 } - h ( n ) _ { 0 } ) } \end{array}$ , where $h ( n ) _ { k }$ is logits for class $k$ of name $n$ $k = 1$ is the positive class). We use list of names provided in Caliskan et al. (2017), which consists of 49 Caucasian and 45 African-American names, among those 48 are female and 46 are male. The gap between African-American and Caucasian names is reported as Race gap, while the gap between male and female names is reported as Gend. gap in Table 1. As in Speer (2017), we also compare sentiment difference of two sentences: “Let’s go get Italian food” and “Let’s go get Mexican food”, i.e. cuisine gap (abbreviated Cuis. gap in Table 1), as a test of generalization beyond names. To embed these sentences we average their word embeddings.
+
+Sensitive subspace We consider embeddings of 94 names that we use for evaluation as sensitive directions, which may be regarded as utilizing the expert knowledge, i.e. these names form a list of words that an expert believes should be treated equally. Fair metric is then defined using an orthogonal complement projector of the span of sensitive directions as we discussed in Section 2.1. When expert knowledge is not available, or we wish to achieve general fairness for names, we utilize a side dataset of popular baby names in New York City.1 The dataset has 11k names, however only 32 overlap with the list of names used for evaluation. Embeddings of these names define a group of comparable samples that we use to learn sensitive directions with SVD (see Appendix B.2 and Algorithm 3 for details). We take top 50 singular vectors to form the sensitive subspace. It is worth noting that, unlike many existing approaches in the fairness literature, we do not use any protected attribute information. Our algorithm only utilizes training words, their sentiments and a vanilla list of names.
+
+Results From the box-plots in Figure 2, we see that both race and gender gaps are significant when using the baseline neural network classifier. It tends to predict Caucasian names as “positive”, while the median for African-American names is negative; the median sentiment for female names is higher than that for male names. We considered three other approaches to this problem: the algorithm of Bolukbasi et al. (2016) for pre-processing word embeddings; pre-processing via projecting out the sensitive subspace that we used for training SenSR (this is analogous to Prost et al. (2019)); training a distributionally robust classifier with Euclidean distance cost (Sinha et al., 2017). All approaches improved upon the baseline, however only SenSR can be considered individually fair. Our algorithm practically eliminates gender and racial gaps and achieves the notion of individual fairness as can be seen from almost equal predicted sentiment score for all names. We remark that using expert knowledge (i.e. evaluation names) allowed SenSR-E (E for expert) to further improve both group and individual fairness. However we warn practitioners that if the expert knowledge is too specific, generalization outside of the expert knowledge may not be very good. In Table 1 we report results averaged across 10 repetitions with $90 \% / 1 0 \%$ train/test splits, where we also verify that accuracy trade-off with the baseline is minor. In the right column we present the generalization check, i.e. comparing a pair of sentences unrelated to names. Utilizing expert knowledge led to a fairness over-fitting effect, however we still see improvement over other methods. When utilizing SVD of a larger dataset of names we observe better generalization. Our generalization check suggests that fairness over-fitting is possible, therefore datasets and procedure for verifying fairness generalization are needed.
+
+Table 2: Summary of Adult classification experiments over 10 restarts   
+
+<table><tr><td></td><td>B-Acc,%</td><td>S-Con.</td><td>GR-Con.</td><td>GapG RMS</td><td>GapR RMS</td><td>GapG max</td><td>GapR max</td></tr><tr><td>SenSR</td><td>78.9</td><td>.934</td><td>.984</td><td>.068</td><td>.055</td><td>.087</td><td>.067</td></tr><tr><td>Baseline</td><td>82.9</td><td>.848</td><td>.865</td><td>.179</td><td>.089</td><td>.216</td><td>.105</td></tr><tr><td>Project</td><td>82.7</td><td>.868</td><td>1.00</td><td>.145</td><td>.064</td><td>.192</td><td>.086</td></tr><tr><td>Adv.Debias.</td><td>81.5</td><td>.807</td><td>.841</td><td>.082</td><td>.070</td><td>.110</td><td>.078</td></tr><tr><td>CoCL</td><td>79.0</td><td>1</td><td>1</td><td>.163</td><td>.080</td><td>.201</td><td>.109</td></tr></table>
+
+# 4.2 ADULT
+
+Problem formulation Demonstrating the broad applicability of SenSR outside of natural language processing tasks, we apply SenSR to a classification task on the Adult (Dua & Graff, 2017) data set to predict whether an individual makes at least $\$ 50\mathrm { k }$ based on features like gender and occupation for approximately 45,000 individuals. Models that predict income without fairness considerations can contribute to the problem of differences in pay between genders or races for the same work. Throughout this section, gender (male or female) and race (Caucasian or non-Caucasian) are binary.
+
+Comparison metrics Arguably a classifier is individually unfair if the classifications for two data points that are the same on all features except demographic features are different. Therefore, to assess individual fairness, we report spouse consistency (S-Con.) and gender and race consistency (GR-Con.), which are measures of how often classifications change only because of differences in demographic features. For S-Con (resp. GR-con), we make 2 (resp. 4) copies of every data point where the only difference is that one is a husband and the other is a wife (resp. difference is in gender and race). S-Con (resp. GR-Con) is the fraction of corresponding pairs (resp. quadruples) that have the same classification. We also report various group fairness measures proposed by De-Arteaga et al. (2019) with respect to race or gender based on true positive rates, i.e. the ability of a classifier to correctly identify a given class. See Appendix D.5 for the definitions. We report $\mathrm { G a p } _ { R } ^ { \mathrm { R M S } }$ , ${ \mathrm { G a p } } _ { G } ^ { \mathrm { R M S } }$ ${ \mathrm { G a p } } _ { R } ^ { \operatorname* { m a x } }$ , and ${ \mathrm { G a p } } _ { G } ^ { \mathrm { m a x } }$ where $R$ refers to race, and $G$ refers to gender. We use balanced accuracy (Bacc) instead of accuracy2 to measure predictive ability since only $2 5 \%$ of individuals make at least $\$ 50\mathbf { k }$ .
+
+Sensitive subspace Let $\{ ( x _ { i } , x _ { g _ { i } } ) \} _ { i = 1 } ^ { m }$ be the set of features $x _ { i } ~ \in ~ \mathbb { R } ^ { D }$ of the data except the coordinate for gender is zeroed and where $x _ { g _ { i } }$ indicates the gender of individual $i$ . For $\gamma > 0$ , let D 1m Pmi=1 −xgi (wT xi) + log(1 + ewT xi ) + γkwk2, i.e. wg is the learned hyperplane that classifies gender given by regularized logistic regression. Let $e _ { g } \in \mathbb { R } ^ { D }$ (resp. $e _ { r }$ ) be the vector that is 1 in the gender (resp. race) coordinate and 0 elsewhere. Then the sensitive subspace is the span of $[ w _ { g } , e _ { g } , e _ { r } ]$ . See Appendix B.1 for details.
+
+Results See Table 2 for the average3 of each metric on the test sets over ten $80 \% / 2 0 \%$ train/test splits for Baseline, Project (projecting features onto the orthogonal complement of the sensitive subspace before training), CoCL (De-Arteaga et al., 2019), Adversarial Debiasing (Zhang et al., 2018), and SenSR. With the exception of CoCL (De-Arteaga et al., 2019), each classifier is a 100 unit single hidden layer neural network. The Baseline clearly exhibits individual and group fairness violations. While SenSR has the lowest B-acc, SenSR is the best by a large margin for S-Con. and has the best group fairness measures. We expect SenSR to do well on GR-consistency since the sensitive subspace includes the race and gender directions. However, SenSR’s individually fair performance generalizes: the sensitive directions do not directly use the husband and wife directions, yet SenSR performs well on S-Con. Furthermore, SenSR outperforms Project on S-Con and group fairness measures illustrating that SenSR does much more than just ignoring the sensitive subspace. CoCL only barely improves group fairness compared to the baseline with a significant drop in Bacc and while Adversarial Debiasing also improves group fairness, it is worse than the baseline on individual fairness measures illustrating that group fairness does not imply individual fairness.
+
+# 5 SUMMARY
+
+We consider the task of training ML systems that are fair in the sense that their performance is invariant under certain perturbations in a sensitive subspace. This notion of fairness is a variant of individual fairness (Dwork et al., 2011). One of the main barriers to the adoption of individual fairness is the lack of consensus on a fair metric for many ML tasks. To circumvent this issue, we consider two approaches to learning a fair metric from data: one for problems in which the sensitive attribute is observed, and another for problems in which the sensitive attribute is unobserved. Given a data-driven choice of fair metric, we provide an algorithm that provably trains individually fair ML models.
+
+# ACKNOWLEDGMENTS
+
+This work was supported by the National Science Foundation under grants DMS-1830247 and DMS-1916271.
+
+# REFERENCES
+
+Solon Barocas and Andrew D. Selbst. Big Data’s Disparate Impact. SSRN Electronic Journal, 2016. ISSN 1556-5068. doi: 10.2139/ssrn.2477899.
+
+Rachel K. E. Bellamy, Kuntal Dey, Michael Hind, Samuel C. Hoffman, Stephanie Houde, Kalapriya Kannan, Pranay Lohia, Jacquelyn Martino, Sameep Mehta, Aleksandra Mojsilovic, Seema Nagar, Karthikeyan Natesan Ramamurthy, John Richards, Diptikalyan Saha, Prasanna Sattigeri, Moninder Singh, Kush R. Varshney, and Yunfeng Zhang. AI Fairness 360: An extensible toolkit for detecting, understanding, and mitigating unwanted algorithmic bias, October 2018. URL https://arxiv.org/abs/1810.01943.
+
+Aharon Ben-Tal, Dick den Hertog, Anja De Waegenaere, Bertrand Melenberg, and Gijs Rennen. Robust Solutions of Optimization Problems Affected by Uncertain Probabilities. Management Science, 59(2):341–357, November 2012. ISSN 0025-1909. doi: 10.1287/mnsc.1120.1641.
+
+Marianne Bertrand and Sendhil Mullainathan. Are Emily and Greg More Employable Than Lakisha and Jamal? A Field Experiment on Labor Market Discrimination. American Economic Review, 94(4):991–1013, September 2004. ISSN 0002-8282. doi: 10.1257/0002828042002561.
+
+Jose Blanchet and Karthyek R. A. Murthy. Quantifying Distributional Model Risk via Optimal Transport. arXiv:1604.01446 [math, stat], April 2016.
+
+Jose Blanchet, Yang Kang, and Karthyek Murthy. Robust Wasserstein Profile Inference and Applications to Machine Learning. arXiv:1610.05627 [math, stat], October 2016.
+
+Tolga Bolukbasi, Kai-Wei Chang, James Y Zou, Venkatesh Saligrama, and Adam T Kalai. Man is to computer programmer as woman is to homemaker? debiasing word embeddings. In Advances in neural information processing systems, pp. 4349–4357, 2016.
+
+Aylin Caliskan, Joanna J. Bryson, and Arvind Narayanan. Semantics derived automatically from language corpora contain human-like biases. Science, 356(6334):183–186, April 2017. ISSN 0036-8075, 1095-9203. doi: 10.1126/science.aal4230.
+
+Nicholas Carlini and David Wagner. Towards Evaluating the Robustness of Neural Networks. arXiv:1608.04644 [cs], August 2016.
+
+Xin Chen, Melvyn Sim, and Peng Sun. A Robust Optimization Perspective on Stochastic Programming. Operations Research, 55:1058–1071, 2007. doi: 10.1287/opre.1070.0441.
+
+Alexandra Chouldechova. Fair prediction with disparate impact: A study of bias in recidivism prediction instruments. arXiv:1703.00056 [cs, stat], February 2017.
+
+Maria De-Arteaga, Alexey Romanov, Hanna Wallach, Jennifer Chayes, Christian Borgs, Alexandra Chouldechova, Sahin Geyik, Krishnaram Kenthapadi, and Adam Tauman Kalai. Bias in bios: A case study of semantic representation bias in a high-stakes setting. arXiv preprint arXiv:1901.09451, 2019.
+
+Erick Delage and Yinyu Ye. Distributionally Robust Optimization Under Moment Uncertainty with Application to Data-Driven Problems. Operations Research, 58:595–612, 2010. doi: 10.1287/ opre.1090.0741.
+
+Dheeru Dua and Casey Graff. UCI machine learning repository, 2017. URL http://archive. ics.uci.edu/ml.
+
+Cynthia Dwork, Moritz Hardt, Toniann Pitassi, Omer Reingold, and Rich Zemel. Fairness Through Awareness. arXiv:1104.3913 [cs], April 2011.
+
+Harrison Edwards and Amos Storkey. Censoring Representations with an Adversary. arXiv:1511.05897 [cs, stat], November 2015.
+
+Peyman Mohajerin Esfahani and Daniel Kuhn. Data-driven Distributionally Robust Optimization Using the Wasserstein Metric: Performance Guarantees and Tractable Reformulations. May 2015.
+
+Sahaj Garg, Vincent Perot, Nicole Limtiaco, Ankur Taly, Ed H Chi, and Alex Beutel. Counterfactual fairness in text classification through robustness. In Proceedings of the 2019 AAAI/ACM Conference on AI, Ethics, and Society, pp. 219–226. ACM, 2019.
+
+Joel Goh and Melvyn Sim. Distributionally Robust Optimization and Its Tractable Approximations. Operations Research, 58(4-part-1):902–917, August 2010. ISSN 0030-364X, 1526-5463. doi: 10.1287/opre.1090.0795.
+
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and Harnessing Adversarial Examples. December 2014.
+
+Tatsunori B. Hashimoto, Megha Srivastava, Hongseok Namkoong, and Percy Liang. Fairness Without Demographics in Repeated Loss Minimization. arXiv:1806.08010 [cs, stat], June 2018.
+
+Minqing Hu and Bing Liu. Mining and summarizing customer reviews. In Proceedings of the tenth ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 168–177. ACM, 2004.
+
+Christina Ilvento. Metric Learning for Individual Fairness. arXiv:1906.00250 [cs, stat], June 2019.
+
+Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing. arXiv preprint arXiv:1803.06373, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Jon Kleinberg, Sendhil Mullainathan, and Manish Raghavan. Inherent Trade-Offs in the Fair Determination of Risk Scores. arXiv:1609.05807 [cs, stat], September 2016.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial Machine Learning at Scale. November 2016.
+
+H. Lam and Enlu Zhou. Quantifying uncertainty in sample average approximation. In 2015 Winter Simulation Conference (WSC), pp. 3846–3857, December 2015. doi: 10.1109/WSC.2015. 7408541.
+
+Jaeho Lee and Maxim Raginsky. Minimax Statistical Learning with Wasserstein Distances. arXiv:1705.07815 [cs], May 2017.
+
+David Madras, Elliot Creager, Toniann Pitassi, and Richard Zemel. Learning Adversarially Fair and Transferable Representations. arXiv:1802.06309 [cs, stat], February 2018.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards Deep Learning Models Resistant to Adversarial Attacks. arXiv:1706.06083 [cs, stat], June 2017.
+
+Cade Metz and Adam Satariano. An Algorithm That Grants Freedom, or Takes It Away. The New York Times, February 2020. ISSN 0362-4331.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Distributional Smoothing with Virtual Adversarial Training. arXiv:1507.00677 [cs, stat], July 2015.
+
+Hongseok Namkoong and John C. Duchi. Stochastic Gradient Methods for Distributionally Robust Optimization with F-divergences. In Proceedings of the 30th International Conference on Neural Information Processing Systems, NIPS’16, pp. 2216–2224, Barcelona, Spain, 2016. Curran Associates Inc. ISBN 978-1-5108-3881-9.
+
+Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z. Berkay Celik, and Ananthram Swami. The Limitations of Deep Learning in Adversarial Settings. November 2015.
+
+Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp. 1532–1543, 2014.
+
+Flavien Prost, Nithum Thain, and Tolga Bolukbasi. Debiasing embeddings for reduced gender bias in text classification. arXiv preprint arXiv:1908.02810, 2019.
+
+Ya’acov Ritov, Yuekai Sun, and Ruofei Zhao. On conditional parity as a notion of nondiscrimination in machine learning. arXiv:1706.08519 [cs, stat], June 2017.
+
+Soroosh Shafieezadeh-Abadeh, Peyman Mohajerin Esfahani, and Daniel Kuhn. Distributionally Robust Logistic Regression. September 2015.
+
+Aman Sinha, Hongseok Namkoong, and John Duchi. Certifying Some Distributional Robustness with Principled Adversarial Training. arXiv:1710.10571 [cs, stat], October 2017.
+
+Robyn Speer. How to make a racist ai without really trying, 2017.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. December 2013.
+
+Hanchen Wang, Nina Grgic-Hlaca, Preethi Lahoti, Krishna P. Gummadi, and Adrian Weller. An Empirical Study on Learning Fairness Metrics for COMPAS Data with Human Supervision. arXiv:1910.10255 [cs], October 2019.
+
+Brian Hu Zhang, Blake Lemoine, and Margaret Mitchell. Mitigating Unwanted Biases with Adversarial Learning. arXiv:1801.07593 [cs], January 2018.
+
+# A PROOFS
+
+# A.1 PROOF OF PROPOSITION 3.1
+
+By the duality result of Blanchet & Murthy (2016), for any $\epsilon > 0$ ,
+
+$$
+\begin{array} { r l } & { \underset { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \underset { P : W ( P , P _ { n } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] } \\ & { \quad = \underset { \lambda \geq 0 } { \operatorname* { i n f } } \big \{ \lambda \epsilon + \mathbb { E } _ { P _ { * } } \big [ \ell _ { \lambda } ^ { c _ { * } } ( Z , \theta ) \big ] \big \} - \lambda _ { n } \epsilon + \mathbb { E } _ { P _ { n } } \big [ \ell _ { \lambda _ { n } } ^ { c } ( Z , \theta ) \big ] } \\ & { \quad \leq \mathbb { E } _ { P _ { * } } \big [ \ell _ { \lambda _ { n } } ^ { c _ { * } } ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { n } } \big [ \ell _ { \lambda _ { n } } ^ { c } ( Z , \theta ) \big ] , } \end{array}
+$$
+
+where $\begin{array} { r } { \lambda _ { n } \in \arg \operatorname* { m i n } _ { \lambda \geq 0 } \lambda \epsilon + \mathbb { E } _ { P _ { n } } \left[ \ell _ { \lambda } ^ { c } ( Z , \theta ) \right] } \end{array}$ . By assumption A3,
+
+$$
+\begin{array} { r l } & { | \ell _ { \lambda _ { n } } ^ { c _ { * } } ( z , \theta ) - \ell _ { \lambda _ { n } } ^ { c } ( z , \theta ) | } \\ & { \quad = \bigg | \underset { x _ { 2 } \in \mathcal { X } } { \operatorname* { s u p } } \ \ell ( ( x _ { 2 } , y ) , \theta ) - \lambda _ { n } c _ { * } ( ( x , y ) , ( x _ { 2 } , y ) ) - \underset { x _ { 2 } \in \mathcal { X } } { \operatorname* { s u p } } \ \ell ( ( x _ { 2 } , y ) , \theta ) - \lambda _ { n } c ( ( x , y ) , ( x _ { 2 } , y ) ) \bigg | } \\ & { \quad \le \underset { x _ { 2 } \in \mathcal { X } } { \operatorname* { s u p } } \ \lambda _ { n } | c _ { * } ( ( x , y ) , ( x _ { 2 } , y ) ) - c ( ( x , y ) , ( x _ { 2 } , y ) ) | } \\ & { \quad \le \lambda _ { n } \delta _ { c } \cdot D ^ { 2 } . } \end{array}
+$$
+
+This implies
+
+$$
+\begin{array} { r l } & { \underset { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \left[ \ell ( Z , \theta ) \right] - \underset { P : W ( P , P _ { n } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \left[ \ell ( Z , \theta ) \right] } \\ & { \quad \leq \mathbb { E } _ { P _ { * } } \left[ \ell _ { \lambda _ { n } } ^ { c _ { * } } ( Z , \theta ) \right] - \mathbb { E } _ { P _ { n } } \left[ \ell _ { \lambda _ { n } } ^ { c _ { * } } ( Z , \theta ) \right] + \lambda _ { n } \delta _ { c } D ^ { 2 } . } \end{array}
+$$
+
+This bound is crude; it is possible to obtain sharper bounds under additional assumptions on the loss and transportation cost functions. We avoid this here to keep the result as general as possible.
+
+Similarly,
+
+$$
+\begin{array} { r l } & { \underset { P : W ( P , P _ { n } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \underset { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] } \\ & { \quad \leq \mathbb { E } _ { P _ { n } } \big [ \ell _ { \lambda _ { * } } ^ { c } ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { * } } \big [ \ell _ { \lambda _ { * } } ^ { c _ { * } } ( Z , \theta ) \big ] } \\ & { \quad \leq \mathbb { E } _ { P _ { n } } \big [ \ell _ { \lambda _ { * } } ^ { c _ { * } } ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { * } } \big [ \ell _ { \lambda _ { * } } ^ { c _ { * } } ( Z , \theta ) \big ] + \lambda _ { * } \delta _ { c } D ^ { 2 } , } \end{array}
+$$
+
+where $\begin{array} { r } { \lambda _ { * } \in \arg \operatorname* { m i n } _ { \lambda \geq 0 } \{ \lambda \epsilon + \mathbb { E } _ { P _ { * } } \left[ \ell _ { \lambda } ^ { c _ { * } } ( Z , \theta ) \right] \} _ { } , } \end{array}$ .
+
+Lemma A.1 (Lee & Raginsky (2017)). Let $\tilde { \lambda } \in \arg \operatorname* { m i n } _ { \lambda \geq 0 } \lambda \epsilon + \mathbb { E } _ { P } \big [ \ell _ { \lambda } ^ { c } ( Z , \theta ) \big ]$ . As long as the function in the loss class are $L$ -Lipschitz with respect to $d _ { x }$ (see Assumption $A 2$ ), $\begin{array} { r } { \tilde { \lambda } \le \frac { L } { \sqrt { \epsilon } } } \end{array}$ .
+
+Proof. By the optimality of $\tilde { \lambda }$ ,
+
+$$
+\begin{array} { r l } & { \tilde { \lambda } \epsilon \le \tilde { \lambda } \epsilon + \mathbb { E } _ { P } \big [ \underset { x _ { 2 } \in \mathcal { X } } { \operatorname* { s u p } } \ell ( ( x _ { 2 } , Y ) , \theta ) - \tilde { \lambda } d _ { x } ( X , x _ { 2 } ) ^ { 2 } - \ell ( ( X , Y ) , \theta ) \big ] } \\ & { \quad = \tilde { \lambda } \epsilon + \mathbb { E } _ { P } \big [ \ell _ { \tilde { \lambda } } ^ { c } ( Z , \theta ) - \ell ( Z , \theta ) \big ] } \\ & { \quad \le \lambda \epsilon + \mathbb { E } _ { P } \big [ \ell _ { \lambda } ^ { c } ( Z , \theta ) - \ell ( Z , \theta ) \big ] } \\ & { \quad = \lambda \epsilon + \mathbb { E } _ { P } \big [ \underset { x _ { 2 } \in \mathcal { X } } { \operatorname* { s u p } } \ell ( ( x _ { 2 } , Y ) , \theta ) - \ell ( ( X , Y ) , \theta ) - \lambda d _ { x } ( X , x _ { 2 } ) ^ { 2 } \big ] } \end{array}
+$$
+
+for any $\lambda \geq 0$ . By Assumption A2, the right side is at most
+
+$$
+\begin{array} { r l } & { \tilde { \lambda } \epsilon \leq \lambda \epsilon + \mathbb { E } _ { P } \big [ \underset { x _ { 2 } \in \mathcal { X } } { \operatorname* { s u p } } L d _ { x } ( X , x _ { 2 } ) - \lambda d _ { x } ( X , x _ { 2 } ) ^ { 2 } \big ] } \\ & { \quad \leq \lambda \epsilon + \underset { t \geq 0 } { \operatorname* { s u p } } L t - \lambda t ^ { 2 } } \end{array}
+$$
+
+We minimize the right side WRT $t$ (set $\begin{array} { r } { t = \frac { L } { 2 \lambda } . } \end{array}$ ) and $\lambda$ (set $\begin{array} { r } { \lambda = \frac { L } { 2 \sqrt { \epsilon } } \rangle } \end{array}$ ) to obtain $\tilde { \lambda } \epsilon \leq L \sqrt { \epsilon }$
+
+By Lemma A.1, we have
+
+$$
+\begin{array} { r l } & { \displaystyle \operatorname* { s u p } _ { { \boldsymbol { \Sigma } } : W _ { * } ( P , P _ { * } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , { \boldsymbol { \theta } } ) \big ] - \operatorname* { s u p } _ { P : W ( P , P _ { * } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , { \boldsymbol { \theta } } ) \big ] \leq \mathbb { E } _ { P _ { * } } \big [ \ell _ { \lambda _ { n } } ^ { c _ { * } } ( Z , { \boldsymbol { \theta } } ) \big ] - \mathbb { E } _ { P _ { n } } \big [ \ell _ { \lambda _ { n } } ^ { c _ { * } } ( Z , { \boldsymbol { \theta } } ) \big ] + \frac { L \delta _ { c } L } { \sqrt { \epsilon } } } \\ & { \displaystyle \operatorname* { s u p } _ { { \boldsymbol { \Sigma } } : W ( P , P _ { n } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , { \boldsymbol { \theta } } ) \big ] - \operatorname* { s u p } _ { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , { \boldsymbol { \theta } } ) \big ] \leq \mathbb { E } _ { P _ { n } } \big [ \ell _ { \lambda _ { * } } ^ { c _ { * } } ( Z , { \boldsymbol { \theta } } ) \big ] - \mathbb { E } _ { P _ { * } } \big [ \ell _ { \lambda _ { * } } ^ { c _ { * } } ( Z , { \boldsymbol { \theta } } ) \big ] + \frac { L \delta _ { c } D } { \sqrt { \epsilon } } } \end{array}
+$$
+
+We combine the preceding bounds to obtain
+
+$$
+\begin{array} { r l } & { \bigg | \underset { P : W ( P , P _ { n } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \underset { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] \bigg | } \\ & { \quad \leq \underset { f \in \mathcal { L } ^ { c _ { * } } } { \operatorname* { s u p } } \big | \int _ { \mathcal { Z } } f ( z ) d ( P _ { n } - P _ { * } ) ( z ) \big | + \frac { L \delta _ { c } D ^ { 2 } } { \sqrt { \epsilon } } , } \end{array}
+$$
+
+where $\begin{array} { r } { \mathcal { L } ^ { c _ { * } } = \{ \ell _ { \lambda } ^ { c _ { * } } ( \cdot , \theta ) : \lambda \in [ 0 , \frac { L } { \sqrt { \epsilon } } ] , \theta \in \Theta \} } \end{array}$ is the DR loss class. In the rest of the proof, we bound $\begin{array} { r } { \operatorname* { s u p } _ { f \in \mathcal { L } ^ { c _ { * } } } \big | \int _ { \mathcal { Z } } f ( z ) d ( P _ { * } - \dot { P _ { n } } ) ( z ) \big | } \end{array}$ with standard techniques from statistical learning theory. Assumption A2 implies the functions in $\scriptstyle { \dot { \mathcal { F } } }$ are bounded:
+
+$$
+0 \leq \ell ( ( x _ { 1 } , y _ { 1 } ) , \theta ) - \underline { { \lambda d _ { \sigma } ( \alpha _ { \hat { \operatorname { T } } } , \mathcal { X } _ { 1 } ) } } \leq \ell _ { \lambda } ^ { c } ( z _ { 1 } , \theta ) \leq \operatorname* { s u p } _ { x _ { 2 } \in \mathcal { X } } \ell ( ( x _ { 2 } , y _ { 1 } ) , \theta ) \leq M .
+$$
+
+This implies has bounded differences, so $\delta _ { n }$ concentrates sharply around its expectation. By the bounded-differences inequality and a symmetrization argument,
+
+$$
+\operatorname* { s u p } _ { f \in { \mathcal { L } } ^ { c _ { * } } } \big | \int _ { { \mathcal { Z } } } f ( z ) d \bigl ( P _ { n } - P _ { * } \bigr ) ( z ) \big | \leq 2 \Re _ { n } ( { \mathcal { L } } ^ { c _ { * } } ) + M ( \frac { \log \frac { 2 } { t } } { 2 n } ) ^ { \frac { 1 } { 2 } }
+$$
+
+WP at least $1 - t$ , where $\Re _ { n } ( \mathcal { F } )$ is the Rademacher complexity of $\mathcal { F }$ :
+
+$$
+\Re _ { n } ( { \mathcal { F } } ) = \mathbb { E } { \left[ \operatorname* { s u p } _ { f \in { \mathcal { F } } } { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } \sigma _ { i } f ( Z _ { i } ) \right] } .
+$$
+
+Lemma A.2. The Rademacher complexity of the DR loss class is at most
+
+$$
+\Re _ { n } ( \mathcal { L } ^ { c } ) \leq \frac { 2 4 \mathfrak { C } ( \mathcal { L } ) } { \sqrt { n } } + \frac { 2 4 L D ^ { 2 } } { \sqrt { n \epsilon } } .
+$$
+
+Proof. process r complexity of  is sub-Gaussia $\mathcal { L } ^ { c }$ , we first show that the RT to a pseudometric. $\mathcal { L } ^ { c }$ -iet cherand $\begin{array} { r } { X _ { f } \triangleq \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \sigma _ { i } f ( Z _ { i } ) } \end{array}$ $f _ { 1 } = \ell _ { \lambda _ { 1 } } ^ { c } ( \cdot , \theta _ { 1 } )$ $f _ { 2 } = \ell _ { \lambda _ { 2 } } ^ { c } ( \cdot , \theta _ { 2 } )$ . Define
+
+$$
+d _ { \mathscr { L } ^ { c } } ( f _ { 1 } , f _ { 2 } ) \triangleq \| \ell ( \cdot , \theta _ { 1 } ) - \ell ( \cdot , \theta _ { 2 } ) \| _ { \infty } + D ^ { 2 } | \lambda _ { 1 } - \lambda _ { 2 } | .
+$$
+
+We check that $X _ { f }$ is sub-Gaussian WRT $d _ { \mathcal { L } ^ { c } }$ :
+
+$$
+\begin{array} { r l } & { \mathbb { E } \Big [ \exp ( t ( X _ { f _ { 1 } } - X _ { f _ { 2 } } ) ) \Big ] } \\ & { \quad = \mathbb { E } \Big [ \exp \Big ( \displaystyle \frac { l } { n } \sum _ { i = 1 } ^ { n } \sigma _ { i } \big ( \mathcal { E } _ { \lambda _ { 1 } } ^ { \kappa } ( Z _ { i } , \theta _ { 1 } ) - \mathcal { E } _ { \lambda _ { 2 } } ^ { \kappa } ( Z _ { \lambda } , \theta _ { 2 } ) \big ) \big ) \Big ] } \\ & { \quad = \mathbb { E } \Big [ \exp \Big ( \displaystyle \frac { l } { n } \sigma \big ( \mathcal { E } _ { \lambda _ { 1 } } ^ { \kappa } ( Z , \theta _ { 1 } ) - \mathcal { E } _ { \lambda _ { 2 } } ^ { \kappa } ( Z , \theta _ { 2 } ) \big ) \Big ) \Big ] ^ { n } } \\ & { \quad = \mathbb { E } \Big [ \exp \Big ( \displaystyle \frac { l } { n } \sigma \big ( \operatorname* { s u p } _ { \lambda = \lambda } \mathrm { ~ f ~ } \mathcal { E } ( ( x _ { 1 } , Y ) , \theta _ { 1 } ) - \lambda _ { 1 } d _ { x } ( x _ { 1 } , X ) ^ { 2 } - \ell ( ( x _ { 2 } , Y ) , \theta _ { 2 } ) + \lambda _ { 2 } d _ { x } ( X , x _ { 2 } ) ^ { 2 } ) ) \big ) \Big ] } \\ & { \quad = \mathbb { E } \Big [ \exp \Big ( \displaystyle \frac { l } { n } \sigma \big ( \operatorname* { s u p } _ { \lambda = \lambda } \mathcal { E } ( ( x _ { 1 } , Y ) , \theta _ { 1 } ) - \ell ( ( x _ { 1 } , Y ) , \theta _ { 2 } ) + ( \lambda _ { 2 } - \lambda _ { 1 } ) d _ { x } ( x _ { 1 } , X ) ^ { 2 } ) ) \big ) \Big ] ^ { n } } \\ & { \quad \le \exp \Big ( \displaystyle \frac { 1 } { n } \sigma \big ( \mathcal { E } _ { \lambda _ { 1 } } ^ { \kappa } ( x _ { 2 } ( \theta _ { 1 } , Y _ { 2 } ) ) . } \end{array}
+$$
+
+Let $N ( \mathcal { L } ^ { c } , d _ { \mathcal { L } ^ { c } } , \epsilon )$ be the $\epsilon$ -covering number of $( \mathcal { L } ^ { c } , d _ { \mathcal { L } ^ { c } } )$ . We observe
+
+$$
+\begin{array} { r } { N ( \mathcal { L } ^ { c } , d _ { \mathcal { L } ^ { c } } , \epsilon ) \leq N ( \mathcal { L } , \| \cdot \| _ { \infty } , \frac { \epsilon } { 2 } ) \cdot N ( [ 0 , \frac { L } { \sqrt { \epsilon } } ] , | \cdot | , \frac { \epsilon } { 2 D ^ { 2 } } ) } \end{array}
+$$
+
+By Dudley’s entropy integral,
+
+$$
+\begin{array} { l } { \displaystyle \mathfrak { R } _ { n } ( \mathcal { L } ^ { c } ) \leq \frac { 1 2 } { \sqrt { n } } \int _ { 0 } ^ { \infty } \log N ( \mathcal { L } ^ { c } , d _ { \mathcal { L } ^ { c } } , \epsilon ) ^ { \frac { 1 } { 2 } } d \epsilon } \\ { \displaystyle \quad \quad \leq \frac { 1 2 } { \sqrt { n } } \int _ { 0 } ^ { \infty } \big ( \log N ( \mathcal { L } , \| \cdot \| _ { \infty } , \frac { \epsilon } { 2 } ) + N \big ( [ 0 , \frac { L } { \sqrt { \epsilon } } ] , | \cdot | , \frac { \epsilon } { 2 D ^ { 2 } } \big ) \big ) ^ { \frac { 1 } { 2 } } d \epsilon } \\ { \displaystyle \quad \leq \frac { 1 2 } { \sqrt { n } } \bigg ( \int _ { 0 } ^ { \infty } \log N ( \mathcal { L } , \| \cdot \| _ { \infty } , \frac { \epsilon } { 2 } ) ^ { \frac { 1 } { 2 } } d \epsilon + \int _ { 0 } ^ { \infty } N \big ( [ 0 , \frac { L } { \sqrt { \epsilon } } ] , | \cdot | , \frac { \epsilon } { 2 D ^ { 2 } } \big ) ^ { \frac { 1 } { 2 } } d \epsilon \bigg ) } \\ { \displaystyle \quad \leq \frac { 2 4 \mathfrak { C } ( \mathcal { L } ) } { \sqrt { n } } + \frac { 2 4 L D ^ { 2 } } { \sqrt { n \epsilon } } \int _ { 0 } ^ { \frac { 1 } { 2 } } \log ( \frac { 1 } { \epsilon } ) d \epsilon } \end{array}
+$$
+
+where we recalled equation A.1 in the second step. We evalaute the integral on the right side to arrive at the stated bound: $\begin{array} { r } { \int _ { 0 } ^ { \frac { 1 } { 2 } } \log ( \frac { 1 } { \epsilon } ) d \epsilon < 1 } \end{array}$ . □
+
+By Lemma A.2,
+
+$$
+\operatorname* { s u p } _ { f \in \mathcal { L } ^ { c _ { * } } } \left. \int _ { \mathcal { Z } } f ( z ) d ( P _ { n } - P _ { * } ) ( z ) \right. \leq \frac { 4 8 \mathfrak { C } ( \mathcal { L } ) } { \sqrt { n } } + \frac { 4 8 L D ^ { 2 } } { \sqrt { n \epsilon } } + M ( \frac { \log \frac { 2 } { t } } { 2 n } ) ^ { \frac { 1 } { 2 } } ,
+$$
+
+which implies
+
+$$
+\begin{array} { r l } & { \boxed { \underset { P : W ( P , P _ { n } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \underset { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] } \Biggr | _ { \begin{array} { l } { \epsilon } \\ { \epsilon } \end{array} } } \\ & { \leq \frac { 4 8 \mathfrak { E } ( \mathcal { L } ) } { \sqrt { n } } + \frac { 4 8 L D ^ { 2 } } { \sqrt { n \epsilon } } + \frac { L \delta _ { c } D ^ { 2 } } { \sqrt { \epsilon } } + M ( \frac { \log \frac { 2 } { t } } { 2 n } ) ^ { \frac { 1 } { 2 } } . } \end{array}
+$$
+
+WP at least $1 - t$ .
+
+# A.2 PROOFS OF PROPOSITIONS 3.2 AND 3.3
+
+Proof of Proposition 3.2. It is enough to show
+
+$$
+\begin{array} { r } { \operatorname* { s u p } _ { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } \mathbb { E } _ { P } \big [ \ell ( Z , \hat { \theta } ) \big ] \leq \delta ^ { * } + 2 \delta _ { n } } \end{array}
+$$
+
+because the loss function is non-negative. We have
+
+$$
+\begin{array} { r l } { \underset { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \hat { \theta } ) \big ] \leq \underset { P : W ( P , P _ { n } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \hat { \theta } ) \big ] + \delta _ { n } } & { } \\ { \leq \underset { P : W ( P , P _ { n } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \bar { \theta } ) \big ] + \delta _ { n } } & { } \\ { \leq \underset { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \bar { \theta } ) \big ] + 2 \delta _ { n } } & { } \\ { \leq \delta ^ { * } + 2 \delta _ { n } . } & { } \end{array}
+$$
+
+# Proof of Proposition 3.3.
+
+$$
+\begin{array} { r l } & { \underset { P : W _ { * } ( P , P _ { n } ) \leq \epsilon } { \operatorname* { s u p } } \left( \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { n } } \big [ \ell ( Z , \theta ) \big ] \right) - \underset { P : W ( P , P _ { * } ) \leq \epsilon } { \operatorname* { s u p } } \left( \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { * } } \big [ \ell ( Z , \theta ) \big ] \right) } \\ & { = \underset { P : W _ { * } ( P , P _ { * } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] - \underset { P : W ( P , P _ { n } ) \leq \epsilon } { \operatorname* { s u p } } \mathbb { E } _ { P } \big [ \ell ( Z , \theta ) \big ] + \mathbb { E } _ { P _ { * } } \big [ \ell ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { n } } \big [ \ell ( Z , \theta ) \big ] } \\ & { \leq \delta _ { n } + \mathbb { E } _ { P _ { * } } \big [ \ell ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { n } } \big [ \ell ( Z , \theta ) \big ] } \end{array}
+$$
+
+The loss function is bounded, so it is possible to bound $\mathbb { E } _ { P _ { * } } \big [ \ell ( Z , \theta ) \big ] - \mathbb { E } _ { P _ { n } } \big [ \ell ( Z , \theta ) \big ]$ by standard uniform convergence results on bounded loss classes.
+
+# B DATA-DRIVEN FAIR METRICS
+
+# B.1 LEARNING THE FAIR METRIC FROM OBSERVATIONS OF THE SENSITIVE ATTRIBUTE
+
+Here we assume the sensitive attribute is discrete and is observed for a small subset of the training data. Formally, we assume this subset of the training data has the form $\{ ( X _ { i } , K _ { i } , Y _ { i } ) \}$ , where $K _ { i }$ is the sensitive attribute of the $i$ -th subject. To learn the sensitive subspace, we fit a softmax regression model to the data
+
+$$
+\mathbb { P } ( K _ { i } = l \mid \boldsymbol { X } _ { i } ) = \frac { \mathsf { e x p } ( a _ { l } ^ { T } \boldsymbol { X } _ { i } + b _ { l } ) } { \sum _ { l = 1 } ^ { k } \mathsf { e x p } ( a _ { l } ^ { T } \boldsymbol { X } _ { i } + b _ { l } ) } , l = 1 , \ldots , k ,
+$$
+
+and take the span of $A = \left[ a _ { 1 } \ldots a _ { k } \right]$ as the sensitive subspace to define the fair metric as
+
+$$
+d _ { x } ( x _ { 1 } , x _ { 2 } ) ^ { 2 } = ( x _ { 1 } - x _ { 2 } ) ^ { T } ( I - P _ { \mathsf { r a n } ( A ) } ) ( x _ { 1 } - x _ { 2 } ) .
+$$
+
+This approach readily generalizes to sensitive attributes that are not discrete-valued: replace the softmax model by an appropriate generalized linear model.
+
+In many applications, the sensitive attribute is part of a user’s demographic information, so it may not be available due to privacy restrictions. This does not preclude the proposed approach because the sensitive attribute is only needed to learn the fair metric and is neither needed to train the classifier nor at test time.
+
+# B.2 LEARNING THE FAIR METRIC FROM COMPARABLE SAMPLES
+
+In this section, we consider the task of learning a fair metric from supervision in a form of comparable samples. This type of supervision has been considered in the literature on debiasing learned representations. For example, method of Bolukbasi et al. (2016) for removing gender bias in word embeddings relies on sets of words whose embeddings mainly vary in a gender subspace (e.g. (king, queen)).
+
+To keep things simple, we focus on learning a generalized Mahalanobis distance
+
+$$
+d _ { x } ( x _ { 1 } , x _ { 2 } ) = ( \varphi ( x _ { 1 } ) - \varphi ( x _ { 2 } ) ) ^ { T } { \widehat \Sigma } ( \varphi ( x _ { 1 } ) - \varphi ( x _ { 2 } ) ) ^ { \frac { 1 } { 2 } } ,
+$$
+
+where $\varphi ( \boldsymbol { x } ) : \boldsymbol { \mathcal { X } }  \mathbf { R } ^ { d }$ is a known feature map and $\widehat { \Sigma } \in \mathbf { S } _ { + } ^ { d \times d }$ is a covariance matrix. Our approach is based on a factor model
+
+$$
+\varphi _ { i } = A _ { * } u _ { i } + B _ { * } v _ { i } + \epsilon _ { i } ,
+$$
+
+where $\varphi _ { i } ~ \in \textbf { R } ^ { d }$ is the learned representation of $x _ { i }$ , $u _ { i } \in \mathbf { R } ^ { K }$ (resp. $v _ { i } \in \mathbf { R } ^ { L }$ ) is the sensitive/irrelevant (resp. relevant) attributes of $x _ { i }$ to the task at hand, and $\epsilon _ { i }$ is an error term. For example, in Bolukbasi et al. (2016), the learned representations are the embeddings of words in the vocabulary, and the sensitive attribute is the gender bias of the words. The sensitive and relevant attributes are generally unobserved.
+
+Recall our goal is to obtain $\widehat { \Sigma }$ so that equation B.2 is small whenever $v _ { 1 } \approx v _ { 2 }$ . One possible choice of $\widehat { \Sigma }$ is the projection matrix onto the orthogonal complement of $\mathsf { r a n } ( A )$ , which we denote by $P _ { \mathsf { r a n } ( A ) }$ . bIndeed,
+
+$$
+\begin{array} { r } { d _ { x } ( x _ { 1 } , x _ { 2 } ) ^ { 2 } = ( \varphi _ { 1 } - \varphi _ { 2 } ) ^ { T } ( I - P _ { \mathrm { r a n } ( A ) } ) ( \varphi _ { 1 } - \varphi _ { 2 } ) \qquad } \\ { \approx ( v _ { 1 } - v _ { 2 } ) ^ { T } B _ { * } ^ { T } ( I - P _ { \mathrm { r a n } ( A ) } ) B _ { * } ( v _ { 1 } - v _ { 2 } ) , } \end{array}
+$$
+
+which is small whenever $v _ { 1 } \approx v _ { 2 }$ . Although $\mathsf { r a n } ( A )$ is unknown, it is possible to estimate it from the learned representations and groups of comparable samples by factor analysis.
+
+The factor model attributes variation in the learned representations to variation in the sensitive and relevant attributes. We consider two samples comparable if their relevant attributes are similar. In other words, if $\mathcal { T } \subset [ n ]$ is (the indices of) a group of comparable samples, then
+
+$$
+H \Phi _ { \mathcal { T } } = H U _ { \mathcal { T } } A _ { * } ^ { T } + H V _ { \mathcal { T } } B _ { * } ^ { \mathcal { F } ^ { \mathcal { F } } } \widetilde { \stackrel { \approx } { + } } H E _ { \mathcal { T } } \approx H U _ { \mathcal { T } } A _ { * } ^ { T } + H E _ { \mathcal { T } } ,
+$$
+
+where $\begin{array} { r } { H = I _ { | \mathcal { T } | } - \frac { 1 } { | \mathcal { T } | } 1 _ { | \mathcal { T } | } 1 _ { | \mathcal { T } | } ^ { T } } \end{array}$ is the centering or de-meaning matrix and the rows of $\Phi _ { \mathcal { T } }$ (resp. $U _ { \mathcal { I } }$ , $V _ { \mathcal { T } } ,$ ) are $\varphi _ { i }$ (resp. $u _ { i } , v _ { i } ,$ ). If this group of samples have identical relevant attributes, i.e. $V _ { \mathcal { I } } = 1 _ { | \mathcal { I } | } v ^ { T }$ for some $v$ , then $H V _ { \mathcal { I } }$ vanishes exactly. As long as $u _ { i }$ and $\epsilon _ { i }$ are uncorrelated (e.g. $\mathbb { E } \big [ u _ { i } \epsilon _ { i } ^ { T } \big ] = 0 ,$ ), equation B.5 implies
+
+$$
+\mathbb { E } \big [ \Phi _ { \mathcal { T } } ^ { T } H \Phi _ { \mathcal { T } } \big ] \approx A \mathbb { E } \big [ U _ { \mathcal { T } } ^ { T } H U _ { \mathcal { T } } \big ] A ^ { T } + \mathbb { E } \big [ E _ { \mathcal { T } } ^ { T } H E _ { \mathcal { T } } \big ] ,
+$$
+
+This suggests estimating $\mathsf { r a n } ( A )$ from the learned representations and groups of comparable samples by factor analysis. We summarize our approach in Algorithm 3.
+
+# Algorithm 3 estimating $\widehat { \Sigma }$ for the fair metric
+
+1: Input: $\{ \varphi _ { i } \} _ { i = 1 } ^ { n }$ , comparable groups $\mathcal { T } _ { 1 } , \ldots , \mathcal { T } _ { G }$   
+2: $\begin{array} { r } { \widehat { A } ^ { T } \in \arg \operatorname* { m i n } _ { W _ { g } , A } \{ \frac { 1 } { 2 } \sum _ { g = 1 } ^ { G } \| H _ { g } \Phi _ { \mathcal { T } _ { g } } - W _ { g } A ^ { T } \| _ { F } ^ { 2 } \} } \end{array}$   
+3: $Q  \operatorname { q r } ( { \widehat { A } } )$   
+4: $\widehat { \Sigma }  I _ { d } - Q Q ^ { T }$
+
+. factor analysis . get orthonormal basis of ran $( \widehat { A } )$
+
+# C SENSR IMPLEMENTATION DETAILS
+
+This section is to accompany the implementation of the SenSR algorithm and is best understood by reading it along with the code implemented using TensorFlow.4 We discuss choices of learning rates and few specifics of the code. Words in italics correspond to variables in the code and following notation in parentheses defines corresponding name in Table 3, where we summarize all hyperparameter choices.
+
+Handling class imbalance Datasets we study have imbalanced classes. To handle it, on every epoch $( E )$ (i.e. number of epochs) we subsample a batch size $( B )$ training samples enforcing equal number of observations per class. This procedure can be understood as data augmentation.
+
+Perturbations specifics Our implementation of SenSR algorithm has two inner optimization problems — subspace perturbation and full perturbation (when $\epsilon > 0$ ). Subspace perturbation can be viewed as an initialization procedure for the attack. We implement both using Adam optimizer (Kingma & Ba, 2014) inside the computation graph for better efficiency, i.e. defining corresponding perturbation parameters as Variables and re-setting them to zeros after every epoch. This is in contrast with a more common strategy in the adversarial robustness implementations, where perturbations (i.e. attacks) are implemented using tf.gradients with respect to the input data defined as a Placeholder.
+
+Learning rates As mentioned above, in addition to regular Adam optimizer for learning the parameters we invoke two more for the inner optimization problems of SenSR. We use same learning rate of 0.001 for the parameters optimizer, however different learning rates across datasets for subspace step(s) and full step $( f )$ . Two other related parameters are number of steps of the inner optimizations: subspace epoch(se) and full epoch $( f e )$ . We observed that setting subspace perturbation learning rate too small may prevent our algorithm from reducing unfairness, however setting it big does not seem to hurt. On the other hand, learning rate for full perturbation should not be set too big as it may prevent algorithm from solving the original task. Note that full perturbation learning rate should be smaller than perturbation budget $e p s ( \epsilon )$ — we always use $\epsilon / 1 0$ . In general, malfunctioning behaviors are immediately noticeable during training and can be easily corrected, therefore we did not need to use any hyperparameter optimization tools.
+
+Table 3: SenSR hyperparameter choices in the experiments   
+
+<table><tr><td></td><td>E</td><td>B</td><td>S</td><td>se</td><td>E</td><td>f</td><td>fe</td></tr><tr><td>Sentiment</td><td>4K</td><td>1K</td><td>0.1</td><td>10</td><td>0.1</td><td>0.01</td><td>10</td></tr><tr><td>Adult</td><td>12K</td><td>1K</td><td>10</td><td>50</td><td>10-3</td><td>10-4</td><td>40</td></tr></table>
+
+Table 4: Summary of Adult classification experiments over 10 restarts   
+
+<table><tr><td></td><td>Accuracy</td><td>B-TPR</td><td>GapG RMS</td><td>GaPR RMS</td><td>GapG max</td><td>GapR max</td></tr><tr><td>SenSR</td><td>.787±.003</td><td>.789±.003</td><td>.068±.004</td><td>.055±.003</td><td>.087±.005</td><td>.067±.004</td></tr><tr><td>Baseline</td><td>.813±.001</td><td>.829±.001</td><td>.179±.004</td><td>.089±.003</td><td>.216±.003</td><td>.105±.003</td></tr><tr><td>Project</td><td>.813±.001</td><td>.827±.001</td><td>.145±.004</td><td>.064±.003</td><td>.192±.004</td><td>.086±.004</td></tr><tr><td>Adv. Debias.</td><td>.812±.001</td><td>.815±.002</td><td>.082±.005</td><td>.070±.006</td><td>.110±.006</td><td>.078±.005</td></tr><tr><td>CoCL</td><td>1</td><td>.790</td><td>.163</td><td>.080</td><td>.201</td><td>.109</td></tr></table>
+
+# D ADDITIONAL ADULT EXPERIMENT DETAILS
+
+# D.1 PREPROCESSING
+
+The continuous features in Adult are the following: age, fnlwgt, capital-gain, capital-loss, hours-per-week, and education-num. The categorical features are the following: workclass, education, marital-stataus, occupation, relationship, race, sex, native-country. See Dua & Graff (2017) for a description of each feature. We remove fnlwgt and education but keep education-num, which is a integer representation of education. We do not use native-country, but use race and sex as predictive features. We treat race as binary: individuals are either White or non-White. For every categorical feature, we use one hot encoding. For every continuous feature, we standardize, i.e., subtract the mean and divide by the standard deviation. We remove anyone with missing data leaving 45,222 individuals.
+
+This data is imbalanced: $2 5 \%$ make at least $\$ 50\mathbf { k }$ per year. Furthermore, there is demographic imbalance with respect to race and gender as well as class imbalance on the outcome when conditioning on race or gender: $86 \%$ of individuals are white of which $26 \%$ make at least $\$ 50\mathbf { k }$ a year; $67 \%$ of individuals are male of which $31 \%$ make at least $\$ 50\mathbf { k }$ a year; $11 \%$ of females make at least $\$ 50\mathbf { k }$ a year; and $15 \%$ of non-whites make at least $\$ 50\mathbf { k }$ a year.
+
+# D.2 FULL EXPERIMENTAL RESULTS
+
+See Tables 4 and 5 for the full experiment results. The tables report the average and the standard error for each metric on the test set for 10 train and test splits.
+
+# D.3 SENSITIVE SUBSPACE
+
+To learn the hyperplane that classifies females and males, we use our implementation of regularized logistic regression with a batch size of 5k, 5k epochs, and . $1 \ell _ { 2 }$ regularization.
+
+Table 5: Summary of individual fairness metrics in Adult classification experiments over 10 restarts   
+
+<table><tr><td></td><td>Spouse Consistency</td><td>Gender and Race Consistency</td></tr><tr><td>SenSR</td><td>.934±.012</td><td>.984±.000</td></tr><tr><td>Baseline</td><td>.848±.008</td><td>.865±.004</td></tr><tr><td>Project</td><td>.868±.005</td><td>1±0</td></tr><tr><td>Adv.Debias.</td><td>.807±.002</td><td>.841±.012</td></tr></table>
+
+# D.4 HYPERPARAMETERS AND TRAINING
+
+For each model, we use the same 10 train/test splits where use $80 \%$ of the data for training. Because of the class imbalance, each minibatch is sampled so that there are an equal number of training points from both the “income at least $\$ 50\mathrm { k }$ class” and the “income below $\$ 50\mathbf { k }$ class.”
+
+# D.4.1 BASELINE, PROJECT, AND SENSR
+
+See Table 3 for the hyperparameters we used when training Baseline, Project, and SenSR (Baseline and Project use a subset). Hyperparameters are defined in Appendix C.
+
+# D.4.2 ADVESARIAL DEBIASING
+
+We used Zhang et al. (2018)’s adversarial debiasing implementation in IBM’s AIF360 package (Bellamy et al., 2018) where the source code was modified so that each mini-batch is balanced with respect to the binary labels just as we did with our experiments and dropout was not used. Hyperparameters are the following: adversary loss weight $\qquad = \ . 0 0 1$ , num epochs $= 5 0 0$ , batch size $= 1 0 0 0$ , and privileged groups are defined by binary gender and binary race.
+
+# D.5 GROUP FAIR METRICS
+
+Let $\mathcal { C }$ be a set of classes, $A$ be a binary protected attribute and $Y , { \hat { Y } } \in { \mathcal { C } }$ be the true class label and the predicted class label. Then for $a \in \{ 0 , 1 \}$ and $c \in { \mathcal { C } }$ define $\mathrm { T P R } _ { a , c } = \mathbb { P } ( \hat { Y } = c | A = a , Y = c )$ ; $\begin{array} { r l } & { \mathrm { G a p } _ { A , c } = \mathrm { T P R } _ { 0 , c } - \mathrm { T P R } _ { 1 , c } ; \mathrm { G a p } _ { A } ^ { \mathrm { R M S } } = \sqrt { \frac { 1 } { | C | } \sum _ { c \in C } \mathrm { G a p } _ { A , c } ^ { 2 } } ; \mathrm { G a p } _ { A } ^ { \mathrm { m a x } } = \mathrm { a r g m a x } _ { c \in C } | \mathrm { G a p } _ { A , c } | } \\ & { \mathrm { B a l a n c e d ~ A c c } = \frac { 1 } { | C | } \sum _ { c \in C } \mathbb { P } ( \hat { Y } = c | Y = c ) . } \end{array}$
+
+For Adult, we report GapRMR , ${ \mathrm { G a p } } _ { G } ^ { \mathrm { R M S } }$ , ${ \mathrm { G a p } } _ { R } ^ { \operatorname* { m a x } }$ , and ${ \mathrm { G a p } } _ { G } ^ { \mathrm { m a x } }$ where $\mathcal { C }$ is composed of the two classes that correspond to whether someone made at least $\$ 50\mathbf { k }$ , $R$ refers to race, and $G$ refers to gender.

parse/train/H139Q_gAW/H139Q_gAW.md

@@ -0,0 +1,287 @@
+# LEARNING GRAPH CONVOLUTION FILTERS FROM DATA MANIFOLD
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Convolution Neural Network (CNN) has gained tremendous success in computer vision tasks with its outstanding ability to capture the local latent features. Recently, there has been an increasing interest in extending CNNs to the general spatial domain. Although various types of graph convolution and geometric convolution methods have been proposed, their connections to traditional 2D-convolution are not well-understood. In this paper, we show that depthwise separable convolution is a path to unify the two kinds of convolution methods in one mathematical view, based on which we derive a novel Depthwise Separable Graph Convolution that subsumes existing graph convolution methods as special cases of our formulation. Experiments show that the proposed approach consistently outperforms other graph convolution and geometric convolution baselines on benchmark datasets in multiple domains.
+
+# 1 INTRODUCTION
+
+Convolution Neural Network (CNN) (LeCun et al., 1995) has been proven to be an efficient model family in extracting hierarchical local patterns from grid-structured data, which has significantly advanced the state-of-the-art performance of a wide range of machine learning tasks, including image classification, object detection and audio recognition (LeCun et al., 2015). Recently, growing attention has been paid to dealing with data with an underlying graph/non-Euclidean structure, such as prediction tasks in sensor networks (Xingjian et al., 2015), transportation systems (Li et al., 2017), and 3D shape correspondence application in the computation graphics (Bronstein et al., 2017). How to replicate the success of CNNs for manifold-structured data remains an open challenge.
+
+Many graph convolution and geometric convolution methods have been proposed recently. The spectral convolution methods (Bruna et al., 2013; Defferrard et al., 2016; Kipf & Welling, 2016) are the mainstream algorithm developed as the graph convolution methods. Because their theory is based on the graph Fourier analysis (Shuman et al., 2013), one of their major limitations is that in this model the knowledge learned from different graphs is not transferrable (Monti et al., 2016). Other group of approaches is geometric convolution methods, which focuses on various ways to leverage spatial information about nodes(Masci et al., 2015; Boscaini et al., 2016; Monti et al., 2016). Existing models mentioned above are either not capable of capturing spatial-wise local information as in the standard convolution, or tend to have very large parameter space and hence, are prone to overfitting. As a result, both the spectral and the geometric convolution methods have not produced the results comparable to CNNs on related tasks. Such a misalignment makes it harder to leverage the rapidly developing 2D-convolution techniques in the generic spatial domain. We note graph convolution methods are also widely used in the pure graph structure data, like citation networks and social networks (Kipf & Welling, 2016). Our paper will only focus on the data with the spatial information.
+
+In this paper, we provide a unified view of the graph convolution and traditional 2D-convolution methods with the label propagation process (Zhu et al., 2003). It helps us better understand and compare the difference between them. Based on it, we propose a novel Depthwise Separable Graph Convolution (DSGC), which inherits the strength of depthwise separable convolution that has been extensively used in different state-of-the-art image classification frameworks including Inception Network (Szegedy et al., 2016), Xception Network (Chollet, 2016) and MobileNet (Howard et al., 2017). Compared with previous graph and geometric methods, the DSGC is more expressive and aligns closer to the depthwise separable convolution network, and shares the desirable characteristic of small parameter size as in the depthwise separable convolution. In experiments section, we evaluate the DSGC and baselines in three different machine learning tasks. The experiment results show that the performance of the proposed method is close to the standard convolution network in the image classification task on CIFAR dataset. And it outperforms previous graph convolution and geometric convolution methods in all tasks. Furthermore, we demonstrate that the proposed method can easily leverage the advanced technique developed for the standard convolution network to enhance the model performance, such as the Inception module (Szegedy et al., 2016), the DenseNet architecture (Huang et al., 2016) and the Squeeze-and-Excitation block (Hu et al., 2017).
+
+The main contribution of this paper is threefold:
+
+• A unified view of traditional 2D-convolution and graph convolution methods by introducing depthwise separable convolution.   
+• A novel Depthwise Separable Graph Convolution (DSGC) for spatial domain data.   
+• We demonstrate the efficiency of the DSGC with extensive experiments and show that it can facilitate the advanced technique of the standard convolution network to improve the model performance.
+
+# 2 A GRAPH PERSPECTIVE OF CONVOLUTION
+
+We provide a unified view of label propagation and graph convolution by showing that they are different ways to aggregate local information over the graphs or data manifolds. We then discuss connections between graph convolution and depthwise separable convolution over the 2D-grid graph, which motivates us to propose a new formulation that subsumes both methods as special cases.
+
+Unless otherwise specified, we denote a matrix by $\boldsymbol { X }$ , the $i$ -th row in the matrix by $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ , and $( i , j )$ -th element in the matrix by $x _ { i j }$ . Superscripts are used to distinguish different matrices when necessary. All the operations being discussed below can be viewed as a function that transforms input feature maps $\pmb { X } \in \mathbb { R } ^ { N \times P }$ to output feature maps $\pmb { Y } \in \mathbb { R } ^ { N \times Q }$ , where $N$ is the number of nodes in the graph and $P , Q$ are the number of input and features (channels) associated with each node respectively. We use $\mathcal { N } ( i )$ to denote the set of neighbors for $i$ -th node.
+
+# 2.1 LABEL PROPAGATION
+
+Label propagation (LP) (Zhu et al., 2003) is a classic approach to aggregate local information over a graph. The basic version of LP can be written as
+
+$$
+y _ { i q } = \sum _ { j \in \mathcal { N } ( i ) } w _ { i j } x _ { j q }
+$$
+
+where $W$ is a normalized adjacency matrix that summarizes the graph structure. The intuition is that the value of node $i$ is updated via a weighted combination of its neighbors.
+
+# 2.2 GRAPH CONVOLUTION
+
+Graph convolution (Kipf & Welling, 2016) (GC) is a recently proposed graph convolution operator that can be viewed as an extension of LP, formulated as
+
+$$
+y _ { i q } = \sum _ { j \in \mathcal { N } ( i ) } w _ { i j } z _ { j q } \quad w h e r e \quad z _ { j } = U \pmb { x } _ { j }
+$$
+
+where $W$ is a symmetrically normalized adjacency matrix with a ridge on its diagonal, which is a deterministic matrix given the input data, and $\dot { \pmb { U } } \in \mathbb { R } ^ { P \times Q }$ represents a linear transformation. Following the Chollet (2016), $W$ is named as the spatial filter and $U$ is named as the channel filter. The original form of graph convolution, such as the Spectral Network (Bruna et al., 2013), is derived from graph signal processing (Shuman et al., 2013) as a generalization of Fourier analysis to the domain of graphs. Several limitations of the Spectral Network, such as its high computation complexity and the lack of locality, are addressed in Defferrard et al. (2016) (ChebyNet) and further refined by Kipf & Welling (2016) via approximation.
+
+![](images/bf22aeecc4d347dc2458fdb8e081d2166b76b099e88b07662d361b13b13d2718.jpg)  
+Figure 1: Visualization of different convolution operations with three output channels. We use different colors to represent different filters (weight configurations of the links). (a) DSC defined on 2D grid graphs. (b) GC defined on generic graphs. (c) DSGC defined on generic graphs.
+
+To Compare LP with GC, the former only utilizes the graphical information, while the latter has an additional linear transformation of $\boldsymbol { \mathscr { x } } _ { j }$ to into the intermediate representation $z _ { j }$ via matrix $U$ . This additional step makes GC capable of capturing the dependencies among features (channels), which yields performance improvement.
+
+# 2.3 DEPTHWISE SEPARABLE CONVOLUTION
+
+For a full 2d-convolution layer, the convolution filters encode channel correlation and spatial correlation simultaneously (Chollet, 2016). Then depthwise separable convolution (DSC) is proposed under the intuition that the channel correlation and spatial correlation could be decoupled, and has been found successful in several modern architectures for image classification (Chollet, 2016). We choose to focus on DSC (instead of full convolution) because of its strong empirical performance with a small number of parameters, and its intimate connections to GC which will be revealed in the following. And we discuss the full convolution formulation with the label propagation process in Section 5.
+
+By viewing each pixel in the image as a node, DSC can be formulated in a graph-based fashion
+
+$$
+y _ { i q } = \sum _ { j \in \mathcal { N } ( i ) } w _ { \Delta _ { i j } } ^ { ( q ) } z _ { j q } \quad w h e r e \quad z _ { j } = U x _ { j }
+$$
+
+where $\Delta _ { i j }$ denotes the relative position of pixel $i$ and pixel $j$ on the image, and $w ^ { ( q ) }$ can be viewed as a lookup table with the pixel-pixel offset $\Delta _ { i j }$ as the key, according to the stationarity (weightsharing) assumption of convolution. In the context of images, $\mathcal { N } ( i )$ denotes the index set of surrounding pixels for $i$ -th pixel, which is equivalent to the $k$ -nearest neighbor set under the Euclidean distant metric. For example, the size of $\bar { \mathcal { N } } ( i )$ , or $k$ , is 9 for a $3 \times 3$ convolution filter (considering self-loop).
+
+# 3 PROPOSED METHOD
+
+# 3.1 DEPTHWISE SEPARABLE GRAPH CONVOLUTION
+
+We notice that the formulation of GC and DSC is similar except that
+
+1. Spatial filters in DSC are channel-specific, while GC uses a global spatial filter. 2. Spatial filters in DSC are learned from the data (under the stationarity constraints), while the filter in GC is a constant matrix with the given input.
+
+On the one hand, DSC does not apply to the domain of generic spatial data lying on the manifold where the space of $\Delta _ { i j }$ (defined as the difference of the spatial coordinates between node $i$ and node $j$ ) can be infinite. On the other hand, GC suffers from the restriction that all channels have to share the same given spatial filter. This heavily constrains the model capacity, which would be more severe when the deeper network structure is used. In the context of graphs, it would be desirable to have multiple spatial filters—to capture a diverse set of diffusion patterns over the graph or data manifold, which is the same as the convolution filters in the image domain.
+
+To address these limitations, we propose Depthwise Separable Graph Convolution (DSGC) which naturally generalizes both GC and DSC
+
+$$
+y _ { i q } = \sum _ { j \in \mathcal { N } ( i ) } w ^ { ( q ) } ( \Delta _ { i j } ) z _ { j q } \quad w h e r e \quad z _ { j } = U x _ { j }
+$$
+
+where we slightly abuse the notation by overloading $w ^ { ( q ) } ( \cdot )$ as a function, which maps $\Delta _ { i j }$ to a real number, and $\mathcal { N } ( i )$ still represents the $k$ -nearest neighbor sets. To understand the proposed formulation, notice
+
+1. Different from DSC, the stationarity requirement is implemented in a “soft” manner by defining a function instead of by the set of equality constraints. In our experiment, each $w ^ { ( q ) } ( \cdot )$ is a function parameterized by a two-layer MLP.   
+2. Different from GC, channel-specific convolution is enabled by learning multiple spatial convolution filters. This amounts to simultaneously constructing multiple graphs under the different node-node similarity metrices, where the metrices are implicitly defined by neural networks and hence, are jointly optimized during the training.
+
+Overfitting is a common issue in graph-based applications, due to limited data available. To alleviate this issue, we propose an option to group the channels into $C$ groups, where $D = Q / C$ channels in the same group would share the same filter.
+
+$$
+w ^ { ( q ) } ( \cdot ) = w ^ { ( q ^ { \prime } ) } ( \cdot ) \quad i f \quad \lfloor \frac { q } { D } \rfloor = \lfloor \frac { q ^ { \prime } } { D } \rfloor
+$$
+
+# 3.2 NORMALIZATION
+
+The context of each node in any given generic graph, namely its connection pattern with neighbors, can be non-stationary over different parts of the graph, while it is constant in the 2d-grid graphs. It is, therefore, a common practice to normalize the adjacency matrix in order to make the nodes adaptive to their own contexts (Eq.1). A natural way to carry out normalization for DSGC is to apply a softmax function over the predicted spatial filter weights at each node, which can be written as $\tilde { \pmb { w } } _ { i } = s o f t m a x ( \pmb { w } _ { i } )$ , where ${ \pmb w } _ { i }$ stands for the $i$ -th row of spatial filter $W$ learned by a neural network. We empirically find normalization leads to better performance and significantly speeds up the convergence.
+
+In the following experiments, we use the proposed depthwise separable graph convolution with a linear highway bypass as the basic convolution component and imitate the rest setting of the standard convolution neural network to solve different machine learning tasks.
+
+# 4 EXPERIMENTS
+
+# 4.1 EXPERIMENT SETTING
+
+We evaluate the proposed Depthwise Separable Graph Convolution (DSGC) method with representative baselines in the prediction tasks of image classification, time series forecasting, and document categorization. The algorithms are implemented in PyTorch; all the data and the code are made publicly accessible 1. For controlled experiments, all the graph convolution methods share the same empirical settings unless otherwise specified, including network structures, the dimension of latent factors, and so on. The optimization algorithm is applied to all models. The neural network used to model the spatial convolution filter $( w ^ { ( q ) } ( \cdot ) )$ in Eq.4 is a two-layers MLP with 256 hidden dimension and tanh activation function. We have conducted ablation tests with the two-layer MLP by changing the number of layers and activation function of each hidden layer, and by trying several weight sharing strategies. The results are very similar; the two-layer MLP provides a reasonable performance with the shortest running time. Appendix A contains more details, such as the network architecture and model hyper-parameters.
+
+# 4.2 EVALUATION ON IMAGE CLASSIFICATION
+
+We conduct experiments on CIFAR10 and CIFAR100 (Krizhevsky & Hinton, 2009), which are popular benchmark datasets in image classification. Both sets contain 60000 images with $3 2 \times 3 2$ pixels but CIFAR10 has 10 category labels and CIFAR100 has 100 category labels. Each image is typically treated as a $3 2 \times 3 2$ grid structure for standard image-based convolution. To enable the comparison on generic graphs, we create the modified versions of CIFAR10 and CIFAR100, respectively, by subsampling only $2 5 \%$ of the pixels from each graph. As illustrated in Figure 2, the subsampling results in irregularly scattered nodes for each image.
+
+![](images/93cb9c2b2bf9ca406d66b70368cba52d00aa0d0ce4f0e87bea8a6d779f71a461.jpg)  
+Figure 2: How to construct subsampled CIFAR datasets: (a) is an example image from CIFAR dataset. (b) is the subsampled pixels map. The blue points indicate which points are sampled. (c) is the image after sampling, where the black points are those being sampled out.
+
+For comparison we include the traditional 2d convolution and graph convolution networks as baselines, including standard CNN; Xception network (Chollet, 2016) which uses the depthwise separable convolution; DCNN (Atwood & Towsley, 2016), the method using multi-hops random walk as the graph filters; ChebyNet (Defferrard et al., 2016), the method using Chebyshev polynomial to approximate the Fourier transformation of (irregular) graphs; GCN (Kipf & Welling, 2016) which is described in Section 2; MoNet (Monti et al., 2016), the method using Gaussian function to define the propagation weights over (irregular) graphs. For a fair comparison, we use the VGG13 architecture (Simonyan & Zisserman, 2014) in all the methods above as the basic platform, and replace the convolution layers according to the methods. The pooling layer is performed by the kmean clustering. The centroid of each clusters is regarded as the new node after pooling, and its hidden vector is the mean or max over the nodes in the cluster, based on the pooling method. Notice that, we only normalize the input signals to [0,1] and do not have other preprocessing or data augmentation.
+
+The experiment results are summarized in Table 1. Firstly, we observe that Xception and CNN have the best results; this is not surprising because both methods use grid-based convolution which is naturally suitable for image recognition. Secondly, DSGC outperforms all the other graph-based convolution methods, and its performance is very close to that of the grid-based convolution methods. Furthermore, contributed by the depthwise separable convolution and sharing graph technique, our model can achieve the competitive performance without increasing the number of parameters as GCN, the one with the smallest number of parameters among the graph convolution approaches. In appendix A.4, we further report the variance of DSGC model, which shows the improvement is significant and stable.
+
+# 4.3 EVALUATION ON TIME SERIES FORECASTING
+
+As another important application domain, here we are interested in how to effectively utilize the locality information about sensor networks in time series forecasting. For example, how to incorporate the longitudes/latitudes of sensors w.r.t. temporal cloud movement is an important question in spatiotemporal modeling for predicting the output of solar energy farms in the United States. Appendix A provides the formal definition of this task.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>Subsampled Graphs</td><td rowspan=1 colspan=5>Original Graphs</td></tr><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>CIFAR100</td><td rowspan=1 colspan=1>P</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=3>CIFAR100</td><td rowspan=1 colspan=1>P</td></tr><tr><td rowspan=5 colspan=1>DCNN (Atwood &amp; Towsley, 2016)ChebyNet (Defferrard et al., 2016)GCN (Kipf &amp; Welling,2016)MoNet (Monti et al., 2016)DSGC</td><td rowspan=5 colspan=1>43.68%25.04%26.78%21.20%18.72%</td><td rowspan=5 colspan=1>76.65%49.44%51.30%47.87%44.33%</td><td rowspan=1 colspan=1>12M</td><td rowspan=1 colspan=1>55.56%</td><td rowspan=1 colspan=3>84.16%</td><td rowspan=1 colspan=1>50M</td></tr><tr><td rowspan=2 colspan=1>10M5.6M</td><td rowspan=2 colspan=1>12.99%19.09%</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=2>36.96%</td><td rowspan=1 colspan=1>19M</td></tr><tr><td rowspan=1 colspan=2>41.64 %</td><td rowspan=1 colspan=2>41.64 %</td><td rowspan=1 colspan=1>9.8M</td></tr><tr><td rowspan=1 colspan=1>11M</td><td rowspan=1 colspan=1>8.34%</td><td rowspan=1 colspan=3>29.56%</td><td rowspan=1 colspan=1>20M</td></tr><tr><td rowspan=1 colspan=1>5.7M</td><td rowspan=1 colspan=1>7.31%</td><td rowspan=1 colspan=3>27.29%</td><td rowspan=1 colspan=1>9.9M</td></tr><tr><td rowspan=2 colspan=1>CNN (Simonyan &amp; Zisserman, 2014)Xception (Chollet,2016)</td><td rowspan=2 colspan=1>18.03%17.07%</td><td rowspan=2 colspan=1>43.42%41.54%</td><td rowspan=1 colspan=1>18M</td><td rowspan=1 colspan=1>6.86%</td><td rowspan=1 colspan=3>26.86%</td><td rowspan=1 colspan=1>18M</td></tr><tr><td rowspan=1 colspan=1>3.1M</td><td rowspan=1 colspan=1>7.08%</td><td rowspan=1 colspan=3>26.84%</td><td rowspan=1 colspan=1>3.1M</td></tr></table>
+
+Table 1: Test-set error rates: P is the number of parameters
+
+We choose three publicly available benchmark datasets for this task:
+
+• The U.S Historical Climatology Network $\mathrm { ( U S H C N ) }$ dataset contains daily climatological data from 1,218 meteorology sensors over the years from 1915 to 2000. The sequence length is 32,507. It includes five subsets, and each has a climate variable: (1) maximum temperature, (2) minimum temperature, (3) precipitation, (4) snowfall and (5) snow depth. We use the daily maximum temperature data and precipitation data, and refer them as the USHCN-TMAX and USHCN-PRCP sets, respectively.   
+• The solar power production records in the year of $2 0 0 6 ^ { 3 }$ has the data with the production rate of every 10 minutes from 1,082 solar power stations in the west of the U.S. The sequence length is 52,560. We refer this set of data as Solar.
+
+All the datasets have been split into the training set $( 6 0 \% )$ , the validation set $( 2 0 \% )$ and the test set $( 2 0 \% )$ in chronological order.
+
+All the graph convolution methods (DCNN, ChebyNet, GCN and MoNet) in the previous section (Section 4.2) are included to form the baselines for comparison. We also add traditional methods for time series forecasting, such as (1) Autoregressive model (AR) which predicts future signal using a window of historical data based on a linear assumption about temporal dependencies, (2) Vector autoregressive model (VAR) which extends AR to the multivariate version, namely, the input is the signals from all sensors in the history window, and (3) the LSTNet deep neural network model (Lai et al., 2017) which combines the strengths of CNN, RNN and AR. None of those methods is capable of leveraging locational dependencies via graph convolution. We exclude the CNN and Xception methods, the 2D-grid based convolution, which could not be generalized to irregular graphs which we focus here.
+
+Table 2 summarizes the evaluation results of all the methods, where the performance is measured using the Root Square Mean Error (RMSE). The best result on each dataset is highlighted in boldface. The first chunk of three methods does not leverage the spatial or locational information in data. The second chuck consists of the neural network models which leverage the spatial information about sensor networks. The graph convolution methods in the second chunk clearly outperforms the methods in the first chunk, which does not explicitly model the spacial correlation within sensor networks. Overall, our proposed method (DSGC) has the best performance on all the datasets, demonstrating its strength in capturing informative local propagation patterns temporally and specially.
+
+# 4.4 DOCUMENT CATEGORIZATION
+
+For the application to text categorization we use the 20NEWS dataset (Joachims (1996)) for our experiments. It consists of 18,845 text documents associated with 20 topic labels. Individual words in the document vocabulary are the nodes in the graph for convolution. Each node also has its word embedding vector which is learned by running the Word2Vec algorithm (Mikolov et al. (2013)) on this corpus. Following the experiment settings in Defferrard et al. (2016) we select the top 1000 most frequent words as the nodes. Table 3 summarizes the results of the graph convolution methods plus three popular traditional classifiers (Linear SVM, Multivariate Naive Bayes and Softmax). DSGC has the best result on this dataset. Notice that the traditional classifiers are trained and tested with
+
+Table 2: Time series prediction: Experiment result in terms of RMSE.   
+
+<table><tr><td>Dataset</td><td>USHCN-TMAX</td><td>USHCN-PRCP</td><td>Solar</td></tr><tr><td>AR VAR</td><td>8.2354</td><td>30.3825</td><td>0.03195</td></tr><tr><td>LSTNet (Lai et al., 2017)</td><td>17.9743 10.1973</td><td>29.2597 29.0624</td><td>0.03296 0.02865</td></tr><tr><td>DCNN (Atwood &amp; Towsley, 2016)</td><td>6.5188</td><td>29.0424</td><td>0.02652</td></tr><tr><td>ChebyNet (Defferrard et al., 2016)</td><td>5.5823</td><td>27.1298</td><td>0.02531</td></tr><tr><td>GCN (Kipf &amp; Welling, 2016)</td><td>5.4671</td><td>27.1172</td><td>0.02512</td></tr><tr><td>MoNet (Monti et al., 2016)</td><td>5.8263</td><td>26.8076</td><td>0.02564</td></tr><tr><td>DSGC</td><td>5.1738</td><td>25.8228</td><td>0.02453</td></tr></table>
+
+the feature set of the top 1000 words, which is the same setting as in the graph convolution models.   
+If all words are used, traditional classifiers would have higher performance.
+
+Table 3: Accuracy on the validation set. The results with † come from Defferrard et al. (2016).   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>Linear SVM†Multinomial Naive Bayes†SoftmaxtFC2500tFC2500-FC500t</td><td rowspan=1 colspan=1>65.90%68.51%66.28%64.64%65.76%</td></tr><tr><td rowspan=1 colspan=1>DCNN (Atwood &amp; Towsley, 2016)ChebyNet (Defferrard et al., 2016)GCN (Kipf &amp; Welling, 2016)MoNet (Monti et al., 2016)DSGC</td><td rowspan=1 colspan=1>70.35%70.92%71.01%70.60%71.88%</td></tr></table>
+
+# 4.5 DSGC VARIANTS WITH ADVANCED CONVOLUTION ARCHITECTURES
+
+The proposed convolution method (DSGC) can be considered as an equivalent component to the depthwise separable convolution method. Naturally, we can leverage the technique developed for the standard convolution network to improve the DSGC framework. Hence we examine DSGC with the following techniques which are popular in recent years for standard convolution over images: (1) Inception module (Szegedy et al., 2016), (2) DenseNet framework (Huang et al., 2016) and (3) Squeeze-and-Excitation block (Hu et al., 2017). The details of those architectures are included in the Appendix A. The results are presented in Table 4. Clearly, combined with the advantageous techniques/architectures, the performance of DSGC in image classificationcan can be further improved. It demonstrates that the DSGC can easily enjoy the benefit of the traditional 2d-convolution network development.
+
+Table 4: Summary of error rate on the test set in different settings.   
+
+<table><tr><td></td><td colspan="3">Subsampled Graphs</td><td colspan="3">Original Graphs</td></tr><tr><td>Dataset</td><td>CIFAR10</td><td>CIFAR100</td><td>P</td><td>CIFAR10</td><td>CIFAR100</td><td>P</td></tr><tr><td>DSGC-VGG13</td><td>18.72%</td><td>44.33%</td><td>5.7M</td><td>7.31%</td><td>27.29%</td><td>9.9M</td></tr><tr><td>DSGC-INCEPTION</td><td>18.27%</td><td>43.41%</td><td>9.9M</td><td>6.44%</td><td>28.55%</td><td>12M</td></tr><tr><td>DSGC-DenseNet</td><td>17.17%</td><td>43.34%</td><td>2.7M</td><td>7.14%</td><td>26.50%</td><td>2.9M</td></tr><tr><td>DSGC-SE</td><td>18.71%</td><td>44.15%</td><td>6.1M</td><td>7.00%</td><td>27.26%</td><td>10M</td></tr><tr><td>CNN</td><td>18.03%</td><td>43.42%</td><td>18M</td><td>6.86%</td><td>26.86%</td><td>18M</td></tr><tr><td>Xception</td><td>17.07%</td><td>41.54%</td><td>3.1M</td><td>7.08%</td><td>26.84%</td><td>3.1M</td></tr></table>
+
+# 4.6 TRAINING TIME COMPARISON
+
+In table 5, we report the mean training time per epoch for DSGC and GCN, the fastest graph convolution baseline. In DSGC, our model computes the convolution weight for each edge of the graph, which requires more computation resources. However, we always perform the graph convolution on the sparse graph, which the number of edges grows only linearly in the graph size. Therefore the training is fairly efficient. Notably, learning the convolution filters as in DSGC leads to consistently better performance over all previous methods, with around $0 . 5 \mathrm { x } - 3 \mathrm { x }$ running time.
+
+Table 5: Training time per epoch for GCN and DSGC methods. The unit is minute.   
+
+<table><tr><td>Dataset</td><td>CIFAR</td><td>USHCN-TMAX</td><td>20news</td></tr><tr><td>GCN</td><td>1.75</td><td>0.465</td><td>0.207</td></tr><tr><td>DSGC</td><td>3.81</td><td>1.73</td><td>0.280</td></tr></table>
+
+# 5 RELATED WORK
+
+In this section, we will summarize the graph convolution methods proposed in recent years with the label propagation process, which reveals the difference between traditional 2D-convolution and them. Firstly, we provide the formulation of the full convolution (LeCun et al., 1995),
+
+$$
+y _ { i q } = \sum _ { p = 1 } ^ { P } \sum _ { j \in \mathcal { N } ( i ) } w _ { \Delta _ { i j } } ^ { ( p q ) } x _ { j p }
+$$
+
+different from the depthwise separable convolution, it captures the channel correlation and spatial correlation simultaneously by $W ^ { ( p q ) }$ , which leads to the larger number of parameters.
+
+In Spectral Network (Bruna et al., 2013), the authors try to leverage the graph Fourier transformation as the basic convolution operation in the graph domain, which can be written as,
+
+$$
+y _ { i q } = \sum _ { p = 1 } ^ { P } \sum _ { j \in \mathcal { N } ( i ) } w _ { i j } ^ { ( p q ) } x _ { j p } w h e r e W ^ { p q } = \Phi \Lambda ^ { p q } \Phi ^ { T }
+$$
+
+where $\Phi \in \mathbb { R } ^ { n \times n }$ contains the eigenvectors of Laplacian matrix of the graph, and $\Lambda$ is a diagonal matrix and learned by the supervision data. The Spectral Network can be matched with the full convolution, but with the different filter subspace, in other words, with different basic filters. However, it suffers from several limitations. (1) It needs to conduct eigenvector decomposition over the Laplacian Matrix, which is a very expensive operation. (2) The filters are not localized in the spatial domain. (3) The number of parameters grows linearly with the number of nodes in the graph. In order to address the previous problems, researchers try to use the Chebyshev polynomial to approximate the non-parameter filter $\Lambda$ , which is referred to as ChebyNet (Defferrard et al., 2016). It can be written as,
+
+$$
+y _ { i q } = \sum _ { k = 1 } ^ { K } \sum _ { j \in \mathcal { N } ( i ) } T _ { k } ( L ) _ { i j } z _ { i q } ^ { ( k ) } \quad w h e r e \quad z _ { i } ^ { ( k ) } = U ^ { ( k ) } \pmb { x } _ { j }
+$$
+
+where $T _ { k } ( L )$ is the $k$ -th order Chebyshev polynomial term. The ChebyNet can be considered as the integration of $K$ depthwise separable convolution components in a layer. But still, it suffers from the similar limitation as the GCN, which is using one graph filter over all channels and the graph filter is constant given the input. So its model capacity still cannot compare with depthwise separable convolution. With larger $K$ , the ChebyNet can approximate the non-parameter filers in the Spectral Network. However, it would require large number of parameters and face the similar limitation as the Spectral Network.
+
+Besides the graph convolution methods, researchers propose another type of models, geometric convolution methods (Masci et al., 2015; Boscaini et al., 2016; Monti et al., 2016), to deal with data in the general spatial domain. Here, we introduce the most advanced one, MoNet (Monti et al., 2016) framework, which is also the most related one to our paper. The updating formula of MoNet in the label propagation process is,
+
+$$
+y _ { i q } = \sum _ { k = 1 } ^ { K } \sum _ { j \in \mathcal { N } ( i ) } w _ { k } \mathopen { } \mathclose \bgroup \left( v ( i , j ) \aftergroup \egroup \right) z _ { j q } ^ { ( k ) } \quad w h e r e \quad z _ { j } ^ { ( k ) } = { U ^ { k } } x _ { j }
+$$
+
+where $w _ { k } ( v ) = e x p ( - { \textstyle \frac { 1 } { 2 } } ( v - \mu _ { k } ) ^ { T } \Sigma _ { k } ^ { - 1 } ( v - \mu _ { k } ) )$ , and $v ( i , j )$ is a mapping from a node pair to a embedding vector, similar to $\Delta _ { i j }$ in our model. $\mu _ { k } , \Sigma _ { k }$ are both model parameters, and $\Sigma _ { k }$ is constrained as the diagonal matrix. MoNet can be viewed as an extension of the ChebyNet by letting the graph filters learn from the data. But it still has two limitations compared with the depthwise separable convolution and proposed method: (1) It uses a simple Gaussian function, which is weaker than non-parametric filter in the depthwise separable convolution, and neural network function in the proposed method. (2) It uses a graph filter for all channels. In order to capture complex propagation patterns in a layer, the model requires a larger $K$ , which leads to much larger number of parameters. And finally the experiment results show that the proposed method (DSGC) consistently outperforms the MoNet with less parameters in multiple tasks.
+
+# 6 CONCLUSION
+
+In this paper, we propose a novel Depthwise Separable Graph Convolution (DSGC) Network which is explicitly generalized from the depthwise separable convolution, and goes beyond to the general graph space. The extensive experiments on multi-field benchmark datasets demonstrate that our method can outperform strong baseline methods with a relatively small number of model parameters, and that it can be easily extended to leverage the advanced techniques/architectures in standard convolution networks for further improvement of the performance. In future work, we want to explore its impact on a broader range of applications, such as social networks and molecular structures by leveraging technical improvements about node/edge embedding based on graph structure information.
+
+# REFERENCES
+
+James Atwood and Don Towsley. Diffusion-convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 1993–2001, 2016.
+
+Davide Boscaini, Jonathan Masci, Emanuele Rodola, and Michael Bronstein. Learning shape cor- \` respondence with anisotropic convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 3189–3197, 2016.
+
+Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013.
+
+Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. arXiv preprint arXiv:1610.02357, 2016.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks ¨ on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pp. 3844–3852, 2016.
+
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.
+
+Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. arXiv preprint arXiv:1709.01507, 2017.
+
+Gao Huang, Zhuang Liu, Kilian Q Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. arXiv preprint arXiv:1608.06993, 2016.
+
+Thorsten Joachims. A probabilistic analysis of the rocchio algorithm with tfidf for text categorization. Technical report, Carnegie-mellon univ pittsburgh pa dept of computer science, 1996.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Guokun Lai, Wei-Cheng Chang, Yiming Yang, and Hanxiao Liu. Modeling long-and short-term temporal patterns with deep neural networks. arXiv preprint arXiv:1703.07015, 2017.
+
+Yann LeCun, Yoshua Bengio, et al. Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, 3361(10):1995, 1995.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015.
+
+Yaguang Li, Rose Yu, Cyrus Shahabi, and Yan Liu. Graph convolutional recurrent neural network: Data-driven traffic forecasting. arXiv preprint arXiv:1707.01926, 2017.
+
+Jonathan Masci, Davide Boscaini, Michael Bronstein, and Pierre Vandergheynst. Geodesic convolutional neural networks on riemannian manifolds. In Proceedings of the IEEE international conference on computer vision workshops, pp. 37–45, 2015.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pp. 3111–3119, 2013.
+
+Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M \` Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. arXiv preprint arXiv:1611.08402, 2016.
+
+David I Shuman, Sunil K Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. The emerging field of signal processing on graphs: Extending high-dimensional data analysis to networks and other irregular domains. IEEE Signal Processing Magazine, 30(3):83–98, 2013.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016.
+
+SHI Xingjian, Zhourong Chen, Hao Wang, Dit-Yan Yeung, Wai-Kin Wong, and Wang-chun Woo. Convolutional lstm network: A machine learning approach for precipitation nowcasting. In Advances in neural information processing systems, pp. 802–810, 2015.
+
+Xiaojin Zhu, Zoubin Ghahramani, and John D Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. In Proceedings of the 20th International conference on Machine learning (ICML-03), pp. 912–919, 2003.
+
+Table 6: Neural Network architecture for CIFAR datasets. Please see the text for more details.   
+
+<table><tr><td rowspan=1 colspan=1>Layers</td><td rowspan=1 colspan=3>VGG13</td><td rowspan=1 colspan=3>DSGC-VGG13</td><td rowspan=1 colspan=3>DSGC-DenseNet</td></tr><tr><td rowspan=1 colspan=1>Convolution</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3 ×3conv]×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=2>9-conv×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>9-conv×6</td><td rowspan=1 colspan=1>×6</td></tr><tr><td rowspan=1 colspan=1>Transition</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3>1-conv</td></tr><tr><td rowspan=1 colspan=1>Pooling</td><td rowspan=1 colspan=3>2 × 2 max-pooling</td><td rowspan=1 colspan=6>4 max-pooling</td></tr><tr><td rowspan=1 colspan=1>Convolution</td><td rowspan=1 colspan=2>3×3 conv×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>9-convx2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=2>9-conv</td><td rowspan=1 colspan=1>×12</td></tr><tr><td rowspan=1 colspan=1>Transition</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3>1-conv</td></tr><tr><td rowspan=1 colspan=1>Pooling</td><td rowspan=1 colspan=3>2×2 max-pooling</td><td rowspan=1 colspan=6>4 max-pooling</td></tr><tr><td rowspan=1 colspan=1>Convolution</td><td rowspan=1 colspan=2>[3×3conv]×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>9-conv]x 2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>[9-conv]×24</td><td rowspan=1 colspan=1>×24</td></tr><tr><td rowspan=1 colspan=1>Transition</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3>1-conv</td></tr><tr><td rowspan=1 colspan=1>Pooling</td><td rowspan=1 colspan=3>2 × 2 max-pooling</td><td rowspan=1 colspan=6>4 max-pooling</td></tr><tr><td rowspan=1 colspan=1>Convolution</td><td rowspan=1 colspan=2>3×3conv×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=3>9-convx2</td><td rowspan=1 colspan=3>9-conv× 16</td></tr><tr><td rowspan=1 colspan=1>Transition</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3>1-conv</td></tr><tr><td rowspan=1 colspan=1>Pooling</td><td rowspan=1 colspan=3>2×2 max-pooling</td><td rowspan=1 colspan=6>4 max-pooling</td></tr><tr><td rowspan=1 colspan=1>Convolution</td><td rowspan=1 colspan=2>3×3conv]×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>9-conv×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=3></td></tr><tr><td rowspan=1 colspan=1>Pooling</td><td rowspan=1 colspan=3>2 ×2 max-pooling</td><td rowspan=1 colspan=6>4 max-pooling</td></tr><tr><td rowspan=1 colspan=1>Classifier</td><td rowspan=1 colspan=9>512D fully-connected, softmax</td></tr></table>
+
+# A EXPERIMENT DETAIL
+
+A.1 IMPLEMENTATION DETAILS OF CIFAR EXPERIMENT
+
+In section 4.2 and 4.5, we conduct the experiment on the CIFAR10 and CIFAR100 datasets. We will introduce the architecture settings for the DSGC and baseline models. Table 6 illustrates the basic architecture used in the experiment. In the DSGC-VGG13 and DSGC-DenseNet models, the $k$ -conv refers to the spatial convolution (Eq.4) with $k$ -nearest neighbors as the neighbor setting. So the 1-conv is the same as the $1 \times 1$ conv, which is doing linear transformation on channels. The hidden dimensions of VGG13 and DSGC-VGG13 are set as $\{ 2 5 6 , 5 1 2 , 5 1 2 , 5 1 2 \}$ and $\{ 2 5 6 , 5 1 2 , 5 1 2 , 1 0 2 4 \}$ . The growth rate of DSGC-DenseNet is 32. And the baseline graph and geometric convolution methods use the identical architecture as DSGC-VGG13. For the subsampled CIFAR experiment, We eliminate the first convolution, transition and pooling layer, and change the spatial convolution from 9-conv to {16-conv, 12-conv, 8-conv, 4-conv}. For the DSGC-SE, we follow the method described in Hu et al. (2017) to add the SE block to DSGC-VGG13 architecture. We use the dropout scheme described in Huang et al. (2016) for the DSGC-DenseNet model, and add the dropout layer after the pooling layer for VGG13 and DSGC-VGG13 models. For the DSGCInception model, we imitate the design of the Inception Network (Szegedy et al. (2016)). The key idea is letting a convolution layer have different size of convolution filters. We use a simple example as our Inception module, which is illustrated in Figure 3.
+
+For the CNN model, we still format the input signal in the matrix shape. The signals in invalid points are set as 0. Furthermore, to perform the fair comparison with standard CNN in the subsampled situation, we append a mask matrix as an additional channel for input signals to indicate whether the pixel is valid or not. For the MoNet, we also apply the softmax trick described in Section 3, which accelerates its training process and improves its final result. For the ChebyNet, we set the polynomial order as $K = 3$ .
+
+For the $\triangle _ { i j }$ used in DSGC and MoNet, we use a 5 dimension feature vector. We denote the coordinate of $i$ -th node as $( x _ { i } , y _ { i } )$ , and $\triangle x _ { i j } = x _ { i } - x _ { j } , \triangle y _ { i j } = y _ { i } - y _ { j } , \triangle d _ { i j } = \triangle x _ { i j } ^ { 2 } + \triangle y _ { i j } ^ { 2 }$ . Then $\begin{array} { r } { \triangle _ { i j } = ( s i g n ( \triangle x _ { i j } ) , | \triangle x _ { i j } | , s i g n ( \triangle y _ { i j } ) , | \triangle y _ { i j } | , \triangle d _ { i j } ) } \end{array}$ .
+
+The same learning schedule is applied to all models. We use SGD to train the model for 400 epochs. The initial learning rate is 0.1, and is divided by 10 at $50 \%$ and $7 5 \%$ of the total number of training epochs.
+
+![](images/ad95d6832217385a5192e14d10fb6a88c853c016619ac7ef58be35065053fb7c.jpg)  
+Figure 3: Inception Module
+
+# A.2 IMPLEMENTATION DETAILS OF TIME SERIES PREDICTION
+
+Firstly, we will give the formal definition of the time series forecasting, that is, spatiotemporal regression problem. We formulate the the spatiotemporal regression problem as a multivariate time series forecasting task with the sensors’ location as the input. More formally, given a series of time series signals observed from sensors $Y = \{ y _ { 1 } , y _ { 2 } , \cdot \cdot \cdot , y _ { T } \}$ where $\ b { y } _ { t } \in \mathbb { R } ^ { n }$ and $n$ are the number of sensors, and the locations of sensors $\pmb { L } = \{ l _ { 1 } , l _ { 2 } , \cdots , l _ { n } \}$ where $\bar { \boldsymbol { l } } _ { i } \in \mathbb { R } ^ { 2 }$ and indicates the coordinate of the sensor, the task is to predict a series of future signals in a rolling forecasting fashion. That being said, to predict ${ \pmb { y } } _ { T + h }$ where $h$ is the desirable horizon ahead of the current time stamp $T$ , we assume $\{ { \pmb y } _ { 1 } , { \pmb y } _ { 2 } , \dotsb , { \pmb y } _ { T } \}$ are available. Likewise, to predict the signal of the next time stamp ${ \pmb y } _ { T + h + 1 }$ , we assume $\{ { \pmb y } _ { 1 } , { \pmb y } _ { 2 } , \cdot \cdot \cdot , { \pmb y } _ { T } , { \pmb y } _ { T + 1 } \}$ are available. In this paper, we follow the setting of the autoregressive model. Define a window size $p$ which is a hyper-parameter firstly. The model input at time stamp $T$ is $X _ { T } = \{ y _ { T - p + 1 } , \cdot \cdot \cdot , y _ { T } \} \in \mathbb { R } ^ { n \times p }$ . In the experiments of this paper, the horizon is always set as 1.
+
+Intuitively, different sensors may have node-level hidden features to influence its propagation patterns and final outputs. Then for each node, the model learns a node embedding vector and concatenate it with the input signals. By using this trick, each node has limited freedom to interface with its propagation patterns. This trick is proven to be useful in this task, USHCN-PRCP and Solar specifically. We set the embedding size as 10 for these two datasets.
+
+One thing readers may notice is that there are $10 \%$ data in USHCN dataset missing. To deal with that, we add an additional feature channel to indicate which point is missing. For the time series models, we tune the historical window $p$ according to the validation set. For the rest of models, we set the window size $p = 1 8$ for Solar dataset and $p = 6$ for USHCN datasets. The network architecture used in this task is 7 convolution layers followed by a regression layer. The $\triangle _ { i j }$ setting is the same as the previous one. We use the Adam optimizer (Kingma & Ba, 2014) for this task, and train each model 200 epochs with learning rate 0.001.
+
+# A.3 IMPLEMENTATION DETAILS OF DOCUMENT CATEGORIZATION
+
+The data preprocessing follows the experiment details in Defferrard et al. (2016). And the network architecture for all models is 5 convolution layers followed by two MLP layers as the classifier. After each convolution layer, a dropout layer is performed with dropout rate of 0.5. The nodes’ coordinate is the word embedding, and the method to calculate $\triangle _ { i j }$ is similar to the previous ones. The optimizer used in this task is the same as the CIFAR experiment.
+
+# A.4 VARIANCE OF DSGC PERFORMANCE
+
+In this section, we report the variance of DSGC method in all 3 tasks. We run the DSGC model for 10 times and report the mean $\pm$ std: CIFAR $7 . 3 9 \pm 0 . 1 3 6$ , USHCN-TMAX $5 . 2 1 1 \pm 0 . 0 4 9 8$ , 20news $7 1 . 7 0 \pm 0 . 2 8 5$ . Obviously, the variance is significantly smaller than the performance gap between the DSGC model and best baseline results (CIFAR 8.34, USHCN-TMAX 5.467, 20news 71.01).

parse/train/H139Q_gAW/H139Q_gAW_content_list.json

@@ -0,0 +1,1505 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING GRAPH CONVOLUTION FILTERS FROM DATA MANIFOLD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            694,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolution Neural Network (CNN) has gained tremendous success in computer vision tasks with its outstanding ability to capture the local latent features. Recently, there has been an increasing interest in extending CNNs to the general spatial domain. Although various types of graph convolution and geometric convolution methods have been proposed, their connections to traditional 2D-convolution are not well-understood. In this paper, we show that depthwise separable convolution is a path to unify the two kinds of convolution methods in one mathematical view, based on which we derive a novel Depthwise Separable Graph Convolution that subsumes existing graph convolution methods as special cases of our formulation. Experiments show that the proposed approach consistently outperforms other graph convolution and geometric convolution baselines on benchmark datasets in multiple domains. ",
+        "bbox": [
+            233,
+            266,
+            764,
+            433
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            334,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolution Neural Network (CNN) (LeCun et al., 1995) has been proven to be an efficient model family in extracting hierarchical local patterns from grid-structured data, which has significantly advanced the state-of-the-art performance of a wide range of machine learning tasks, including image classification, object detection and audio recognition (LeCun et al., 2015). Recently, growing attention has been paid to dealing with data with an underlying graph/non-Euclidean structure, such as prediction tasks in sensor networks (Xingjian et al., 2015), transportation systems (Li et al., 2017), and 3D shape correspondence application in the computation graphics (Bronstein et al., 2017). How to replicate the success of CNNs for manifold-structured data remains an open challenge. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many graph convolution and geometric convolution methods have been proposed recently. The spectral convolution methods (Bruna et al., 2013; Defferrard et al., 2016; Kipf & Welling, 2016) are the mainstream algorithm developed as the graph convolution methods. Because their theory is based on the graph Fourier analysis (Shuman et al., 2013), one of their major limitations is that in this model the knowledge learned from different graphs is not transferrable (Monti et al., 2016). Other group of approaches is geometric convolution methods, which focuses on various ways to leverage spatial information about nodes(Masci et al., 2015; Boscaini et al., 2016; Monti et al., 2016). Existing models mentioned above are either not capable of capturing spatial-wise local information as in the standard convolution, or tend to have very large parameter space and hence, are prone to overfitting. As a result, both the spectral and the geometric convolution methods have not produced the results comparable to CNNs on related tasks. Such a misalignment makes it harder to leverage the rapidly developing 2D-convolution techniques in the generic spatial domain. We note graph convolution methods are also widely used in the pure graph structure data, like citation networks and social networks (Kipf & Welling, 2016). Our paper will only focus on the data with the spatial information. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we provide a unified view of the graph convolution and traditional 2D-convolution methods with the label propagation process (Zhu et al., 2003). It helps us better understand and compare the difference between them. Based on it, we propose a novel Depthwise Separable Graph Convolution (DSGC), which inherits the strength of depthwise separable convolution that has been extensively used in different state-of-the-art image classification frameworks including Inception Network (Szegedy et al., 2016), Xception Network (Chollet, 2016) and MobileNet (Howard et al., 2017). Compared with previous graph and geometric methods, the DSGC is more expressive and aligns closer to the depthwise separable convolution network, and shares the desirable characteristic of small parameter size as in the depthwise separable convolution. In experiments section, we evaluate the DSGC and baselines in three different machine learning tasks. The experiment results show that the performance of the proposed method is close to the standard convolution network in the image classification task on CIFAR dataset. And it outperforms previous graph convolution and geometric convolution methods in all tasks. Furthermore, we demonstrate that the proposed method can easily leverage the advanced technique developed for the standard convolution network to enhance the model performance, such as the Inception module (Szegedy et al., 2016), the DenseNet architecture (Huang et al., 2016) and the Squeeze-and-Excitation block (Hu et al., 2017). ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contribution of this paper is threefold: ",
+        "bbox": [
+            174,
+            236,
+            488,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• A unified view of traditional 2D-convolution and graph convolution methods by introducing depthwise separable convolution.   \n• A novel Depthwise Separable Graph Convolution (DSGC) for spatial domain data.   \n• We demonstrate the efficiency of the DSGC with extensive experiments and show that it can facilitate the advanced technique of the standard convolution network to improve the model performance. ",
+        "bbox": [
+            215,
+            262,
+            825,
+            358
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 A GRAPH PERSPECTIVE OF CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            378,
+            563,
+            395
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We provide a unified view of label propagation and graph convolution by showing that they are different ways to aggregate local information over the graphs or data manifolds. We then discuss connections between graph convolution and depthwise separable convolution over the 2D-grid graph, which motivates us to propose a new formulation that subsumes both methods as special cases. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unless otherwise specified, we denote a matrix by $\\boldsymbol { X }$ , the $i$ -th row in the matrix by $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ , and $( i , j )$ -th element in the matrix by $x _ { i j }$ . Superscripts are used to distinguish different matrices when necessary. All the operations being discussed below can be viewed as a function that transforms input feature maps $\\pmb { X } \\in \\mathbb { R } ^ { N \\times P }$ to output feature maps $\\pmb { Y } \\in \\mathbb { R } ^ { N \\times Q }$ , where $N$ is the number of nodes in the graph and $P , Q$ are the number of input and features (channels) associated with each node respectively. We use $\\mathcal { N } ( i )$ to denote the set of neighbors for $i$ -th node. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            559
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 LABEL PROPAGATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            366,
+            590
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Label propagation (LP) (Zhu et al., 2003) is a classic approach to aggregate local information over a graph. The basic version of LP can be written as ",
+        "bbox": [
+            173,
+            602,
+            823,
+            630
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a59f3976f07f7d6b6b429ff2dcc4c4b0669c7fceb53325dc27d46c8169c0b39c.jpg",
+        "text": "$$\ny _ { i q } = \\sum _ { j \\in \\mathcal { N } ( i ) } w _ { i j } x _ { j q }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            637,
+            566,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $W$ is a normalized adjacency matrix that summarizes the graph structure. The intuition is that the value of node $i$ is updated via a weighted combination of its neighbors. ",
+        "bbox": [
+            171,
+            689,
+            823,
+            718
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 GRAPH CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            734,
+            375,
+            750
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph convolution (Kipf & Welling, 2016) (GC) is a recently proposed graph convolution operator that can be viewed as an extension of LP, formulated as ",
+        "bbox": [
+            174,
+            761,
+            823,
+            790
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d11b91998945b2c764d877ad8e6b7b3e17780d740b01a4d27563e285da00c153.jpg",
+        "text": "$$\ny _ { i q } = \\sum _ { j \\in \\mathcal { N } ( i ) } w _ { i j } z _ { j q } \\quad w h e r e \\quad z _ { j } = U \\pmb { x } _ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            796,
+            642,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $W$ is a symmetrically normalized adjacency matrix with a ridge on its diagonal, which is a deterministic matrix given the input data, and $\\dot { \\pmb { U } } \\in \\mathbb { R } ^ { P \\times Q }$ represents a linear transformation. Following the Chollet (2016), $W$ is named as the spatial filter and $U$ is named as the channel filter. The original form of graph convolution, such as the Spectral Network (Bruna et al., 2013), is derived from graph signal processing (Shuman et al., 2013) as a generalization of Fourier analysis to the domain of graphs. Several limitations of the Spectral Network, such as its high computation complexity and the lack of locality, are addressed in Defferrard et al. (2016) (ChebyNet) and further refined by Kipf & Welling (2016) via approximation. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf22aeecc4d347dc2458fdb8e081d2166b76b099e88b07662d361b13b13d2718.jpg",
+        "image_caption": [
+            "Figure 1: Visualization of different convolution operations with three output channels. We use different colors to represent different filters (weight configurations of the links). (a) DSC defined on 2D grid graphs. (b) GC defined on generic graphs. (c) DSGC defined on generic graphs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            98,
+            727,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            303,
+            823,
+            332
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To Compare LP with GC, the former only utilizes the graphical information, while the latter has an additional linear transformation of $\\boldsymbol { \\mathscr { x } } _ { j }$ to into the intermediate representation $z _ { j }$ via matrix $U$ . This additional step makes GC capable of capturing the dependencies among features (channels), which yields performance improvement. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 DEPTHWISE SEPARABLE CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            411,
+            493,
+            425
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For a full 2d-convolution layer, the convolution filters encode channel correlation and spatial correlation simultaneously (Chollet, 2016). Then depthwise separable convolution (DSC) is proposed under the intuition that the channel correlation and spatial correlation could be decoupled, and has been found successful in several modern architectures for image classification (Chollet, 2016). We choose to focus on DSC (instead of full convolution) because of its strong empirical performance with a small number of parameters, and its intimate connections to GC which will be revealed in the following. And we discuss the full convolution formulation with the label propagation process in Section 5. ",
+        "bbox": [
+            173,
+            436,
+            825,
+            549
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "By viewing each pixel in the image as a node, DSC can be formulated in a graph-based fashion ",
+        "bbox": [
+            171,
+            554,
+            797,
+            570
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e2861fb8d54887c49b4ad3a21b155683a359d4be48a27790dd68fb13ac1ed1fe.jpg",
+        "text": "$$\ny _ { i q } = \\sum _ { j \\in \\mathcal { N } ( i ) } w _ { \\Delta _ { i j } } ^ { ( q ) } z _ { j q } \\quad w h e r e \\quad z _ { j } = U x _ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            594,
+            645,
+            631
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\Delta _ { i j }$ denotes the relative position of pixel $i$ and pixel $j$ on the image, and $w ^ { ( q ) }$ can be viewed as a lookup table with the pixel-pixel offset $\\Delta _ { i j }$ as the key, according to the stationarity (weightsharing) assumption of convolution. In the context of images, $\\mathcal { N } ( i )$ denotes the index set of surrounding pixels for $i$ -th pixel, which is equivalent to the $k$ -nearest neighbor set under the Euclidean distant metric. For example, the size of $\\bar { \\mathcal { N } } ( i )$ , or $k$ , is 9 for a $3 \\times 3$ convolution filter (considering self-loop). ",
+        "bbox": [
+            173,
+            647,
+            825,
+            732
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROPOSED METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            751,
+            377,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 DEPTHWISE SEPARABLE GRAPH CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            784,
+            549,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We notice that the formulation of GC and DSC is similar except that ",
+        "bbox": [
+            174,
+            809,
+            622,
+            824
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Spatial filters in DSC are channel-specific, while GC uses a global spatial filter. 2. Spatial filters in DSC are learned from the data (under the stationarity constraints), while the filter in GC is a constant matrix with the given input. ",
+        "bbox": [
+            202,
+            835,
+            825,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "On the one hand, DSC does not apply to the domain of generic spatial data lying on the manifold where the space of $\\Delta _ { i j }$ (defined as the difference of the spatial coordinates between node $i$ and node $j$ ) can be infinite. On the other hand, GC suffers from the restriction that all channels have to share the same given spatial filter. This heavily constrains the model capacity, which would be more severe when the deeper network structure is used. In the context of graphs, it would be desirable to have multiple spatial filters—to capture a diverse set of diffusion patterns over the graph or data manifold, which is the same as the convolution filters in the image domain. ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To address these limitations, we propose Depthwise Separable Graph Convolution (DSGC) which naturally generalizes both GC and DSC ",
+        "bbox": [
+            173,
+            180,
+            821,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5c206ffbd6704fd54c1bab747baefe9aedb2c576b402fdf3fdb7e6b9946dc721.jpg",
+        "text": "$$\ny _ { i q } = \\sum _ { j \\in \\mathcal { N } ( i ) } w ^ { ( q ) } ( \\Delta _ { i j } ) z _ { j q } \\quad w h e r e \\quad z _ { j } = U x _ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            213,
+            661,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where we slightly abuse the notation by overloading $w ^ { ( q ) } ( \\cdot )$ as a function, which maps $\\Delta _ { i j }$ to a real number, and $\\mathcal { N } ( i )$ still represents the $k$ -nearest neighbor sets. To understand the proposed formulation, notice ",
+        "bbox": [
+            176,
+            263,
+            825,
+            306
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Different from DSC, the stationarity requirement is implemented in a “soft” manner by defining a function instead of by the set of equality constraints. In our experiment, each $w ^ { ( q ) } ( \\cdot )$ is a function parameterized by a two-layer MLP.   \n2. Different from GC, channel-specific convolution is enabled by learning multiple spatial convolution filters. This amounts to simultaneously constructing multiple graphs under the different node-node similarity metrices, where the metrices are implicitly defined by neural networks and hence, are jointly optimized during the training. ",
+        "bbox": [
+            210,
+            316,
+            825,
+            421
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Overfitting is a common issue in graph-based applications, due to limited data available. To alleviate this issue, we propose an option to group the channels into $C$ groups, where $D = Q / C$ channels in the same group would share the same filter. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d5e136939d19fde57fe5a1f9851d289203278861bf38ae603ddbd8e56d4be46e.jpg",
+        "text": "$$\nw ^ { ( q ) } ( \\cdot ) = w ^ { ( q ^ { \\prime } ) } ( \\cdot ) \\quad i f \\quad \\lfloor \\frac { q } { D } \\rfloor = \\lfloor \\frac { q ^ { \\prime } } { D } \\rfloor\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            478,
+            627,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            525,
+            336,
+            539
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The context of each node in any given generic graph, namely its connection pattern with neighbors, can be non-stationary over different parts of the graph, while it is constant in the 2d-grid graphs. It is, therefore, a common practice to normalize the adjacency matrix in order to make the nodes adaptive to their own contexts (Eq.1). A natural way to carry out normalization for DSGC is to apply a softmax function over the predicted spatial filter weights at each node, which can be written as $\\tilde { \\pmb { w } } _ { i } = s o f t m a x ( \\pmb { w } _ { i } )$ , where ${ \\pmb w } _ { i }$ stands for the $i$ -th row of spatial filter $W$ learned by a neural network. We empirically find normalization leads to better performance and significantly speeds up the convergence. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the following experiments, we use the proposed depthwise separable graph convolution with a linear highway bypass as the basic convolution component and imitate the rest setting of the standard convolution neural network to solve different machine learning tasks. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            710
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            731,
+            326,
+            746
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENT SETTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            761,
+            372,
+            776
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the proposed Depthwise Separable Graph Convolution (DSGC) method with representative baselines in the prediction tasks of image classification, time series forecasting, and document categorization. The algorithms are implemented in PyTorch; all the data and the code are made publicly accessible 1. For controlled experiments, all the graph convolution methods share the same empirical settings unless otherwise specified, including network structures, the dimension of latent factors, and so on. The optimization algorithm is applied to all models. The neural network used to model the spatial convolution filter $( w ^ { ( q ) } ( \\cdot ) )$ in Eq.4 is a two-layers MLP with 256 hidden dimension and tanh activation function. We have conducted ablation tests with the two-layer MLP by changing the number of layers and activation function of each hidden layer, and by trying several weight sharing strategies. The results are very similar; the two-layer MLP provides a reasonable performance with the shortest running time. Appendix A contains more details, such as the network architecture and model hyper-parameters. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            901
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 EVALUATION ON IMAGE CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            176,
+            503,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on CIFAR10 and CIFAR100 (Krizhevsky & Hinton, 2009), which are popular benchmark datasets in image classification. Both sets contain 60000 images with $3 2 \\times 3 2$ pixels but CIFAR10 has 10 category labels and CIFAR100 has 100 category labels. Each image is typically treated as a $3 2 \\times 3 2$ grid structure for standard image-based convolution. To enable the comparison on generic graphs, we create the modified versions of CIFAR10 and CIFAR100, respectively, by subsampling only $2 5 \\%$ of the pixels from each graph. As illustrated in Figure 2, the subsampling results in irregularly scattered nodes for each image. ",
+        "bbox": [
+            173,
+            202,
+            825,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/93cb9c2b2bf9ca406d66b70368cba52d00aa0d0ce4f0e87bea8a6d779f71a461.jpg",
+        "image_caption": [
+            "Figure 2: How to construct subsampled CIFAR datasets: (a) is an example image from CIFAR dataset. (b) is the subsampled pixels map. The blue points indicate which points are sampled. (c) is the image after sampling, where the black points are those being sampled out. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            290,
+            315,
+            717,
+            444
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For comparison we include the traditional 2d convolution and graph convolution networks as baselines, including standard CNN; Xception network (Chollet, 2016) which uses the depthwise separable convolution; DCNN (Atwood & Towsley, 2016), the method using multi-hops random walk as the graph filters; ChebyNet (Defferrard et al., 2016), the method using Chebyshev polynomial to approximate the Fourier transformation of (irregular) graphs; GCN (Kipf & Welling, 2016) which is described in Section 2; MoNet (Monti et al., 2016), the method using Gaussian function to define the propagation weights over (irregular) graphs. For a fair comparison, we use the VGG13 architecture (Simonyan & Zisserman, 2014) in all the methods above as the basic platform, and replace the convolution layers according to the methods. The pooling layer is performed by the kmean clustering. The centroid of each clusters is regarded as the new node after pooling, and its hidden vector is the mean or max over the nodes in the cluster, based on the pooling method. Notice that, we only normalize the input signals to [0,1] and do not have other preprocessing or data augmentation. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The experiment results are summarized in Table 1. Firstly, we observe that Xception and CNN have the best results; this is not surprising because both methods use grid-based convolution which is naturally suitable for image recognition. Secondly, DSGC outperforms all the other graph-based convolution methods, and its performance is very close to that of the grid-based convolution methods. Furthermore, contributed by the depthwise separable convolution and sharing graph technique, our model can achieve the competitive performance without increasing the number of parameters as GCN, the one with the smallest number of parameters among the graph convolution approaches. In appendix A.4, we further report the variance of DSGC model, which shows the improvement is significant and stable. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            811
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 EVALUATION ON TIME SERIES FORECASTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            828,
+            531,
+            843
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As another important application domain, here we are interested in how to effectively utilize the locality information about sensor networks in time series forecasting. For example, how to incorporate the longitudes/latitudes of sensors w.r.t. temporal cloud movement is an important question in spatiotemporal modeling for predicting the output of solar energy farms in the United States. Appendix A provides the formal definition of this task. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/5ed43c680d913e5f723dbb0de89a07ce7ff5d66e249c54b4807494e4c0745f02.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Test-set error rates: P is the number of parameters "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>Subsampled Graphs</td><td rowspan=1 colspan=5>Original Graphs</td></tr><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>CIFAR100</td><td rowspan=1 colspan=1>P</td><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=3>CIFAR100</td><td rowspan=1 colspan=1>P</td></tr><tr><td rowspan=5 colspan=1>DCNN (Atwood &amp; Towsley, 2016)ChebyNet (Defferrard et al., 2016)GCN (Kipf &amp; Welling,2016)MoNet (Monti et al., 2016)DSGC</td><td rowspan=5 colspan=1>43.68%25.04%26.78%21.20%18.72%</td><td rowspan=5 colspan=1>76.65%49.44%51.30%47.87%44.33%</td><td rowspan=1 colspan=1>12M</td><td rowspan=1 colspan=1>55.56%</td><td rowspan=1 colspan=3>84.16%</td><td rowspan=1 colspan=1>50M</td></tr><tr><td rowspan=2 colspan=1>10M5.6M</td><td rowspan=2 colspan=1>12.99%19.09%</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=2>36.96%</td><td rowspan=1 colspan=1>19M</td></tr><tr><td rowspan=1 colspan=2>41.64 %</td><td rowspan=1 colspan=2>41.64 %</td><td rowspan=1 colspan=1>9.8M</td></tr><tr><td rowspan=1 colspan=1>11M</td><td rowspan=1 colspan=1>8.34%</td><td rowspan=1 colspan=3>29.56%</td><td rowspan=1 colspan=1>20M</td></tr><tr><td rowspan=1 colspan=1>5.7M</td><td rowspan=1 colspan=1>7.31%</td><td rowspan=1 colspan=3>27.29%</td><td rowspan=1 colspan=1>9.9M</td></tr><tr><td rowspan=2 colspan=1>CNN (Simonyan &amp; Zisserman, 2014)Xception (Chollet,2016)</td><td rowspan=2 colspan=1>18.03%17.07%</td><td rowspan=2 colspan=1>43.42%41.54%</td><td rowspan=1 colspan=1>18M</td><td rowspan=1 colspan=1>6.86%</td><td rowspan=1 colspan=3>26.86%</td><td rowspan=1 colspan=1>18M</td></tr><tr><td rowspan=1 colspan=1>3.1M</td><td rowspan=1 colspan=1>7.08%</td><td rowspan=1 colspan=3>26.84%</td><td rowspan=1 colspan=1>3.1M</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            821,
+            217
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We choose three publicly available benchmark datasets for this task: ",
+        "bbox": [
+            174,
+            268,
+            619,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• The U.S Historical Climatology Network $\\mathrm { ( U S H C N ) }$ dataset contains daily climatological data from 1,218 meteorology sensors over the years from 1915 to 2000. The sequence length is 32,507. It includes five subsets, and each has a climate variable: (1) maximum temperature, (2) minimum temperature, (3) precipitation, (4) snowfall and (5) snow depth. We use the daily maximum temperature data and precipitation data, and refer them as the USHCN-TMAX and USHCN-PRCP sets, respectively.   \n• The solar power production records in the year of $2 0 0 6 ^ { 3 }$ has the data with the production rate of every 10 minutes from 1,082 solar power stations in the west of the U.S. The sequence length is 52,560. We refer this set of data as Solar. ",
+        "bbox": [
+            215,
+            295,
+            825,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "All the datasets have been split into the training set $( 6 0 \\% )$ , the validation set $( 2 0 \\% )$ and the test set $( 2 0 \\% )$ in chronological order. ",
+        "bbox": [
+            174,
+            439,
+            821,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "All the graph convolution methods (DCNN, ChebyNet, GCN and MoNet) in the previous section (Section 4.2) are included to form the baselines for comparison. We also add traditional methods for time series forecasting, such as (1) Autoregressive model (AR) which predicts future signal using a window of historical data based on a linear assumption about temporal dependencies, (2) Vector autoregressive model (VAR) which extends AR to the multivariate version, namely, the input is the signals from all sensors in the history window, and (3) the LSTNet deep neural network model (Lai et al., 2017) which combines the strengths of CNN, RNN and AR. None of those methods is capable of leveraging locational dependencies via graph convolution. We exclude the CNN and Xception methods, the 2D-grid based convolution, which could not be generalized to irregular graphs which we focus here. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2 summarizes the evaluation results of all the methods, where the performance is measured using the Root Square Mean Error (RMSE). The best result on each dataset is highlighted in boldface. The first chunk of three methods does not leverage the spatial or locational information in data. The second chuck consists of the neural network models which leverage the spatial information about sensor networks. The graph convolution methods in the second chunk clearly outperforms the methods in the first chunk, which does not explicitly model the spacial correlation within sensor networks. Overall, our proposed method (DSGC) has the best performance on all the datasets, demonstrating its strength in capturing informative local propagation patterns temporally and specially. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            732
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 DOCUMENT CATEGORIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            426,
+            763
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the application to text categorization we use the 20NEWS dataset (Joachims (1996)) for our experiments. It consists of 18,845 text documents associated with 20 topic labels. Individual words in the document vocabulary are the nodes in the graph for convolution. Each node also has its word embedding vector which is learned by running the Word2Vec algorithm (Mikolov et al. (2013)) on this corpus. Following the experiment settings in Defferrard et al. (2016) we select the top 1000 most frequent words as the nodes. Table 3 summarizes the results of the graph convolution methods plus three popular traditional classifiers (Linear SVM, Multivariate Naive Bayes and Softmax). DSGC has the best result on this dataset. Notice that the traditional classifiers are trained and tested with ",
+        "bbox": [
+            173,
+            775,
+            825,
+            887
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/0ea1a392259d907cd8a1100274bdecfa9ffc022371bd51cb528ee2e1e50264f3.jpg",
+        "table_caption": [
+            "Table 2: Time series prediction: Experiment result in terms of RMSE. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>USHCN-TMAX</td><td>USHCN-PRCP</td><td>Solar</td></tr><tr><td>AR VAR</td><td>8.2354</td><td>30.3825</td><td>0.03195</td></tr><tr><td>LSTNet (Lai et al., 2017)</td><td>17.9743 10.1973</td><td>29.2597 29.0624</td><td>0.03296 0.02865</td></tr><tr><td>DCNN (Atwood &amp; Towsley, 2016)</td><td>6.5188</td><td>29.0424</td><td>0.02652</td></tr><tr><td>ChebyNet (Defferrard et al., 2016)</td><td>5.5823</td><td>27.1298</td><td>0.02531</td></tr><tr><td>GCN (Kipf &amp; Welling, 2016)</td><td>5.4671</td><td>27.1172</td><td>0.02512</td></tr><tr><td>MoNet (Monti et al., 2016)</td><td>5.8263</td><td>26.8076</td><td>0.02564</td></tr><tr><td>DSGC</td><td>5.1738</td><td>25.8228</td><td>0.02453</td></tr></table>",
+        "bbox": [
+            212,
+            101,
+            785,
+            231
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "the feature set of the top 1000 words, which is the same setting as in the graph convolution models.   \nIf all words are used, traditional classifiers would have higher performance. ",
+        "bbox": [
+            173,
+            289,
+            821,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4758f96058c32864df93f4422c944e3e9abc6d67d5ef0a54a68cf262dd3dd913.jpg",
+        "table_caption": [
+            "Table 3: Accuracy on the validation set. The results with † come from Defferrard et al. (2016). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>Linear SVM†Multinomial Naive Bayes†SoftmaxtFC2500tFC2500-FC500t</td><td rowspan=1 colspan=1>65.90%68.51%66.28%64.64%65.76%</td></tr><tr><td rowspan=1 colspan=1>DCNN (Atwood &amp; Towsley, 2016)ChebyNet (Defferrard et al., 2016)GCN (Kipf &amp; Welling, 2016)MoNet (Monti et al., 2016)DSGC</td><td rowspan=1 colspan=1>70.35%70.92%71.01%70.60%71.88%</td></tr></table>",
+        "bbox": [
+            331,
+            338,
+            665,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.5 DSGC VARIANTS WITH ADVANCED CONVOLUTION ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            694,
+            590
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The proposed convolution method (DSGC) can be considered as an equivalent component to the depthwise separable convolution method. Naturally, we can leverage the technique developed for the standard convolution network to improve the DSGC framework. Hence we examine DSGC with the following techniques which are popular in recent years for standard convolution over images: (1) Inception module (Szegedy et al., 2016), (2) DenseNet framework (Huang et al., 2016) and (3) Squeeze-and-Excitation block (Hu et al., 2017). The details of those architectures are included in the Appendix A. The results are presented in Table 4. Clearly, combined with the advantageous techniques/architectures, the performance of DSGC in image classificationcan can be further improved. It demonstrates that the DSGC can easily enjoy the benefit of the traditional 2d-convolution network development. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            743
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/dd84dba8d3dfb32d4bdc8de9b6ab38a7307451f3e4a9d274c3232f0f49c3bcb7.jpg",
+        "table_caption": [
+            "Table 4: Summary of error rate on the test set in different settings. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Subsampled Graphs</td><td colspan=\"3\">Original Graphs</td></tr><tr><td>Dataset</td><td>CIFAR10</td><td>CIFAR100</td><td>P</td><td>CIFAR10</td><td>CIFAR100</td><td>P</td></tr><tr><td>DSGC-VGG13</td><td>18.72%</td><td>44.33%</td><td>5.7M</td><td>7.31%</td><td>27.29%</td><td>9.9M</td></tr><tr><td>DSGC-INCEPTION</td><td>18.27%</td><td>43.41%</td><td>9.9M</td><td>6.44%</td><td>28.55%</td><td>12M</td></tr><tr><td>DSGC-DenseNet</td><td>17.17%</td><td>43.34%</td><td>2.7M</td><td>7.14%</td><td>26.50%</td><td>2.9M</td></tr><tr><td>DSGC-SE</td><td>18.71%</td><td>44.15%</td><td>6.1M</td><td>7.00%</td><td>27.26%</td><td>10M</td></tr><tr><td>CNN</td><td>18.03%</td><td>43.42%</td><td>18M</td><td>6.86%</td><td>26.86%</td><td>18M</td></tr><tr><td>Xception</td><td>17.07%</td><td>41.54%</td><td>3.1M</td><td>7.08%</td><td>26.84%</td><td>3.1M</td></tr></table>",
+        "bbox": [
+            191,
+            763,
+            805,
+            881
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.6 TRAINING TIME COMPARISON ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            426,
+            118
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In table 5, we report the mean training time per epoch for DSGC and GCN, the fastest graph convolution baseline. In DSGC, our model computes the convolution weight for each edge of the graph, which requires more computation resources. However, we always perform the graph convolution on the sparse graph, which the number of edges grows only linearly in the graph size. Therefore the training is fairly efficient. Notably, learning the convolution filters as in DSGC leads to consistently better performance over all previous methods, with around $0 . 5 \\mathrm { x } - 3 \\mathrm { x }$ running time. ",
+        "bbox": [
+            173,
+            128,
+            826,
+            214
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/81f83f2824e42c279ccfc528ac1222a49ab028512237f8c7e54408aabaf436bb.jpg",
+        "table_caption": [
+            "Table 5: Training time per epoch for GCN and DSGC methods. The unit is minute. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>CIFAR</td><td>USHCN-TMAX</td><td>20news</td></tr><tr><td>GCN</td><td>1.75</td><td>0.465</td><td>0.207</td></tr><tr><td>DSGC</td><td>3.81</td><td>1.73</td><td>0.280</td></tr></table>",
+        "bbox": [
+            330,
+            228,
+            666,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            329,
+            344,
+            345
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will summarize the graph convolution methods proposed in recent years with the label propagation process, which reveals the difference between traditional 2D-convolution and them. Firstly, we provide the formulation of the full convolution (LeCun et al., 1995), ",
+        "bbox": [
+            174,
+            362,
+            825,
+            405
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a7682268d5ae4b6b795011fdbf053122cfffc4c91ed81f188162e73913117778.jpg",
+        "text": "$$\ny _ { i q } = \\sum _ { p = 1 } ^ { P } \\sum _ { j \\in \\mathcal { N } ( i ) } w _ { \\Delta _ { i j } } ^ { ( p q ) } x _ { j p }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            421,
+            586,
+            469
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "different from the depthwise separable convolution, it captures the channel correlation and spatial correlation simultaneously by $W ^ { ( p q ) }$ , which leads to the larger number of parameters. ",
+        "bbox": [
+            173,
+            479,
+            825,
+            512
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Spectral Network (Bruna et al., 2013), the authors try to leverage the graph Fourier transformation as the basic convolution operation in the graph domain, which can be written as, ",
+        "bbox": [
+            173,
+            517,
+            825,
+            547
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6b425dc4ba98fc97d3393637a1db4628e17e473e216fda485dc0f5c31eac24a.jpg",
+        "text": "$$\ny _ { i q } = \\sum _ { p = 1 } ^ { P } \\sum _ { j \\in \\mathcal { N } ( i ) } w _ { i j } ^ { ( p q ) } x _ { j p } w h e r e W ^ { p q } = \\Phi \\Lambda ^ { p q } \\Phi ^ { T }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            564,
+            692,
+            611
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\Phi \\in \\mathbb { R } ^ { n \\times n }$ contains the eigenvectors of Laplacian matrix of the graph, and $\\Lambda$ is a diagonal matrix and learned by the supervision data. The Spectral Network can be matched with the full convolution, but with the different filter subspace, in other words, with different basic filters. However, it suffers from several limitations. (1) It needs to conduct eigenvector decomposition over the Laplacian Matrix, which is a very expensive operation. (2) The filters are not localized in the spatial domain. (3) The number of parameters grows linearly with the number of nodes in the graph. In order to address the previous problems, researchers try to use the Chebyshev polynomial to approximate the non-parameter filter $\\Lambda$ , which is referred to as ChebyNet (Defferrard et al., 2016). It can be written as, ",
+        "bbox": [
+            173,
+            622,
+            825,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a100f1735b88d8004243b62affdb9687da17acbc25660bb4d2b39d61b13a98f0.jpg",
+        "text": "$$\ny _ { i q } = \\sum _ { k = 1 } ^ { K } \\sum _ { j \\in \\mathcal { N } ( i ) } T _ { k } ( L ) _ { i j } z _ { i q } ^ { ( k ) } \\quad w h e r e \\quad z _ { i } ^ { ( k ) } = U ^ { ( k ) } \\pmb { x } _ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            767,
+            686,
+            814
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $T _ { k } ( L )$ is the $k$ -th order Chebyshev polynomial term. The ChebyNet can be considered as the integration of $K$ depthwise separable convolution components in a layer. But still, it suffers from the similar limitation as the GCN, which is using one graph filter over all channels and the graph filter is constant given the input. So its model capacity still cannot compare with depthwise separable convolution. With larger $K$ , the ChebyNet can approximate the non-parameter filers in the Spectral Network. However, it would require large number of parameters and face the similar limitation as the Spectral Network. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Besides the graph convolution methods, researchers propose another type of models, geometric convolution methods (Masci et al., 2015; Boscaini et al., 2016; Monti et al., 2016), to deal with data in the general spatial domain. Here, we introduce the most advanced one, MoNet (Monti et al., 2016) framework, which is also the most related one to our paper. The updating formula of MoNet in the label propagation process is, ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2bb3f300d6c0d707974d171ad5b123eb8f4749edcd5a4c75520d2164a79684ac.jpg",
+        "text": "$$\ny _ { i q } = \\sum _ { k = 1 } ^ { K } \\sum _ { j \\in \\mathcal { N } ( i ) } w _ { k } \\mathopen { } \\mathclose \\bgroup \\left( v ( i , j ) \\aftergroup \\egroup \\right) z _ { j q } ^ { ( k ) } \\quad w h e r e \\quad z _ { j } ^ { ( k ) } = { U ^ { k } } x _ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            189,
+            692,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where $w _ { k } ( v ) = e x p ( - { \\textstyle \\frac { 1 } { 2 } } ( v - \\mu _ { k } ) ^ { T } \\Sigma _ { k } ^ { - 1 } ( v - \\mu _ { k } ) )$ , and $v ( i , j )$ is a mapping from a node pair to a embedding vector, similar to $\\Delta _ { i j }$ in our model. $\\mu _ { k } , \\Sigma _ { k }$ are both model parameters, and $\\Sigma _ { k }$ is constrained as the diagonal matrix. MoNet can be viewed as an extension of the ChebyNet by letting the graph filters learn from the data. But it still has two limitations compared with the depthwise separable convolution and proposed method: (1) It uses a simple Gaussian function, which is weaker than non-parametric filter in the depthwise separable convolution, and neural network function in the proposed method. (2) It uses a graph filter for all channels. In order to capture complex propagation patterns in a layer, the model requires a larger $K$ , which leads to much larger number of parameters. And finally the experiment results show that the proposed method (DSGC) consistently outperforms the MoNet with less parameters in multiple tasks. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            388
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            409,
+            318,
+            424
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a novel Depthwise Separable Graph Convolution (DSGC) Network which is explicitly generalized from the depthwise separable convolution, and goes beyond to the general graph space. The extensive experiments on multi-field benchmark datasets demonstrate that our method can outperform strong baseline methods with a relatively small number of model parameters, and that it can be easily extended to leverage the advanced techniques/architectures in standard convolution networks for further improvement of the performance. In future work, we want to explore its impact on a broader range of applications, such as social networks and molecular structures by leveraging technical improvements about node/edge embedding based on graph structure information. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            565
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            587,
+            285,
+            602
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James Atwood and Don Towsley. Diffusion-convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 1993–2001, 2016. ",
+        "bbox": [
+            173,
+            611,
+            823,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Davide Boscaini, Jonathan Masci, Emanuele Rodola, and Michael Bronstein. Learning shape cor- \\` respondence with anisotropic convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 3189–3197, 2016. ",
+        "bbox": [
+            174,
+            648,
+            821,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017. ",
+        "bbox": [
+            174,
+            700,
+            821,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013. ",
+        "bbox": [
+            169,
+            752,
+            823,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. arXiv preprint arXiv:1610.02357, 2016. ",
+        "bbox": [
+            171,
+            791,
+            825,
+            820
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks ¨ on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pp. 3844–3852, 2016. ",
+        "bbox": [
+            174,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. arXiv preprint arXiv:1709.01507, 2017. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Kilian Q Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. arXiv preprint arXiv:1608.06993, 2016. ",
+        "bbox": [
+            174,
+            145,
+            823,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thorsten Joachims. A probabilistic analysis of the rocchio algorithm with tfidf for text categorization. Technical report, Carnegie-mellon univ pittsburgh pa dept of computer science, 1996. ",
+        "bbox": [
+            173,
+            185,
+            823,
+            215
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            227,
+            823,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016. ",
+        "bbox": [
+            171,
+            268,
+            823,
+            297
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            309,
+            821,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guokun Lai, Wei-Cheng Chang, Yiming Yang, and Hanxiao Liu. Modeling long-and short-term temporal patterns with deep neural networks. arXiv preprint arXiv:1703.07015, 2017. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            366
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, et al. Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, 3361(10):1995, 1995. ",
+        "bbox": [
+            173,
+            377,
+            823,
+            407
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015. ",
+        "bbox": [
+            174,
+            419,
+            823,
+            449
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yaguang Li, Rose Yu, Cyrus Shahabi, and Yan Liu. Graph convolutional recurrent neural network: Data-driven traffic forecasting. arXiv preprint arXiv:1707.01926, 2017. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Masci, Davide Boscaini, Michael Bronstein, and Pierre Vandergheynst. Geodesic convolutional neural networks on riemannian manifolds. In Proceedings of the IEEE international conference on computer vision workshops, pp. 37–45, 2015. ",
+        "bbox": [
+            174,
+            501,
+            823,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pp. 3111–3119, 2013. ",
+        "bbox": [
+            173,
+            556,
+            823,
+            601
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M \\` Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. arXiv preprint arXiv:1611.08402, 2016. ",
+        "bbox": [
+            173,
+            611,
+            825,
+            655
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David I Shuman, Sunil K Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. The emerging field of signal processing on graphs: Extending high-dimensional data analysis to networks and other irregular domains. IEEE Signal Processing Magazine, 30(3):83–98, 2013. ",
+        "bbox": [
+            173,
+            666,
+            823,
+            710
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            173,
+            722,
+            823,
+            751
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016. ",
+        "bbox": [
+            173,
+            762,
+            823,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "SHI Xingjian, Zhourong Chen, Hao Wang, Dit-Yan Yeung, Wai-Kin Wong, and Wang-chun Woo. Convolutional lstm network: A machine learning approach for precipitation nowcasting. In Advances in neural information processing systems, pp. 802–810, 2015. ",
+        "bbox": [
+            176,
+            818,
+            823,
+            862
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaojin Zhu, Zoubin Ghahramani, and John D Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. In Proceedings of the 20th International conference on Machine learning (ICML-03), pp. 912–919, 2003. ",
+        "bbox": [
+            173,
+            873,
+            826,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/fad98b433cd55ba72cbf91366465ce337ba4a9659eef5c89dd56393343501af2.jpg",
+        "table_caption": [
+            "Table 6: Neural Network architecture for CIFAR datasets. Please see the text for more details. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Layers</td><td rowspan=1 colspan=3>VGG13</td><td rowspan=1 colspan=3>DSGC-VGG13</td><td rowspan=1 colspan=3>DSGC-DenseNet</td></tr><tr><td rowspan=1 colspan=1>Convolution</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3 ×3conv]×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=2>9-conv×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>9-conv×6</td><td rowspan=1 colspan=1>×6</td></tr><tr><td rowspan=1 colspan=1>Transition</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3>1-conv</td></tr><tr><td rowspan=1 colspan=1>Pooling</td><td rowspan=1 colspan=3>2 × 2 max-pooling</td><td rowspan=1 colspan=6>4 max-pooling</td></tr><tr><td rowspan=1 colspan=1>Convolution</td><td rowspan=1 colspan=2>3×3 conv×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>9-convx2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=2>9-conv</td><td rowspan=1 colspan=1>×12</td></tr><tr><td rowspan=1 colspan=1>Transition</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3>1-conv</td></tr><tr><td rowspan=1 colspan=1>Pooling</td><td rowspan=1 colspan=3>2×2 max-pooling</td><td rowspan=1 colspan=6>4 max-pooling</td></tr><tr><td rowspan=1 colspan=1>Convolution</td><td rowspan=1 colspan=2>[3×3conv]×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>9-conv]x 2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>[9-conv]×24</td><td rowspan=1 colspan=1>×24</td></tr><tr><td rowspan=1 colspan=1>Transition</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3>1-conv</td></tr><tr><td rowspan=1 colspan=1>Pooling</td><td rowspan=1 colspan=3>2 × 2 max-pooling</td><td rowspan=1 colspan=6>4 max-pooling</td></tr><tr><td rowspan=1 colspan=1>Convolution</td><td rowspan=1 colspan=2>3×3conv×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=3>9-convx2</td><td rowspan=1 colspan=3>9-conv× 16</td></tr><tr><td rowspan=1 colspan=1>Transition</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=3>1-conv</td></tr><tr><td rowspan=1 colspan=1>Pooling</td><td rowspan=1 colspan=3>2×2 max-pooling</td><td rowspan=1 colspan=6>4 max-pooling</td></tr><tr><td rowspan=1 colspan=1>Convolution</td><td rowspan=1 colspan=2>3×3conv]×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>9-conv×2</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=3></td></tr><tr><td rowspan=1 colspan=1>Pooling</td><td rowspan=1 colspan=3>2 ×2 max-pooling</td><td rowspan=1 colspan=6>4 max-pooling</td></tr><tr><td rowspan=1 colspan=1>Classifier</td><td rowspan=1 colspan=9>512D fully-connected, softmax</td></tr></table>",
+        "bbox": [
+            248,
+            101,
+            750,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENT DETAIL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            416,
+            390,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 IMPLEMENTATION DETAILS OF CIFAR EXPERIMENT ",
+        "bbox": [
+            173,
+            469,
+            583,
+            484
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In section 4.2 and 4.5, we conduct the experiment on the CIFAR10 and CIFAR100 datasets. We will introduce the architecture settings for the DSGC and baseline models. Table 6 illustrates the basic architecture used in the experiment. In the DSGC-VGG13 and DSGC-DenseNet models, the $k$ -conv refers to the spatial convolution (Eq.4) with $k$ -nearest neighbors as the neighbor setting. So the 1-conv is the same as the $1 \\times 1$ conv, which is doing linear transformation on channels. The hidden dimensions of VGG13 and DSGC-VGG13 are set as $\\{ 2 5 6 , 5 1 2 , 5 1 2 , 5 1 2 \\}$ and $\\{ 2 5 6 , 5 1 2 , 5 1 2 , 1 0 2 4 \\}$ . The growth rate of DSGC-DenseNet is 32. And the baseline graph and geometric convolution methods use the identical architecture as DSGC-VGG13. For the subsampled CIFAR experiment, We eliminate the first convolution, transition and pooling layer, and change the spatial convolution from 9-conv to {16-conv, 12-conv, 8-conv, 4-conv}. For the DSGC-SE, we follow the method described in Hu et al. (2017) to add the SE block to DSGC-VGG13 architecture. We use the dropout scheme described in Huang et al. (2016) for the DSGC-DenseNet model, and add the dropout layer after the pooling layer for VGG13 and DSGC-VGG13 models. For the DSGCInception model, we imitate the design of the Inception Network (Szegedy et al. (2016)). The key idea is letting a convolution layer have different size of convolution filters. We use a simple example as our Inception module, which is illustrated in Figure 3. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            731
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For the CNN model, we still format the input signal in the matrix shape. The signals in invalid points are set as 0. Furthermore, to perform the fair comparison with standard CNN in the subsampled situation, we append a mask matrix as an additional channel for input signals to indicate whether the pixel is valid or not. For the MoNet, we also apply the softmax trick described in Section 3, which accelerates its training process and improves its final result. For the ChebyNet, we set the polynomial order as $K = 3$ . ",
+        "bbox": [
+            174,
+            739,
+            825,
+            821
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For the $\\triangle _ { i j }$ used in DSGC and MoNet, we use a 5 dimension feature vector. We denote the coordinate of $i$ -th node as $( x _ { i } , y _ { i } )$ , and $\\triangle x _ { i j } = x _ { i } - x _ { j } , \\triangle y _ { i j } = y _ { i } - y _ { j } , \\triangle d _ { i j } = \\triangle x _ { i j } ^ { 2 } + \\triangle y _ { i j } ^ { 2 }$ . Then $\\begin{array} { r } { \\triangle _ { i j } = ( s i g n ( \\triangle x _ { i j } ) , | \\triangle x _ { i j } | , s i g n ( \\triangle y _ { i j } ) , | \\triangle y _ { i j } | , \\triangle d _ { i j } ) } \\end{array}$ . ",
+        "bbox": [
+            174,
+            829,
+            825,
+            877
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The same learning schedule is applied to all models. We use SGD to train the model for 400 epochs. The initial learning rate is 0.1, and is divided by 10 at $50 \\%$ and $7 5 \\%$ of the total number of training epochs. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/ad95d6832217385a5192e14d10fb6a88c853c016619ac7ef58be35065053fb7c.jpg",
+        "image_caption": [
+            "Figure 3: Inception Module "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            429,
+            102,
+            568,
+            277
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 IMPLEMENTATION DETAILS OF TIME SERIES PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            329,
+            620,
+            343
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Firstly, we will give the formal definition of the time series forecasting, that is, spatiotemporal regression problem. We formulate the the spatiotemporal regression problem as a multivariate time series forecasting task with the sensors’ location as the input. More formally, given a series of time series signals observed from sensors $Y = \\{ y _ { 1 } , y _ { 2 } , \\cdot \\cdot \\cdot , y _ { T } \\}$ where $\\ b { y } _ { t } \\in \\mathbb { R } ^ { n }$ and $n$ are the number of sensors, and the locations of sensors $\\pmb { L } = \\{ l _ { 1 } , l _ { 2 } , \\cdots , l _ { n } \\}$ where $\\bar { \\boldsymbol { l } } _ { i } \\in \\mathbb { R } ^ { 2 }$ and indicates the coordinate of the sensor, the task is to predict a series of future signals in a rolling forecasting fashion. That being said, to predict ${ \\pmb { y } } _ { T + h }$ where $h$ is the desirable horizon ahead of the current time stamp $T$ , we assume $\\{ { \\pmb y } _ { 1 } , { \\pmb y } _ { 2 } , \\dotsb , { \\pmb y } _ { T } \\}$ are available. Likewise, to predict the signal of the next time stamp ${ \\pmb y } _ { T + h + 1 }$ , we assume $\\{ { \\pmb y } _ { 1 } , { \\pmb y } _ { 2 } , \\cdot \\cdot \\cdot , { \\pmb y } _ { T } , { \\pmb y } _ { T + 1 } \\}$ are available. In this paper, we follow the setting of the autoregressive model. Define a window size $p$ which is a hyper-parameter firstly. The model input at time stamp $T$ is $X _ { T } = \\{ y _ { T - p + 1 } , \\cdot \\cdot \\cdot , y _ { T } \\} \\in \\mathbb { R } ^ { n \\times p }$ . In the experiments of this paper, the horizon is always set as 1. ",
+        "bbox": [
+            173,
+            354,
+            825,
+            521
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, different sensors may have node-level hidden features to influence its propagation patterns and final outputs. Then for each node, the model learns a node embedding vector and concatenate it with the input signals. By using this trick, each node has limited freedom to interface with its propagation patterns. This trick is proven to be useful in this task, USHCN-PRCP and Solar specifically. We set the embedding size as 10 for these two datasets. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "One thing readers may notice is that there are $10 \\%$ data in USHCN dataset missing. To deal with that, we add an additional feature channel to indicate which point is missing. For the time series models, we tune the historical window $p$ according to the validation set. For the rest of models, we set the window size $p = 1 8$ for Solar dataset and $p = 6$ for USHCN datasets. The network architecture used in this task is 7 convolution layers followed by a regression layer. The $\\triangle _ { i j }$ setting is the same as the previous one. We use the Adam optimizer (Kingma & Ba, 2014) for this task, and train each model 200 epochs with learning rate 0.001. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            703
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 IMPLEMENTATION DETAILS OF DOCUMENT CATEGORIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            719,
+            647,
+            734
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The data preprocessing follows the experiment details in Defferrard et al. (2016). And the network architecture for all models is 5 convolution layers followed by two MLP layers as the classifier. After each convolution layer, a dropout layer is performed with dropout rate of 0.5. The nodes’ coordinate is the word embedding, and the method to calculate $\\triangle _ { i j }$ is similar to the previous ones. The optimizer used in this task is the same as the CIFAR experiment. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            815
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.4 VARIANCE OF DSGC PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            833,
+            475,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this section, we report the variance of DSGC method in all 3 tasks. We run the DSGC model for 10 times and report the mean $\\pm$ std: CIFAR $7 . 3 9 \\pm 0 . 1 3 6$ , USHCN-TMAX $5 . 2 1 1 \\pm 0 . 0 4 9 8$ , 20news $7 1 . 7 0 \\pm 0 . 2 8 5$ . Obviously, the variance is significantly smaller than the performance gap between the DSGC model and best baseline results (CIFAR 8.34, USHCN-TMAX 5.467, 20news 71.01). ",
+        "bbox": [
+            176,
+            859,
+            825,
+            915
+        ],
+        "page_idx": 11
+    }
+]

parse/train/HJGwcKclx/HJGwcKclx.md

@@ -0,0 +1,334 @@
+# SOFT WEIGHT-SHARING FOR NEURAL NETWORK COMPRESSION
+
+Karen Ullrich University of Amsterdam karen.ullrich@uva.nl
+
+Max Welling   
+University of Amsterdam   
+Canadian Institute for Advanced Research (CIFAR)   
+welling.max@gmail.com
+
+# ABSTRACT
+
+The success of deep learning in numerous application domains created the desire to run and train them on mobile devices. This however, conflicts with their computationally, memory and energy intense nature, leading to a growing interest in compression. Recent work by Han et al. (2015a) propose a pipeline that involves retraining, pruning and quantization of neural network weights, obtaining state-of-the-art compression rates. In this paper, we show that competitive compression rates can be achieved by using a version of ”soft weight-sharing” (Nowlan & Hinton, 1992). Our method achieves both quantization and pruning in one simple (re-)training procedure. This point of view also exposes the relation between compression and the minimum description length (MDL) principle.
+
+# 1 INTRODUCTION
+
+”Bigger is better” is the ruling maxim in deep learning land. Deep neural nets with billions of parameters are no longer an exception. Networks of such size are unfortunately not practical for mobile, on-device applications which face strong limitations with respect to memory and energy consumption. Compressing neural networks could not only improve memory and energy consumption, but also lead to less network bandwidth, faster processing and better privacy. It has been shown that large networks are heavily over-parametrized and can be compressed by approximately two orders of magnitude without significant loss of accuracy. Apparently, over-parametrization is beneficial for optimization, but not necessary for accurate prediction. This observation has opened the door for a number of highly successful compression algorithms, which either train the network from scratch (Hinton et al., 2015; Iandola et al., 2016; Courbariaux & Bengio, 2016; Courbariaux et al., 2016) or apply compression post-optimization (Han et al., 2015b;a; Guo et al., 2016; Chen et al., 2015; Wen et al., 2016).
+
+It has been long known that compression is directly related to (variational) Bayesian inference and the minimum description principle (Hinton & Van Camp, 1993). One can show that good compression can be achieved by encoding the parameters of a model using a good prior and specifying the parameters up to an uncertainty given, optimally, by the posterior distribution. An ingenious bitsback argument can then be used to get a refund for using these noisy weights. A number of papers have appeared that encode the weights of a neural network with limited precision (say 8 bits per weight), effectively cashing in on this ”bits-back” argument (Gupta et al., 2015; Courbariaux et al., 2014; Venkatesh et al., 2016). Some authors go so far of arguing that even a single bit per weight can be used without much loss of accuracy (Courbariaux et al., 2015; Courbariaux & Bengio, 2016).
+
+In this work we follow a different but related direction, namely to learn the prior that we use to encode the parameters. In Bayesian statistics this is known as empirical Bayes. To encourage compression of the weights to $K$ clusters, we fit a mixture of Gaussians prior model over the weights. This idea originates from the nineties, known as soft weight-sharing (Nowlan & Hinton, 1992) where it was used to regularize a neural network. Here our primary goal is network compression, but as was shown in Hinton & Van Camp (1993) these two objectives are almost perfectly aligned. By fitting the mixture components alongside the weights, the weights tend to concentrate very tightly around a number of cluster components, while the cluster centers optimize themselves to give the network high predictive accuracy. Compression is achieved because we only need to encode $K$ cluster means (in full precision) in addition to the assignment of each weight to one of these $J$ values (using $\log ( J )$ bits per weight). We find that competitive compression rates can be achieved by this simple idea.
+
+# 2 MDL VIEW ON VARIATIONAL LEARNING
+
+Model compression was first discussed in the context of information theory. The minimum description length (MDL) principle identifies the best hypothesis to be the one that best compresses the data. More specifically, it minimizes the cost to describe the model (complexity cost $\mathcal { L } ^ { C }$ ) and the misfit between model and data (error cost $\mathcal { L } ^ { E }$ ) (Rissanen, 1978; 1986). It has been shown that variational learning can be reinterpreted as an MDL problem (Wallace, 1990; Hinton & Van Camp, 1993; Honkela & Valpola, 2004; Graves, 2011). In particular, given data $\mathcal D = \left\{ \mathbf X = \{ \mathbf x _ { n } \} _ { n = 1 } ^ { N } , \mathbf T = \{ \mathbf t _ { n } \} _ { n = 1 } ^ { N } \right\}$ , a set of parameters $\mathbf { w } = \{ w _ { i } \} _ { i = 1 } ^ { I }$ that describes the model and an approximation $q ( \mathbf { w } )$ of the posterior $p ( \mathbf { w } | \mathcal { D } )$ , the variational lower bound, also known as negative variational free energy, $\mathcal { L } ( q ( \mathbf { w } ) , \mathbf { w } )$ can be decomposed in terms of error and complexity losses
+
+$$
+{ \mathcal { L } } ( q ( \mathbf { w } ) , \mathbf { w } ) = - \mathbb { E } _ { q ( \mathbf { w } ) } \left[ \log \left( { \frac { p ( { \mathcal { D } } | \mathbf { w } ) p ( \mathbf { w } ) } { q ( \mathbf { w } ) } } \right) \right] = \underbrace { \mathbb { E } _ { q ( \mathbf { w } ) } \left[ - \log p ( { \mathcal { D } } | \mathbf { w } ) \right] } _ { { \mathcal { L } } ^ { E } } + \underbrace { \mathrm { K L } ( q ( \mathbf { w } ) | | p ( \mathbf { w } ) ) } _ { { \mathcal { L } } ^ { C } }
+$$
+
+where $p ( \mathbf { w } )$ is the prior over $\mathbf { w }$ and $p ( \mathcal { D } | \mathbf { w } )$ is the model likelihood. According to Shannon’s source coding theorem, $\mathring { \mathcal { L } } ^ { E }$ lower bounds the expected amount of information needed to communicate the targets $\mathbf { T }$ , given the receiver knows the inputs $\mathbf { X }$ and the model w. The functional form of the likelihood term is conditioned by the target distribution. For example, in case of regression the predictions of the model are assumed be normally distributed around the targets $\mathbf { T }$ .
+
+$$
+p ( \mathcal { D } | \mathbf { w } ) = p ( \mathbf { T } | \mathbf { X } , \mathbf { w } ) = \prod _ { n = 1 } ^ { N } \mathcal { N } ( \mathbf { t } _ { n } | \mathbf { x } _ { n } , \mathbf { w } )
+$$
+
+where $\mathcal { N } ( \mathbf { t } _ { n } , \mathbf { x } _ { n } , \mathbf { w } )$ is a normal distribution. Another typical example is classification where the conditional distribution of targets given data is assumed to be Bernoulli distributed1. These assumptions eventually lead to the well known error functions, namely cross-entropy error and squared error for classification and regression, respectively.
+
+Before however we can communicate the data we first seek to communicate the model. Similarly to $\mathcal { L } ^ { E } , \mathcal { L } ^ { C }$ is a lower bound for transmitting the model. More specifically, if sender and receiver agree on a prior, $\mathcal { L } ^ { C }$ is the expected cost of communicating the parameters w. This cost is again twofold,
+
+$$
+\mathrm { K L } ( q ( \mathbf { w } ) | | p ( \mathbf { w } ) ) = \mathbb { E } _ { q ( \mathbf { w } ) } \left[ - \log p ( \mathbf { w } ) \right] - H ( q ( \mathbf { w } ) )
+$$
+
+where $H ( \cdot )$ denotes the entropy. In Wallace (1990) and Hinton & Van Camp (1993) it was shown that noisy encoding of the weights can be beneficial due to the bits-back argument if the uncertainty does not harm the error loss too much. The number of bits to get refunded by an uncertain weight distribution $q ( \mathbf { w } )$ is given by its entropy. Further, it can be shown that the optimal distribution for $q ( \mathbf { w } )$ is the Bayesian posterior distribution. While bits-back is proven to be an optimal coding scheme (Honkela $\&$ Valpola, 2004), it is often not practical in real world settings. A practical way to cash in on noisy weights (or bits-back) is to only encode a weight value up to a limited number of bits. To see this, assume a factorized variational posteriors $q ( \mathbf { w } ) { \bar { \mathbf { \Gamma } } } = \prod q ( w _ { i } )$ . Each posterior $q ( w _ { i } )$ is associated with a Dirac distribution up to machine precision, for example, a Gaussian distribution with variance $\sigma$ , for small values of $\sigma$ . This implies that we formally incur a very small refund per weight,
+
+$$
+H ( q ( \mathbf { w } ) ) = - \intop _ { \Omega } q ( \mathbf { w } ) \log q ( \mathbf { w } ) \mathrm { d } \mathbf { w } = - \intop _ { \mathbb { R } ^ { I } } \mathcal { N } ( \mathbf { w } | \mathbf { 0 } , \sigma \mathbf { I } ) \log \mathcal { N } ( \mathbf { w } | \mathbf { 0 } , \sigma \mathbf { I } ) = [ \log ( 2 \pi e \sigma ^ { 2 } ) ] ^ { I } .
+$$
+
+Note that the more coarse the quantization of weights the more compressible the model. The bitsback scheme makes three assumptions: (i) weights are being transmitted independently, (ii) weights are independent of each other (no mutual information), and (iii) the receiver knows the prior. Han et al. (2015a) show that one can successfully exploit (i) and (ii) by using a form of arithmetic coding (Witten et al., 1987). In particular, they employ range coding schemes such as the Sparse Matrix Format (discussed in Appendix A). This is beneficial because the weight distribution has low entropy. Note that the cost of transmitting the prior should be negligible. Thus a factorized prior with different parameters for each factor is not desirable.
+
+The main objective of this work is to find a suitable prior for optimizing the cross-entropy between a delta posterior $q ( \mathbf { w } )$ and the prior $p ( \mathbf { w } )$ while at the same time keeping a practical coding scheme in mind. Recall that the cross entropy is a lower bound on the average number of bits required to encode the weights of the neural network (given infinite precision). Following Nowlan & Hinton (1992) we will model the prior $p ( \mathbf { w } )$ as a mixture of Gaussians,
+
+$$
+p ( \mathbf { w } ) = \prod _ { i = 1 } ^ { I } \sum _ { j = 0 } ^ { J } \pi _ { j } \mathcal { N } ( w _ { i } | \mu _ { j } , \sigma _ { j } ^ { 2 } ) .
+$$
+
+We learn the mixture parameters $\mu _ { j } , \sigma _ { j } ,$ $\pi _ { j }$ via maximum likelihood simultaneously with the network weights. This is equivalent to an empirical Bayes approach in Bayesian statistics. For stateof-the-art compression schemes pruning plays a major role. By enforcing an arbitrary “zero” component to have fixed $\mu _ { 0 } = 0$ location and $\pi _ { 0 }$ to be close to 1, a desired weight pruning rate can be enforced. In this scenario $\pi _ { 0 }$ may be fixed or trainable. In the latter case a Beta distribution as hyperprior might be helpful. The approach naturally encourages quantization because in order to optimize the cross-entropy the weights will cluster tightly around the cluster means, while the cluster means themselves move to some optimal location driven by $\mathcal { L } ^ { E }$ . The effect might even be so strong that it is beneficial to have a Gamma hyper-prior on the variances of the mixture components to prevent the components from collapsing. Furthermore, note that, mixture components merge when there is not enough pressure from the error loss to keep them separated because weights are attracted by means and means are attracted by weights hence means also attract each other. In that way the network learns how many quantization intervals are necessary. We demonstrate that behaviour in Figure 3.
+
+# 3 RELATED WORK
+
+There has been a recent surge in interest in compression in the deep neural network community. Denil et al. (2013) showed that by predicting parameters of neural networks there is great redundancy in the amount of parameters being used. This suggests that pruning, originally introduced to reduce structure in neural networks and hence improve generalization, can be applied to the problem of compression and speed-up (LeCun et al., 1989). In fact, (Han et al., 2015b; Guo et al., 2016) show that neural network survive severe weight pruning (up to $9 9 \%$ ) without significant loss of accuracy. A variational version is is proposed by Molchanov et al. (2017), the authors learn the dropout rate for each weight in the network separately. Some parameters will effectively be pruned when the dropout rate is very high. In an approach slightly orthogonal to weight pruning, (Wen et al., 2016) applied structural regularization to prune entire sets of weights from the neural network. Such extreme weight pruning can lead to entire structures being obsolete, which for the case of convolutional filters, can greatly speed up prediction. Most importantly for compression, however, is that in conjunction with Compressed Sparse Column (CSC) format, weight pruning is a highly effective way to store and transfer weights. In Appendix A we discuss CSC format in more detail.
+
+Reducing the bit size per stored weight is another approach to model compression. For example, reducing 32 bit floats to 1 bit leads to a $3 2 \times$ storage improvement. Gong et al. (2014) proposed and experimented with a number of quantization approaches: binary quantization, $\mathbf { k }$ -means quantization, product quantization and residual quantization. Other work finds optimal fixed points (Lin et al., 2015), applies hashing (Chen et al., 2015) or minimizes the estimation error (Wu et al., 2015). Merolla et al. (2016) demonstrates that neural networks are robust against certain amounts of low precision; indeed several groups have exploited this and showed that decreasing the weight encoding precision has little to no effect on the accuracy loss (Gupta et al., 2015; Courbariaux et al., 2014; Venkatesh et al., 2016). Pushing the idea of extreme quantization, (Courbariaux et al., 2015) and Courbariaux & Bengio (2016) trained networks from scratch that use only 1bit weights with floating point gradients; to achieve competitive results, however, they require many more of these weights.
+
+Han et al. (2015a) elaborate on combining these ideas. They introduce an multi-step algorithm that compresses CNNS up to $4 9 \times$ . First, weights are pruned (giving $9 - 1 3 \times$ compression); second they quantize the weights (increasing compression to $2 7 - 3 1 \times )$ ; and last, they apply Huffman Encoding (giving a final compression of $3 5 - 4 9 \times )$ . The quantization step is trainable in that after each weight is assigned to a cluster centroid, the centroids get trained with respect to the original loss function. Note that this approach has several restrictions: the number of weights set to zero is fixed after the pruning step, as is the assignment of a weight to a given cluster in the second step. Our approach overcomes all these restrictions.
+
+A final approach to compressing information is to apply low rank matrix decomposition. First introduced by (Denton et al., 2014) and Jaderberg et al. (2014), and elaborated on by using low rank filters (Ioannou et al., 2015), low rank regularization (Tai et al., 2015) or combining low rank decomposition with sparsity (Liu et al., 2015).
+
+# 4 METHOD
+
+This section presents the procedure of network compression as applied in the experiment section. A summary can be found in Algorithm 1.
+
+# 4.1 GENERAL SET-UP
+
+We retrain pre-trained neural networks with soft weight-sharing and factorized Dirac posteriors. Hence we optimize
+
+$$
+\begin{array} { r l } & { \mathcal { L } ( \mathbf { w } , \{ \mu _ { j } , \sigma _ { j } , \pi _ { j } \} _ { j = 0 } ^ { J } ) = \mathcal { L } ^ { E } + \tau \mathcal { L } ^ { C } } \\ & { \qquad = - \log p ( \mathbf { T } | \mathbf { X } , \mathbf { w } ) - \tau \log p ( \mathbf { w } , \{ \mu _ { j } , \sigma _ { j } , \pi _ { j } \} _ { j = 0 } ^ { J } ) , } \end{array}
+$$
+
+via gradient descent, specifically using Adam (Kingma & Ba, 2014). The KL divergence reduces to the prior because the entropy term does not depend on any trainable parameters. Note that, similar to (Nowlan & Hinton, 1992) we weigh the log-prior contribution to the gradient by a factor of $\tau = 0 . 0 0 5$ . In the process of retraining the weights, the variances, means, and mixing proportions of all but one component are learned. For one component, we fix $\mu _ { j = 0 } = 0$ and $\pi _ { j = 0 } = 0 . 9 9 9$ . Alternatively we can train $\pi _ { j = 0 }$ as well but restrict it by a Beta distribution hyper-prior. Our Gaussian MM prior is initialized with $2 ^ { 4 } + 1 = 1 7$ components. We initialize the learning rate for the weights and means, log-variances and log-mixing proportions separately. The weights should be trained with approximately the same learning rate used for pre-training. The remaining learning rates are set to $5 \cdot 1 0 ^ { - 4 }$ . Note that this is a very sensitive parameter. The Gaussian mixtures will collapse very fast as long as the error loss does not object. However if it collapses too fast weights might be left behind, thus it is important to set the learning rate such that the mixture does collapse too soon. If the learning rate is too small the mixture will converge too slowly. Another option to keep the mixture components from collapsing is to apply an Inverse-Gamma hyperprior on the mixture variances.
+
+# 4.2 INITIALIZATION OF MIXTURE MODEL COMPONENTS
+
+In principle, we follow the method proposed by Nowlan & Hinton (1992). We distribute the means of the 16 non-fixed components evenly over the range of the pre-trained weights. The variances will be initialized such that each Gaussian has significant probability mass in its region. A good orientation for setting a good initial variance is weight decay rate the original network has been trained on. The trainable mixing proportions are initialized evenly $\pi _ { j } = ( 1 - \pi _ { j = 0 } ) / J$ . We also experimented with other approaches such as distributing the means such that each component assumes an equal amount of probability. We did not observe any significant improvement over the simpler initialization procedure.
+
+# 4.3 POST-PROCESSING
+
+After re-training we set each weight to the mean of the component that takes most responsibility for it i.e. we quantize the weights. Before quantizing, however, there might be redundant components
+
+as explained in section 2. To eliminate those we follow Adhikari & Hollmen (2012) by computing ´ the KL divergence between all components. For a KL divergence smaller than a threshold, we merge two components as follows
+
+$$
+\pi _ { \mathrm { n e w } } = \pi _ { i } + \pi _ { j } , \mu _ { \mathrm { n e w } } = \frac { \pi _ { i } \mu _ { i } + \pi _ { j } \mu _ { j } } { \pi _ { i } + \pi _ { j } } , \sigma _ { \mathrm { n e w } } ^ { 2 } = \frac { \pi _ { i } \sigma _ { i } ^ { 2 } + \pi _ { j } \sigma _ { j } ^ { 2 } } { \pi _ { i } + \pi _ { j } }
+$$
+
+for two components with indices $i$ and $j$ .
+
+Finally, for practical compression we use the storage format used in Han et al. (2015a) (see Appendix A).
+
+Algorithm 1 Soft weight-sharing for compression, our proposed algorithm for neural network model compression. It is divided into two main steps: network re-training and post-processing.
+
+Require: $\tau  \mathrm { s e t }$ the trade-off between error and complexity loss   
+Require: $\Theta $ set parameters for gradient decent scheme such as learning rate or momentum   
+Require: $\alpha , \beta \gets { \sf s e t }$ gamma hyper-prior parameter (optional) $\mathbf { w } \gets$ initialize network weights with pre-trained network weights $\theta = \{ \mu _ { j } , \sigma _ { j } , \pi _ { j } \} _ { j = 1 } ^ { J } $ initialize mixture parameters (see Sec. 4.2) while $\mathbf { w } , \theta$ not converged do $\mathbf { w } , \theta \gets \nabla _ { \mathbf { w } , \theta } \mathcal { L } ^ { E } + \overline { { \tau } } \mathcal { L } ^ { C }$ update $\mathbf { w }$ and $\theta$ with the gradient decent scheme of choice end while $\mathbf { w } \gets \mathop { \mathrm { a r g m a x } } _ { \mu _ { k } } \frac { \pi _ { k } \mathcal { N } ( \mathbf { w } | \mu _ { k } , \sigma _ { k } ) } { \sum \pi _ { j } \mathcal { N } ( \mathbf { w } | \mu _ { j } , \sigma _ { j } ) }$ compute final weight by setting it to the mean that takes most responsibility (for details see Sec. 4.3)
+
+# 5 MODELS
+
+We test our compression procedure on two neural network models used in previous work we compare against in our experiments:
+
+(a) LeNet-300-100 an MNIST model described in LeCun et al. (1998). As no pre-trained model is available, we train our own, resulting in an error rate of $1 . 8 9 \%$ .   
+(b) LeNet-5-Caffe a modified version of the LeNet-5 MNIST model in LeCun et al. (1998). The model specification can be downloaded from the Caffe MNIST tutorial page 2. As no pre-trained model is available, we train our own, resulting in an error rate of $0 . 8 8 \%$ .   
+(c) ResNets have been invented by He et al. (2015) and further developed by He et al. (2016) and Zagoruyko & Komodakis (2016). We choose a model version of the latter authors. In accordance with their notation, we choose a network with depth 16, width $k = 4$ and no dropout. This model has $2 . 7 \mathbf { M }$ parameters. In our experiments, we follow the authors by using only light augmentation, i.e., horizontal flips and random shifts by up to 4 pixels. Furthermore the data is normalized. The authors report error rates of $5 . 0 2 \%$ and $2 4 . 0 3 \%$ for CIFAR-10 and CIFAR-100 respectively. By reimplementing their model we trained models that achieve errors $6 . 4 8 \%$ and $2 8 . 2 3 \%$ .
+
+# 6 EXPERIMENTS
+
+# 6.1 INITIAL EXPERIMENT
+
+First, we run our algorithm without any hyper-priors, an experiment on LeNet-300-100. In Figure 1 we visualise the original distribution over weights, the final distribution over weight and how each weight changed its position in the training process. After retraining, the distribution is sharply peaked around zero. Note that with our procedure the optimization process automatically determines how many weights per layer are pruned. Specifically in this experiment, $96 \%$ of the first layer (235K parameter), $90 \%$ of the second (30K) and only $18 \%$ of the final layer (10K) are pruned. From observations of this and other experiments, we conclude that the amount of pruned weights depends mainly on the number of parameters in the layer rather than its position or type (convolutional or fully connected).
+
+Evaluating the model reveals a compression rate of 64.2. The accuracy of the model does not drop significantly from 0.9811 to 0.9806. However, we do observe that the mixture components eventually collapse, i.e., the variances go to zero. This makes the prior inflexible and the optimization can easily get stuck because the prior is accumulating probability mass around the mixture means. For a weight, escaping from those high probability plateaus is impossible. This motivates the use hyper-priors such as an Inverse-Gamma prior on the variances to essentially lower bound them.
+
+![](images/366fcfb9d4f32f72391a0724ed8b6315b098dcac6186c9ceaf7a26d458a50213.jpg)  
+Figure 1: On top we show the distribution of a pretrained network. On the right the same distribution after retraining. The change in value of each weight is illustrated by a scatter plot.
+
+6.2 HYPER-PARAMETER TUNING USING BAYESIAN OPTIMIZATION
+
+The proposed procedure offers various freedoms: there are many hyper-parameters to optimize, one may use hyper-priors as motivated in the previous section or even go as far as using other distributions as mixture components.
+
+To cope with the variety of choices, we optimize 13 hyper-parameters using the Bayesian optimization tool Spearmint Snoek et al. (2012). These include the learning rates of the weight and mixing components, the number of components, and $\tau$ . Furthermore, we assume an Inverse-Gamma prior over the variances separately for the zero component and the other components and a Beta prior over the zero mixing components.
+
+In these experiments, we optimize re-training hyperparameters for LeNet-300-100 and LeNet-5- Caffe. Due to computational restrictions, we set the number of training epochs to 40 (previously 100), knowing that this may lead to solutions that have not fully converged. Spearmint acts on an objective that balances accuracy loss vs compression rate. The accuracy loss in this case is measured over the training data. The results are shown in Figure 2. In the illustration we use the accuracy loss as given by the test data. The best results predicted by our spearmint objective are colored in dark blue. Note that we achieve competitive results in this experiment despite the restricted optimization time of 40 epochs, i.e. 18K updates.
+
+![](images/62da5f3a931a29608a1c8683b52053a43dbe573da65df1fe113163626c3d12b3.jpg)  
+Figure 2: We show the results of optimizing hyper-parameters with spearmint. Specifically, we plot the accuracy loss of a re-trained network against the compression rate. Each point represents one hyper-parameter setting. The guesses of the optimizer improve over time. We also present the results of other methods for comparison. Left: LeNet-300-100 Right: LeNet-5-Caffe.
+
+![](images/b0bf8e6826b727729b43ba5975e9440a88a49d3cdb787f100f770c3392a0e2f2.jpg)  
+Figure 3: Illustration of our mixture model compression procedure on LeNet-5-Caffe. Left: Dynamics of Gaussian mixture components during the learning procedure. Initially there are $1 7 \mathrm { \ c o m { - } }$ ponents, including the zero component. During learning components are absorbed into other components, resulting in roughly 6 significant components. Right: A scatter plot of initial versus final weights, along with the Gaussian components’ uncertainties. The initial weight distribution is roughly one broad Gaussian, whereas the final weight distribution matches closely the final, learned prior which has become very peaked, resulting in good quantization properties.
+
+The conclusions from this experiment are a bit unclear, on the one hand we do achieve state-ofthe-art results for LeNet-5-Caffe, on the other hand there seems to be little connection between the parameter settings of best results. One wonders if a 13 dimensional parameter space can be searched efficiently with the amount of runs we were conducting. It may be more reasonable to get more inside in the optimization process and tune parameters according to those.
+
+# 6.3 COMPRESSION RESULTS
+
+We compare our compression scheme with Han et al. (2015a) and Guo et al. (2016) in Table 1. The results on MNIST networks are very promising. We achieve state-of-the-art compression rates in both examples. We can furthermore show results for a light version of ResNet with 2.7M parameters to illustrate that our method does scale to modern architectures. We used more components (64)
+
+Table 1: Compression Results. We compare methods based on the post-processing error (we also indicate the starting error), the accuracy loss $\Delta$ , the number of non zero weights $| \mathbf { W } _ { \neq 0 } |$ and the final compression rate CR based on the method proposed by Han et al. (2015a).   
+
+<table><tr><td>Model</td><td>Method</td><td>Top-1 Error[%]</td><td>△[%]</td><td>[W|[106]</td><td>W0 [%] W</td><td>CR</td></tr><tr><td rowspan="3">LeNet-300-100</td><td>Han et al. (2015a)</td><td>1.64 → 1.58</td><td>0.06</td><td>0.2</td><td>8.0</td><td>40</td></tr><tr><td>Guo et al. (2016)</td><td>2.28→ 1.99</td><td>-0.29</td><td></td><td>1.8</td><td>56</td></tr><tr><td>Ours</td><td>1.89 →1.94</td><td>-0.05</td><td></td><td>4.3</td><td>64</td></tr><tr><td rowspan="3">LeNet-5-Caffe</td><td>Han et al. (2015a)</td><td>0.80 →0.74</td><td>-0.06</td><td>0.4</td><td>8.0</td><td>39</td></tr><tr><td>Guo et al. (2016)</td><td>0.91 →0.91</td><td>0.00</td><td></td><td>0.9</td><td>108</td></tr><tr><td>Ours</td><td>0.88 →0.97</td><td>0.09</td><td></td><td>0.5</td><td>162</td></tr><tr><td>ResNet (light)</td><td>Ours</td><td>6.48 →8.50</td><td>2.02</td><td>2.7</td><td>6.6</td><td>45</td></tr></table>
+
+here to cover the large regime of weights. However, for large networks such as VGG with 138M parameters the algorithm is too slow to get usable results. We propose a solution for this problem in Appendix C; however, we do not have any experimental results yet.
+
+# 7 DISCUSSION AND FUTURE WORK
+
+In this work we revived a simple and principled regularization method based on soft weight-sharing and applied it directly to the problem of model compression. On the one hand we showed that we can optimize the MDL complexity lower bound, while on the other hand we showed that our method works well in practice when being applied to different models. A short-coming of the method at the moment is its computational cost and the ease of implementation. For the first, we provide a proposal that will be tested in future work. The latter is an open question at the moment. Note that our method—since it is optimizing the lower bound directly—will most likely also work when applied to other storage formats, such as those proposed originally by Hinton & Van Camp (1993). In the future we would like to extend beyond Dirac posteriors as done in Graves (2011) by extending the weight sharing prior to more general priors. For example, from a compression point of view, we could learn to prune entire structures from the network by placing Bernoulli priors over structures such as convolutional filters or ResNet units. Furthermore, it could be interesting to train models from scratch or in a student-teacher setting.
+
+# ACKNOWLEDGEMENTS
+
+We would like to thank Louis Smit, Christos Louizos, Thomas Kipf, Rianne van den Berg and Peter O’Connor for helpful discussions on the paper and the public code3.
+
+This research has been supported by Google.
+
+# REFERENCES
+
+Prem Raj Adhikari and Jaakko Hollmen. Multiresolution mixture modeling using merging of mix- ´ ture components. 2012.
+
+Christopher M Bishop. Pattern recognition. Machine Learning, 2006.
+
+Wenlin Chen, James T Wilson, Stephen Tyree, Kilian Q Weinberger, and Yixin Chen. Compressing convolutional neural networks. arXiv preprint arXiv:1506.04449, 2015.
+
+Matthieu Courbariaux and Yoshua Bengio. Binarynet: Training deep neural networks with weights and activations constrained to $+ 1$ or $- 1$ . arXiv preprint arXiv:1602.02830, 2016.
+
+Matthieu Courbariaux, Jean-Pierre David, and Yoshua Bengio. Training deep neural networks with low precision multiplications. arXiv preprint arXiv:1412.7024, 2014.
+
+Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In Advances in Neural Information Processing Systems, pp. 3123–3131, 2015.
+
+Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training neural networks with weights and activations constrained to $+ 1$ or $- 1$ 2016.
+
+Misha Denil, Babak Shakibi, Laurent Dinh, Nando de Freitas, et al. Predicting parameters in deep learning. In Advances in Neural Information Processing Systems, pp. 2148–2156, 2013.
+
+Emily L Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. In Advances in Neural Information Processing Systems, pp. 1269–1277, 2014.
+
+Yunchao Gong, Liu Liu, Ming Yang, and Lubomir Bourdev. Compressing deep convolutional networks using vector quantization. arXiv preprint arXiv:1412.6115, 2014.
+
+Alex Graves. Practical variational inference for neural networks. In Advances in Neural Information Processing Systems, pp. 2348–2356, 2011.
+
+Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. In Advances In Neural Information Processing Systems, pp. 1379–1387, 2016.
+
+Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. CoRR, abs/1502.02551, 392, 2015.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. CoRR, abs/1510.00149, 2, 2015a.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural networks. In Advances in Neural Information Processing Systems, pp. 1135– 1143, 2015b.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. arXiv preprint arXiv:1603.05027, 2016.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Geoffrey E Hinton and Drew Van Camp. Keeping the neural networks simple by minimizing the description length of the weights. In Proceedings of the sixth annual conference on Computational learning theory, pp. 5–13. ACM, 1993.
+
+Antti Honkela and Harri Valpola. Variational learning and bits-back coding: an informationtheoretic view to bayesian learning. IEEE Transactions on Neural Networks, 15(4):800–810, 2004.
+
+Forrest N Iandola, Matthew W Moskewicz, Khalid Ashraf, Song Han, William J Dally, and Kurt Keutzer. Squeezenet: Alexnet-level accuracy with 50x fewer parameters and¡ 1mb model size. arXiv preprint arXiv:1602.07360, 2016.
+
+Yani Ioannou, Duncan Robertson, Jamie Shotton, Roberto Cipolla, and Antonio Criminisi. Training cnns with low-rank filters for efficient image classification. arXiv preprint arXiv:1511.06744, 2015.
+
+Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. arXiv preprint arXiv:1405.3866, 2014.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Yann LeCun, John S Denker, Sara A Solla, Richard E Howard, and Lawrence D Jackel. Optimal brain damage. In NIPs, volume 2, pp. 598–605, 1989.   
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   
+Darryl D Lin, Sachin S Talathi, and V Sreekanth Annapureddy. Fixed point quantization of deep convolutional networks. arXiv preprint arXiv:1511.06393, 2015.   
+Baoyuan Liu, Min Wang, Hassan Foroosh, Marshall Tappen, and Marianna Pensky. Sparse convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 806–814, 2015.   
+Paul Merolla, Rathinakumar Appuswamy, John Arthur, Steve K Esser, and Dharmendra Modha. Deep neural networks are robust to weight binarization and other non-linear distortions. arXiv preprint arXiv:1606.01981, 2016.   
+Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. arXiv preprint arXiv:1701.05369, 2017.   
+Steven J Nowlan and Geoffrey E Hinton. Simplifying neural networks by soft weight-sharing. Neural computation, 4(4):473–493, 1992.   
+Jorma Rissanen. Modeling by shortest data description. Automatica, 14(5):465–471, 1978.   
+Jorma Rissanen. Stochastic complexity and modeling. The annals of statistics, pp. 1080–1100, 1986.   
+Herbert Robbins and Sutton Monro. A stochastic approximation method. The annals of mathematical statistics, pp. 400–407, 1951.   
+Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pp. 2951–2959, 2012.   
+Cheng Tai, Tong Xiao, Xiaogang Wang, et al. Convolutional neural networks with low-rank regularization. arXiv preprint arXiv:1511.06067, 2015.   
+Ganesh Venkatesh, Eriko Nurvitadhi, and Debbie Marr. Accelerating deep convolutional networks using low-precision and sparsity. arXiv preprint arXiv:1610.00324, 2016.   
+Chris S Wallace. Classification by minimum-message-length inference. In International Conference on Computing and Information, pp. 72–81. Springer, 1990.   
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances In Neural Information Processing Systems, pp. 2074–2082, 2016.   
+Ian H Witten, Radford M Neal, and John G Cleary. Arithmetic coding for data compression. Communications of the ACM, 30(6):520–540, 1987.   
+Jiaxiang Wu, Cong Leng, Yuhang Wang, Qinghao Hu, and Jian Cheng. Quantized convolutional neural networks for mobile devices. arXiv preprint arXiv:1512.06473, 2015.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+# APPENDIX
+
+# A REVIEW OF STATE-OF-THE-ART NEURAL NETWORK COMPRESSION
+
+We apply the compression scheme proposed by Han et al. (2015b;a) that highly optimizes the storage utilized by the weights. First of all, the authors store the weights in regular compressed sparse-row (CSR) format. Instead of storing $| W ^ { ( l ) } |$ parameters with a bit length of (commonly) $p _ { \mathrm { o r i g } } = 3 2 $ bit, CSR format stores three vectors (A, IR, IC).
+
+• A stores all non-zero entries. It is thus of size $| W ^ { ( l ) } | _ { \neq 0 } \times p _ { \mathrm { o r i g } }$ , where $\vert W ^ { ( l ) } \vert _ { \neq 0 }$ is the number of non-zero entries in $W ^ { ( l ) }$ .   
+• IR Is defined recursively: $\mathrm { { I R } _ { 0 } ~ = ~ 0 }$ , $\mathrm { I R } _ { k } \ = \mathrm { I R } _ { k - 1 } +$ (number of non-zero entries in the $( k - 1 )$ -th row of $W ^ { ( l ) }$ ). It got $K + 1$ entries each of size $p _ { \mathrm { o r i g } }$ .   
+• IC contains the column index in $W ^ { ( l ) }$ of each element of A. The size is hence, $| W ^ { ( l ) } | _ { \neq 0 } \times$ $p _ { \mathrm { o r i g } }$ .
+
+An example shall illustrate the format, let
+
+$$
+W ^ { ( l ) } = \left( \begin{array} { c c c c } { { 0 } } & { { 0 } } & { { 0 } } & { { 1 } } \\ { { 0 } } & { { 2 } } & { { 0 } } & { { 0 } } \\ { { 0 } } & { { 0 } } & { { 0 } } & { { 0 } } \\ { { 2 } } & { { 5 } } & { { 0 } } & { { 0 } } \\ { { 0 } } & { { 0 } } & { { 0 } } & { { 1 } } \end{array} \right)
+$$
+
+than
+
+$$
+\begin{array} { r } { \mathbf { A } = [ 1 , 2 , 2 , 5 , 1 ] } \\ { \mathbf { I R } = [ 0 , 1 , 2 , 2 , 4 , 5 ] } \\ { \mathbf { I C } = [ 3 , 1 , 0 , 1 , 3 ] } \end{array}
+$$
+
+The compression rate achieved by applying the CSC format naively is
+
+$$
+r _ { p } = \frac { | W ^ { ( l ) } | } { 2 | W ^ { ( l ) } | \neq 0 + ( K + 1 ) }
+$$
+
+However, this result can be significantly improved by optimizing each of the three arrays.
+
+# A.1 STORING THE INDEX ARRAY IR
+
+To optimize IR, note that the biggest number in IR is $\vert W ^ { ( l ) } \vert _ { \neq 0 }$ . This number will be much smaller than $2 ^ { p _ { \mathrm { o r i g } } }$ . Thus one could try to find $p \in \mathbf { Z } _ { + }$ such that $| W ^ { ( l ) } | _ { \neq 0 } < 2 ^ { p _ { \mathrm { p r u n } } }$ . A codebook would not be necessary. Thus instead of storing $( K + 1 )$ values with $p _ { \mathrm { o r i g } }$ , we store them with $p _ { \mathrm { p r u n } }$ depth.
+
+# A.2 STORING THE INDEX ARRAY IC
+
+Instead of storing the indexes, we store the differences between indexes. Thus there is a smaller range of values being used. We further shrink the range of utilized values by filling A with zeros whenever the distance between two non-zero weights extends the span of $2 _ { \mathrm { p r u n } } ^ { p ^ { \mathrm { - } } }$ . Han et al. (2015a) propose $\mathrm { p } = 5$ for fully connected layers and $\mathtt { p } = 8$ for convolutional layers. An illustration of the process can is shown in Fig. 4. Furthermore, the indexes will be compressed Hoffman encoding.
+
+# A.3 STORING THE WEIGHT ARRAY A
+
+In order to minimize the storage occupied by A. We quantize the values of A. Storing indexes in A and a consecutive codebook. Indexing can be improved further by again applying Huffman encoding.
+
+![](images/967d05c1ee545bf31e180b6cf4b3b53db00615e1a558cc6d8dbde06265e37d8f.jpg)  
+Figure 4: Illustration of the process described in A.2. IC is represented by relative indexes(diff). If the a relative index is larger than $8 ( = 2 ^ { \bar { 3 } } )$ , A will be filled with an additional zero. Figure from Han et al. (2015a).
+
+# B CONFIGURING THE HYPER-PRIORS
+
+# B.1 GAMMA DISTRIBUTION
+
+The Gamma distribution is the conjugate prior for the precision of a univariate Gaussian distribution.   
+It is defined for positive random variables $\lambda > 0$ .
+
+$$
+\Gamma ( \lambda | \alpha , \beta ) = \frac { \beta ^ { \alpha } } { \Gamma ( \alpha ) } \lambda ^ { \alpha - 1 } e ^ { - \beta \lambda }
+$$
+
+For our purposes it is best characterised by its mode $\lambda ^ { * } = \frac { \alpha - 1 } { \beta }$ and its variance $\operatorname { v a r } _ { \gamma } = { \frac { \alpha } { \beta ^ { 2 } } }$ I n our experiments we set the desired variance of the mixture components to 0.05. This corresponds to $\lambda ^ { * } \stackrel { - } { = } 1 / ( 0 . 0 5 ) ^ { 2 } = 4 0 0$ . We show the effect of different choices for the variance of the Gamma distribution in Figure 5.
+
+![](images/2fedb28eefbd0883b40013cbd6042a6a9179fd6fe06521759b16e872c3976948.jpg)  
+Figure 5: Gamma distribution with $\lambda ^ { * } ~ = ~ 1 0 0$ . $\alpha$ and $\beta$ correspond to different choices for the variance of the distribution.
+
+# B.2 BETA DISTRIBUTION
+
+The Beta distribution is the conjugate prior for the Bernoulli distribution, thus is often used to represent the probability for a binary event. It is defined for some random variable $\pi _ { j = 0 } \in [ 0 , 1 ]$
+
+$$
+\mathcal { B } ( \pi _ { j = 0 } | \alpha , \beta ) = \frac { \Gamma ( \alpha + \beta ) } { \Gamma ( \alpha ) \Gamma ( \beta ) } ( \pi _ { j = 0 } ) ^ { \alpha - 1 } ( 1 - \pi _ { j = 0 } ) ^ { \beta - 1 }
+$$
+
+with $\alpha , \beta \ > \ 0$ . $\alpha$ and $\beta$ can be interpreted as the effective number of observations prior to an experiment, of $\pi _ { j = 0 } = 1$ and $\pi _ { j = 0 } = 0$ , respectively. In the literature, $\alpha + \beta$ is defined as the pseudo-count. The higher the pseudo-count the stronger the prior. In Figure 6, we show the Beta distribution at constant mode $\pi _ { j = 0 } ^ { * } = \frac { \alpha - 1 } { \alpha + \beta - 2 } = 0 . 9$ . Note, that, the beta distribution is a special case of the Dirichlet distribution in a different problem setting it might be better to rely on this distribution to control all $\pi _ { j }$ .
+
+![](images/fb22eba7ee7a7216b148cabc5af0ccbc7462a7dbb5d9204749c1581c7c945cfb.jpg)  
+Figure 6: Beta distribution with $\pi _ { j = 0 } ^ { * } = 0 . 9$ . $\alpha$ and $\beta$ correspond to different choices for the pseudocount.
+
+# C SCALABILITY
+
+Neural Networks are usually trained with a form of batch gradient decent (GD) algorithm. These methods fall into the umbrella of stochastic optimization (Robbins $\&$ Monro, 1951). Here the model parameters $\mathbf { W }$ are updated iteratively. At each iteration $t$ , a set of $B$ data instances is used to compute a noisy approximation of the posterior derivative with respect to $\mathbf { W }$ given all data instances $N$ .
+
+$$
+\nabla _ { \mathbf { W } } \log p ( \mathbf { W } | \mathcal { D } ) = \frac { N } { B } \sum _ { n = 1 } ^ { B } \nabla _ { \mathbf { W } } \log p ( \mathbf { t } _ { n } | \mathbf { x } _ { n } , \mathbf { w } ) + \sum _ { i = 1 } ^ { I } \nabla _ { \mathbf { W } } \log p ( w _ { i } )
+$$
+
+This gradient approximation can subsequently be used in various update schemes such as simple GD.
+
+For large models estimating the prior gradient can be an expensive operation. This is why we propose to apply similar measures for the gradient estimation of the prior as we did for the likelihood term. To do so, we sample $\mathbf { K }$ weights randomly. The noisy approximation of the posterior derivative is
+
+now:
+
+$$
+\nabla _ { \mathbf { W } } \log p ( \mathbf { W } | \mathcal { D } ) = \frac { N } { B } \sum _ { n = 1 } ^ { B } \nabla _ { \mathbf { w } } \log p ( \mathbf { t } _ { n } | \mathbf { x } _ { n } , \mathbf { w } ) + \frac { I } { K } \sum _ { i = 1 } ^ { K } \nabla _ { \mathbf { w } } \log p ( w _ { i } )
+$$
+
+# D FILTER VISUALISATION
+
+In Figure D we show the pre-trained and compressed filters for the first and second layers of LeNet5-Caffe. For some of the feature maps from layer 2 seem to be redundant hence the almost empty columns. In Figure D we show the pre-trained and compressed filters for the first and second layers of LeNet-300-100.
+
+![](images/2d79616dc4994d71c20571be67f8d8cf0e2083ec9b4c242efabdf8774c606032.jpg)  
+Figure 7: Convolution filters from LeNet-5-Caffe. Left: Pre-trained filters. Right: Compressed filters. The top filters are the 20 first layer convolution weights; the bottom filters are the 20 by 50 convolution weights of the second layer.
+
+![](images/d76996240a46681f55f0e1b612c41b39ea04f303b875a74effbeff5ef9fd1f26.jpg)  
+Figure 8: Feature filters for LeNet-300-100. Left: Pre-trained filters. Right: Compressed filters.
+
+![](images/7ecb0ba3ec00310a1cdf97893c7d3ec5e1e886c75fb0891f197f03a357b0b852.jpg)

parse/train/HJGwcKclx/HJGwcKclx_content_list.json

@@ -0,0 +1,1602 @@
+[
+    {
+        "type": "text",
+        "text": "SOFT WEIGHT-SHARING FOR NEURAL NETWORK COMPRESSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            596,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Karen Ullrich University of Amsterdam karen.ullrich@uva.nl ",
+        "bbox": [
+            184,
+            170,
+            380,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Max Welling   \nUniversity of Amsterdam   \nCanadian Institute for Advanced Research (CIFAR)   \nwelling.max@gmail.com ",
+        "bbox": [
+            183,
+            233,
+            522,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            327,
+            544,
+            342
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The success of deep learning in numerous application domains created the desire to run and train them on mobile devices. This however, conflicts with their computationally, memory and energy intense nature, leading to a growing interest in compression. Recent work by Han et al. (2015a) propose a pipeline that involves retraining, pruning and quantization of neural network weights, obtaining state-of-the-art compression rates. In this paper, we show that competitive compression rates can be achieved by using a version of ”soft weight-sharing” (Nowlan & Hinton, 1992). Our method achieves both quantization and pruning in one simple (re-)training procedure. This point of view also exposes the relation between compression and the minimum description length (MDL) principle. ",
+        "bbox": [
+            233,
+            354,
+            764,
+            494
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            517,
+            336,
+            534
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "”Bigger is better” is the ruling maxim in deep learning land. Deep neural nets with billions of parameters are no longer an exception. Networks of such size are unfortunately not practical for mobile, on-device applications which face strong limitations with respect to memory and energy consumption. Compressing neural networks could not only improve memory and energy consumption, but also lead to less network bandwidth, faster processing and better privacy. It has been shown that large networks are heavily over-parametrized and can be compressed by approximately two orders of magnitude without significant loss of accuracy. Apparently, over-parametrization is beneficial for optimization, but not necessary for accurate prediction. This observation has opened the door for a number of highly successful compression algorithms, which either train the network from scratch (Hinton et al., 2015; Iandola et al., 2016; Courbariaux & Bengio, 2016; Courbariaux et al., 2016) or apply compression post-optimization (Han et al., 2015b;a; Guo et al., 2016; Chen et al., 2015; Wen et al., 2016). ",
+        "bbox": [
+            173,
+            547,
+            825,
+            714
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It has been long known that compression is directly related to (variational) Bayesian inference and the minimum description principle (Hinton & Van Camp, 1993). One can show that good compression can be achieved by encoding the parameters of a model using a good prior and specifying the parameters up to an uncertainty given, optimally, by the posterior distribution. An ingenious bitsback argument can then be used to get a refund for using these noisy weights. A number of papers have appeared that encode the weights of a neural network with limited precision (say 8 bits per weight), effectively cashing in on this ”bits-back” argument (Gupta et al., 2015; Courbariaux et al., 2014; Venkatesh et al., 2016). Some authors go so far of arguing that even a single bit per weight can be used without much loss of accuracy (Courbariaux et al., 2015; Courbariaux & Bengio, 2016). ",
+        "bbox": [
+            174,
+            722,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work we follow a different but related direction, namely to learn the prior that we use to encode the parameters. In Bayesian statistics this is known as empirical Bayes. To encourage compression of the weights to $K$ clusters, we fit a mixture of Gaussians prior model over the weights. This idea originates from the nineties, known as soft weight-sharing (Nowlan & Hinton, 1992) where it was used to regularize a neural network. Here our primary goal is network compression, but as was shown in Hinton & Van Camp (1993) these two objectives are almost perfectly aligned. By fitting the mixture components alongside the weights, the weights tend to concentrate very tightly around a number of cluster components, while the cluster centers optimize themselves to give the network high predictive accuracy. Compression is achieved because we only need to encode $K$ cluster means (in full precision) in addition to the assignment of each weight to one of these $J$ values (using $\\log ( J )$ bits per weight). We find that competitive compression rates can be achieved by this simple idea. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MDL VIEW ON VARIATIONAL LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            208,
+            550,
+            224
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Model compression was first discussed in the context of information theory. The minimum description length (MDL) principle identifies the best hypothesis to be the one that best compresses the data. More specifically, it minimizes the cost to describe the model (complexity cost $\\mathcal { L } ^ { C }$ ) and the misfit between model and data (error cost $\\mathcal { L } ^ { E }$ ) (Rissanen, 1978; 1986). It has been shown that variational learning can be reinterpreted as an MDL problem (Wallace, 1990; Hinton & Van Camp, 1993; Honkela & Valpola, 2004; Graves, 2011). In particular, given data $\\mathcal D = \\left\\{ \\mathbf X = \\{ \\mathbf x _ { n } \\} _ { n = 1 } ^ { N } , \\mathbf T = \\{ \\mathbf t _ { n } \\} _ { n = 1 } ^ { N } \\right\\}$ , a set of parameters $\\mathbf { w } = \\{ w _ { i } \\} _ { i = 1 } ^ { I }$ that describes the model and an approximation $q ( \\mathbf { w } )$ of the posterior $p ( \\mathbf { w } | \\mathcal { D } )$ , the variational lower bound, also known as negative variational free energy, $\\mathcal { L } ( q ( \\mathbf { w } ) , \\mathbf { w } )$ can be decomposed in terms of error and complexity losses ",
+        "bbox": [
+            173,
+            239,
+            825,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b112d11a965f1ee3f1fc4ef0da7f96e1777bf7c1ead3d05427c98d31a27a0298.jpg",
+        "text": "$$\n{ \\mathcal { L } } ( q ( \\mathbf { w } ) , \\mathbf { w } ) = - \\mathbb { E } _ { q ( \\mathbf { w } ) } \\left[ \\log \\left( { \\frac { p ( { \\mathcal { D } } | \\mathbf { w } ) p ( \\mathbf { w } ) } { q ( \\mathbf { w } ) } } \\right) \\right] = \\underbrace { \\mathbb { E } _ { q ( \\mathbf { w } ) } \\left[ - \\log p ( { \\mathcal { D } } | \\mathbf { w } ) \\right] } _ { { \\mathcal { L } } ^ { E } } + \\underbrace { \\mathrm { K L } ( q ( \\mathbf { w } ) | | p ( \\mathbf { w } ) ) } _ { { \\mathcal { L } } ^ { C } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            385,
+            787,
+            431
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $p ( \\mathbf { w } )$ is the prior over $\\mathbf { w }$ and $p ( \\mathcal { D } | \\mathbf { w } )$ is the model likelihood. According to Shannon’s source coding theorem, $\\mathring { \\mathcal { L } } ^ { E }$ lower bounds the expected amount of information needed to communicate the targets $\\mathbf { T }$ , given the receiver knows the inputs $\\mathbf { X }$ and the model w. The functional form of the likelihood term is conditioned by the target distribution. For example, in case of regression the predictions of the model are assumed be normally distributed around the targets $\\mathbf { T }$ . ",
+        "bbox": [
+            174,
+            438,
+            825,
+            507
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb04039f84fdfcf36c07b191440e742db645ad96d8b96972ef4dd6266f34054c.jpg",
+        "text": "$$\np ( \\mathcal { D } | \\mathbf { w } ) = p ( \\mathbf { T } | \\mathbf { X } , \\mathbf { w } ) = \\prod _ { n = 1 } ^ { N } \\mathcal { N } ( \\mathbf { t } _ { n } | \\mathbf { x } _ { n } , \\mathbf { w } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            515,
+            637,
+            559
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { N } ( \\mathbf { t } _ { n } , \\mathbf { x } _ { n } , \\mathbf { w } )$ is a normal distribution. Another typical example is classification where the conditional distribution of targets given data is assumed to be Bernoulli distributed1. These assumptions eventually lead to the well known error functions, namely cross-entropy error and squared error for classification and regression, respectively. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            621
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Before however we can communicate the data we first seek to communicate the model. Similarly to $\\mathcal { L } ^ { E } , \\mathcal { L } ^ { C }$ is a lower bound for transmitting the model. More specifically, if sender and receiver agree on a prior, $\\mathcal { L } ^ { C }$ is the expected cost of communicating the parameters w. This cost is again twofold, ",
+        "bbox": [
+            174,
+            622,
+            823,
+            664
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/18ee03870e21cc1c81eb70e090efba5bfb856f7b80e79736f464b310e8cfbfba.jpg",
+        "text": "$$\n\\mathrm { K L } ( q ( \\mathbf { w } ) | | p ( \\mathbf { w } ) ) = \\mathbb { E } _ { q ( \\mathbf { w } ) } \\left[ - \\log p ( \\mathbf { w } ) \\right] - H ( q ( \\mathbf { w } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            670,
+            666,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $H ( \\cdot )$ denotes the entropy. In Wallace (1990) and Hinton & Van Camp (1993) it was shown that noisy encoding of the weights can be beneficial due to the bits-back argument if the uncertainty does not harm the error loss too much. The number of bits to get refunded by an uncertain weight distribution $q ( \\mathbf { w } )$ is given by its entropy. Further, it can be shown that the optimal distribution for $q ( \\mathbf { w } )$ is the Bayesian posterior distribution. While bits-back is proven to be an optimal coding scheme (Honkela $\\&$ Valpola, 2004), it is often not practical in real world settings. A practical way to cash in on noisy weights (or bits-back) is to only encode a weight value up to a limited number of bits. To see this, assume a factorized variational posteriors $q ( \\mathbf { w } ) { \\bar { \\mathbf { \\Gamma } } } = \\prod q ( w _ { i } )$ . Each posterior $q ( w _ { i } )$ is associated with a Dirac distribution up to machine precision, for example, a Gaussian distribution with variance $\\sigma$ , for small values of $\\sigma$ . This implies that we formally incur a very small refund per weight, ",
+        "bbox": [
+            173,
+            695,
+            825,
+            851
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c42cfc8f3c50834def4e1ec05772c00ad46723d9d3b588d698c7c2022bbae25e.jpg",
+        "text": "$$\nH ( q ( \\mathbf { w } ) ) = - \\intop _ { \\Omega } q ( \\mathbf { w } ) \\log q ( \\mathbf { w } ) \\mathrm { d } \\mathbf { w } = - \\intop _ { \\mathbb { R } ^ { I } } \\mathcal { N } ( \\mathbf { w } | \\mathbf { 0 } , \\sigma \\mathbf { I } ) \\log \\mathcal { N } ( \\mathbf { w } | \\mathbf { 0 } , \\sigma \\mathbf { I } ) = [ \\log ( 2 \\pi e \\sigma ^ { 2 } ) ] ^ { I } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            856,
+            785,
+            898
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that the more coarse the quantization of weights the more compressible the model. The bitsback scheme makes three assumptions: (i) weights are being transmitted independently, (ii) weights are independent of each other (no mutual information), and (iii) the receiver knows the prior. Han et al. (2015a) show that one can successfully exploit (i) and (ii) by using a form of arithmetic coding (Witten et al., 1987). In particular, they employ range coding schemes such as the Sparse Matrix Format (discussed in Appendix A). This is beneficial because the weight distribution has low entropy. Note that the cost of transmitting the prior should be negligible. Thus a factorized prior with different parameters for each factor is not desirable. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The main objective of this work is to find a suitable prior for optimizing the cross-entropy between a delta posterior $q ( \\mathbf { w } )$ and the prior $p ( \\mathbf { w } )$ while at the same time keeping a practical coding scheme in mind. Recall that the cross entropy is a lower bound on the average number of bits required to encode the weights of the neural network (given infinite precision). Following Nowlan & Hinton (1992) we will model the prior $p ( \\mathbf { w } )$ as a mixture of Gaussians, ",
+        "bbox": [
+            174,
+            222,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7bff6ca94c4e314c8596c390101763b0ca01a109ed8c31b9e9d476ec76e7e09f.jpg",
+        "text": "$$\np ( \\mathbf { w } ) = \\prod _ { i = 1 } ^ { I } \\sum _ { j = 0 } ^ { J } \\pi _ { j } \\mathcal { N } ( w _ { i } | \\mu _ { j } , \\sigma _ { j } ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            292,
+            609,
+            338
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We learn the mixture parameters $\\mu _ { j } , \\sigma _ { j } ,$ $\\pi _ { j }$ via maximum likelihood simultaneously with the network weights. This is equivalent to an empirical Bayes approach in Bayesian statistics. For stateof-the-art compression schemes pruning plays a major role. By enforcing an arbitrary “zero” component to have fixed $\\mu _ { 0 } = 0$ location and $\\pi _ { 0 }$ to be close to 1, a desired weight pruning rate can be enforced. In this scenario $\\pi _ { 0 }$ may be fixed or trainable. In the latter case a Beta distribution as hyperprior might be helpful. The approach naturally encourages quantization because in order to optimize the cross-entropy the weights will cluster tightly around the cluster means, while the cluster means themselves move to some optimal location driven by $\\mathcal { L } ^ { E }$ . The effect might even be so strong that it is beneficial to have a Gamma hyper-prior on the variances of the mixture components to prevent the components from collapsing. Furthermore, note that, mixture components merge when there is not enough pressure from the error loss to keep them separated because weights are attracted by means and means are attracted by weights hence means also attract each other. In that way the network learns how many quantization intervals are necessary. We demonstrate that behaviour in Figure 3. ",
+        "bbox": [
+            173,
+            339,
+            825,
+            518
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            539,
+            343,
+            555
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There has been a recent surge in interest in compression in the deep neural network community. Denil et al. (2013) showed that by predicting parameters of neural networks there is great redundancy in the amount of parameters being used. This suggests that pruning, originally introduced to reduce structure in neural networks and hence improve generalization, can be applied to the problem of compression and speed-up (LeCun et al., 1989). In fact, (Han et al., 2015b; Guo et al., 2016) show that neural network survive severe weight pruning (up to $9 9 \\%$ ) without significant loss of accuracy. A variational version is is proposed by Molchanov et al. (2017), the authors learn the dropout rate for each weight in the network separately. Some parameters will effectively be pruned when the dropout rate is very high. In an approach slightly orthogonal to weight pruning, (Wen et al., 2016) applied structural regularization to prune entire sets of weights from the neural network. Such extreme weight pruning can lead to entire structures being obsolete, which for the case of convolutional filters, can greatly speed up prediction. Most importantly for compression, however, is that in conjunction with Compressed Sparse Column (CSC) format, weight pruning is a highly effective way to store and transfer weights. In Appendix A we discuss CSC format in more detail. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Reducing the bit size per stored weight is another approach to model compression. For example, reducing 32 bit floats to 1 bit leads to a $3 2 \\times$ storage improvement. Gong et al. (2014) proposed and experimented with a number of quantization approaches: binary quantization, $\\mathbf { k }$ -means quantization, product quantization and residual quantization. Other work finds optimal fixed points (Lin et al., 2015), applies hashing (Chen et al., 2015) or minimizes the estimation error (Wu et al., 2015). Merolla et al. (2016) demonstrates that neural networks are robust against certain amounts of low precision; indeed several groups have exploited this and showed that decreasing the weight encoding precision has little to no effect on the accuracy loss (Gupta et al., 2015; Courbariaux et al., 2014; Venkatesh et al., 2016). Pushing the idea of extreme quantization, (Courbariaux et al., 2015) and Courbariaux & Bengio (2016) trained networks from scratch that use only 1bit weights with floating point gradients; to achieve competitive results, however, they require many more of these weights. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Han et al. (2015a) elaborate on combining these ideas. They introduce an multi-step algorithm that compresses CNNS up to $4 9 \\times$ . First, weights are pruned (giving $9 - 1 3 \\times$ compression); second they quantize the weights (increasing compression to $2 7 - 3 1 \\times )$ ; and last, they apply Huffman Encoding (giving a final compression of $3 5 - 4 9 \\times )$ . The quantization step is trainable in that after each weight is assigned to a cluster centroid, the centroids get trained with respect to the original loss function. Note that this approach has several restrictions: the number of weights set to zero is fixed after the pruning step, as is the assignment of a weight to a given cluster in the second step. Our approach overcomes all these restrictions. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A final approach to compressing information is to apply low rank matrix decomposition. First introduced by (Denton et al., 2014) and Jaderberg et al. (2014), and elaborated on by using low rank filters (Ioannou et al., 2015), low rank regularization (Tai et al., 2015) or combining low rank decomposition with sparsity (Liu et al., 2015). ",
+        "bbox": [
+            174,
+            222,
+            823,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            299,
+            281,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This section presents the procedure of network compression as applied in the experiment section. A summary can be found in Algorithm 1. ",
+        "bbox": [
+            174,
+            330,
+            823,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 GENERAL SET-UP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            377,
+            336,
+            391
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We retrain pre-trained neural networks with soft weight-sharing and factorized Dirac posteriors. Hence we optimize ",
+        "bbox": [
+            171,
+            404,
+            823,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f54c4f37c640bebc2e736dcf09bf8f4432fc830442f2f6402b940039773d5652.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } ( \\mathbf { w } , \\{ \\mu _ { j } , \\sigma _ { j } , \\pi _ { j } \\} _ { j = 0 } ^ { J } ) = \\mathcal { L } ^ { E } + \\tau \\mathcal { L } ^ { C } } \\\\ & { \\qquad = - \\log p ( \\mathbf { T } | \\mathbf { X } , \\mathbf { w } ) - \\tau \\log p ( \\mathbf { w } , \\{ \\mu _ { j } , \\sigma _ { j } , \\pi _ { j } \\} _ { j = 0 } ^ { J } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            438,
+            738,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "via gradient descent, specifically using Adam (Kingma & Ba, 2014). The KL divergence reduces to the prior because the entropy term does not depend on any trainable parameters. Note that, similar to (Nowlan & Hinton, 1992) we weigh the log-prior contribution to the gradient by a factor of $\\tau = 0 . 0 0 5$ . In the process of retraining the weights, the variances, means, and mixing proportions of all but one component are learned. For one component, we fix $\\mu _ { j = 0 } = 0$ and $\\pi _ { j = 0 } = 0 . 9 9 9$ . Alternatively we can train $\\pi _ { j = 0 }$ as well but restrict it by a Beta distribution hyper-prior. Our Gaussian MM prior is initialized with $2 ^ { 4 } + 1 = 1 7$ components. We initialize the learning rate for the weights and means, log-variances and log-mixing proportions separately. The weights should be trained with approximately the same learning rate used for pre-training. The remaining learning rates are set to $5 \\cdot 1 0 ^ { - 4 }$ . Note that this is a very sensitive parameter. The Gaussian mixtures will collapse very fast as long as the error loss does not object. However if it collapses too fast weights might be left behind, thus it is important to set the learning rate such that the mixture does collapse too soon. If the learning rate is too small the mixture will converge too slowly. Another option to keep the mixture components from collapsing is to apply an Inverse-Gamma hyperprior on the mixture variances. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 INITIALIZATION OF MIXTURE MODEL COMPONENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            713,
+            581,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In principle, we follow the method proposed by Nowlan & Hinton (1992). We distribute the means of the 16 non-fixed components evenly over the range of the pre-trained weights. The variances will be initialized such that each Gaussian has significant probability mass in its region. A good orientation for setting a good initial variance is weight decay rate the original network has been trained on. The trainable mixing proportions are initialized evenly $\\pi _ { j } = ( 1 - \\pi _ { j = 0 } ) / J$ . We also experimented with other approaches such as distributing the means such that each component assumes an equal amount of probability. We did not observe any significant improvement over the simpler initialization procedure. ",
+        "bbox": [
+            173,
+            739,
+            825,
+            852
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.3 POST-PROCESSING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            346,
+            882
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After re-training we set each weight to the mean of the component that takes most responsibility for it i.e. we quantize the weights. Before quantizing, however, there might be redundant components ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "as explained in section 2. To eliminate those we follow Adhikari & Hollmen (2012) by computing ´ the KL divergence between all components. For a KL divergence smaller than a threshold, we merge two components as follows ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1264e049926202d9c0027def791c68aaff3e71cf394e884505f40687fc4f6793.jpg",
+        "text": "$$\n\\pi _ { \\mathrm { n e w } } = \\pi _ { i } + \\pi _ { j } , \\mu _ { \\mathrm { n e w } } = \\frac { \\pi _ { i } \\mu _ { i } + \\pi _ { j } \\mu _ { j } } { \\pi _ { i } + \\pi _ { j } } , \\sigma _ { \\mathrm { n e w } } ^ { 2 } = \\frac { \\pi _ { i } \\sigma _ { i } ^ { 2 } + \\pi _ { j } \\sigma _ { j } ^ { 2 } } { \\pi _ { i } + \\pi _ { j } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            152,
+            723,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "for two components with indices $i$ and $j$ . ",
+        "bbox": [
+            176,
+            196,
+            442,
+            210
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, for practical compression we use the storage format used in Han et al. (2015a) (see Appendix A). ",
+        "bbox": [
+            173,
+            212,
+            823,
+            238
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Soft weight-sharing for compression, our proposed algorithm for neural network model compression. It is divided into two main steps: network re-training and post-processing. ",
+        "bbox": [
+            169,
+            253,
+            825,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Require: $\\tau  \\mathrm { s e t }$ the trade-off between error and complexity loss   \nRequire: $\\Theta $ set parameters for gradient decent scheme such as learning rate or momentum   \nRequire: $\\alpha , \\beta \\gets { \\sf s e t }$ gamma hyper-prior parameter (optional) $\\mathbf { w } \\gets$ initialize network weights with pre-trained network weights $\\theta = \\{ \\mu _ { j } , \\sigma _ { j } , \\pi _ { j } \\} _ { j = 1 } ^ { J } $ initialize mixture parameters (see Sec. 4.2) while $\\mathbf { w } , \\theta$ not converged do $\\mathbf { w } , \\theta \\gets \\nabla _ { \\mathbf { w } , \\theta } \\mathcal { L } ^ { E } + \\overline { { \\tau } } \\mathcal { L } ^ { C }$ update $\\mathbf { w }$ and $\\theta$ with the gradient decent scheme of choice end while $\\mathbf { w } \\gets \\mathop { \\mathrm { a r g m a x } } _ { \\mu _ { k } } \\frac { \\pi _ { k } \\mathcal { N } ( \\mathbf { w } | \\mu _ { k } , \\sigma _ { k } ) } { \\sum \\pi _ { j } \\mathcal { N } ( \\mathbf { w } | \\mu _ { j } , \\sigma _ { j } ) }$ compute final weight by setting it to the mean that takes most responsibility (for details see Sec. 4.3) ",
+        "bbox": [
+            173,
+            285,
+            820,
+            441
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            473,
+            279,
+            489
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We test our compression procedure on two neural network models used in previous work we compare against in our experiments: ",
+        "bbox": [
+            173,
+            506,
+            823,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(a) LeNet-300-100 an MNIST model described in LeCun et al. (1998). As no pre-trained model is available, we train our own, resulting in an error rate of $1 . 8 9 \\%$ .   \n(b) LeNet-5-Caffe a modified version of the LeNet-5 MNIST model in LeCun et al. (1998). The model specification can be downloaded from the Caffe MNIST tutorial page 2. As no pre-trained model is available, we train our own, resulting in an error rate of $0 . 8 8 \\%$ .   \n(c) ResNets have been invented by He et al. (2015) and further developed by He et al. (2016) and Zagoruyko & Komodakis (2016). We choose a model version of the latter authors. In accordance with their notation, we choose a network with depth 16, width $k = 4$ and no dropout. This model has $2 . 7 \\mathbf { M }$ parameters. In our experiments, we follow the authors by using only light augmentation, i.e., horizontal flips and random shifts by up to 4 pixels. Furthermore the data is normalized. The authors report error rates of $5 . 0 2 \\%$ and $2 4 . 0 3 \\%$ for CIFAR-10 and CIFAR-100 respectively. By reimplementing their model we trained models that achieve errors $6 . 4 8 \\%$ and $2 8 . 2 3 \\%$ . ",
+        "bbox": [
+            173,
+            545,
+            826,
+            737
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            758,
+            326,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "6.1 INITIAL EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            790,
+            364,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First, we run our algorithm without any hyper-priors, an experiment on LeNet-300-100. In Figure 1 we visualise the original distribution over weights, the final distribution over weight and how each weight changed its position in the training process. After retraining, the distribution is sharply peaked around zero. Note that with our procedure the optimization process automatically determines how many weights per layer are pruned. Specifically in this experiment, $96 \\%$ of the first layer (235K parameter), $90 \\%$ of the second (30K) and only $18 \\%$ of the final layer (10K) are pruned. From observations of this and other experiments, we conclude that the amount of pruned weights depends mainly on the number of parameters in the layer rather than its position or type (convolutional or fully connected). ",
+        "bbox": [
+            174,
+            816,
+            823,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluating the model reveals a compression rate of 64.2. The accuracy of the model does not drop significantly from 0.9811 to 0.9806. However, we do observe that the mixture components eventually collapse, i.e., the variances go to zero. This makes the prior inflexible and the optimization can easily get stuck because the prior is accumulating probability mass around the mixture means. For a weight, escaping from those high probability plateaus is impossible. This motivates the use hyper-priors such as an Inverse-Gamma prior on the variances to essentially lower bound them. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            251
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/366fcfb9d4f32f72391a0724ed8b6315b098dcac6186c9ceaf7a26d458a50213.jpg",
+        "image_caption": [
+            "Figure 1: On top we show the distribution of a pretrained network. On the right the same distribution after retraining. The change in value of each weight is illustrated by a scatter plot. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            284,
+            807,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.2 HYPER-PARAMETER TUNING USING BAYESIAN OPTIMIZATION ",
+        "bbox": [
+            176,
+            657,
+            643,
+            671
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proposed procedure offers various freedoms: there are many hyper-parameters to optimize, one may use hyper-priors as motivated in the previous section or even go as far as using other distributions as mixture components. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To cope with the variety of choices, we optimize 13 hyper-parameters using the Bayesian optimization tool Spearmint Snoek et al. (2012). These include the learning rates of the weight and mixing components, the number of components, and $\\tau$ . Furthermore, we assume an Inverse-Gamma prior over the variances separately for the zero component and the other components and a Beta prior over the zero mixing components. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            805
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In these experiments, we optimize re-training hyperparameters for LeNet-300-100 and LeNet-5- Caffe. Due to computational restrictions, we set the number of training epochs to 40 (previously 100), knowing that this may lead to solutions that have not fully converged. Spearmint acts on an objective that balances accuracy loss vs compression rate. The accuracy loss in this case is measured over the training data. The results are shown in Figure 2. In the illustration we use the accuracy loss as given by the test data. The best results predicted by our spearmint objective are colored in dark blue. Note that we achieve competitive results in this experiment despite the restricted optimization time of 40 epochs, i.e. 18K updates. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/62da5f3a931a29608a1c8683b52053a43dbe573da65df1fe113163626c3d12b3.jpg",
+        "image_caption": [
+            "Figure 2: We show the results of optimizing hyper-parameters with spearmint. Specifically, we plot the accuracy loss of a re-trained network against the compression rate. Each point represents one hyper-parameter setting. The guesses of the optimizer improve over time. We also present the results of other methods for comparison. Left: LeNet-300-100 Right: LeNet-5-Caffe. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            813,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b0bf8e6826b727729b43ba5975e9440a88a49d3cdb787f100f770c3392a0e2f2.jpg",
+        "image_caption": [
+            "Figure 3: Illustration of our mixture model compression procedure on LeNet-5-Caffe. Left: Dynamics of Gaussian mixture components during the learning procedure. Initially there are $1 7 \\mathrm { \\ c o m { - } }$ ponents, including the zero component. During learning components are absorbed into other components, resulting in roughly 6 significant components. Right: A scatter plot of initial versus final weights, along with the Gaussian components’ uncertainties. The initial weight distribution is roughly one broad Gaussian, whereas the final weight distribution matches closely the final, learned prior which has become very peaked, resulting in good quantization properties. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            385,
+            789,
+            606
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The conclusions from this experiment are a bit unclear, on the one hand we do achieve state-ofthe-art results for LeNet-5-Caffe, on the other hand there seems to be little connection between the parameter settings of best results. One wonders if a 13 dimensional parameter space can be searched efficiently with the amount of runs we were conducting. It may be more reasonable to get more inside in the optimization process and tune parameters according to those. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            823
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.3 COMPRESSION RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            383,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare our compression scheme with Han et al. (2015a) and Guo et al. (2016) in Table 1. The results on MNIST networks are very promising. We achieve state-of-the-art compression rates in both examples. We can furthermore show results for a light version of ResNet with 2.7M parameters to illustrate that our method does scale to modern architectures. We used more components (64) ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/eb6f67da7e4c9bb727a35971ca1f1c5c6925a4669a8bfc3835b80fe21689ddb0.jpg",
+        "table_caption": [
+            "Table 1: Compression Results. We compare methods based on the post-processing error (we also indicate the starting error), the accuracy loss $\\Delta$ , the number of non zero weights $| \\mathbf { W } _ { \\neq 0 } |$ and the final compression rate CR based on the method proposed by Han et al. (2015a). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Method</td><td>Top-1 Error[%]</td><td>△[%]</td><td>[W|[106]</td><td>W0 [%] W</td><td>CR</td></tr><tr><td rowspan=\"3\">LeNet-300-100</td><td>Han et al. (2015a)</td><td>1.64 → 1.58</td><td>0.06</td><td>0.2</td><td>8.0</td><td>40</td></tr><tr><td>Guo et al. (2016)</td><td>2.28→ 1.99</td><td>-0.29</td><td></td><td>1.8</td><td>56</td></tr><tr><td>Ours</td><td>1.89 →1.94</td><td>-0.05</td><td></td><td>4.3</td><td>64</td></tr><tr><td rowspan=\"3\">LeNet-5-Caffe</td><td>Han et al. (2015a)</td><td>0.80 →0.74</td><td>-0.06</td><td>0.4</td><td>8.0</td><td>39</td></tr><tr><td>Guo et al. (2016)</td><td>0.91 →0.91</td><td>0.00</td><td></td><td>0.9</td><td>108</td></tr><tr><td>Ours</td><td>0.88 →0.97</td><td>0.09</td><td></td><td>0.5</td><td>162</td></tr><tr><td>ResNet (light)</td><td>Ours</td><td>6.48 →8.50</td><td>2.02</td><td>2.7</td><td>6.6</td><td>45</td></tr></table>",
+        "bbox": [
+            173,
+            160,
+            825,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "here to cover the large regime of weights. However, for large networks such as VGG with 138M parameters the algorithm is too slow to get usable results. We propose a solution for this problem in Appendix C; however, we do not have any experimental results yet. ",
+        "bbox": [
+            176,
+            315,
+            823,
+            358
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            377,
+            485,
+            393
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work we revived a simple and principled regularization method based on soft weight-sharing and applied it directly to the problem of model compression. On the one hand we showed that we can optimize the MDL complexity lower bound, while on the other hand we showed that our method works well in practice when being applied to different models. A short-coming of the method at the moment is its computational cost and the ease of implementation. For the first, we provide a proposal that will be tested in future work. The latter is an open question at the moment. Note that our method—since it is optimizing the lower bound directly—will most likely also work when applied to other storage formats, such as those proposed originally by Hinton & Van Camp (1993). In the future we would like to extend beyond Dirac posteriors as done in Graves (2011) by extending the weight sharing prior to more general priors. For example, from a compression point of view, we could learn to prune entire structures from the network by placing Bernoulli priors over structures such as convolutional filters or ResNet units. Furthermore, it could be interesting to train models from scratch or in a student-teacher setting. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            611,
+            366,
+            626
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Louis Smit, Christos Louizos, Thomas Kipf, Rianne van den Berg and Peter O’Connor for helpful discussions on the paper and the public code3. ",
+        "bbox": [
+            174,
+            641,
+            823,
+            670
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This research has been supported by Google. ",
+        "bbox": [
+            176,
+            676,
+            467,
+            690
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            287,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Prem Raj Adhikari and Jaakko Hollmen. Multiresolution mixture modeling using merging of mix- ´ ture components. 2012. ",
+        "bbox": [
+            173,
+            736,
+            823,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Christopher M Bishop. Pattern recognition. Machine Learning, 2006. ",
+        "bbox": [
+            174,
+            772,
+            632,
+            787
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Wenlin Chen, James T Wilson, Stephen Tyree, Kilian Q Weinberger, and Yixin Chen. Compressing convolutional neural networks. arXiv preprint arXiv:1506.04449, 2015. ",
+        "bbox": [
+            173,
+            795,
+            823,
+            825
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux and Yoshua Bengio. Binarynet: Training deep neural networks with weights and activations constrained to $+ 1$ or $- 1$ . arXiv preprint arXiv:1602.02830, 2016. ",
+        "bbox": [
+            174,
+            833,
+            823,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Jean-Pierre David, and Yoshua Bengio. Training deep neural networks with low precision multiplications. arXiv preprint arXiv:1412.7024, 2014. ",
+        "bbox": [
+            178,
+            871,
+            825,
+            900
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In Advances in Neural Information Processing Systems, pp. 3123–3131, 2015. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training neural networks with weights and activations constrained to $+ 1$ or $- 1$ 2016. ",
+        "bbox": [
+            174,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Misha Denil, Babak Shakibi, Laurent Dinh, Nando de Freitas, et al. Predicting parameters in deep learning. In Advances in Neural Information Processing Systems, pp. 2148–2156, 2013. ",
+        "bbox": [
+            173,
+            205,
+            821,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Emily L Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. In Advances in Neural Information Processing Systems, pp. 1269–1277, 2014. ",
+        "bbox": [
+            171,
+            244,
+            823,
+            287
+        ],
+        "page_idx": 8
+    },
+    {
+        "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": [
+            173,
+            296,
+            823,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Practical variational inference for neural networks. In Advances in Neural Information Processing Systems, pp. 2348–2356, 2011. ",
+        "bbox": [
+            174,
+            334,
+            823,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. In Advances In Neural Information Processing Systems, pp. 1379–1387, 2016. ",
+        "bbox": [
+            174,
+            371,
+            823,
+            401
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. CoRR, abs/1502.02551, 392, 2015. ",
+        "bbox": [
+            173,
+            409,
+            823,
+            439
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. CoRR, abs/1510.00149, 2, 2015a. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural networks. In Advances in Neural Information Processing Systems, pp. 1135– 1143, 2015b. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            527
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            566
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. arXiv preprint arXiv:1603.05027, 2016. ",
+        "bbox": [
+            174,
+            574,
+            823,
+            604
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            174,
+            612,
+            823,
+            642
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton and Drew Van Camp. Keeping the neural networks simple by minimizing the description length of the weights. In Proceedings of the sixth annual conference on Computational learning theory, pp. 5–13. ACM, 1993. ",
+        "bbox": [
+            174,
+            650,
+            823,
+            694
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Antti Honkela and Harri Valpola. Variational learning and bits-back coding: an informationtheoretic view to bayesian learning. IEEE Transactions on Neural Networks, 15(4):800–810, 2004. ",
+        "bbox": [
+            174,
+            702,
+            823,
+            744
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Forrest N Iandola, Matthew W Moskewicz, Khalid Ashraf, Song Han, William J Dally, and Kurt Keutzer. Squeezenet: Alexnet-level accuracy with 50x fewer parameters and¡ 1mb model size. arXiv preprint arXiv:1602.07360, 2016. ",
+        "bbox": [
+            176,
+            753,
+            823,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yani Ioannou, Duncan Robertson, Jamie Shotton, Roberto Cipolla, and Antonio Criminisi. Training cnns with low-rank filters for efficient image classification. arXiv preprint arXiv:1511.06744, 2015. ",
+        "bbox": [
+            176,
+            805,
+            823,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. arXiv preprint arXiv:1405.3866, 2014. ",
+        "bbox": [
+            173,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S Denker, Sara A Solla, Richard E Howard, and Lawrence D Jackel. Optimal brain damage. In NIPs, volume 2, pp. 598–605, 1989.   \nYann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   \nDarryl D Lin, Sachin S Talathi, and V Sreekanth Annapureddy. Fixed point quantization of deep convolutional networks. arXiv preprint arXiv:1511.06393, 2015.   \nBaoyuan Liu, Min Wang, Hassan Foroosh, Marshall Tappen, and Marianna Pensky. Sparse convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 806–814, 2015.   \nPaul Merolla, Rathinakumar Appuswamy, John Arthur, Steve K Esser, and Dharmendra Modha. Deep neural networks are robust to weight binarization and other non-linear distortions. arXiv preprint arXiv:1606.01981, 2016.   \nDmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. arXiv preprint arXiv:1701.05369, 2017.   \nSteven J Nowlan and Geoffrey E Hinton. Simplifying neural networks by soft weight-sharing. Neural computation, 4(4):473–493, 1992.   \nJorma Rissanen. Modeling by shortest data description. Automatica, 14(5):465–471, 1978.   \nJorma Rissanen. Stochastic complexity and modeling. The annals of statistics, pp. 1080–1100, 1986.   \nHerbert Robbins and Sutton Monro. A stochastic approximation method. The annals of mathematical statistics, pp. 400–407, 1951.   \nJasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pp. 2951–2959, 2012.   \nCheng Tai, Tong Xiao, Xiaogang Wang, et al. Convolutional neural networks with low-rank regularization. arXiv preprint arXiv:1511.06067, 2015.   \nGanesh Venkatesh, Eriko Nurvitadhi, and Debbie Marr. Accelerating deep convolutional networks using low-precision and sparsity. arXiv preprint arXiv:1610.00324, 2016.   \nChris S Wallace. Classification by minimum-message-length inference. In International Conference on Computing and Information, pp. 72–81. Springer, 1990.   \nWei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances In Neural Information Processing Systems, pp. 2074–2082, 2016.   \nIan H Witten, Radford M Neal, and John G Cleary. Arithmetic coding for data compression. Communications of the ACM, 30(6):520–540, 1987.   \nJiaxiang Wu, Cong Leng, Yuhang Wang, Qinghao Hu, and Jian Cheng. Quantized convolutional neural networks for mobile devices. arXiv preprint arXiv:1512.06473, 2015.   \nSergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            171,
+            85,
+            828,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            101,
+            279,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A REVIEW OF STATE-OF-THE-ART NEURAL NETWORK COMPRESSION ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            136,
+            769,
+            152
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We apply the compression scheme proposed by Han et al. (2015b;a) that highly optimizes the storage utilized by the weights. First of all, the authors store the weights in regular compressed sparse-row (CSR) format. Instead of storing $| W ^ { ( l ) } |$ parameters with a bit length of (commonly) $p _ { \\mathrm { o r i g } } = 3 2 $ bit, CSR format stores three vectors (A, IR, IC). ",
+        "bbox": [
+            176,
+            167,
+            825,
+            226
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• A stores all non-zero entries. It is thus of size $| W ^ { ( l ) } | _ { \\neq 0 } \\times p _ { \\mathrm { o r i g } }$ , where $\\vert W ^ { ( l ) } \\vert _ { \\neq 0 }$ is the number of non-zero entries in $W ^ { ( l ) }$ .   \n• IR Is defined recursively: $\\mathrm { { I R } _ { 0 } ~ = ~ 0 }$ , $\\mathrm { I R } _ { k } \\ = \\mathrm { I R } _ { k - 1 } +$ (number of non-zero entries in the $( k - 1 )$ -th row of $W ^ { ( l ) }$ ). It got $K + 1$ entries each of size $p _ { \\mathrm { o r i g } }$ .   \n• IC contains the column index in $W ^ { ( l ) }$ of each element of A. The size is hence, $| W ^ { ( l ) } | _ { \\neq 0 } \\times$ $p _ { \\mathrm { o r i g } }$ . ",
+        "bbox": [
+            215,
+            236,
+            825,
+            342
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "An example shall illustrate the format, let ",
+        "bbox": [
+            176,
+            352,
+            447,
+            367
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bfbcb93475b8e9cda37b2306194481bb25e92db3d92308748697e55fadd78b30.jpg",
+        "text": "$$\nW ^ { ( l ) } = \\left( \\begin{array} { c c c c } { { 0 } } & { { 0 } } & { { 0 } } & { { 1 } } \\\\ { { 0 } } & { { 2 } } & { { 0 } } & { { 0 } } \\\\ { { 0 } } & { { 0 } } & { { 0 } } & { { 0 } } \\\\ { { 2 } } & { { 5 } } & { { 0 } } & { { 0 } } \\\\ { { 0 } } & { { 0 } } & { { 0 } } & { { 1 } } \\end{array} \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            375,
+            584,
+            448
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "than ",
+        "bbox": [
+            173,
+            455,
+            205,
+            469
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8790499479588c28a0dc528565a5d5941bbc03478cbd3966eca7c5f06f5a1b28.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { A } = [ 1 , 2 , 2 , 5 , 1 ] } \\\\ { \\mathbf { I R } = [ 0 , 1 , 2 , 2 , 4 , 5 ] } \\\\ { \\mathbf { I C } = [ 3 , 1 , 0 , 1 , 3 ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            476,
+            566,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The compression rate achieved by applying the CSC format naively is ",
+        "bbox": [
+            173,
+            554,
+            632,
+            570
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a21c8320c6f71acbb77b503c76cc8a0ed49481bc91ef5b1e5a7b2f2283151e2e.jpg",
+        "text": "$$\nr _ { p } = \\frac { | W ^ { ( l ) } | } { 2 | W ^ { ( l ) } | \\neq 0 + ( K + 1 ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            575,
+            593,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "However, this result can be significantly improved by optimizing each of the three arrays. ",
+        "bbox": [
+            171,
+            619,
+            758,
+            636
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 STORING THE INDEX ARRAY IR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            436,
+            666
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "To optimize IR, note that the biggest number in IR is $\\vert W ^ { ( l ) } \\vert _ { \\neq 0 }$ . This number will be much smaller than $2 ^ { p _ { \\mathrm { o r i g } } }$ . Thus one could try to find $p \\in \\mathbf { Z } _ { + }$ such that $| W ^ { ( l ) } | _ { \\neq 0 } < 2 ^ { p _ { \\mathrm { p r u n } } }$ . A codebook would not be necessary. Thus instead of storing $( K + 1 )$ values with $p _ { \\mathrm { o r i g } }$ , we store them with $p _ { \\mathrm { p r u n } }$ depth. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            724
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 STORING THE INDEX ARRAY IC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            741,
+            436,
+            755
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Instead of storing the indexes, we store the differences between indexes. Thus there is a smaller range of values being used. We further shrink the range of utilized values by filling A with zeros whenever the distance between two non-zero weights extends the span of $2 _ { \\mathrm { p r u n } } ^ { p ^ { \\mathrm { - } } }$ . Han et al. (2015a) propose $\\mathrm { p } = 5$ for fully connected layers and $\\mathtt { p } = 8$ for convolutional layers. An illustration of the process can is shown in Fig. 4. Furthermore, the indexes will be compressed Hoffman encoding. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            838
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.3 STORING THE WEIGHT ARRAY A ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            442,
+            869
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In order to minimize the storage occupied by A. We quantize the values of A. Storing indexes in A and a consecutive codebook. Indexing can be improved further by again applying Huffman encoding. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/967d05c1ee545bf31e180b6cf4b3b53db00615e1a558cc6d8dbde06265e37d8f.jpg",
+        "image_caption": [
+            "Figure 4: Illustration of the process described in A.2. IC is represented by relative indexes(diff). If the a relative index is larger than $8 ( = 2 ^ { \\bar { 3 } } )$ , A will be filled with an additional zero. Figure from Han et al. (2015a). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            258,
+            103,
+            736,
+            199
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B CONFIGURING THE HYPER-PRIORS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            301,
+            500,
+            319
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 GAMMA DISTRIBUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            340,
+            383,
+            356
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The Gamma distribution is the conjugate prior for the precision of a univariate Gaussian distribution.   \nIt is defined for positive random variables $\\lambda > 0$ . ",
+        "bbox": [
+            171,
+            372,
+            823,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/35f452aa166244032383c71043b272ea6b78cfb5e84bdad053bc49ded8c36c12.jpg",
+        "text": "$$\n\\Gamma ( \\lambda | \\alpha , \\beta ) = \\frac { \\beta ^ { \\alpha } } { \\Gamma ( \\alpha ) } \\lambda ^ { \\alpha - 1 } e ^ { - \\beta \\lambda }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            417,
+            598,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For our purposes it is best characterised by its mode $\\lambda ^ { * } = \\frac { \\alpha - 1 } { \\beta }$ and its variance $\\operatorname { v a r } _ { \\gamma } = { \\frac { \\alpha } { \\beta ^ { 2 } } }$ I n our experiments we set the desired variance of the mixture components to 0.05. This corresponds to $\\lambda ^ { * } \\stackrel { - } { = } 1 / ( 0 . 0 5 ) ^ { 2 } = 4 0 0$ . We show the effect of different choices for the variance of the Gamma distribution in Figure 5. ",
+        "bbox": [
+            173,
+            477,
+            826,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/2fedb28eefbd0883b40013cbd6042a6a9179fd6fe06521759b16e872c3976948.jpg",
+        "image_caption": [
+            "Figure 5: Gamma distribution with $\\lambda ^ { * } ~ = ~ 1 0 0$ . $\\alpha$ and $\\beta$ correspond to different choices for the variance of the distribution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            571,
+            821,
+            845
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 BETA DISTRIBUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            362,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The Beta distribution is the conjugate prior for the Bernoulli distribution, thus is often used to represent the probability for a binary event. It is defined for some random variable $\\pi _ { j = 0 } \\in [ 0 , 1 ]$ ",
+        "bbox": [
+            169,
+            131,
+            825,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2f3a4c41d5fd42d5491db87b51802adc87f933d5c8c0fbc17a77da1e7df84692.jpg",
+        "text": "$$\n\\mathcal { B } ( \\pi _ { j = 0 } | \\alpha , \\beta ) = \\frac { \\Gamma ( \\alpha + \\beta ) } { \\Gamma ( \\alpha ) \\Gamma ( \\beta ) } ( \\pi _ { j = 0 } ) ^ { \\alpha - 1 } ( 1 - \\pi _ { j = 0 } ) ^ { \\beta - 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            169,
+            676,
+            204
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "with $\\alpha , \\beta \\ > \\ 0$ . $\\alpha$ and $\\beta$ can be interpreted as the effective number of observations prior to an experiment, of $\\pi _ { j = 0 } = 1$ and $\\pi _ { j = 0 } = 0$ , respectively. In the literature, $\\alpha + \\beta$ is defined as the pseudo-count. The higher the pseudo-count the stronger the prior. In Figure 6, we show the Beta distribution at constant mode $\\pi _ { j = 0 } ^ { * } = \\frac { \\alpha - 1 } { \\alpha + \\beta - 2 } = 0 . 9$ . Note, that, the beta distribution is a special case of the Dirichlet distribution in a different problem setting it might be better to rely on this distribution to control all $\\pi _ { j }$ . ",
+        "bbox": [
+            173,
+            212,
+            826,
+            311
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb22eba7ee7a7216b148cabc5af0ccbc7462a7dbb5d9204749c1581c7c945cfb.jpg",
+        "image_caption": [
+            "Figure 6: Beta distribution with $\\pi _ { j = 0 } ^ { * } = 0 . 9$ . $\\alpha$ and $\\beta$ correspond to different choices for the pseudocount. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            332,
+            818,
+            606
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C SCALABILITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            695,
+            325,
+            712
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Neural Networks are usually trained with a form of batch gradient decent (GD) algorithm. These methods fall into the umbrella of stochastic optimization (Robbins $\\&$ Monro, 1951). Here the model parameters $\\mathbf { W }$ are updated iteratively. At each iteration $t$ , a set of $B$ data instances is used to compute a noisy approximation of the posterior derivative with respect to $\\mathbf { W }$ given all data instances $N$ . ",
+        "bbox": [
+            174,
+            728,
+            825,
+            785
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1737f741406d56d4c9c8db69a30deb743d7c9b7331c66ddaf6678cc83f185512.jpg",
+        "text": "$$\n\\nabla _ { \\mathbf { W } } \\log p ( \\mathbf { W } | \\mathcal { D } ) = \\frac { N } { B } \\sum _ { n = 1 } ^ { B } \\nabla _ { \\mathbf { W } } \\log p ( \\mathbf { t } _ { n } | \\mathbf { x } _ { n } , \\mathbf { w } ) + \\sum _ { i = 1 } ^ { I } \\nabla _ { \\mathbf { W } } \\log p ( w _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            794,
+            722,
+            838
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "This gradient approximation can subsequently be used in various update schemes such as simple GD. ",
+        "bbox": [
+            174,
+            845,
+            821,
+            875
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For large models estimating the prior gradient can be an expensive operation. This is why we propose to apply similar measures for the gradient estimation of the prior as we did for the likelihood term. To do so, we sample $\\mathbf { K }$ weights randomly. The noisy approximation of the posterior derivative is ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "now: ",
+        "bbox": [
+            173,
+            104,
+            209,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b54f177608dd44d454b2d4cca223adeb4466cd15c6907b8ad33741ea0e04c7b.jpg",
+        "text": "$$\n\\nabla _ { \\mathbf { W } } \\log p ( \\mathbf { W } | \\mathcal { D } ) = \\frac { N } { B } \\sum _ { n = 1 } ^ { B } \\nabla _ { \\mathbf { w } } \\log p ( \\mathbf { t } _ { n } | \\mathbf { x } _ { n } , \\mathbf { w } ) + \\frac { I } { K } \\sum _ { i = 1 } ^ { K } \\nabla _ { \\mathbf { w } } \\log p ( w _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            122,
+            733,
+            166
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D FILTER VISUALISATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            181,
+            408,
+            198
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Figure D we show the pre-trained and compressed filters for the first and second layers of LeNet5-Caffe. For some of the feature maps from layer 2 seem to be redundant hence the almost empty columns. In Figure D we show the pre-trained and compressed filters for the first and second layers of LeNet-300-100. ",
+        "bbox": [
+            173,
+            213,
+            823,
+            268
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/2d79616dc4994d71c20571be67f8d8cf0e2083ec9b4c242efabdf8774c606032.jpg",
+        "image_caption": [
+            "Figure 7: Convolution filters from LeNet-5-Caffe. Left: Pre-trained filters. Right: Compressed filters. The top filters are the 20 first layer convolution weights; the bottom filters are the 20 by 50 convolution weights of the second layer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            196,
+            797,
+            776
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/d76996240a46681f55f0e1b612c41b39ea04f303b875a74effbeff5ef9fd1f26.jpg",
+        "image_caption": [
+            "Figure 8: Feature filters for LeNet-300-100. Left: Pre-trained filters. Right: Compressed filters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            193,
+            485,
+            794
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/7ecb0ba3ec00310a1cdf97893c7d3ec5e1e886c75fb0891f197f03a357b0b852.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            547,
+            193,
+            802,
+            787
+        ],
+        "page_idx": 15
+    }
+]

parse/train/HkuVu3ige/HkuVu3ige.md

@@ -0,0 +1,253 @@
+# ON ORTHOGONALITY AND LEARNING RECURRENTNETWORKS WITH LONG TERM DEPENDENCIES
+
+Eugene Vorontsov 1,2, Chiheb Trabelsi 1,2, Samuel Kadoury 1,3, Chris Pal 1,2
+
+1 Ecole Polytechnique de Montr ´ eal, Montr ´ eal, Canada ´ 2 Montreal Institute for Learning Algorithms, Montreal, Canada ´ 3 CHUM Research Center, Montreal, Canada ´ {eugene.vorontsov, chiheb.trabelsi, samuel.kadoury, christopher.pal}@polymtl.ca
+
+# ABSTRACT
+
+It is well known that it is challenging to train deep neural networks and recurrent neural networks for tasks that exhibit long term dependencies. The vanishing or exploding gradient problem is a well known issue associated with these challenges. One approach to addressing vanishing and exploding gradients is to use either soft or hard constraints on weight matrices so as to encourage or enforce orthogonality. Orthogonal matrices preserve gradient norm during backpropagation and can therefore be a desirable property; however, we find that hard constraints on orthogonality can negatively affect the speed of convergence and model performance. This paper explores the issues of optimization convergence, speed and gradient stability using a variety of different methods for encouraging or enforcing orthogonality. In particular we propose a weight matrix factorization and parameterization strategy through which we can bound matrix norms and therein control the degree of expansivity induced during backpropagation.
+
+# 1 INTRODUCTION
+
+The depth of deep neural networks confers representational power, but also makes model optimization more challenging. Training deep networks with gradient descent based methods is known to be difficult as a consequence of the vanishing and exploding gradient problem (Hochreiter & Schmidhuber, 1997). Typically, exploding gradients are avoided by clipping large gradients (Pascanu et al., 2013) or introducing an $L _ { 2 }$ or $L _ { 1 }$ weight norm penalty. The latter has the effect of bounding the spectral radius of the linear transformations, thus limiting the maximal gain across the transformation. Krueger & Memisevic (2015) attempt to stabilize the norm of propagating signals directly by penalizing differences in successive norm pairs in the forward pass and Pascanu et al. (2013) propose to penalize successive gradient norm pairs in the backward pass. These regularizers affect the network parameterization with respect to the data instead of penalizing weights directly.
+
+Both expansivity and contractivity of linear transformations can also be limited by more tightly bounding their spectra. By limiting the transformations to be orthogonal, their singular spectra are limited to unitary gain causing the transformations to be norm-preserving. Le et al. (2015) and Henaff et al. (2016) have respectively shown that identity initialization and orthogonal initialization can be beneficial. Arjovsky et al. (2015) have gone beyond initialization, building unitary recurrent neural network (RNN) models with transformations that are unitary by construction which they achieved by composing multiple basic unitary transformations. The resulting transformations, for some n-dimensional input, cover only some subset of possible $n \times n$ unitary matrices but appear to perform well on simple tasks and have the benefit of having low complexity in memory and computation.
+
+The entire set of possible unitary or orthogonal parameterizations forms the Stiefel manifold. At a much higher computational cost, gradient descent optimization directly along this manifold can be done via geodesic steps (Nishimori, 2005; Tagare, 2011). Recent work (Wisdom et al., 2016) has proposed the optimization of unitary matrices along the Stiefel manifold using geodesic gradient descent. To produce a full-capacity parameterization for unitary matrices they use some insights from Tagare (2011), combining the use of a canonical inner products and Cayley transformations. Their experimental work indicates that full capacity unitary RNN models can solve the copy memory problem whereas both LSTM networks and restricted capacity unitary RNN models having similar complexity appear unable to solve the task for a longer sequence length ( $T = 2 0 0 0$ ).
+
+In contrast, here we explore the optimization of real valued matrices within a configurable margin about the Stiefel manifold. We suspect that a strong constraint of orthogonality limits the model’s representational power, hindering its performance, and may make optimization more difficult. We explore this hypothesis empirically by employing a factorization technique that allows us to limit the degree of deviation from the Stiefel manifold. While we use geodesic gradient descent, we simultaneously update the singular spectra of our matrices along Euclidean steps, allowing optimization to step away from the manifold while still curving about it.
+
+# 1.1 VANISHING AND EXPLODING GRADIENTS
+
+The issue of vanishing and exploding gradients as it pertains to the parameterization of neural networks can be illuminated by looking at the gradient back-propagation chain through a network.
+
+A neural network with $n$ hidden layers has pre-activations
+
+$$
+\mathbf { a } _ { i } ( \mathbf { h } _ { i - 1 } ) = \mathbf { W } _ { i } \mathbf { \ h } _ { i - 1 } + \mathbf { \ b } _ { i } , \ i \in \{ 2 , \cdots , n \}
+$$
+
+For notational convenience, we combine parameters $\mathbf { W } _ { i }$ and $\mathbf { b } _ { i }$ to form an affine matrix θ. We can see that for some loss function $L$ at layer $n$ , the derivative with respect to parameters $\theta _ { i }$ is:
+
+$$
+\frac { \partial { \cal L } } { \partial \Theta _ { i } } = \frac { \partial { \bf a } _ { n + 1 } } { \partial \Theta _ { i } } \frac { \partial { \cal L } } { \partial { \bf a } _ { n + 1 } }
+$$
+
+The partial derivatives for the pre-activations can be decomposed as follows:
+
+$$
+\begin{array} { r l r } {  { \frac { \partial \mathbf { a } _ { i + 1 } } { \partial \mathbf { \boldsymbol { \Theta } } _ { i } } = \frac { \partial \mathbf { a } _ { i } } { \partial \mathbf { \boldsymbol { \Theta } } _ { i } } \frac { \partial \mathbf { h } _ { i } } { \partial \mathbf { a } _ { i } } \frac { \partial \mathbf { a } _ { i + 1 } } { \partial \mathbf { h } _ { i } } } } \\ & { } & { = \frac { \partial \mathbf { a } _ { i } } { \partial \mathbf { \boldsymbol { \Theta } } _ { i } } \mathbf { \boldsymbol { D } } _ { i } \mathbf { \boldsymbol { W } } _ { i + 1 } \to \frac { \partial \mathbf { a } _ { i + 1 } } { \partial \mathbf { a } _ { i } } = \mathbf { \boldsymbol { D } } _ { i } \mathbf { \boldsymbol { W } } _ { i + 1 } , } \end{array}
+$$
+
+where $\mathbf { D _ { i } }$ is the Jacobian corresponding to the activation function, containing partial derivatives of the hidden units at layer $i + 1$ with respect to the pre-activation inputs. Typically, $\mathbf { D }$ is diagonal. Following the above, the gradient in equation 2 can be fully decomposed into a recursive chain of matrix products:
+
+$$
+\frac { \partial L } { \partial \pmb { \theta } _ { i } } = \frac { \partial \mathbf { a } _ { i } } { \partial \pmb { \theta } _ { i } } \prod _ { j = i } ^ { n } ( \mathbf { D } _ { j } \mathbf { W } _ { j + 1 } ) \frac { \partial L } { \partial \mathbf { a } _ { n + 1 } }
+$$
+
+In (Pascanu et al., 2013), it is shown that the 2-norm of $\frac { \partial \mathbf { a } _ { i + 1 } } { \partial \mathbf { a } _ { i } }$ is bounded by the product of the norms of the non-linearity’s Jacobian and transition matrix at time $t$ (layer $i$ ), as follows:
+
+$$
+\left\| \frac { \partial \mathbf { a } _ { t + 1 } } { \partial \mathbf { a } _ { t } } \right\| \leq \left\| \mathbf { D } _ { t } \right\| \left\| \mathbf { W } _ { t } \right\| \leq \lambda _ { \mathbf { D } _ { t } } \lambda _ { \mathbf { W } _ { t } } = \eta _ { t } ,
+$$
+
+where $\lambda _ { \mathbf { D } _ { t } }$ and $\lambda _ { \mathbf { W } _ { t } }$ are the largest singular values of the non-linearity’s Jacobian $\mathbf { D } _ { t }$ and the transition matrix $\mathbf { W } _ { t }$ . In RNNs, $\mathbf { W } _ { t }$ is shared across time and can be simply denoted as $\mathbf { W }$ .
+
+Equation 5 shows that the gradient can grow or shrink at each layer depending on the gain of each layer’s linear transformation $\mathbf { W }$ and the gain of the Jacobian $\mathbf { D }$ . The gain caused by each layer is magnified across all time steps or layers. It is easy to have extreme amplification in a recurrent neural network where $\mathbf { W }$ is shared across time steps and a non-unitary gain in W is amplified exponentially. The phenomena of extreme growth or contraction of the gradient across time steps or layers are known as the exploding and the vanishing gradient problems, respectively. It is sufficient for RNNs to have $\eta _ { t } \leq 1$ at each time $t$ to enable the possibility of vanishing gradients, typically for some large number of time steps $T$ . The rate at which a gradient (or forward signal) vanishes depends on both the parameterization of the model and on the input data. The parameterization may be conditioned by placing appropriate constraints on W. It is worth keeping in mind that the Jacobian $\mathbf { D }$ is typically contractive, thus tending to be norm-reducing) and is also data-dependent, whereas W can vary from being contractive to norm-preserving, to expansive and applies the same gain on the forward signal as on the back-propagated gradient signal.
+
+# 2 OUR APPROACH
+
+Vanishing and exploding gradients can be controlled to a large extent by controlling the maximum and minimum gain of $\mathbf { W }$ . The maximum gain of a matrix $\mathbf { W }$ is given by the spectral norm which is given by
+
+$$
+| | \mathbf { W } | | _ { 2 } = \operatorname* { m a x } \left[ \frac { | | \mathbf { W } \mathbf { x } | | } { | | \mathbf { x } | | } \right] .
+$$
+
+By keeping our weight matrix W close to orthogonal, one can ensure that it is close to a normpreserving transformation (where the spectral norm is equal to one, but the minimum gain is also one). One way to achieve this is via a simple soft constraint or regularization term of the form:
+
+$$
+\lambda \sum _ { i } | | \mathbf { W } _ { i } ^ { T } \mathbf { W } _ { i } - \mathbf { I } | | ^ { 2 } .
+$$
+
+However, it is possible to formulate a more direct parameterization or factorization for W which permits hard bounds on the amount of expansion and contraction induced by W. This can be achieved by simply parameterizing $\mathbf { W }$ according to its singular value decomposition, which consists of the composition of orthogonal basis matrices $\mathbf { U }$ and $\mathbf { V }$ with a diagonal spectral matrix S containing the singular values which are real and positive by definition. We have
+
+$$
+\mathbf { W } = \mathbf { U } \mathbf { S } \mathbf { V } ^ { T } .
+$$
+
+Since the spectral norm or maximum gain of a matrix is equal to its largest singular value, this decomposition allows us to control the maximum gain or expansivity of the weight matrix by controlling the magnitude of the largest singular value. Similarly, the minimum gain or contractivity of a matrix can be obtained from the minimum singular value.
+
+We can keep the bases $\mathbf { U }$ and $\mathbf { V }$ orthogonal via geodesic gradient descent along the set of weights that satisfy $\mathbf { \dot { U } } ^ { T } \mathbf { U } = \mathbf { I }$ and $\mathbf { V } ^ { T } \mathbf { V } = \mathbf { I }$ respectively. The submanifolds that satisfy these constraints are called Stiefel manifolds. We discuss how this is achieved in more detail below, then discuss our construction for bounding the singular values.
+
+During optimization, in order to maintain the orthogonality of an orthogonally-initialized matrix M, i.e. where $\mathbf { M } = \mathbf { U }$ , $\mathbf { M } = \mathbf { V }$ or $\mathbf { M } = \mathbf { W }$ if so desired, we employ a Cayley transformation of the update step onto the Stiefel manifold of (semi-)orthogonal matrices, as in Nishimori (2005) and Tagare (2011). Given an orthogonally-initialized parameter matrix $\mathbf { M }$ and its Jacobian, $\mathbf { G }$ with respect to the objective function, an update is performed as follows:
+
+$$
+\begin{array} { l } { \mathbf { A } = \mathbf { G } \mathbf { M } ^ { T } - \mathbf { M } \mathbf { G } ^ { T } } \\ { \mathbf { M } _ { n e w } = \mathbf { M } + ( \mathbf { I } + \frac { \eta } { 2 } \mathbf { A } ) ^ { - 1 } ( \mathbf { I } - \frac { \eta } { 2 } \mathbf { A } ) , } \end{array}
+$$
+
+where $\mathbf { A }$ is a skew-symmetric matrix (that depends on the Jacobian and on the parameter matrix) which is mapped to an orthogonal matrix via a Cayley transform and $\eta$ is the learning rate.
+
+While the update rule in (9) allows us to maintain an orthogonal hidden to hidden transition matrix W if desired, we are interested in exploring the effect of stepping away from the Stiefel manifold. As such, we parameterize the transition matrix W in factorized form, as a singular value decomposition with orthogonal bases $\mathbf { U }$ and $\mathbf { V }$ updated by geodesic gradient descent using the Cayley transform approach above.
+
+If W is an orthogonal matrix, the singular values in the diagonal matrix S are all equal to one. However, in our formulation we allow these singular values to deviate from one and employ a sigmoidal parameterization to apply a hard constraint on the maximum and minimum amount of deviation. Specifically, we define a margin $m$ around 1 within which the singular values must lie. This is achieved with the parameterization
+
+$$
+s _ { i } = 2 m ( \sigma ( p _ { i } ) - 0 . 5 ) + 1 , \qquad s _ { i } \in \{ \mathrm { d i a g } ( \mathbf { S } ) \} , \ m \in [ 0 , \ 1 ] .
+$$
+
+The singular values are thus restricted to the range $[ 1 - m , 1 + m ]$ and the underlying parameters $p _ { i }$ are updated freely via stochastic gradient descent. Note that this parameterization strategy also has implications on the step sizes that gradient descent based optimization will take when updating the singular values – they tend to be smaller compared to models with no margin constraining their values. Specifically, a singular value’s progression toward a margin is slowed the closer it is to the margin. The sigmoidal parameterization can also impart another effect on the step size along the spectrum which needs to be accounted for. Considering 10, the gradient backpropagation of some loss $L$ toward parameters $p _ { i }$ is found as
+
+$$
+\frac { d L } { d p _ { i } } = \frac { d s _ { i } } { d p _ { i } } \frac { d L } { d s _ { i } } = 2 m \frac { d \sigma ( p _ { i } ) } { d p _ { i } } \frac { d L } { d s _ { i } } .
+$$
+
+From (11), it can be seen that the magnitude of the update step for $p _ { i }$ is scaled by the margin hyperparameter $m$ . This means for example that for margins less than one, the effective learning rate for the spectrum is reduced in proportion to the margin. Consequently, we adjust the learning rate along the spectrum to be independent of the margin by renormalizing it by ${ \it 2 m }$ .
+
+This margin formulation both guarantees singular values lie within a well defined range and slows deviation from orthogonality. Alternatively, one could enforce the orthogonality of $\mathbf { U }$ and $\mathbf { V }$ and impose a regularization term corresponding to a mean one Gaussian prior on these singular values. This encourages the weight matrix W to be norm preserving with a controllable strength equivalent to the variance of the Gaussian. We also explore this approach further below.
+
+# 3 EXPERIMENTS
+
+In this section, we explore hard and soft orthogonality constraints on factorized weight matrices for recurrent neural network hidden to hidden transitions. With hard orthogonality constraints on $\mathbf { U }$ and $\mathbf { V }$ , we investigate the effect of widening the spectral margin or bounds on convergence and performance. Loosening these bounds allows increasingly larger margins within which the transition matrix W can deviate from orthogonality. We confirm that orthogonal initialization is useful as noted in Henaff et al. (2016), and we show that although strict orthogonality guarantees stable gradient norm, loosening orthogonality constraints can increase the rate of gradient descent convergence. We begin our analyses on tasks that are designed to stress memory: a sequence copying task and a basic addition task (Hochreiter & Schmidhuber, 1997). We then move on to tasks on real data that require models to capture long-range dependencies: digit classification based on sequential and permuted MNIST vectors (Le et al., 2015; LeCun et al., 1998). Finally, we look at a basic language modeling task using the Penn Treebank dataset (Marcus et al., 1993).
+
+The copy and adding tasks, introduced by Hochreiter & Schmidhuber (1997), are synthetic benchmarks with pathologically hard long distance dependencies that require long-term memory in models. The copy task consists of an input sequence that must be remembered by the network, followed by a series of blank inputs terminated by a delimiter that denotes the point at which the network must begin to output a copy of the initial sequence. We use an input sequence of $T + 2 0$ elements that begins with a sub-sequence of 10 elements to copy, each containing a symbol $a _ { i } \in \{ a _ { 1 } , . . . , a _ { p } \}$ out of $p = \delta$ possible symbols. This sub-sequence is followed by $T - 1$ elements of the blank category $a _ { \theta }$ which is terminated at step $T$ by a delimiter symbol $a _ { p + 1 }$ and 10 more elements of the blank category. The network must learn to remember the initial 10 element sequence for $T$ time steps and output it after receiving the delimiter symbol.
+
+The goal of the adding task is to add two numbers together after a long delay. Each number is randomly picked at a unique position in a sequence of length $T$ . The sequence is composed of $T$ values sampled from a uniform distribution in the range $[ 0 , 1 )$ , with each value paired with an indicator value that identifies the value as one of the two numbers to remember (marked 1) or as a value to ignore (marked 0). The two numbers are positioned randomly in the sequence, the first in the range $[ 0 , \frac { T } { 2 } - 1 ]$ and the second in the range $\begin{array} { r l r } {  { [ \frac { T } { 2 } , T - 1 ] } } \end{array}$ , where 0 marks the first element. The network must learn to identify and remember the two numbers and output their sum.
+
+The sequential MNIST task from Le et al. (2015), MNIST digits are flattened into vectors that can be traversed sequentially by a recurrent neural network. The goal is to classify the digit based on the sequential input of pixels. The simple variant of this task is with a simple flattening of the image matrices; the harder variant of this task includes a random permutation of the pixels in the input vector that is determined once for an experiment. The latter formulation introduces longer distance dependencies between pixels that must be interpreted by the classification model.
+
+The English Penn Treebank (PTB) dataset from Marcus et al. (1993) is an annotated corpus of English sentences, commonly used for benchmarking language models. We employ a sequential character prediction task: given a sentence, a recurrent neural network must predict the next character at each step, from left to right. We use input sequences of variable length, with each sequence containing one sentence. We model 49 characters including lowercase letters (all strings are in lowercase), numbers, common punctuation, and an unknown character placeholder. In our experiments on two subsets of the data: in the first, we first use $23 \%$ of the data with strings with up to 75 characters and in the second we include over $9 9 \%$ of the dataset, picking strings with up to 300 characters.
+
+# 3.1 LOOSENING HARD ORTHOGONALITY CONSTRAINTS
+
+In this section, we experimentally explore the effect of loosening hard orthogonality constraints through loosening the spectral margin defined above for the hidden to hidden transition matrix.
+
+In all experiments, we employed RMSprop (Tieleman & Hinton, 2012) when not using geodesic gradient descent. We used minibatches of size 50 and for generated data (the copy and adding tasks), we assumed an epoch length of 100 minibatches. We cautiously introduced gradient clipping at magnitude 100 (unless stated otherwise) in all of our RNN experiments although it may not be required and we consistently applied a small weight decay of 0.0001. Unless otherwise specified, we trained all simple recurrent neural networks with the hidden to hidden matrix factorization as in (8) using geodesic gradient descent on the bases (learning rate $1 0 ^ { - 6 }$ ) and RMSprop on the other parameters (learning rate 0.0001), using a tanh transition nonlinearity, and clipping gradients of 100 magnitude. The neural network code was built on the Theano framework (Theano Development Team, 2016). When parameterizing a matrix in factorized form, we apply the weight decay on the composite matrix rather than on the factors in order to be consistent across experiments. For MNIST and PTB, test set metrics were computed based on the parameterization that gave the best validation set accuracy.
+
+# 3.1.1 CONVERGENCE ON SYNTHETIC MEMORY TASKS
+
+For different sequence lengths $T$ of the copy and adding tasks, we trained a factorized RNN with 128 hidden units and various spectral margins $m$ . For the copy task, we used Elman networks without a transition non-linearity as in Henaff et al. (2016). We discuss our investigations into the use of a non-linearity on the copy task in the Appendix.
+
+As shown in Figure 1 we see an increase in the rate of convergence as we increase the spectral margin. This observation generally holds across the tested sequence lengths ( $T = 2 0 0$ , $T \stackrel { = } { = } 5 0 0$ , $T = 1 0 0 0 , \ T = 1 0 0 0 0 )$ ; however, large spectral margins hinder convergence on extremely long sequence lengths. At sequence length $T = 1 0 0 0 0$ , parameterizations with spectral margins larger than 0.001 converge slower than when using a margin of 0.001. In addition, the experiment without a margin failed to converge on the longest sequence length. This follows the expected pattern where stepping away from the Stiefel manifold may help with gradient descent optimization but loosening orthogonality constraints can reduce the stability of signal propagation through the network.
+
+For the adding task, we trained a factorized RNN on $T = 1 0 0 0$ length sequences, using a ReLU activation function on the hidden to hidden transition matrix. The mean squared error (MSE) is shown for different spectral margins in Figure 5 in the Appendix. Testing spectral margins $m = 0$ , $m = 1 , \ m = 1 0 , \ m = 1 0 0$ , and no margin, we find that the models with the purely orthogonal ( $\mathrm { ~ m ~ } = 0$ ) and the unconstrained (no margin) transition matrices failed to begin converging beyond baseline MSE within 2000 epochs.
+
+![](images/bedb92ba810d6f82c67aaac3918c6706b07e966d8d209fab7a969dfdb8a2a818.jpg)  
+Figure 1: Accuracy curves on the copy task for sequence lengths of (from left to right) ${ \mathrm { T } } { = } 2 0 0$ , $\mathrm { T } { = } 5 0 0$ , $\scriptstyle \mathrm { T = 1 0 0 0 }$ , $\scriptstyle \mathrm { T = 1 0 0 0 0 }$ given different spectral margins. Convergence speed increases with margin size; however, large margin sizes are ineffective at longer sequence lengths $\mathrm { { T } = 1 0 0 0 0 }$ , right).
+
+Table 1: Ordered sequential MNIST classification with different margin sizes and an LSTM.   
+
+<table><tr><td>margin</td><td>initialization</td><td>accuracy</td></tr><tr><td>0</td><td>orthogonal</td><td>77.18</td></tr><tr><td>0.001</td><td>orthogonal</td><td>79.26</td></tr><tr><td>0.01</td><td>orthogonal</td><td>85.47</td></tr><tr><td>0.1</td><td>orthogonal</td><td>94.10</td></tr><tr><td>1</td><td>orthogonal</td><td>93.84</td></tr><tr><td>none</td><td>orthogonal</td><td>93.24</td></tr><tr><td>none</td><td>Glorot normal</td><td>66.71</td></tr><tr><td>none</td><td>identity</td><td>53.53</td></tr><tr><td></td><td>LSTM</td><td>97.30</td></tr></table>
+
+Table 2: Permuted sequential MNIST classification with different margin sizes and an LSTM.   
+
+<table><tr><td>margin</td><td>initialization</td><td>accuracy</td></tr><tr><td>0</td><td>orthogonal</td><td>83.56</td></tr><tr><td>0.001 0.01</td><td>orthogonal</td><td>84.59 89.63</td></tr><tr><td>0.1</td><td>orthogonal orthogonal</td><td>91.44</td></tr><tr><td>1</td><td>orthogonal</td><td>90.83</td></tr><tr><td>none</td><td>orthogonal</td><td>90.51</td></tr><tr><td>none</td><td>Glorot normal</td><td>79.33</td></tr><tr><td>none</td><td>identity</td><td></td></tr><tr><td></td><td>LSTM</td><td>42.72 92.62</td></tr></table>
+
+# 3.1.2 PERFORMANCE ON REAL DATA
+
+Having confirmed that an orthogonality constraint can negatively impact convergence rate, we seek to investigate the effect on model performance for tasks on real data. We show the results of experiments on permuted sequential MNIST in Table 2 and ordered sequential MNIST in Table 1. The loss curves are shown in Figure 6 in the Appendix and reveal an increased convergence rate for larger spectral margins. We trained the factorized RNN models with 128 hidden units for 120 epochs. We also trained an LSTM with 128 hidden units on both tasks for 150 epochs, configured with peephole connections, orthogonally initialized (and forget gate bias initialized to one), and trained with RMSprop (learning rate 0.0001, clipping gradients of magnitude 1).
+
+We show the results of experiments on PTB character prediction, in terms of bits per character (bpc) and prediction accuracy, for a subset of short sequences (up to 75 characters; $23 \%$ of data) in Table 3 and for a subset of long sequences (up to 300 characters; $9 9 \%$ of data) in Table 4. We trained factorized RNN models with 512 hidden units for 200 epochs with geodesic gradient descent on the bases (learning rate $1 0 ^ { - 6 }$ ) and RMSprop on the other parameters (learning rate 0.001), using a tanh transition nonlinearity, and clipping gradients of 30 magnitude.
+
+Interestingly, for both the ordered and permuted sequential MNIST tasks, models with a non-zero margin significantly outperform those that are constrained to have purely orthogonal transition matrices (margin of zero). The best results on both the ordered and sequential MNIST tasks were yielded by models with a spectral margin of 0.1, at $9 4 . 1 0 \%$ accuracy and $9 1 . 4 4 \%$ accuracy, respectively. An LSTM outperformed the RNNs in both tasks; nevertheless, RNNs with hidden to hidden transitions initialized as orthogonal matrices performed admirably without a memory component and without all of the additional parameters associated with gates. Indeed, orthogonally initialized RNNs performed almost on par with the LSTM in the permuted sequential MNIST task which presents longer distance dependencies than the ordered task. Although the optimal margin appears to be 0.1, RNNs with large margins perform almost identically to an RNN without a margin, as long as the transition matrix is initialized as orthogonal. On these tasks, orthogonal initialization appears to significantly outperform Glorot normal initialization (Glorot & Bengio, 2010) or initializing the matrix as identity. It is interesting to note that for the MNIST tasks, orthogonal initialization appears useful while orthogonality constraints appear mainly detrimental. This suggests that while orthogonality helps early training by stabilizing gradient flow across many time steps, orthogonality constraints may need to be loosened on some tasks so as not to over-constrain the model’s representational ability.
+
+Table 3: Character prediction on PTB sentences of to 75 characters, using different margins.   
+
+<table><tr><td>margin</td><td>initialization</td><td>bpc</td><td>accuracy</td></tr><tr><td>0</td><td>orthogonal</td><td>2.16</td><td>55.31</td></tr><tr><td>0.01</td><td>orthogonal</td><td>2.16</td><td>55.33</td></tr><tr><td>0.1</td><td>orthogonal</td><td>2.12</td><td>55.37</td></tr><tr><td>1</td><td>orthogonal</td><td>2.06</td><td>57.07</td></tr><tr><td>100</td><td>orthogonal</td><td>2.04</td><td>57.51</td></tr><tr><td>none</td><td>orthogonal</td><td>2.06</td><td>57.38</td></tr><tr><td>none</td><td>Glorot normal</td><td>2.08</td><td>57.37</td></tr><tr><td>none</td><td>identity</td><td>2.25</td><td>53.83</td></tr></table>
+
+Table 4: Character prediction on PTB sentences of up to 300 characters, using different margins.   
+
+<table><tr><td>margin</td><td>initialization bpc</td><td>accuracy</td></tr><tr><td>0</td><td>orthogonal 2.20</td><td>54.88</td></tr><tr><td>0.01</td><td>orthogonal 2.20</td><td>54.83</td></tr><tr><td>0.1</td><td>orthogonal 2.24</td><td>54.10</td></tr><tr><td>1</td><td>orthogonal 2.36</td><td>51.12</td></tr><tr><td>100</td><td>orthogonal 2.36</td><td>51.20</td></tr><tr><td>none</td><td>orthogonal 2.34</td><td>51.30</td></tr><tr><td>none</td><td>Glorot normal 2.34</td><td>51.04</td></tr><tr><td>none</td><td>identity 2.68</td><td>45.35</td></tr></table>
+
+Curiously, larger margins and even models without sigmoidal constraints on the spectrum (no margin) performed well as long as they were initialized to be orthogonal, suggesting that evolution away from orthogonality is not a serious problem on MNIST. It is not surprising that orthogonality is useful for the MNIST tasks since they depend on long distance signal propagation with a single output at the end of the input sequence. On the other hand, character prediction with PTB produces an output at every time step. Constraining deviation from orthogonality proved detrimental for short sentences (Table 3) and beneficial when long sentences were included (Table 4). Furthermore, Glorot normal initialization did not perform worse than orthogonal initialization for PTB. Since an output is generated for every character in a sentence, short distance signal propagation is possible. Thus it is possible that the RNN is first learning very local dependencies between neighbouring characters and that given enough context, constraining deviation from orthogonality can help force the network to learn longer distance dependencies.
+
+# 3.1.3 SPECTRAL AND GRADIENT EVOLUTION
+
+It is interesting to note that even long sequence lengths $( \mathrm { T } { = } 1 0 0 0 )$ ) in the copy task can be solved efficiently with rather large margins on the spectrum. In Figure 2 we look at the gradient propagation of the loss from the last time step in the network with respect to the hidden activations. We can see that for a purely orthogonal parameterization of the transition matrix (when the margin is zero), the gradient norm is preserved across time steps, as expected. We further observe that with increasing margin size, the number of update steps over which this norm preservation survives decreases, though surprisingly not as quickly as expected.
+
+![](images/e71e3ebaed3b5fd5794943085fc9dd1a230a8a632c97e25751f215ada0b27e31.jpg)  
+Figure 2: The norm of the gradient of the loss from the last time step with respect to the hidden units at a given time step for a length 220 RNN over 1000 update iterations for different margins. Iterations are along the abscissa and time steps are denoted along the ordinate. The first column margins are: 0, 0.001, 0.01. The second column margins are: 0.1, 1, no margin. Gradient norms are normalized across the time dimension.
+
+Although the deviation of singular values from one should be slowed by the sigmoidal parameterizations, even parameterizations without a sigmoid (no margin) can be effectively trained for all but the longest sequence lengths. This suggests that the spectrum is not deviating far from orthogonality and that inputs to the hidden to hidden transitions are mostly not aligned along the dimensions of greatest expansion or contraction. We evaluated the spread of the spectrum in all of our experiments and found that indeed, singular values tend to stay well within their prescribed bounds and only reach the margin when using a very large learning rate that does not permit convergence. Furthermore, when transition matrices are initialized as orthogonal, singular values remain near one throughout training even without a sigmoidal margin for tasks that require long term memory (copy, adding, sequential MNIST). On the other hand, singular value distributions tend to drift away from one for PTB character prediction which may help explain why enforcing an orthogonality constraint can be helpful for this task, when modeling long sequences. Interestingly, singular values spread out less for longer sequence lengths (nevertheless, the $\scriptstyle \mathrm { T = 1 0 0 0 0 }$ copy task could not be solved with no sigmoid on the spectrum).
+
+We visualize the spread of singular values for different model parameterizations on the permuted sequential MNIST task in Figure 3. Curiously, we find that the distribution of singular values tends to shift upward to a mean of approximately 1.05 on both the ordered and permuted sequential MNIST tasks. We note that in those experiments, a tanh transition nonlinearity was used which is contractive in both the forward signal pass and the gradient backward pass. An upward shift in the distribution of singular values of the transition matrix would help compensate for that contraction. Indeed, (Saxe et al., 2013) describe this as a possibly good regime for learning in deep neural networks. That the model appears to evolve toward this regime suggests that deviating from it may incur a cost. This is interesting because the cost function cannot take into account numerical issues such as vanishing or exploding gradients (or forward signals); we do not know what could make this deviation costly. That the transition matrix may be compensating for the contraction of the tanh is supported by further experiments: applying a 1.05 pre-activation gain appears to allow a model with a margin of 0 to nearly match the top performance reached on both of the MNIST tasks. Furthermore, when using the OPLU norm-preserving activation function (Chernodub & Nowicki, 2016), we found that orthogonally initialized models performed equally well with all margins, achieving over $90 \%$ accuracy on the permuted sequential MNIST task. Unlike orthgonally initialized models, the RNN on the bottom right of Figure 3 with Glorot normal initialized transition matrices, begins and ends with a wide singular spectrum. While there is no clear positive shift in the distribution of singular values, the mean value appears to very gradually increase for both the ordered and permuted sequential MNIST tasks. If the model is to be expected to positively shift singular values to compensate for the contractivity of the tanh nonlinearity, it is not doing so well for the Glorot-initialized case; however, this may be due to the inefficiency of training as a result of vanishing gradients, given that initialization.
+
+![](images/c37c480f2de6dda53baf106dd72e4b8f3118c713cf6c5957311a6d4222ee2528.jpg)  
+Figure 3: Singular value evolution on the permuted sequential MNIST task for factorized RNNs with different margin sizes. Margins are, from left to right: top row: 0.001, 0.01, 0.1; bottom row: 1, no margin, no margin. The singular value distributions are summarized with the mean (green line, center) and standard deviation (green shading about mean), minimum (red, bottom) and maximum (blue, top) values. All models are initialized with orthogonal hidden to hidden transition matrices except for the model on the bottom right where Glorot normal initialization is used.
+
+# 3.2 EXPLORING SOFT ORTHOGONALITY CONSTRAINTS
+
+Having established that it may indeed be useful to step away from orthogonality, here we explore two forms of soft constraints (rather than hard bounds as above) on hidden to hidden transition matrix orthogonality. The first is a simple penalty that directly encourages a transition matrix W to be orthogonal, of the form $\lambda | | \mathbf { W } ^ { T } \mathbf { W } \bar { \mathbf { \Lambda } } - \mathbf { I } | | _ { 2 } ^ { 2 }$ . This is similar to the orthogonality penalty introduced by Henaff et al. (2016). In the first two subfigures on the left of Figure 4, we explore the effect of weakening this form of regularization. We trained both a regular non-factorized RNN on the $T = 2 0 0$ copy task and a factorized RNN with orthogonal bases on the $T = 5 0 0$ copy task. For the regular RNN, we had to reduce the learning rate to $\mathrm { \bar { 1 0 } ^ { - 5 } }$ . Here again we see that weakening the strength of the orthogonality-encouraging penalty can increase convergence speed.
+
+![](images/687b45fda05840b6cde45ba158ba70663757e961b6ca8f4fafd56abe7466fd47.jpg)  
+Figure 4: Accuracy curves on the copy task for different strengths of soft orthogonality constraints. A soft orthogonality constraint is applied to the transition matrix W for a regular RNN on $T = 2 0 0$ (Left) and the same is applied on a factorized RNN on $T = 5 0 0$ (Left center). Another constraint in the form of a mean one Gaussian prior on the singular values is applied to a factorized RNN on $T = 2 0 0$ (Right center); the same is applied to a factorized RNN with a sigmoidal parameterization of the spectrum, using a large margin of 1 (Right). Loosening orthogonality speeds convergence.
+
+The second approach we explore replaces the sigmoidal margin parameterization with a mean one Gaussian prior on the singular values. In the two right subfigures of Figure 4, we visualize the accuracy on the length 200 copy task, using geoSGD (learning rate $1 0 ^ { - 6 }$ ) to keep $\mathbf { U }$ and $\mathbf { V }$ orthogonal and different strengths of a Gaussian prior with mean one on the singular values. We trained these experiments with regular SGD on the spectrum and other non-orthogonal parameter matrices, using a $\mathrm { i 0 ^ { - 5 } }$ learning rate. We see that priors which are too strong lead to slow convergence. Loosening the strength of the prior makes the optimization more efficient. Furthermore, we compare a direct parameterization of the spectrum (no sigmoid) in Figure 4 with a sigmoidal parameterization, using a large margin of 1. Without the sigmoidal parameterization, optimization quickly becomes unstable; on the other hand, the optimization also becomes unstable if the prior is removed completely in the sigmoidal formulation (margin 1). These results further motivate the idea that parameterizations that deviate from orthogonality may perform better than purely orthogonal ones, as long as they are sufficiently constrained to avoid instability during training.
+
+# 4 CONCLUSIONS
+
+We have explored a number of methods for controlling the expansivity of gradients during backpropagation based learning in RNNs through manipulating orthogonality constraints and regularization on matrices. Our experiments indicate that while orthogonal initialization may be beneficial, maintaining constraints on orthogonality can be detrimental. Indeed, moving away from hard constraints on matrix orthogonality can help improve optimization convergence rate and model performance. However, we also observe with synthetic tasks that relaxing regularization which encourages the spectral norms of weight matrices to be close to one, or allowing bounds on the spectral norms of weight matrices to be too wide, can reverse these gains and may lead to unstable optimization.
+
+# ACKNOWLEDGMENTS
+
+We thank the Natural Sciences and Engineeering Research Council (NSERC) of Canada and Samsung for supporting this research.
+
+# REFERENCES
+
+Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. arXiv preprint arXiv:1511.06464, 2015.
+
+Artem Chernodub and Dimitri Nowicki. Norm-preserving orthogonal permutation linear unit activation functions (oplu). arXiv preprint arXiv:1604.02313, 2016.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Aistats, volume 9, pp. 249–256, 2010.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026–1034, 2015.
+
+Mikael Henaff, Arthur Szlam, and Yann LeCun. Orthogonal rnns and long-memory tasks. arXiv preprint arXiv:1602.06662, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+David Krueger and Roland Memisevic. Regularizing rnns by stabilizing activations. arXiv preprint arXiv:1511.08400, 2015.
+
+Quoc V Le, Navdeep Jaitly, and Geoffrey E Hinton. A simple way to initialize recurrent networks of rectified linear units. arXiv preprint arXiv:1504.00941, 2015.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 19(2):313–330, 1993.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 807–814, 2010.
+
+Yasunori Nishimori. A note on riemannian optimization methods on the stiefel and the grassmann manifolds. dim, 1:2, 2005.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. ICML (3), 28:1310–1318, 2013.
+
+Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv preprint arXiv:1312.6120, 2013.
+
+Hemant D Tagare. Notes on optimization on stiefel manifolds. Technical report, Tech. Rep., Yale University, 2011.
+
+Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. URL http://arxiv.org/abs/ 1605.02688.
+
+T. Tieleman and G. Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012.
+
+Scott Wisdom, Thomas Powers, John R. Hershey, Jonathan Le Roux, and Les Atlas. Full-capacity unitary recurrent neural networks. To appear in NIPS, 2016.
+
+# 5 APPENDIX
+
+# 5.1 ADDITIONAL FIGURES
+
+![](images/dbbb26122d9c1b18baef9fb3969444306e99337b717346b55304b1882d89af7d.jpg)  
+Figure 5: Mean squared error (MSE) curves on the adding task for different spectral margins $m$ . For a trivial baseline solution of always outputting the same number, the expected baseline MSE is 0.167.
+
+![](images/ef5d2d8346b204d7aae860dfebe321ec6d017184dee170574f14d5165e374c93.jpg)  
+Figure 6: Loss curves for different factorized RNN parameterizations on the sequential MNIST task (left) and the permuted sequential MNIST task (right). The spectral margin is denoted by m; models with no margin have singular values that are directly optimized with no constraints; Glorot refers to a factorized RNN with no margin that is initialized with Glorot normal initialization.
+
+# 5.2 COPY TASK NONLINEARITY
+
+We found that nonlinearities such as a rectified linear unit (ReLU) (Nair & Hinton, 2010) or hyperbolic tangent (tanh) made the copy task far more difficult to solve. Using tanh, a short sequence length ( $T = 1 0 0$ ) copy task required both a soft constraint that encourages orthogonality and thousands of epochs for training. It is worth noting that in the unitary evolution recurrent neural network of Arjovsky et al. (2015), the non-linearity (referred to as the ”modReLU”) is actually initialized as an identity operation that is free to deviate from identity during training. Furthermore, Henaff et al. (2016) derive a solution mechanism for the copy task that drops the non-linearity from an RNN. To explore this further, we experimented with a parametric leaky ReLU activation function (PReLU) which introduces a trainable slope $\alpha$ for negative valued inputs $x$ , producing $f ( x ) = m a x ( x , 0 ) + \alpha m i n ( x , 0 )$ (He et al., 2015). Setting the slope $\alpha$ to one would make the PReLU equivalent to an identity function. We experimented with clamping $\alpha$ to 0.5, 0.7 or 1 in a factorized RNN with a spectral margin of 0.3 and found that only the model with $\alpha = 1$ solved the $T = 1 0 0 0$ length copy task. We also experimented with a trainable slope $\alpha$ , initialized to 0.7 and found that it converges to 0.96, further suggesting the optimal solution for the copy task is without a transition nonlinearity. Since the copy task is purely a memory task, one may imagine that a transition nonlinearity such as a tanh or ReLU may be detrimental to the task as it can lose information. Thus, we also tried a recent activation function that preserves information, called an orthogonal permutation linear unit (OPLU) (Chernodub & Nowicki, 2016). The OPLU preserves norm, making a fully norm-preserving RNN possible. Interestingly, this activation function allowed us to recover identical results on the copy task to those without a nonlinearity for different spectral margins.
+
+# 5.3 METHOD RUNNING TIME
+
+Although the method proposed in section 2 relies on a matrix inversion, an operation with $O ( n ^ { 3 } )$ complexity for an $\textbf { n } \times \textbf { n }$ matrix, the running time of an RNN factorized in such a way actually remains reasonable. This running time is summarized in Table 5 and includes all computations in the graph, together with the matrix inversion. As this method is meant to be used only for the analysis in this work, we find the running times acceptable for that purpose. Models were run on an Nvidia GTX-770 GPU and were run against the $\mathrm { T } { = } 1 0 0$ length copy task.
+
+Table 5: Run time in seconds for 1000 iterations on a $\mathrm { T } { = } 1 0 0$ copy task of a regular RNN trained with stochastic gradient descent (SGD) compared against a factorized RNN trained with geodesic SGD on the bases (geoSGD) and regular SGD for other parameters.   
+
+<table><tr><td>hidden units</td><td>SGD</td><td>geoSGD</td></tr><tr><td>128</td><td>21.9 ± 0.2</td><td>40.4 ± 0.1</td></tr><tr><td>500</td><td>46.7 ± 0.2</td><td>161.4 ± 0.2</td></tr><tr><td>1000</td><td>95.4 ± 0.3</td><td>711.2 ± 0.8</td></tr></table>

parse/train/HkuVu3ige/HkuVu3ige_content_list.json

@@ -0,0 +1,1334 @@
+[
+    {
+        "type": "text",
+        "text": "ON ORTHOGONALITY AND LEARNING RECURRENTNETWORKS WITH LONG TERM DEPENDENCIES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Eugene Vorontsov 1,2, Chiheb Trabelsi 1,2, Samuel Kadoury 1,3, Chris Pal 1,2 ",
+        "bbox": [
+            186,
+            167,
+            709,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Ecole Polytechnique de Montr ´ eal, Montr ´ eal, Canada ´ 2 Montreal Institute for Learning Algorithms, Montreal, Canada ´ 3 CHUM Research Center, Montreal, Canada ´ {eugene.vorontsov, chiheb.trabelsi, samuel.kadoury, christopher.pal}@polymtl.ca ",
+        "bbox": [
+            184,
+            186,
+            604,
+            257
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            294,
+            544,
+            309
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It is well known that it is challenging to train deep neural networks and recurrent neural networks for tasks that exhibit long term dependencies. The vanishing or exploding gradient problem is a well known issue associated with these challenges. One approach to addressing vanishing and exploding gradients is to use either soft or hard constraints on weight matrices so as to encourage or enforce orthogonality. Orthogonal matrices preserve gradient norm during backpropagation and can therefore be a desirable property; however, we find that hard constraints on orthogonality can negatively affect the speed of convergence and model performance. This paper explores the issues of optimization convergence, speed and gradient stability using a variety of different methods for encouraging or enforcing orthogonality. In particular we propose a weight matrix factorization and parameterization strategy through which we can bound matrix norms and therein control the degree of expansivity induced during backpropagation. ",
+        "bbox": [
+            233,
+            324,
+            764,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            336,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The depth of deep neural networks confers representational power, but also makes model optimization more challenging. Training deep networks with gradient descent based methods is known to be difficult as a consequence of the vanishing and exploding gradient problem (Hochreiter & Schmidhuber, 1997). Typically, exploding gradients are avoided by clipping large gradients (Pascanu et al., 2013) or introducing an $L _ { 2 }$ or $L _ { 1 }$ weight norm penalty. The latter has the effect of bounding the spectral radius of the linear transformations, thus limiting the maximal gain across the transformation. Krueger & Memisevic (2015) attempt to stabilize the norm of propagating signals directly by penalizing differences in successive norm pairs in the forward pass and Pascanu et al. (2013) propose to penalize successive gradient norm pairs in the backward pass. These regularizers affect the network parameterization with respect to the data instead of penalizing weights directly. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Both expansivity and contractivity of linear transformations can also be limited by more tightly bounding their spectra. By limiting the transformations to be orthogonal, their singular spectra are limited to unitary gain causing the transformations to be norm-preserving. Le et al. (2015) and Henaff et al. (2016) have respectively shown that identity initialization and orthogonal initialization can be beneficial. Arjovsky et al. (2015) have gone beyond initialization, building unitary recurrent neural network (RNN) models with transformations that are unitary by construction which they achieved by composing multiple basic unitary transformations. The resulting transformations, for some n-dimensional input, cover only some subset of possible $n \\times n$ unitary matrices but appear to perform well on simple tasks and have the benefit of having low complexity in memory and computation. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The entire set of possible unitary or orthogonal parameterizations forms the Stiefel manifold. At a much higher computational cost, gradient descent optimization directly along this manifold can be done via geodesic steps (Nishimori, 2005; Tagare, 2011). Recent work (Wisdom et al., 2016) has proposed the optimization of unitary matrices along the Stiefel manifold using geodesic gradient descent. To produce a full-capacity parameterization for unitary matrices they use some insights from Tagare (2011), combining the use of a canonical inner products and Cayley transformations. Their experimental work indicates that full capacity unitary RNN models can solve the copy memory problem whereas both LSTM networks and restricted capacity unitary RNN models having similar complexity appear unable to solve the task for a longer sequence length ( $T = 2 0 0 0$ ). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In contrast, here we explore the optimization of real valued matrices within a configurable margin about the Stiefel manifold. We suspect that a strong constraint of orthogonality limits the model’s representational power, hindering its performance, and may make optimization more difficult. We explore this hypothesis empirically by employing a factorization technique that allows us to limit the degree of deviation from the Stiefel manifold. While we use geodesic gradient descent, we simultaneously update the singular spectra of our matrices along Euclidean steps, allowing optimization to step away from the manifold while still curving about it. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            265
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 VANISHING AND EXPLODING GRADIENTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            281,
+            501,
+            295
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The issue of vanishing and exploding gradients as it pertains to the parameterization of neural networks can be illuminated by looking at the gradient back-propagation chain through a network. ",
+        "bbox": [
+            176,
+            306,
+            823,
+            335
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A neural network with $n$ hidden layers has pre-activations ",
+        "bbox": [
+            174,
+            342,
+            557,
+            357
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a78b85fbae00cb68c544b470e1c91f25b9d5d44a3ce3c59fd4a254e466493006.jpg",
+        "text": "$$\n\\mathbf { a } _ { i } ( \\mathbf { h } _ { i - 1 } ) = \\mathbf { W } _ { i } \\mathbf { \\ h } _ { i - 1 } + \\mathbf { \\ b } _ { i } , \\ i \\in \\{ 2 , \\cdots , n \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            363,
+            650,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For notational convenience, we combine parameters $\\mathbf { W } _ { i }$ and $\\mathbf { b } _ { i }$ to form an affine matrix θ. We can see that for some loss function $L$ at layer $n$ , the derivative with respect to parameters $\\theta _ { i }$ is: ",
+        "bbox": [
+            173,
+            386,
+            828,
+            415
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0c4ee2f4e2cbd43027d300cf8f7be076eee1c4e756802d71c3b7e577173a31d5.jpg",
+        "text": "$$\n\\frac { \\partial { \\cal L } } { \\partial \\Theta _ { i } } = \\frac { \\partial { \\bf a } _ { n + 1 } } { \\partial \\Theta _ { i } } \\frac { \\partial { \\cal L } } { \\partial { \\bf a } _ { n + 1 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            429,
+            575,
+            464
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The partial derivatives for the pre-activations can be decomposed as follows: ",
+        "bbox": [
+            174,
+            472,
+            674,
+            488
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/76383e751a5f8f99383e8822b5566f459b22330779718cfe7e6792a52446f95a.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\frac { \\partial \\mathbf { a } _ { i + 1 } } { \\partial \\mathbf { \\boldsymbol { \\Theta } } _ { i } } = \\frac { \\partial \\mathbf { a } _ { i } } { \\partial \\mathbf { \\boldsymbol { \\Theta } } _ { i } } \\frac { \\partial \\mathbf { h } _ { i } } { \\partial \\mathbf { a } _ { i } } \\frac { \\partial \\mathbf { a } _ { i + 1 } } { \\partial \\mathbf { h } _ { i } } } } \\\\ & { } & { = \\frac { \\partial \\mathbf { a } _ { i } } { \\partial \\mathbf { \\boldsymbol { \\Theta } } _ { i } } \\mathbf { \\boldsymbol { D } } _ { i } \\mathbf { \\boldsymbol { W } } _ { i + 1 } \\to \\frac { \\partial \\mathbf { a } _ { i + 1 } } { \\partial \\mathbf { a } _ { i } } = \\mathbf { \\boldsymbol { D } } _ { i } \\mathbf { \\boldsymbol { W } } _ { i + 1 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            492,
+            665,
+            560
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { D _ { i } }$ is the Jacobian corresponding to the activation function, containing partial derivatives of the hidden units at layer $i + 1$ with respect to the pre-activation inputs. Typically, $\\mathbf { D }$ is diagonal. Following the above, the gradient in equation 2 can be fully decomposed into a recursive chain of matrix products: ",
+        "bbox": [
+            174,
+            563,
+            825,
+            618
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8a720fe48f9732ed98f40f078816e34b61cb04d25e43ee91e92aef926501fc02.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial \\pmb { \\theta } _ { i } } = \\frac { \\partial \\mathbf { a } _ { i } } { \\partial \\pmb { \\theta } _ { i } } \\prod _ { j = i } ^ { n } ( \\mathbf { D } _ { j } \\mathbf { W } _ { j + 1 } ) \\frac { \\partial L } { \\partial \\mathbf { a } _ { n + 1 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            616,
+            616,
+            660
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In (Pascanu et al., 2013), it is shown that the 2-norm of $\\frac { \\partial \\mathbf { a } _ { i + 1 } } { \\partial \\mathbf { a } _ { i } }$ is bounded by the product of the norms of the non-linearity’s Jacobian and transition matrix at time $t$ (layer $i$ ), as follows: ",
+        "bbox": [
+            174,
+            671,
+            825,
+            713
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3907a2de2262911234ff4f428177d337b5803a9826f80f1e4a89f9cbe5998b4e.jpg",
+        "text": "$$\n\\left\\| \\frac { \\partial \\mathbf { a } _ { t + 1 } } { \\partial \\mathbf { a } _ { t } } \\right\\| \\leq \\left\\| \\mathbf { D } _ { t } \\right\\| \\left\\| \\mathbf { W } _ { t } \\right\\| \\leq \\lambda _ { \\mathbf { D } _ { t } } \\lambda _ { \\mathbf { W } _ { t } } = \\eta _ { t } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            717,
+            651,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { \\mathbf { D } _ { t } }$ and $\\lambda _ { \\mathbf { W } _ { t } }$ are the largest singular values of the non-linearity’s Jacobian $\\mathbf { D } _ { t }$ and the transition matrix $\\mathbf { W } _ { t }$ . In RNNs, $\\mathbf { W } _ { t }$ is shared across time and can be simply denoted as $\\mathbf { W }$ . ",
+        "bbox": [
+            169,
+            776,
+            821,
+            806
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Equation 5 shows that the gradient can grow or shrink at each layer depending on the gain of each layer’s linear transformation $\\mathbf { W }$ and the gain of the Jacobian $\\mathbf { D }$ . The gain caused by each layer is magnified across all time steps or layers. It is easy to have extreme amplification in a recurrent neural network where $\\mathbf { W }$ is shared across time steps and a non-unitary gain in W is amplified exponentially. The phenomena of extreme growth or contraction of the gradient across time steps or layers are known as the exploding and the vanishing gradient problems, respectively. It is sufficient for RNNs to have $\\eta _ { t } \\leq 1$ at each time $t$ to enable the possibility of vanishing gradients, typically for some large number of time steps $T$ . The rate at which a gradient (or forward signal) vanishes depends on both the parameterization of the model and on the input data. The parameterization may be conditioned by placing appropriate constraints on W. It is worth keeping in mind that the Jacobian $\\mathbf { D }$ is typically contractive, thus tending to be norm-reducing) and is also data-dependent, whereas W can vary from being contractive to norm-preserving, to expansive and applies the same gain on the forward signal as on the back-propagated gradient signal. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 OUR APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            339,
+            210
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Vanishing and exploding gradients can be controlled to a large extent by controlling the maximum and minimum gain of $\\mathbf { W }$ . The maximum gain of a matrix $\\mathbf { W }$ is given by the spectral norm which is given by ",
+        "bbox": [
+            174,
+            226,
+            825,
+            268
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf28505f55b28fc2b71138665ea1b8ed42af76bea4fe6ea2ae3d4feaf516be2f.jpg",
+        "text": "$$\n| | \\mathbf { W } | | _ { 2 } = \\operatorname* { m a x } \\left[ \\frac { | | \\mathbf { W } \\mathbf { x } | | } { | | \\mathbf { x } | | } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            267,
+            589,
+            310
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "By keeping our weight matrix W close to orthogonal, one can ensure that it is close to a normpreserving transformation (where the spectral norm is equal to one, but the minimum gain is also one). One way to achieve this is via a simple soft constraint or regularization term of the form: ",
+        "bbox": [
+            174,
+            319,
+            825,
+            362
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/763008042b3f7b473548bb3dcdbcc34cc4bbb3b08fd314705dbaa6f6619cb0a3.jpg",
+        "text": "$$\n\\lambda \\sum _ { i } | | \\mathbf { W } _ { i } ^ { T } \\mathbf { W } _ { i } - \\mathbf { I } | | ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            369,
+            576,
+            402
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, it is possible to formulate a more direct parameterization or factorization for W which permits hard bounds on the amount of expansion and contraction induced by W. This can be achieved by simply parameterizing $\\mathbf { W }$ according to its singular value decomposition, which consists of the composition of orthogonal basis matrices $\\mathbf { U }$ and $\\mathbf { V }$ with a diagonal spectral matrix S containing the singular values which are real and positive by definition. We have ",
+        "bbox": [
+            173,
+            409,
+            825,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5fca7fa842eb0c2303aa0842d14890288cefa5d99be3a2f9480f668972667c8c.jpg",
+        "text": "$$\n\\mathbf { W } = \\mathbf { U } \\mathbf { S } \\mathbf { V } ^ { T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            447,
+            487,
+            549,
+            503
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since the spectral norm or maximum gain of a matrix is equal to its largest singular value, this decomposition allows us to control the maximum gain or expansivity of the weight matrix by controlling the magnitude of the largest singular value. Similarly, the minimum gain or contractivity of a matrix can be obtained from the minimum singular value. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            569
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We can keep the bases $\\mathbf { U }$ and $\\mathbf { V }$ orthogonal via geodesic gradient descent along the set of weights that satisfy $\\mathbf { \\dot { U } } ^ { T } \\mathbf { U } = \\mathbf { I }$ and $\\mathbf { V } ^ { T } \\mathbf { V } = \\mathbf { I }$ respectively. The submanifolds that satisfy these constraints are called Stiefel manifolds. We discuss how this is achieved in more detail below, then discuss our construction for bounding the singular values. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            632
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "During optimization, in order to maintain the orthogonality of an orthogonally-initialized matrix M, i.e. where $\\mathbf { M } = \\mathbf { U }$ , $\\mathbf { M } = \\mathbf { V }$ or $\\mathbf { M } = \\mathbf { W }$ if so desired, we employ a Cayley transformation of the update step onto the Stiefel manifold of (semi-)orthogonal matrices, as in Nishimori (2005) and Tagare (2011). Given an orthogonally-initialized parameter matrix $\\mathbf { M }$ and its Jacobian, $\\mathbf { G }$ with respect to the objective function, an update is performed as follows: ",
+        "bbox": [
+            173,
+            638,
+            825,
+            709
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d33fc2ed34277af2b8346b440b1290de020bd8f83b1ff6e645674e231df3cdbe.jpg",
+        "text": "$$\n\\begin{array} { l } { \\mathbf { A } = \\mathbf { G } \\mathbf { M } ^ { T } - \\mathbf { M } \\mathbf { G } ^ { T } } \\\\ { \\mathbf { M } _ { n e w } = \\mathbf { M } + ( \\mathbf { I } + \\frac { \\eta } { 2 } \\mathbf { A } ) ^ { - 1 } ( \\mathbf { I } - \\frac { \\eta } { 2 } \\mathbf { A } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            714,
+            630,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { A }$ is a skew-symmetric matrix (that depends on the Jacobian and on the parameter matrix) which is mapped to an orthogonal matrix via a Cayley transform and $\\eta$ is the learning rate. ",
+        "bbox": [
+            176,
+            770,
+            821,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the update rule in (9) allows us to maintain an orthogonal hidden to hidden transition matrix W if desired, we are interested in exploring the effect of stepping away from the Stiefel manifold. As such, we parameterize the transition matrix W in factorized form, as a singular value decomposition with orthogonal bases $\\mathbf { U }$ and $\\mathbf { V }$ updated by geodesic gradient descent using the Cayley transform approach above. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If W is an orthogonal matrix, the singular values in the diagonal matrix S are all equal to one. However, in our formulation we allow these singular values to deviate from one and employ a sigmoidal parameterization to apply a hard constraint on the maximum and minimum amount of deviation. Specifically, we define a margin $m$ around 1 within which the singular values must lie. This is achieved with the parameterization ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f65096e05ae06cae23965c9cb6035bd41b466a16add33eb75efa8a1077d3134a.jpg",
+        "text": "$$\ns _ { i } = 2 m ( \\sigma ( p _ { i } ) - 0 . 5 ) + 1 , \\qquad s _ { i } \\in \\{ \\mathrm { d i a g } ( \\mathbf { S } ) \\} , \\ m \\in [ 0 , \\ 1 ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            138,
+            702,
+            156
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The singular values are thus restricted to the range $[ 1 - m , 1 + m ]$ and the underlying parameters $p _ { i }$ are updated freely via stochastic gradient descent. Note that this parameterization strategy also has implications on the step sizes that gradient descent based optimization will take when updating the singular values – they tend to be smaller compared to models with no margin constraining their values. Specifically, a singular value’s progression toward a margin is slowed the closer it is to the margin. The sigmoidal parameterization can also impart another effect on the step size along the spectrum which needs to be accounted for. Considering 10, the gradient backpropagation of some loss $L$ toward parameters $p _ { i }$ is found as ",
+        "bbox": [
+            174,
+            162,
+            825,
+            275
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33635557f734e15be1f2ffc7afe5bf0846c3c5330bd3c43fda2810cb9556038c.jpg",
+        "text": "$$\n\\frac { d L } { d p _ { i } } = \\frac { d s _ { i } } { d p _ { i } } \\frac { d L } { d s _ { i } } = 2 m \\frac { d \\sigma ( p _ { i } ) } { d p _ { i } } \\frac { d L } { d s _ { i } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            281,
+            614,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "From (11), it can be seen that the magnitude of the update step for $p _ { i }$ is scaled by the margin hyperparameter $m$ . This means for example that for margins less than one, the effective learning rate for the spectrum is reduced in proportion to the margin. Consequently, we adjust the learning rate along the spectrum to be independent of the margin by renormalizing it by ${ \\it 2 m }$ . ",
+        "bbox": [
+            174,
+            321,
+            825,
+            378
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This margin formulation both guarantees singular values lie within a well defined range and slows deviation from orthogonality. Alternatively, one could enforce the orthogonality of $\\mathbf { U }$ and $\\mathbf { V }$ and impose a regularization term corresponding to a mean one Gaussian prior on these singular values. This encourages the weight matrix W to be norm preserving with a controllable strength equivalent to the variance of the Gaussian. We also explore this approach further below. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            454
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            326,
+            491
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we explore hard and soft orthogonality constraints on factorized weight matrices for recurrent neural network hidden to hidden transitions. With hard orthogonality constraints on $\\mathbf { U }$ and $\\mathbf { V }$ , we investigate the effect of widening the spectral margin or bounds on convergence and performance. Loosening these bounds allows increasingly larger margins within which the transition matrix W can deviate from orthogonality. We confirm that orthogonal initialization is useful as noted in Henaff et al. (2016), and we show that although strict orthogonality guarantees stable gradient norm, loosening orthogonality constraints can increase the rate of gradient descent convergence. We begin our analyses on tasks that are designed to stress memory: a sequence copying task and a basic addition task (Hochreiter & Schmidhuber, 1997). We then move on to tasks on real data that require models to capture long-range dependencies: digit classification based on sequential and permuted MNIST vectors (Le et al., 2015; LeCun et al., 1998). Finally, we look at a basic language modeling task using the Penn Treebank dataset (Marcus et al., 1993). ",
+        "bbox": [
+            174,
+            506,
+            825,
+            674
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The copy and adding tasks, introduced by Hochreiter & Schmidhuber (1997), are synthetic benchmarks with pathologically hard long distance dependencies that require long-term memory in models. The copy task consists of an input sequence that must be remembered by the network, followed by a series of blank inputs terminated by a delimiter that denotes the point at which the network must begin to output a copy of the initial sequence. We use an input sequence of $T + 2 0$ elements that begins with a sub-sequence of 10 elements to copy, each containing a symbol $a _ { i } \\in \\{ a _ { 1 } , . . . , a _ { p } \\}$ out of $p = \\delta$ possible symbols. This sub-sequence is followed by $T - 1$ elements of the blank category $a _ { \\theta }$ which is terminated at step $T$ by a delimiter symbol $a _ { p + 1 }$ and 10 more elements of the blank category. The network must learn to remember the initial 10 element sequence for $T$ time steps and output it after receiving the delimiter symbol. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The goal of the adding task is to add two numbers together after a long delay. Each number is randomly picked at a unique position in a sequence of length $T$ . The sequence is composed of $T$ values sampled from a uniform distribution in the range $[ 0 , 1 )$ , with each value paired with an indicator value that identifies the value as one of the two numbers to remember (marked 1) or as a value to ignore (marked 0). The two numbers are positioned randomly in the sequence, the first in the range $[ 0 , \\frac { T } { 2 } - 1 ]$ and the second in the range $\\begin{array} { r l r } {  { [ \\frac { T } { 2 } , T - 1 ] } } \\end{array}$ , where 0 marks the first element. The network must learn to identify and remember the two numbers and output their sum. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The sequential MNIST task from Le et al. (2015), MNIST digits are flattened into vectors that can be traversed sequentially by a recurrent neural network. The goal is to classify the digit based on the sequential input of pixels. The simple variant of this task is with a simple flattening of the image matrices; the harder variant of this task includes a random permutation of the pixels in the input vector that is determined once for an experiment. The latter formulation introduces longer distance dependencies between pixels that must be interpreted by the classification model. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            186
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The English Penn Treebank (PTB) dataset from Marcus et al. (1993) is an annotated corpus of English sentences, commonly used for benchmarking language models. We employ a sequential character prediction task: given a sentence, a recurrent neural network must predict the next character at each step, from left to right. We use input sequences of variable length, with each sequence containing one sentence. We model 49 characters including lowercase letters (all strings are in lowercase), numbers, common punctuation, and an unknown character placeholder. In our experiments on two subsets of the data: in the first, we first use $23 \\%$ of the data with strings with up to 75 characters and in the second we include over $9 9 \\%$ of the dataset, picking strings with up to 300 characters. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 LOOSENING HARD ORTHOGONALITY CONSTRAINTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            343,
+            566,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we experimentally explore the effect of loosening hard orthogonality constraints through loosening the spectral margin defined above for the hidden to hidden transition matrix. ",
+        "bbox": [
+            176,
+            376,
+            823,
+            404
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In all experiments, we employed RMSprop (Tieleman & Hinton, 2012) when not using geodesic gradient descent. We used minibatches of size 50 and for generated data (the copy and adding tasks), we assumed an epoch length of 100 minibatches. We cautiously introduced gradient clipping at magnitude 100 (unless stated otherwise) in all of our RNN experiments although it may not be required and we consistently applied a small weight decay of 0.0001. Unless otherwise specified, we trained all simple recurrent neural networks with the hidden to hidden matrix factorization as in (8) using geodesic gradient descent on the bases (learning rate $1 0 ^ { - 6 }$ ) and RMSprop on the other parameters (learning rate 0.0001), using a tanh transition nonlinearity, and clipping gradients of 100 magnitude. The neural network code was built on the Theano framework (Theano Development Team, 2016). When parameterizing a matrix in factorized form, we apply the weight decay on the composite matrix rather than on the factors in order to be consistent across experiments. For MNIST and PTB, test set metrics were computed based on the parameterization that gave the best validation set accuracy. ",
+        "bbox": [
+            173,
+            411,
+            825,
+            592
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 CONVERGENCE ON SYNTHETIC MEMORY TASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            627,
+            560,
+            640
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For different sequence lengths $T$ of the copy and adding tasks, we trained a factorized RNN with 128 hidden units and various spectral margins $m$ . For the copy task, we used Elman networks without a transition non-linearity as in Henaff et al. (2016). We discuss our investigations into the use of a non-linearity on the copy task in the Appendix. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            714
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 1 we see an increase in the rate of convergence as we increase the spectral margin. This observation generally holds across the tested sequence lengths ( $T = 2 0 0$ , $T \\stackrel { = } { = } 5 0 0$ , $T = 1 0 0 0 , \\ T = 1 0 0 0 0 )$ ; however, large spectral margins hinder convergence on extremely long sequence lengths. At sequence length $T = 1 0 0 0 0$ , parameterizations with spectral margins larger than 0.001 converge slower than when using a margin of 0.001. In addition, the experiment without a margin failed to converge on the longest sequence length. This follows the expected pattern where stepping away from the Stiefel manifold may help with gradient descent optimization but loosening orthogonality constraints can reduce the stability of signal propagation through the network. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the adding task, we trained a factorized RNN on $T = 1 0 0 0$ length sequences, using a ReLU activation function on the hidden to hidden transition matrix. The mean squared error (MSE) is shown for different spectral margins in Figure 5 in the Appendix. Testing spectral margins $m = 0$ , $m = 1 , \\ m = 1 0 , \\ m = 1 0 0$ , and no margin, we find that the models with the purely orthogonal ( $\\mathrm { ~ m ~ } = 0$ ) and the unconstrained (no margin) transition matrices failed to begin converging beyond baseline MSE within 2000 epochs. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/bedb92ba810d6f82c67aaac3918c6706b07e966d8d209fab7a969dfdb8a2a818.jpg",
+        "image_caption": [
+            "Figure 1: Accuracy curves on the copy task for sequence lengths of (from left to right) ${ \\mathrm { T } } { = } 2 0 0$ , $\\mathrm { T } { = } 5 0 0$ , $\\scriptstyle \\mathrm { T = 1 0 0 0 }$ , $\\scriptstyle \\mathrm { T = 1 0 0 0 0 }$ given different spectral margins. Convergence speed increases with margin size; however, large margin sizes are ineffective at longer sequence lengths $\\mathrm { { T } = 1 0 0 0 0 }$ , right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            106,
+            807,
+            181
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/59390e5b14a57a5e0e57e788b41a4d98df3a115218e862bcaf5543d3dfe9a398.jpg",
+        "table_caption": [
+            "Table 1: Ordered sequential MNIST classification with different margin sizes and an LSTM. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>margin</td><td>initialization</td><td>accuracy</td></tr><tr><td>0</td><td>orthogonal</td><td>77.18</td></tr><tr><td>0.001</td><td>orthogonal</td><td>79.26</td></tr><tr><td>0.01</td><td>orthogonal</td><td>85.47</td></tr><tr><td>0.1</td><td>orthogonal</td><td>94.10</td></tr><tr><td>1</td><td>orthogonal</td><td>93.84</td></tr><tr><td>none</td><td>orthogonal</td><td>93.24</td></tr><tr><td>none</td><td>Glorot normal</td><td>66.71</td></tr><tr><td>none</td><td>identity</td><td>53.53</td></tr><tr><td></td><td>LSTM</td><td>97.30</td></tr></table>",
+        "bbox": [
+            210,
+            256,
+            450,
+            396
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/cddb91b2932bb0afc2b5f2bc754c9ca058dd00a9d6eeacd31b573f25f9f2ffdf.jpg",
+        "table_caption": [
+            "Table 2: Permuted sequential MNIST classification with different margin sizes and an LSTM. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>margin</td><td>initialization</td><td>accuracy</td></tr><tr><td>0</td><td>orthogonal</td><td>83.56</td></tr><tr><td>0.001 0.01</td><td>orthogonal</td><td>84.59 89.63</td></tr><tr><td>0.1</td><td>orthogonal orthogonal</td><td>91.44</td></tr><tr><td>1</td><td>orthogonal</td><td>90.83</td></tr><tr><td>none</td><td>orthogonal</td><td>90.51</td></tr><tr><td>none</td><td>Glorot normal</td><td>79.33</td></tr><tr><td>none</td><td>identity</td><td></td></tr><tr><td></td><td>LSTM</td><td>42.72 92.62</td></tr></table>",
+        "bbox": [
+            545,
+            256,
+            787,
+            396
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 PERFORMANCE ON REAL DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            441,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Having confirmed that an orthogonality constraint can negatively impact convergence rate, we seek to investigate the effect on model performance for tasks on real data. We show the results of experiments on permuted sequential MNIST in Table 2 and ordered sequential MNIST in Table 1. The loss curves are shown in Figure 6 in the Appendix and reveal an increased convergence rate for larger spectral margins. We trained the factorized RNN models with 128 hidden units for 120 epochs. We also trained an LSTM with 128 hidden units on both tasks for 150 epochs, configured with peephole connections, orthogonally initialized (and forget gate bias initialized to one), and trained with RMSprop (learning rate 0.0001, clipping gradients of magnitude 1). ",
+        "bbox": [
+            173,
+            491,
+            825,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We show the results of experiments on PTB character prediction, in terms of bits per character (bpc) and prediction accuracy, for a subset of short sequences (up to 75 characters; $23 \\%$ of data) in Table 3 and for a subset of long sequences (up to 300 characters; $9 9 \\%$ of data) in Table 4. We trained factorized RNN models with 512 hidden units for 200 epochs with geodesic gradient descent on the bases (learning rate $1 0 ^ { - 6 }$ ) and RMSprop on the other parameters (learning rate 0.001), using a tanh transition nonlinearity, and clipping gradients of 30 magnitude. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            694
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, for both the ordered and permuted sequential MNIST tasks, models with a non-zero margin significantly outperform those that are constrained to have purely orthogonal transition matrices (margin of zero). The best results on both the ordered and sequential MNIST tasks were yielded by models with a spectral margin of 0.1, at $9 4 . 1 0 \\%$ accuracy and $9 1 . 4 4 \\%$ accuracy, respectively. An LSTM outperformed the RNNs in both tasks; nevertheless, RNNs with hidden to hidden transitions initialized as orthogonal matrices performed admirably without a memory component and without all of the additional parameters associated with gates. Indeed, orthogonally initialized RNNs performed almost on par with the LSTM in the permuted sequential MNIST task which presents longer distance dependencies than the ordered task. Although the optimal margin appears to be 0.1, RNNs with large margins perform almost identically to an RNN without a margin, as long as the transition matrix is initialized as orthogonal. On these tasks, orthogonal initialization appears to significantly outperform Glorot normal initialization (Glorot & Bengio, 2010) or initializing the matrix as identity. It is interesting to note that for the MNIST tasks, orthogonal initialization appears useful while orthogonality constraints appear mainly detrimental. This suggests that while orthogonality helps early training by stabilizing gradient flow across many time steps, orthogonality constraints may need to be loosened on some tasks so as not to over-constrain the model’s representational ability. ",
+        "bbox": [
+            173,
+            700,
+            823,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/cd8a0dba76f1ffb1c93b8742fb58e008b64a43d4e45215e3676dd3f66bf24040.jpg",
+        "table_caption": [
+            "Table 3: Character prediction on PTB sentences of to 75 characters, using different margins. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>margin</td><td>initialization</td><td>bpc</td><td>accuracy</td></tr><tr><td>0</td><td>orthogonal</td><td>2.16</td><td>55.31</td></tr><tr><td>0.01</td><td>orthogonal</td><td>2.16</td><td>55.33</td></tr><tr><td>0.1</td><td>orthogonal</td><td>2.12</td><td>55.37</td></tr><tr><td>1</td><td>orthogonal</td><td>2.06</td><td>57.07</td></tr><tr><td>100</td><td>orthogonal</td><td>2.04</td><td>57.51</td></tr><tr><td>none</td><td>orthogonal</td><td>2.06</td><td>57.38</td></tr><tr><td>none</td><td>Glorot normal</td><td>2.08</td><td>57.37</td></tr><tr><td>none</td><td>identity</td><td>2.25</td><td>53.83</td></tr></table>",
+        "bbox": [
+            191,
+            755,
+            472,
+            882
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7ce91b05215e78d9fb08c9be66daa286806ba018d8dcc0ad9a48414ddbf85a06.jpg",
+        "table_caption": [
+            "Table 4: Character prediction on PTB sentences of up to 300 characters, using different margins. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>margin</td><td>initialization bpc</td><td>accuracy</td></tr><tr><td>0</td><td>orthogonal 2.20</td><td>54.88</td></tr><tr><td>0.01</td><td>orthogonal 2.20</td><td>54.83</td></tr><tr><td>0.1</td><td>orthogonal 2.24</td><td>54.10</td></tr><tr><td>1</td><td>orthogonal 2.36</td><td>51.12</td></tr><tr><td>100</td><td>orthogonal 2.36</td><td>51.20</td></tr><tr><td>none</td><td>orthogonal 2.34</td><td>51.30</td></tr><tr><td>none</td><td>Glorot normal 2.34</td><td>51.04</td></tr><tr><td>none</td><td>identity 2.68</td><td>45.35</td></tr></table>",
+        "bbox": [
+            524,
+            755,
+            808,
+            882
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            297
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Curiously, larger margins and even models without sigmoidal constraints on the spectrum (no margin) performed well as long as they were initialized to be orthogonal, suggesting that evolution away from orthogonality is not a serious problem on MNIST. It is not surprising that orthogonality is useful for the MNIST tasks since they depend on long distance signal propagation with a single output at the end of the input sequence. On the other hand, character prediction with PTB produces an output at every time step. Constraining deviation from orthogonality proved detrimental for short sentences (Table 3) and beneficial when long sentences were included (Table 4). Furthermore, Glorot normal initialization did not perform worse than orthogonal initialization for PTB. Since an output is generated for every character in a sentence, short distance signal propagation is possible. Thus it is possible that the RNN is first learning very local dependencies between neighbouring characters and that given enough context, constraining deviation from orthogonality can help force the network to learn longer distance dependencies. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            472
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 SPECTRAL AND GRADIENT EVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            486,
+            500,
+            501
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It is interesting to note that even long sequence lengths $( \\mathrm { T } { = } 1 0 0 0 )$ ) in the copy task can be solved efficiently with rather large margins on the spectrum. In Figure 2 we look at the gradient propagation of the loss from the last time step in the network with respect to the hidden activations. We can see that for a purely orthogonal parameterization of the transition matrix (when the margin is zero), the gradient norm is preserved across time steps, as expected. We further observe that with increasing margin size, the number of update steps over which this norm preservation survives decreases, though surprisingly not as quickly as expected. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            608
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e71e3ebaed3b5fd5794943085fc9dd1a230a8a632c97e25751f215ada0b27e31.jpg",
+        "image_caption": [
+            "Figure 2: The norm of the gradient of the loss from the last time step with respect to the hidden units at a given time step for a length 220 RNN over 1000 update iterations for different margins. Iterations are along the abscissa and time steps are denoted along the ordinate. The first column margins are: 0, 0.001, 0.01. The second column margins are: 0.1, 1, no margin. Gradient norms are normalized across the time dimension. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            622,
+            779,
+            771
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Although the deviation of singular values from one should be slowed by the sigmoidal parameterizations, even parameterizations without a sigmoid (no margin) can be effectively trained for all but the longest sequence lengths. This suggests that the spectrum is not deviating far from orthogonality and that inputs to the hidden to hidden transitions are mostly not aligned along the dimensions of greatest expansion or contraction. We evaluated the spread of the spectrum in all of our experiments and found that indeed, singular values tend to stay well within their prescribed bounds and only reach the margin when using a very large learning rate that does not permit convergence. Furthermore, when transition matrices are initialized as orthogonal, singular values remain near one throughout training even without a sigmoidal margin for tasks that require long term memory (copy, adding, sequential MNIST). On the other hand, singular value distributions tend to drift away from one for PTB character prediction which may help explain why enforcing an orthogonality constraint can be helpful for this task, when modeling long sequences. Interestingly, singular values spread out less for longer sequence lengths (nevertheless, the $\\scriptstyle \\mathrm { T = 1 0 0 0 0 }$ copy task could not be solved with no sigmoid on the spectrum). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We visualize the spread of singular values for different model parameterizations on the permuted sequential MNIST task in Figure 3. Curiously, we find that the distribution of singular values tends to shift upward to a mean of approximately 1.05 on both the ordered and permuted sequential MNIST tasks. We note that in those experiments, a tanh transition nonlinearity was used which is contractive in both the forward signal pass and the gradient backward pass. An upward shift in the distribution of singular values of the transition matrix would help compensate for that contraction. Indeed, (Saxe et al., 2013) describe this as a possibly good regime for learning in deep neural networks. That the model appears to evolve toward this regime suggests that deviating from it may incur a cost. This is interesting because the cost function cannot take into account numerical issues such as vanishing or exploding gradients (or forward signals); we do not know what could make this deviation costly. That the transition matrix may be compensating for the contraction of the tanh is supported by further experiments: applying a 1.05 pre-activation gain appears to allow a model with a margin of 0 to nearly match the top performance reached on both of the MNIST tasks. Furthermore, when using the OPLU norm-preserving activation function (Chernodub & Nowicki, 2016), we found that orthogonally initialized models performed equally well with all margins, achieving over $90 \\%$ accuracy on the permuted sequential MNIST task. Unlike orthgonally initialized models, the RNN on the bottom right of Figure 3 with Glorot normal initialized transition matrices, begins and ends with a wide singular spectrum. While there is no clear positive shift in the distribution of singular values, the mean value appears to very gradually increase for both the ordered and permuted sequential MNIST tasks. If the model is to be expected to positively shift singular values to compensate for the contractivity of the tanh nonlinearity, it is not doing so well for the Glorot-initialized case; however, this may be due to the inefficiency of training as a result of vanishing gradients, given that initialization. ",
+        "bbox": [
+            173,
+            250,
+            825,
+            568
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c37c480f2de6dda53baf106dd72e4b8f3118c713cf6c5957311a6d4222ee2528.jpg",
+        "image_caption": [
+            "Figure 3: Singular value evolution on the permuted sequential MNIST task for factorized RNNs with different margin sizes. Margins are, from left to right: top row: 0.001, 0.01, 0.1; bottom row: 1, no margin, no margin. The singular value distributions are summarized with the mean (green line, center) and standard deviation (green shading about mean), minimum (red, bottom) and maximum (blue, top) values. All models are initialized with orthogonal hidden to hidden transition matrices except for the model on the bottom right where Glorot normal initialization is used. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            604,
+            807,
+            792
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.2 EXPLORING SOFT ORTHOGONALITY CONSTRAINTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            560,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Having established that it may indeed be useful to step away from orthogonality, here we explore two forms of soft constraints (rather than hard bounds as above) on hidden to hidden transition matrix orthogonality. The first is a simple penalty that directly encourages a transition matrix W to be orthogonal, of the form $\\lambda | | \\mathbf { W } ^ { T } \\mathbf { W } \\bar { \\mathbf { \\Lambda } } - \\mathbf { I } | | _ { 2 } ^ { 2 }$ . This is similar to the orthogonality penalty introduced by Henaff et al. (2016). In the first two subfigures on the left of Figure 4, we explore the effect of weakening this form of regularization. We trained both a regular non-factorized RNN on the $T = 2 0 0$ copy task and a factorized RNN with orthogonal bases on the $T = 5 0 0$ copy task. For the regular RNN, we had to reduce the learning rate to $\\mathrm { \\bar { 1 0 } ^ { - 5 } }$ . Here again we see that weakening the strength of the orthogonality-encouraging penalty can increase convergence speed. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/687b45fda05840b6cde45ba158ba70663757e961b6ca8f4fafd56abe7466fd47.jpg",
+        "image_caption": [
+            "Figure 4: Accuracy curves on the copy task for different strengths of soft orthogonality constraints. A soft orthogonality constraint is applied to the transition matrix W for a regular RNN on $T = 2 0 0$ (Left) and the same is applied on a factorized RNN on $T = 5 0 0$ (Left center). Another constraint in the form of a mean one Gaussian prior on the singular values is applied to a factorized RNN on $T = 2 0 0$ (Right center); the same is applied to a factorized RNN with a sigmoidal parameterization of the spectrum, using a large margin of 1 (Right). Loosening orthogonality speeds convergence. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            286,
+            808,
+            358
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The second approach we explore replaces the sigmoidal margin parameterization with a mean one Gaussian prior on the singular values. In the two right subfigures of Figure 4, we visualize the accuracy on the length 200 copy task, using geoSGD (learning rate $1 0 ^ { - 6 }$ ) to keep $\\mathbf { U }$ and $\\mathbf { V }$ orthogonal and different strengths of a Gaussian prior with mean one on the singular values. We trained these experiments with regular SGD on the spectrum and other non-orthogonal parameter matrices, using a $\\mathrm { i 0 ^ { - 5 } }$ learning rate. We see that priors which are too strong lead to slow convergence. Loosening the strength of the prior makes the optimization more efficient. Furthermore, we compare a direct parameterization of the spectrum (no sigmoid) in Figure 4 with a sigmoidal parameterization, using a large margin of 1. Without the sigmoidal parameterization, optimization quickly becomes unstable; on the other hand, the optimization also becomes unstable if the prior is removed completely in the sigmoidal formulation (margin 1). These results further motivate the idea that parameterizations that deviate from orthogonality may perform better than purely orthogonal ones, as long as they are sufficiently constrained to avoid instability during training. ",
+        "bbox": [
+            173,
+            482,
+            825,
+            662
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            693,
+            328,
+            708
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have explored a number of methods for controlling the expansivity of gradients during backpropagation based learning in RNNs through manipulating orthogonality constraints and regularization on matrices. Our experiments indicate that while orthogonal initialization may be beneficial, maintaining constraints on orthogonality can be detrimental. Indeed, moving away from hard constraints on matrix orthogonality can help improve optimization convergence rate and model performance. However, we also observe with synthetic tasks that relaxing regularization which encourages the spectral norms of weight matrices to be close to one, or allowing bounds on the spectral norms of weight matrices to be too wide, can reverse these gains and may lead to unstable optimization. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            842
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            868,
+            326,
+            881
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank the Natural Sciences and Engineeering Research Council (NSERC) of Canada and Samsung for supporting this research. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. arXiv preprint arXiv:1511.06464, 2015. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Artem Chernodub and Dimitri Nowicki. Norm-preserving orthogonal permutation linear unit activation functions (oplu). arXiv preprint arXiv:1604.02313, 2016. ",
+        "bbox": [
+            174,
+            162,
+            823,
+            193
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Aistats, volume 9, pp. 249–256, 2010. ",
+        "bbox": [
+            173,
+            200,
+            823,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026–1034, 2015. ",
+        "bbox": [
+            176,
+            238,
+            823,
+            281
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mikael Henaff, Arthur Szlam, and Yann LeCun. Orthogonal rnns and long-memory tasks. arXiv preprint arXiv:1602.06662, 2016. ",
+        "bbox": [
+            171,
+            290,
+            825,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            171,
+            328,
+            823,
+            357
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Krueger and Roland Memisevic. Regularizing rnns by stabilizing activations. arXiv preprint arXiv:1511.08400, 2015. ",
+        "bbox": [
+            173,
+            366,
+            823,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Quoc V Le, Navdeep Jaitly, and Geoffrey E Hinton. A simple way to initialize recurrent networks of rectified linear units. arXiv preprint arXiv:1504.00941, 2015. ",
+        "bbox": [
+            173,
+            404,
+            823,
+            433
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            173,
+            440,
+            823,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 19(2):313–330, 1993. ",
+        "bbox": [
+            171,
+            478,
+            823,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 807–814, 2010. ",
+        "bbox": [
+            176,
+            516,
+            823,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yasunori Nishimori. A note on riemannian optimization methods on the stiefel and the grassmann manifolds. dim, 1:2, 2005. ",
+        "bbox": [
+            173,
+            568,
+            823,
+            598
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. ICML (3), 28:1310–1318, 2013. ",
+        "bbox": [
+            174,
+            606,
+            821,
+            636
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv preprint arXiv:1312.6120, 2013. ",
+        "bbox": [
+            173,
+            643,
+            821,
+            674
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hemant D Tagare. Notes on optimization on stiefel manifolds. Technical report, Tech. Rep., Yale University, 2011. ",
+        "bbox": [
+            173,
+            681,
+            821,
+            712
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. URL http://arxiv.org/abs/ 1605.02688. ",
+        "bbox": [
+            173,
+            719,
+            823,
+            762
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "T. Tieleman and G. Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012. ",
+        "bbox": [
+            173,
+            771,
+            821,
+            800
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott Wisdom, Thomas Powers, John R. Hershey, Jonathan Le Roux, and Les Atlas. Full-capacity unitary recurrent neural networks. To appear in NIPS, 2016. ",
+        "bbox": [
+            173,
+            809,
+            823,
+            838
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            294,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5.1 ADDITIONAL FIGURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            136,
+            369,
+            150
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/dbbb26122d9c1b18baef9fb3969444306e99337b717346b55304b1882d89af7d.jpg",
+        "image_caption": [
+            "Figure 5: Mean squared error (MSE) curves on the adding task for different spectral margins $m$ . For a trivial baseline solution of always outputting the same number, the expected baseline MSE is 0.167. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            352,
+            169,
+            640,
+            294
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/ef5d2d8346b204d7aae860dfebe321ec6d017184dee170574f14d5165e374c93.jpg",
+        "image_caption": [
+            "Figure 6: Loss curves for different factorized RNN parameterizations on the sequential MNIST task (left) and the permuted sequential MNIST task (right). The spectral margin is denoted by m; models with no margin have singular values that are directly optimized with no constraints; Glorot refers to a factorized RNN with no margin that is initialized with Glorot normal initialization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            383,
+            761,
+            512
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5.2 COPY TASK NONLINEARITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            619,
+            405,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We found that nonlinearities such as a rectified linear unit (ReLU) (Nair & Hinton, 2010) or hyperbolic tangent (tanh) made the copy task far more difficult to solve. Using tanh, a short sequence length ( $T = 1 0 0$ ) copy task required both a soft constraint that encourages orthogonality and thousands of epochs for training. It is worth noting that in the unitary evolution recurrent neural network of Arjovsky et al. (2015), the non-linearity (referred to as the ”modReLU”) is actually initialized as an identity operation that is free to deviate from identity during training. Furthermore, Henaff et al. (2016) derive a solution mechanism for the copy task that drops the non-linearity from an RNN. To explore this further, we experimented with a parametric leaky ReLU activation function (PReLU) which introduces a trainable slope $\\alpha$ for negative valued inputs $x$ , producing $f ( x ) = m a x ( x , 0 ) + \\alpha m i n ( x , 0 )$ (He et al., 2015). Setting the slope $\\alpha$ to one would make the PReLU equivalent to an identity function. We experimented with clamping $\\alpha$ to 0.5, 0.7 or 1 in a factorized RNN with a spectral margin of 0.3 and found that only the model with $\\alpha = 1$ solved the $T = 1 0 0 0$ length copy task. We also experimented with a trainable slope $\\alpha$ , initialized to 0.7 and found that it converges to 0.96, further suggesting the optimal solution for the copy task is without a transition nonlinearity. Since the copy task is purely a memory task, one may imagine that a transition nonlinearity such as a tanh or ReLU may be detrimental to the task as it can lose information. Thus, we also tried a recent activation function that preserves information, called an orthogonal permutation linear unit (OPLU) (Chernodub & Nowicki, 2016). The OPLU preserves norm, making a fully norm-preserving RNN possible. Interestingly, this activation function allowed us to recover identical results on the copy task to those without a nonlinearity for different spectral margins. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5.3 METHOD RUNNING TIME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            387,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Although the method proposed in section 2 relies on a matrix inversion, an operation with $O ( n ^ { 3 } )$ complexity for an $\\textbf { n } \\times \\textbf { n }$ matrix, the running time of an RNN factorized in such a way actually remains reasonable. This running time is summarized in Table 5 and includes all computations in the graph, together with the matrix inversion. As this method is meant to be used only for the analysis in this work, we find the running times acceptable for that purpose. Models were run on an Nvidia GTX-770 GPU and were run against the $\\mathrm { T } { = } 1 0 0$ length copy task. ",
+        "bbox": [
+            173,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/c7070a0762b84d0008148881c43f1764a38001b82cc5bfdd2b3345f14fc03efe.jpg",
+        "table_caption": [
+            "Table 5: Run time in seconds for 1000 iterations on a $\\mathrm { T } { = } 1 0 0$ copy task of a regular RNN trained with stochastic gradient descent (SGD) compared against a factorized RNN trained with geodesic SGD on the bases (geoSGD) and regular SGD for other parameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>hidden units</td><td>SGD</td><td>geoSGD</td></tr><tr><td>128</td><td>21.9 ± 0.2</td><td>40.4 ± 0.1</td></tr><tr><td>500</td><td>46.7 ± 0.2</td><td>161.4 ± 0.2</td></tr><tr><td>1000</td><td>95.4 ± 0.3</td><td>711.2 ± 0.8</td></tr></table>",
+        "bbox": [
+            364,
+            226,
+            632,
+            284
+        ],
+        "page_idx": 11
+    }
+]

parse/train/HyxnnnVtwB/HyxnnnVtwB.md

@@ -0,0 +1,474 @@
+# HIGH-PERFORMANCE RNNS WITH SPIKING NEURONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The increasing need for compact and low-power computing solutions for machine learning applications has triggered significant interest in energy-efficient neuromorphic systems. However, most of these architectures rely on spiking neural networks, which typically perform poorly compared to their non-spiking counterparts in terms of accuracy. In this paper, we propose a new adaptive spiking neuron model that can be abstracted as a low-pass filter. This abstraction enables faster and better training of spiking networks using back-propagation, without simulating spikes. We show that this model dramatically improves the inference performance of a recurrent neural network and validate it with three complex spatio-temporal learning tasks: the temporal addition task, the temporal copying task, and a spoken-phrase recognition task. We estimate at least $5 0 0 \times$ higher energy-efficiency using our models on compatible neuromorphic chips in comparison to Cortex-M4, a popular embedded microprocessor.
+
+# 1 INTRODUCTION
+
+Exponential growth in computational power and efficiency have played a vital role in the development of neural networks and their training algorithms. However, it has also led to higher design complexity and increasing difficulty to keep up with Moore’s law (Schaller, 1997; Waldrop, 2016). Recent years have also seen the movement of computation from data-centres to compact, distributed, and portable embedded systems. These factors have created a demand for energy-efficient AI-capable devices, leading to the development of dedicated and optimized von Neumann-style Artificial Neural Network (ANN) accelerators (Aimar et al., 2018; Cavigelli and Benini, 2016; Chen et al., 2016) and a renewed interest in neuromorphic systems (Chicca et al., 2014; Frenkel et al., 2019; Davies et al., 2018; Moradi et al., 2018; Akopyan et al., 2015; Qiao et al., 2015; Neckar et al., 2019).
+
+A key difference between neural networks deployed on von Neumann systems and most neuromorphic platforms is the use of spikes or train of pulses to represent signals in the latter. Such networks are called Spiking Neural Networks (SNNs). Spiking neuromorphic systems have a number of features that inhibit their use in real-world problems: (1) mixed-signal circuits suffer from Complementary Metal-Oxide-Semiconductor (CMOS) mismatch (Pelgrom et al., 1989) that degrades performance; (2) rate-based SNNs generate a large number of spikes to represent signals that reduces their energy benefit; (3) complex spiking dynamics makes it difficult to train them using gradient-descent methods. In this paper, we describe a new neuron model that addresses these problems and discuss how its Low-Pass Filter (LPF) abstraction enables training spiking Recurrent Neural Networks (RNNs) using the backpropagation algorithm (or Backprop). This is a significant breakthrough as it enables training and deployment of energy-efficient spiking neural network devices without simulating complex spiking dynamics.
+
+# 2 PROCESSING-IN-MEMORY FOR RNNS
+
+Consider an RNN layer with $n$ nodes. At each time-step, the processor computes one or several matrix products of the form $y = W . x$ , where $_ y$ and $x$ are vectors of length $n$ , and $W$ is a 2-D matrix of size $n \times n$ . When operating on a von Neumann system with batch-size 1, as is common in most edge applications, the bottleneck in throughput and energy-efficiency is the $O ( n ^ { 2 } )$ memory fetches of $W$ at every timestep. An in-memory matrix multiplier addresses this problem. It is a module where a “read” from the memory location of the $W$ matrix, using “X” as the “address” gives out “Y”, without ever moving $W$ . This leads to a quadratic reduction in energy consumption. Processing in-memory systems have been implemented for various tasks such as DNA sequencing (Ghose et al., 2018), graph processing (Ahn et al., 2015), etc and with dramatic reduction in energy consumption.
+
+The energy reduction from in-memory computing is well established, but the key challenge with deploying such systems is the absence of compatible algorithms. In this paper, we propose an RNN model for such a system. The implementation of the in-memory module depends on how $x$ and $y$ are encoded and transported. It can be synchronous or asynchronous and analogue or digital. We adopt an asynchronous digital approach as it offers some implementation advantages. Encoding information in binary digital format is less susceptible to noise in comparison to analogue. Asynchronous signalling allows the energy-consumption to scale in proportion to chip activity, while also permitting lowlatency response. Chips implementing such schemes have been published in literature (Qiao et al., 2015; Moradi et al., 2018). The model presented in this paper is designed to integrate on similar chips (A reference framework is described in supplementary section D). However, most of the algorithmic ideas presented in this paper are general and applicable to a range of compute systems.
+
+# 3 THE SPIKING NEURON MODEL
+
+Spiking neuron models for encoding signals typically use rate- or time-coded spike-generation schemes (Diehl et al., 2015; Rueckauer et al., 2017; Bohte, 2012; Mostafa, 2017). In rate-coding, the firing rate of the neuron is proportional to the input signal. Therefore, achieving high data-resolution with rate-coding requires a large number of spikes, which is not energy-efficient (Nair and Indiveri, 2019). To address this problem, several time-coding schemes have been proposed. In this work, we build on existing models to propose an Adaptive Integrate and Fire (aI&F) neuron model, which can also be interpreted as an asynchronous $\Sigma \Delta$ circuit (Nair and Indiveri, 2019; Bohte, 2012; Yoon, 2016). This mechanism reduces the spike count by only transmitting the error between an internal state and the input. The aI&F neuron model implemented with current-mode neuromorphic circuits (Nair and Indiveri, 2019) can be described by the following equations:
+
+$$
+\begin{array} { c } { { \tau _ { m e m } \displaystyle \frac { d I _ { m e m } } { d t } = \alpha _ { L } ( I _ { L } - I _ { m e m } ) - s + i } } \\ { { \tau _ { w } \displaystyle \frac { d s } { d t } = \alpha _ { s } ( I _ { m e m } - I _ { L } ) - s } } \\ { { \displaystyle I _ { m e m } = 0 , \mathrm { w h e n } I _ { m e m } > \Delta } } \end{array}
+$$
+
+where the currents $I _ { m e m }$ and $I _ { L }$ represent the “membrane potential” and “leak reversal potential” variables. The term $s$ represents the neuron adaptation current, $i$ the input current, $\tau _ { m e m }$ the membrane time constant, $\alpha _ { L }$ a gain factor, $\Delta$ the threshold, $\alpha _ { s }$ the adaptation coupling parameter and $\tau _ { w }$ is the adaptation time constant. The aI&F model is a feedback loop that tries to decrease the difference between the $i ( t )$ and $s ( t )$ . The difference, $i ( t ) - s ( t )$ , is filtered with gain, $\alpha _ { L }$ , and time constant, $\tau _ { m e m }$ . When the output of this filter, $I _ { m e m }$ , exceeds the spiking threshold, $\Delta$ , $I _ { m e m }$ is reset and a spike is generated. The $\Sigma \Delta$ circuit model used in this work is different from the aI&F model in the computation of the feedback term. Instead of filtering $I _ { m e m }$ , we operate on the spike train generated by the spiking neuron. This ensures that the noise inserted by the spike-generation mechanism is also suppressed by the $\Sigma \Delta$ feedback. The modified feedback equation is as follows:
+
+$$
+\tau _ { k } \frac { d s } { d t } = \alpha _ { s } ( \delta _ { i } I _ { i n } - I _ { L } ) - s
+$$
+
+Where, $\delta _ { i }$ indicates the spike train and $I _ { i n }$ is a programmable maximum current value that the analogue filter implementation can generate. The product $\delta _ { i } I _ { i n }$ models the feedback filter that integrates a current $I _ { i n }$ for the duration of the spikes. Figure 1a shows a block diagram of the circuit implementation of the Equation 3 with the modification described by Equation 4. In this diagram, $F ( s )$ is a first order LPF that receives inputs to the neuron. $H ( s )$ is a first-order low-pass filter that produces $s ( t )$ in response to spikes generated by the neuron. $\operatorname { \dot { \cal E } } ( s )$ is also a first-order low-pass filter on the difference between the input current $i ( t )$ and the feedback signal $s ( t )$ . When the output of $E ( s )$ , $I _ { m e m }$ , exceeds the spiking threshold $( \Delta )$ of the neuron, a spike-event is produced. With each spike-event, $s ( t )$ increases and $i ( t ) - s ( t )$ decreases. Figure 1b shows the asynchronous $\Sigma \Delta$ feedback loop in action for a test-case. It can be shown that the Laplace domain representation of the output spike train can be expressed by the equation:
+
+$$
+Y ( s ) = { \frac { X ( s ) F ( s ) E ( s ) } { 1 + H ( s ) E ( s ) } } + { \frac { N ( s ) } { 1 + H ( s ) E ( s ) } }
+$$
+
+![](images/5a9e0adbe76cc0959d8fd95338613690f26cad54122cfe3b46d8a3ecea27a041.jpg)  
+Figure 1: (a) The block marked pulse $\Delta$ encoder is similar to the aI&F neuron model. The LPF stage at the input makes it an asynchronous $\Sigma \Delta$ loop. (b) Evolution of the feedback signal, $s ( t )$ , over time. The sudden jumps in $s ( t )$ correspond to spike events, $y ( t )$ .
+
+where, $N ( s )$ indicates the Laplace-domain representation of the noise introduced into the loop, for example by the spike generation mechanism. The $\Sigma \Delta$ loop described by Equation 5 is similar to a continuous-time $\Sigma \Delta$ modulation loop (Pavan et al., 2017) with the key difference being that the output spikes are unipolar. This is valuable because the output of a conventional $\Sigma \Delta$ loop is always active ( $+ 1$ or $^ { - 1 }$ ), whereas the asynchronous model is only active at the time of a spike event, making the model more energy-efficient.
+
+The input signals to the neuron may be encoded as spikes trains or as continuous analogue values from a sensor. The transmitted analogue signal is reconstructed from a spike train by simply low-pass filtering it. An advantage of the $\Sigma \Delta$ neuron model is that it comes with a low-pass filter in its input stage. Therefore, a $\Sigma \Delta$ neuron is a “codec” - It can both encode an analogue signal into a spike train and decode an incoming spike train back to the transmitted analogue signal. As the low-pass filter at the input stage is agnostic of the type of input to it, a $\Sigma \Delta$ can encode and decode both types of signals - spike trains or continuous analogue ones. A description of the biological motivation and noise-filtering properties of the model is provided in supplementary section A. The circuit implementing this model has been fully characterized in Nair and Indiveri (2019).
+
+# 4 TRAINING A SPIKING RNN WITHOUT SIMULATING SPIKES
+
+The neuron model introduced in the previous section allows us to train a recurrent SNN by treating the spiking neurons as LPFs and modifying the recurrent ANN equations suitably. We will show that the trained weight parameters of the recurrent ANN model can be mapped to a recurrent SNN, without additional training. We measure the effectiveness of this mapping procedure by comparing the temporal dynamics of the neurons in the recurrent ANN to the low-pass filtered spike trains generated by the spiking neurons in the corresponding recurrent SNN. In this demonstration, we use high precision synaptic weights. This is typically not available in most spiking neuromorphic platforms. However, the same mapping procedure can be used for mapping ANNs trained with binary or noisy weights. Before introducing the mapping procedure, we describe three operations that are needed for it.
+
+Input re-scaling: When implementing an SNN in mixed-signal neuromorphic systems, the state variables of the neuron are represented by voltages or currents that are of the order of $\mathrm { m V }$ or nA. Using such small values when training an ANN in software may lead to computational instability. To avoid this we train the network with normalized input signals and re-scale the parameters and activation functions after training. For example, if a single layer calculation is represented as $y = \sigma _ { n l } ( W \cdot x )$ , where $\sigma _ { n l }$ is a non-linear activation function, $x$ , $W$ and $y$ are the inputs, weights, and outputs from the layer, respectively, then, to re-scale the inputs by a factor $\gamma$ , the activation function used in the ANN will be modified, during inference, as $y = \overline { { \sigma _ { n l } } } ( W \cdot \gamma \cdot x )$ , where, $\overline { { \sigma _ { n l } } } ( . ) = \sigma _ { n l } \left( \frac { . } { \gamma } \right)$
+
+Low-pass filtering: The input signal can be reconstructed from the spikes trains generated by the $\Sigma \Delta$ neuron if $s ( t )$ tracks $i ( t )$ (Equation 4). This is because $s ( t )$ is obtained by filtering the neuron spike train. This is why a $\Sigma \Delta$ neuron can be modelled as an LPF with time constant $\tau _ { w }$ . The LPF approximation ignores the high-frequency components injected by the spiking mechanism, as they are suppressed by feedback loop (the $N ( s )$ term in the transfer function of $\Sigma \Delta$ neuron, Equation 5). We model this by using a discrete-time Euler approximation to incorporate a LPF-term at the output of the RNN stage. This results in the Low-Pass Recurrent Neural Network (lpRNN) cell by a simple tweak to the classical equation:
+
+$$
+y _ { t } = \alpha \odot y _ { t - 1 } + ( 1 - \alpha ) \odot \sigma ( W _ { r e c } \cdot y _ { t - 1 } + W _ { i n } \cdot x _ { t } + b )
+$$
+
+where, $\sigma , \odot$ and $\cdot$ denote non-linearity, element-wise Hadamard product and matrix multiplication functions, respectively. The variables $\alpha$ , $y _ { n }$ , $x _ { n }$ , $W _ { r e c }$ , $W _ { i n }$ , and $b$ represent the retention ratio vector, input vector, output vector, recurrent connectivity weight matrix, input connectivity weight matrix, and biases, respectively. The subscripts on variable $y$ and $x$ indicate the time step. $\alpha$ models the time constant of the recurrent ANN, and it is matched to the SNN time constant by setting it to $\alpha = e ^ { \frac { - T s } { \tau _ { s } } }$ where, $T s$ is the time-step of the input data-stream fed to the recurrent ANN, and $\tau _ { s }$ is the feedback time constant of the $\Sigma \Delta$ neurons used in the desiredSNN.
+
+For example, if the recurrent ANN is being trained to detect speech from an audio-signal, then $T s$ should be set equal to the time difference between the consecutive samples. The value of $\tau _ { s }$ , for the ANN set to $m i n ( \tau _ { w } , \tau _ { m e m } )$ in the $\Sigma \Delta$ equations. $\tau _ { s }$ must therefore be chosen such that the signals being transmitted lie well within the pass-band of the feedback filter. This ensures that all the in-band components are transmitted well, even when different neurons in the systems have different values of $\tau _ { s }$ , for example, due to mismatch. This is an important observation for mixed-signal systems, where mismatch effects may result in different neurons to have differing time-constants. We will demonstrate that the effect of device mismatch is well-tolerated for most practical cases and leads to gradual degradation in performance as it increases. It must be noted that while computing $T s$ or the bandwidth of an audio or sensor measurement is easy, it is not trivial for data-sets such as text.
+
+Saturating non-linearity: It has already been shown in the literature that the Rectified Linear Unit (ReLU) non-linearity is a good non-linear model of the aI&F neuron (Yoon, 2016; Bohte, 2012). However, the $\Sigma \Delta$ neuron also filters incoming spike trains using a low-pass filter which limits its maximum output current to $I _ { i n }$ (see Equation 4). To model this effect we can either set $I _ { i n }$ in the SNN to the largest activation output found in the ANN simulation or clamp the maximum output of the activation function in the ANN simulation to $I _ { i n }$ . In our experiments, we do the latter.
+
+# 4.1 THE MAPPING PROCEDURE
+
+First, the recurrent ANN cell is modified by replacing the RNN units with the lpRNN. The modified network is then trained using Backprop with conventional Autograd tools provided by libraries such as PyTorch or Tensorflow. This gives us the synaptic weights for the recurrent SNN. Then, the largest value attained by the state variables in the trained network is mapped to $I _ { i n }$ . This ensures that the spiking neurons do not saturate. Finally, the inputs to the SNN are re-scaled to suitable currents or voltage values as described earlier.
+
+Limitation: A recurrent SNN is a continuous-time system that spikes hundreds to thousands of times per second to achieve the necessary transmission accuracy. Therefore, the time step of the transient simulation needs to be made very fine. The mapping algorithm assumes that the mapped SNN operates on the same sequence that the original ANN is trained on. This is a problem. Training a recurrent ANN on a long sequence using back-propagation is computationally expensive and often intractable because of vanishing and exploding gradients. For example, with speech signals sampled at the standard rate of $4 4 . 1 \mathrm { k H z }$ , even a short utterance is thousands of samples long. If we are unable to train an ANN for the desired task, the mapping mechanism is useless. Our approach to addressing this issue is to train the ANN with sub-sampled signals. After we compute the desired weights, we rescale the time-constants of the network before mapping it to the SNN. If the simulation time-step for the SNN is TsSNN and that of ANN is TsANN , then the time constants of the two simulations are given by $\alpha _ { A N N } = e ^ { - \frac { T _ { s _ { A N N } } } { \tau } }$ and $\alpha _ { S N N } = e ^ { - \frac { T _ { s _ { S N N } } } { \tau } }$ . We only rescale the time constants without changing the weights of the mapped network, introducing inaccuracies in the mapped network. The mismatch arises because a single time-step of the ANN corresponds to several simulation time-steps in the mapped SNN TsANNTs ). The mapping is exact for a first-order LPF because of the Linear Time-Invariant (LTI) property. However, even though an RNN is non-linear, by making the low-pass filtering effect more dominant (for example, with $\alpha = 0 . 9 9$ ), we observe that the mapped dynamics match well.
+
+# 5 EXPERIMENTAL RESULTS
+
+All the spiking simulations in the following sections are run on a custom transient mixed-signal modeling library, called spiking simulator for systems of 1st-order LPFs (Spiker). The motivation for design and operation of Spiker is described in supplementary section E.
+
+# 5.1 ENCODING PERFORMANCE OF THE SIGMA–DELTA NEURON MODEL
+
+The $\Sigma \Delta$ neuron model used in the mapped SNN is not an ideal transmitter of information as the spiking mechanism introduces error akin to quantization noise. This is analogous to use of low bit-precision in conventional ANNs. It is important to measure how much precision is available using a metric that is meaningful for the proposed spiking architecture. We measure this using a Signal-to-Distortion ratio (SDR) metric when encoding a sinusoidal input and reconstructing it with an LPF. The SDR is the ratio between the energy contained in the transmitted signal and total energy in all other frequency components generated by the distortions introduced in the signal chain. The results of these experiments are shown in Figure 2. We note in Figure 2a that highest SDR of the $\Sigma \Delta$ neuron is 55dB, with a 20 dB/decade roll-off as a function of frequency with a pole corresponding to $\tau _ { m e m }$ . Figure 2b highlights the input amplitude-dependence of the SDR. We note in Figure 2b that the SDR improves as a logarithmic function of the input amplitude and then drops suddenly. The logarithmic improvement in SDR is because the error component corresponding to the spiking threshold, $\Delta$ , becomes a smaller fraction of the input amplitude. The sudden drop occurs when the input amplitude approaches and exceeds $I _ { i n }$ in Equation 4. This is because the maximum attainable value of the feedback term, $s ( t )$ in Equation 4 is $I _ { i n }$ . Under these conditions, $I _ { m e m }$ is always greater than $s ( t )$ , causing the neuron to fire at a very high rate. For the rest of the SNN simulations in this paper, the $\Sigma \Delta$ neuron settings listed in Figure 2 caption are used.
+
+![](images/58f4eee7113259e88f398f5c5ff0a9fe333f03a8eac3de75fa3c46aab7b000cb.jpg)  
+Figure 2: SDR of the $\Sigma \Delta$ neuron as a function of sinusoidal input parameters. The $\Sigma \Delta$ neuron is fed a single-tone sinusoid riding on a DC bias to ensures that the input is non-negative. The transient simulations are run with a simulation time step of $1 \mu \mathrm { s }$ . This is the reason for the saturation in the firing rate in (b). The SDR ratio is reported after subtracting the DC component. The neuron parameters for the simulation are $\tau _ { m e m } = 0 . 0 0 7 s$ , $\tau _ { w } = 0 . 0 0 1 4 s$ , $\alpha _ { L } = 5 0 0 0$ , $\alpha _ { s } = 1$ , $\Delta = 0 . 1 n A$ , $I _ { i n } = 4 0 n A$ , $I _ { L } = 0 n A$ .
+
+# 5.2 DEMONSTRATION OF THE MAPPING MECHANISM
+
+We demonstrate the mapping mechanism using multi-layer RNNs. The ANN dynamics are compared against a signal obtained by low-pass filtering the spike trains generated by the $\Sigma \Delta$ neuron. Our assertion is that the mapping mechanism will map any recurrent ANN to an equivalent recurrent SNN. Therefore, instead of demonstrating the mapping for a particular task, we set synaptic weights to random samples from a Gaussian distribution. We then compare the dynamics of all the neuron units in the mapped and original networks. To ensure that our nodes do not saturate, we constrain the largest eigenvalue of the recurrent weight matrices to 1.4. The motivation for this trick was from obtained from Echo-State Networks (ESNs)(Jaeger, 2002; Jaeger et al., 2007). The quality or goodness of fit is measured using an Normalized mean square error (NMSE) metric, which measures the mean square error normalized by the signal power. It is used to compare two time series signals $x _ { r e f }$ and $x$ using the following formulation:
+
+$$
+N M S E = 1 - \frac { | | x _ { r e f } - x | | ^ { 2 } } { | | x _ { r e f } - m e a n ( x _ { r e f } ) | | ^ { 2 } }
+$$
+
+where, $| | . | |$ indicates the L2 norm. The $N M S E$ metric lies between 1 and $- \infty$ , with 1 indicating a perfect match and $- \infty$ indicating a very bad fit. If $N M S E = 0$ , then $\mathbf { X }$ is at least as good a fit as a straight line at $x _ { r e f } .$ . In our results, we report the mean and standard deviation in the NMSE scores for all the units in a layer.
+
+The effectiveness of the mapping mechanism is demonstrated using a four-layer RNN. The input and output stages are implemented as fully-connected feed-forward layers, and the recurrent layers are also interleaved with fully-connected layers. The input feature dimension was set to two and the output to three. The input data was a weighted sum of sinusoidal signals that were band-limited to $5 0 \mathrm { H z }$ and sampled at 1 MHz for 0.2 seconds. The high sampling rate is necessary to accurately capture the dynamics of the SNN, whose neuron models are highly non-linear, in a transient simulation. The length of the simulation is a key consideration as we want our mapped SNN implementation to remain matched for arbitrarily long sequences. Computational considerations limited the duration of our simulations, but this should be tested before large scale deployment in real-world use.
+
+Fully-digital neuromorphic platforms, such as Intel Loihi, IBM TrueNorth, or SpinNaker, do not suffer for mismatch issues. However, mixed-signal neuromorphic chips, such as Qiao et al. (2015); Neckar et al. (2019); Schemmel et al. (2012), are potentially more energy-efficient than their digital counterparts but suffer from device mismatch. A $\Sigma \Delta$ feedback loop naturally compensates for such effects (Pavan et al., 2017) but there are many components in the model that lies outside the feedback loop. To study this, we add the effect of mismatch in our simulations by sampling the parameters, $p$ of the mapped SNN:
+
+$$
+p = p \cdot ( 1 + c _ { v _ { p } } \cdot \mathcal { N } ( 0 , 1 ) )
+$$
+
+where, $c _ { v _ { p } }$ is the coefficient of variation $\begin{array} { r } { ( = \frac { s t a n d a r d d e v i a t i o n } { m e a n } ) } \end{array}$ in the parameter, $p$ . To understand the statistics in the quality of the mapping mechanism, we generate multiple samples of network parameters and measure the quality of fit. These results are tabulated in Tables 1 and 2, where we list the measured mean of and standard deviation in $N M S E$ values for a 4-layer RNN with 51 and 500 units per layer, respectively. With no mismatch effects, the reconstruction is very good to all layers, in both cases. Furthermore, we observe nearly perfect reproduction of the network dynamics for up to 2 layers, and a gradual degradation as the size, depth and mismatch of the network increases. We note that the mapping mechanism is robust for $c _ { v _ { p } } < 0 . 2$ . Reduced mismatch sensitivity is useful for design of neuromorphic chips because it simplifies the design, and that, in turn, reduces the energy and area consumed by these chips. Visualization of the transient dynamics of all the nodes in the original and mapped RNNs is provided in supplementary section F. Finally, the performance of the mapping algorithm comparing the dynamics of the ANN with sub-sampled data to that of the SNN is shown in Table 3. The length of the SNN simulation is $0 . 2 s$ , translating to input sequence lengths, L. We note that the mapping technique works well for fairly high sub-sampling ratios and shows significant degradation only for $L = 2 0$ . Note that a near perfect match ( $N M S E > 0 . 5$ ) is achieved up for depth of two. This restricts the models used for benchmarking in Section 5.3.
+
+# 5.3 LEARNING PERFORMANCE OF THE LPRNN CELL
+
+The key idea behind enabling the mapping between an recurrent ANN to its spiking equivalent was the addition of a low pass filter to the the state variables. It must be highlighted that the idea of using a low-pass filter model for neurons is fairly old and has been studied in various contexts (Beer, 1995; Mozer, 1992; Jaeger et al., 2007). The novelty in this work is in identifying its use in the mapping mechanism and in the study of its learning properties. The mapping procedure would be of no use if the resulting ANN was unable to perform as well as their unfiltered counterparts in learning tasks, and it is the focus of this section.
+
+In our experiments, we set $\alpha$ in Equation 6 by sampling from a distribution with a common mean value shared by all the neuron units in the network. This simplifies the design of the neuromorphic system by eliminating the need to create precise tunable time constants in the neuron implementations.
+
+<table><tr><td rowspan="3">Layer</td><td colspan="4">μNMSE</td><td colspan="4">ONMSE</td></tr><tr><td>CuP =0</td><td>Cup = 0.2</td><td>Cup =1</td><td>Cup =2</td><td>Cup =0</td><td>Cup = 0.2</td><td>Cup =1</td><td>Cup =2</td></tr><tr><td>Rec. layer 1</td><td>1.0</td><td>0.9</td><td>-5.1</td><td>-4.0</td><td>0.1</td><td>0.3</td><td>55.1</td><td>15.5</td></tr><tr><td>Rec. layer 2</td><td>1.0</td><td>0.5</td><td>-8.8</td><td>-17.5</td><td>0.1</td><td>1.1</td><td>54.4</td><td>41.4</td></tr><tr><td>Rec. layer 3</td><td>0.9</td><td>-1.5</td><td>-36.8</td><td>-100.2</td><td>0.1</td><td>6.4</td><td>117.1</td><td>300.0</td></tr><tr><td>Rec. layer 4</td><td>0.9</td><td>-3.7</td><td>-107.5</td><td>-278.9</td><td>0.2</td><td>8.2</td><td>202.4</td><td>535.9</td></tr></table>
+
+Table 1: Mapping a four layer network with 51 units per layer for different mismatch values.   
+
+<table><tr><td rowspan="2">Layer</td><td colspan="4">μNMSE</td><td colspan="4">ONMSE</td></tr><tr><td>Cup =0</td><td>Cup = 0.2</td><td>Cup =1</td><td>Cup =2</td><td>Cup =0</td><td>Cup = 0.2</td><td>Cup =1</td><td>cup = 2</td></tr><tr><td>Rec. layer 1</td><td>1.0</td><td>1.0</td><td>0.4</td><td>0.6</td><td>0.1</td><td>0.1</td><td>1.8</td><td>1.3</td></tr><tr><td>Rec. layer 2</td><td>0.9</td><td>-1.0</td><td>-48.9</td><td>-132.0</td><td>0.1</td><td>1.6</td><td>52.1</td><td>143.7</td></tr><tr><td>Rec. layer 3</td><td>0.8</td><td>-6.8</td><td>-185.1</td><td>-683.6</td><td>0.2</td><td>2.9</td><td>73.2</td><td>295.9</td></tr><tr><td>Rec. layer 4</td><td>0.2</td><td>-6.3</td><td>-133.7</td><td>-416.3</td><td>0.9</td><td>3.5</td><td>64.0</td><td>203.6</td></tr></table>
+
+Table 2: Mapping a four layer network with 500 units per layer for different mismatch values.   
+
+<table><tr><td rowspan="3">Layer</td><td colspan="4">μNMSE</td><td colspan="4">ONMSE</td></tr><tr><td>TsANN =10μs L = 20000</td><td>100μs 2000</td><td>1ms 200</td><td>10ms 20</td><td>10 μs 20000</td><td>100μs 2000</td><td>1ms 200</td><td>10ms 20</td></tr><tr><td>Rec. layer 1</td><td>1.0</td><td>1.0</td><td>0.8</td><td>-0.4</td><td>0.0</td><td>0.0</td><td>0.1</td><td>0.4</td></tr><tr><td>Rec. layer 2</td><td>0.9</td><td>1.0</td><td>0.7</td><td>-1.7</td><td>0.8</td><td>0.0</td><td>0.2</td><td>5.2</td></tr><tr><td>Rec.layer 3</td><td>0.9</td><td>0.9</td><td>0.4</td><td>-1.6</td><td>0.5</td><td>0.1</td><td>1.0</td><td>2.2</td></tr><tr><td>Rec. layer 4</td><td>0.9</td><td>0.9</td><td>0.1</td><td>-2.0</td><td>0.3</td><td>0.3</td><td>1.2</td><td>2.2</td></tr></table>
+
+Table 3: Performance when mapping resampled data for a four layer network with 128 units per layer.   
+
+<table><tr><td rowspan="2">Task</td><td colspan="3">Results in this work</td><td rowspan="2">Reference literature</td></tr><tr><td>SimpleRNN</td><td>lpRNN</td><td>LSTM</td></tr><tr><td>Temporal addition</td><td>40 steps</td><td>642 steps</td><td>8</td><td>5000 steps (Li et al., 2018)</td></tr><tr><td>Temporal copy</td><td>30 steps</td><td>120 steps</td><td>200 steps</td><td>500 steps (Arjovsky et al., 2016)</td></tr><tr><td>Spoken phrase (acc.)</td><td>27%</td><td>93%</td><td>92%</td><td>90% (Sainath and Parada, 2015)</td></tr></table>
+
+Table 4: The performance of the lpRNN cell on three benchmarks. The reference literature column reports the best results (to our knowledge) with neural networks with less than 100K parameters. lpRNN and SimpleRNN networks for the add and copy tasks used a single layer with 128 hidden units. Arjovsky et al. (2016) use unitary recurrent weight matrices and Li et al. (2018) use two layers of 128-unit IndRNN layers. The spoken phrase task reference is a CNN model released as a Tensorflow example (Google, 2019).
+
+First, we study the short-term memory capabilities of the lpRNNs using the synthetic addition and copying tasks (Hochreiter and Schmidhuber, 1997; Arjovsky et al., 2016; Le et al., 2015). Next, we compare the performance of the lpRNN cell vs a SimpleRNN cell in a speech recognition task. We summarize the key observations in this section and details are in the supplementary material.
+
+Temporal addition task: The addition task (Le et al., 2015) involves processing two parallel input data streams of equal length. The first stream comprises random numbers $\in ( 0 , 1 )$ and the second is full of zeros except at two time steps. The network is trained to generate the sum of the two numbers in the first data stream corresponding to the time-steps when the second stream had non-zero entries. The baseline to beat is a mean square error (mse) of 0.1767, corresponding to a network that always generates 1. We adopt a curriculum learning (Bengio et al., 2009) procedure for this task, by first training the RNN cell on a short sequence and progressively increasing the number of time steps. Each curriculum used 10,000 training and 1000 test samples. The length of the task was incremented when the mse went below 0.001. The SimpleRNN cell failed to converge beyond sequences of length 40, while the lpRNN cell converged to mse $< 0 . 0 0 1$ for sequences up to 642 steps. Interestingly, the
+
+Long Short-Term Memory (LSTM) cell learnt a general solution when trained by this procedure and could solve arbitrarily long sequences, even with just two hidden units in the cell!
+
+Temporal copying task: We train the RNN cells on a varying length copying task as defined in (Graves et al., 2014) instead of the original definition (Hochreiter and Schmidhuber, 1997; Arjovsky et al., 2016). This problem is harder to solve than the temporal addition task. The network receives a sequence of up to S symbols (in the original definition, S is fixed) drawn from an alphabet of size K. At the end of S symbols, a sequence of T blank symbols ending with a trigger symbol is passed. The trigger symbol indicates that the network should reproduce the first S symbols in the same order. We adopt a curriculum learning procedure here too and first train the network on a short sequence $( \mathrm { T } { = } 3 )$ and gradually increase it $( \mathrm { T } { \leq } 2 0 0 )$ . The sequence length is incremented when the categorical accuracy is better than $9 9 \%$ . The SimpleRNN cell failed at this task even for $\mathrm { T } { = } 3 0$ . The lpRNN cell was able to achieve $9 9 \%$ accuracy for up to 120 time steps. After that, it generates $\mathrm { T }$ blank entries accurately but the accuracy of the last S symbols drops (For ${ \mathrm { T } } { = } 2 0 0$ , it was $96 \%$ ).
+
+Spoken phrase classification: The target for the lpRNN cell are neuromorphic platforms that are typically resource-constrained, due to power, memory, and area restrictions. Therefore, we test the performance of the lpRNN cell on a problem that is compatible with such systems (see supplementary section D). We chose a limited vocabulary spoken commands detection task using the Google commands dataset (Warden, 2018), which comprises 36 classes of short-length spoken commands such as “left”, “up”, or “go”. The dataset was created for hardware and algorithm developers to evaluate their low footprint neural network models in limited dictionary speech recognition tasks. The neural network receives a Mel-spectrogram as inputs, and comprises, from input to output, two fully-connected dense layers with 128 and 32 units with batch normalization, two RNN layers with 128 units, two fully-connected dense layers, topped by a softmax readout. In total, the network has about 80K trainable parameters. We use Adam optimizer (Kingma and Ba, 2014), with a learning rate of 0.001 for training. We note that all lpRNN variants massively outperform the SimpleRNN and slightly outperform the LSTM variants, all with the same number of parameters. We further note that the performance of the network peaks for certain values of $\alpha$ and the random sampling case. The high performance of the lpRNN cell is a crucial result because not only did the addition of the low-pass filter enable mapping of the recurrent ANN model to neuromorphic platforms, it also resulted in a much-improved performance.
+
+Table 5: Performance of the lpRNN cell on the Google commands classification task with different filtering coefficients, $\alpha$ . $\alpha = 0$ is equivalent to a SimpleRNN and $\alpha = 1$ is an MLP.   
+
+<table><tr><td>α</td><td>[0.1,1]</td><td>0</td><td>0.1</td><td>0.5</td><td>0.8</td><td>0.9</td><td>0.99</td><td>1</td></tr><tr><td> Accuracy</td><td>93%</td><td>26%</td><td>25%</td><td>69%</td><td>92%</td><td>93%</td><td>90%</td><td>4%</td></tr></table>
+
+Energy-efficiency estimation: We compare the energy cost of computing a two-layer RNN with 128 hidden units (used in the audio task) for an in-memory lpRNN system with $\Sigma \Delta$ neurons against Cortex-M4, a popular low-power microprocessor used in milliWatt-range applications. We conservatively estimate that our implementation yields $5 0 0 \times$ better energy-efficiency in this instance. Larger networks will see a dramatic increase in this difference. (see supplementary section J).
+
+# 6 CONCLUSION AND OUTLOOK
+
+We presented a novel aI&F spiking neuron model and discussed its spike-coding and noise-tolerance benefits. Then, we discussed how the LPF abstraction of the aI&F neuron model enables training of recurrent SNNs without having to simulate the complex dynamics of a large network of spiking neurons. This strategy enables training a recurrent SNN using standard optimization algorithms such as backpropagation. The mapping technique that allowed us to achieve this result is studied in detail, including its limitations.. We observe a dramatic improvement in the performance of the RNN cell with the addition of the low-pass filtering term. We think that this improvement is because the LPF acts as a temporal regularizer (see supplementary section C). Current spiking RNNs are benchmarked on much simpler tasks than presented in this paper, often due to the computational cost and lack of algorithms for training them. The importance of this work lies in proposing algorithmic solutions to address this key problem, to enable a new generation of ultra-low-power neuromorphic chips.
+
+# REFERENCES
+
+Ahn, J., Yoo, S., Mutlu, O., and Choi, K. (2015). Pim-enabled instructions: a low-overhead, locality-aware processing-in-memory architecture. In 2015 ACM/IEEE 42nd Annual International Symposium on Computer Architecture (ISCA), pages 336–348. IEEE.
+
+Aimar, A., Mostafa, H., Calabrese, E., Rios-Navarro, A., Tapiador-Morales, R., Lungu, I.-A., Milde, M. B., Corradi, F., Linares-Barranco, A., Liu, S.-C., et al. (2018). Nullhop: A flexible convolutional neural network accelerator based on sparse representations of feature maps. IEEE transactions on neural networks and learning systems.
+
+Akopyan, F., Sawada, J., Cassidy, A., Alvarez-Icaza, R., Arthur, J., Merolla, P., Imam, N., Nakamura, Y., Datta, P., Nam, G.-J., et al. (2015). Truenorth: Design and tool flow of a 65 mw 1 million neuron programmable neurosynaptic chip. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 34(10):1537–1557.
+
+Arjovsky, M., Shah, A., and Bengio, Y. (2016). Unitary evolution recurrent neural networks. In International Conference on Machine Learning, pages 1120–1128.
+
+ARM (2019). Arm cortex. Datasheet Cortex-M4. Accessed on 2019-11-07.
+
+Bai, S., Kolter, J. Z., and Koltun, V. (2018). An empirical evaluation of generic convolutional and recurrent networks for sequence modeling. arXiv preprint arXiv:1803.01271.
+
+Beer, R. D. (1995). On the dynamics of small continuous-time recurrent neural networks. Adaptive Behavior, 3(4):469–509.
+
+Bengio, Y., Louradour, J., Collobert, R., and Weston, J. (2009). Curriculum learning. In Proceedings of the 26th annual international conference on machine learning, pages 41–48. ACM.
+
+Bohte, S. M. (2012). Efficient spike-coding with multiplicative adaptation in a spike response model. In Advances in Neural Information Processing Systems, pages 1835–1843.
+
+Brette, R. and Gerstner, W. (2005). Adaptive exponential integrate-and-fire model as an effective description of neuronal activity. Journal of neurophysiology, 94(5):3637–3642.
+
+Cavigelli, L. and Benini, L. (2016). Origami: A 803-gop/s/w convolutional network accelerator. IEEE Transactions on Circuits and Systems for Video Technology, 27(11):2461–2475.
+
+Chan, V., Liu, S.-C., and van Schaik, A. (2007). Aer ear: A matched silicon cochlea pair with address event representation interface. IEEE Transactions on Circuits and Systems I: Regular Papers, 54(1):48–59.
+
+Chen, Y.-H., Krishna, T., Emer, J. S., and Sze, V. (2016). Eyeriss: An energy-efficient reconfigurable accelerator for deep convolutional neural networks. IEEE Journal of Solid-State Circuits, 52(1):127– 138.
+
+Chicca, E., Stefanini, F., Bartolozzi, C., and Indiveri, G. (2014). Neuromorphic electronic circuits for building autonomous cognitive systems. Proceedings of the IEEE, 102(9):1367–1388.
+
+Chung, J., Gulcehre, C., Cho, K., and Bengio, Y. (2014). Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555.
+
+Davies, M., Srinivasa, N., Lin, T.-H., Chinya, G., Cao, Y., Choday, S. H., Dimou, G., Joshi, P., Imam, N., Jain, S., et al. (2018). Loihi: A neuromorphic manycore processor with on-chip learning. IEEE Micro, 38(1):82–99.
+
+Diehl, P. U., Neil, D., Binas, J., Cook, M., Liu, S.-C., and Pfeiffer, M. (2015). Fast-classifying, highaccuracy spiking deep networks through weight and threshold balancing. In 2015 International Joint Conference on Neural Networks (IJCNN), pages 1–8. IEEE.
+
+Frenkel, C., Lefebvre, M., Legat, J.-D., and Bol, D. (2019). A 0.086-mm2 12.7-pj/sop 64k-synapse 256-neuron online-learning digital spiking neuromorphic processor in 28-nm cmos. IEEE transactions on biomedical circuits and systems, 13(1):145–158.
+
+Gers, F. A., Schmidhuber, J., and Cummins, F. (2000). Learning to forget: Continual prediction with lstm. Neural Computation, 12(10):2451–2471.
+
+Gerstner, W. and Kistler, W. M. (2002). Spiking neuron models: Single neurons, populations, plasticity. Cambridge university press.
+
+Gewaltig, M.-O. and Diesmann, M. (2007). Nest (neural simulation tool). Scholarpedia, 2(4):1430.
+
+Ghose, S., Hsieh, K., Boroumand, A., Ausavarungnirun, R., and Mutlu, O. (2018). Enabling the adoption of processing-in-memory: Challenges, mechanisms, future research directions. arXiv preprint arXiv:1802.00320.
+
+Google (2019). Audio recognition. Github source code for Tensorflow v1.x. Accessed on 2019-11-07.
+
+Graves, A., Wayne, G., and Danihelka, I. (2014). Neural turing machines. CoRR, abs/1410.5401.
+
+Hamilton, T. J., Jin, C., Van Schaik, A., and Tapson, J. (2008). An active 2-d silicon cochlea. IEEE Transactions on biomedical circuits and systems, 2(1):30–43.
+
+Henaff, M., Szlam, A., and LeCun, Y. (2016). Recurrent orthogonal networks and long-memory tasks. arXiv preprint arXiv:1602.06662.
+
+Hochreiter, S. and Schmidhuber, J. (1997). Long short-term memory. Neural computation, 9(8):1735– 1780.
+
+Hu, Y., Huber, A., Anumula, J., and Liu, S.-C. (2018). Overcoming the vanishing gradient problem in plain recurrent networks. arXiv preprint arXiv:1801.06105.
+
+Jaeger, H. (2002). Tutorial on training recurrent neural networks, covering BPPT, RTRL, EKF and the" echo state network" approach. GMD-Forschungszentrum Informationstechnik.
+
+Jaeger, H., Lukoševicius, M., Popovici, D., and Siewert, U. (2007). Optimization and applications of ˇ echo state networks with leaky-integrator neurons. Neural networks, 20(3):335–352.
+
+Kim, Y., Jernite, Y., Sontag, D., and Rush, A. M. (2016). Character-aware neural language models. In Thirtieth AAAI Conference on Artificial Intelligence.
+
+Kingma, D. P. and Ba, J. (2014). Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980.
+
+Le, Q. V., Jaitly, N., and Hinton, G. E. (2015). A simple way to initialize recurrent networks of rectified linear units. arXiv preprint arXiv:1504.00941.
+
+Li, S., Li, W., Cook, C., Zhu, C., and Gao, Y. (2018). Independently recurrent neural network (indrnn): Building a longer and deeper rnn. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5457–5466.
+
+Marcus, M., Kim, G., Marcinkiewicz, M. A., MacIntyre, R., Bies, A., Ferguson, M., Katz, K., and Schasberger, B. (1994). The penn treebank: annotating predicate argument structure. In Proceedings of the workshop on Human Language Technology, pages 114–119. Association for Computational Linguistics.
+
+Moradi, S., Qiao, N., Stefanini, F., and Indiveri, G. (2018). A scalable multicore architecture with heterogeneous memory structures for dynamic neuromorphic asynchronous processors (DYNAPs). Biomedical Circuits and Systems, IEEE Transactions on, 12(1):106–122.
+
+Mostafa, H. (2017). Supervised learning based on temporal coding in spiking neural networks. IEEE transactions on neural networks and learning systems, 29(7):3227–3235.
+
+Mozer, M. C. (1992). Induction of multiscale temporal structure. In Advances in neural information processing systems, pages 275–282.
+
+Nair, M. V. and Indiveri, G. (2019). An ultra-low power sigma-delta neuron circuit. In 2019 IEEE International Symposium on Circuits and Systems (ISCAS), pages 1–5.
+
+Neckar, A., Fok, S., Benjamin, B. V., Stewart, T. C., Oza, N. N., Voelker, A. R., Eliasmith, C., Manohar, R., and Boahen, K. (2019). Braindrop: A mixed-signal neuromorphic architecture with a dynamical systems-based programming model. Proceedings of the IEEE, 107(1):144–164.
+
+Neil, D., Pfeiffer, M., and Liu, S.-C. (2016). Phased lstm: Accelerating recurrent network training for long or event-based sequences. In Advances in neural information processing systems, pages 3882–3890.
+
+Oliphant, T. (2006). Guide to NumPy.
+
+Pascanu, R., Mikolov, T., and Bengio, Y. (2013). On the difficulty of training recurrent neural networks. In International Conference on Machine Learning, pages 1310–1318.
+
+Paszke, A., Gross, S., Chintala, S., Chanan, G., Yang, E., DeVito, Z., Lin, Z., Desmaison, A., Antiga, L., and Lerer, A. (2017). Automatic differentiation in PyTorch. In NIPS Autodiff Workshop.
+
+Pavan, S., Schreier, R., and Temes, G. C. (2017). Understanding delta-sigma data converters. John Wiley & Sons.
+
+Pelgrom, M., Duinmaijer, A., and Welbers, A. (1989). Matching properties of MOS transistors. IEEE Journal of Solid-State Circuits, 24(5):1433–1440.
+
+Qiao, N., Mostafa, H., Corradi, F., Osswald, M., Stefanini, F., Sumislawska, D., and Indiveri, G. (2015). A reconfigurable on-line learning spiking neuromorphic processor comprising 256 neurons and 128k synapses. Frontiers in neuroscience, 9:141.
+
+Rethinagiri, S. K., Palomar, O., Ben Atitallah, R., Niar, S., Unsal, O., and Kestelman, A. C. (2014). System-level power estimation tool for embedded processor based platforms. In Proceedings of the 6th Workshop on Rapid Simulation and Performance Evaluation: Methods and Tools, page 5. ACM.
+
+Rueckauer, B., Lungu, I.-A., Hu, Y., Pfeiffer, M., and Liu, S.-C. (2017). Conversion of continuousvalued deep networks to efficient event-driven networks for image classification. Frontiers in neuroscience, 11:682.
+
+Sainath, T. and Parada, C. (2015). Convolutional neural networks for small-footprint keyword spotting.
+
+Sarpeshkar, R. (1998). Analog versus digital: Extrapolating from electronics to neurobiology. Neural Computation, 10(7):1601–1638.
+
+Schaller, R. R. (1997). Moore’s law: past, present and future. IEEE spectrum, 34(6):52–59.
+
+Schemmel, J., Grübl, A., Hartmann, S., Kononov, A., Mayr, C., Meier, K., Millner, S., Partzsch, J., Schiefer, S., Scholze, S., Schüffny, R., and Schwartz, M. (2012). Live demonstration: A scaled-down version of the BrainScaleS wafer-scale neuromorphic system. In IEEE International Symposium on Circuits and Systems ISCAS 2012, page 702.
+
+Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I., and Salakhutdinov, R. (2014). Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929–1958.
+
+Stimberg, M., Brette, R., and Goodman, D. (2019). Brian 2: an intuitive and efficient neural simulator. BioRxiv, page 595710.
+
+Waldrop, M. M. (2016). The chips are down for moore’s law. Nature News, 530(7589):144.
+
+Wang, Y. and Tian, F. (2016). Recurrent residual learning for sequence classification. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 938–943.
+
+Warden, P. (2018). Speech commands: A dataset for limited-vocabulary speech recognition. arXiv preprint arXiv:1804.03209.
+
+Xingjian, S., Chen, Z., Wang, H., Yeung, D.-Y., Wong, W.-K., and Woo, W.-c. (2015). Convolutional lstm network: A machine learning approach for precipitation nowcasting. In Advances in neural information processing systems, pages 802–810.
+
+Yoon, Y. C. (2016). Lif and simplified srm neurons encode signals into spikes via a form of asynchronous pulse sigma–delta modulation. IEEE transactions on neural networks and learning systems, 28(5):1192–1205.
+
+A MOTIVATION FOR THE USE OF THE SIGMA-DELTA NEURON MODEL
+
+# A.1 CODING MECHANISM
+
+A neuron in deep learning has one primary function - the non-linear transformation of its input. However, a biological neuron and its neuromorphic counterpart have the added job of encoding information in spike trains. The most popular model for this encoding mechanism is rate coding, where the neuron fires at a rate proportional to the incoming signal. This mechanism is not efficient for transmitting high-resolution data. For example, to transmit a signal at 8-bit resolution, it will require O(256) spikes for each sample. An improvement to this coding mechanism is theaI&F model (Brette and Gerstner, 2005), which can be interpreted as an asynchronous delta-sigma $( \Delta \Sigma )$ loop (Yoon, 2016; Bohte, 2012; Nair and Indiveri, 2019). The $\Delta \Sigma$ mechanism is a time-coding model that is more efficient in its use of spike trains (Nair and Indiveri, 2019) than rate-coding models. Other time-coding schemes have also been proposed in literature (Rueckauer et al., 2017; Gerstner and Kistler, 2002). However, the advantage of the $\Delta \Sigma$ interpretation is that it leads to highly power-efficient circuit implementations (Nair and Indiveri, 2019) that is tolerant to mismatch and noise effects. Furthermore, the model allows us to treat the neuron state as an analogue variable and ignoring the specific timing details of the encoding spike trains (Nair and Indiveri, 2019). The independence from the monitoring precise spike-times is beneficial because state-dependency, noise and device mismatch cause different neurons to generate spikes at different times for the same input. Modelling it is computationally expensive. The $\Delta \Sigma$ feedback loop ensures that they all represent the same signal with the same accuracy in spite of their differences (Nair and Indiveri, 2019). This abstraction enables the network designer to only look at the internal state of the neuron when optimizing the network weights for an SNN. It is a crucial enabler for this paper as simulating and training mismatch-prone SNNs is computationally much more expensive than ANNs.
+
+# A.2 BIOLOGICAL NEURAL NETWORKS ARE LOW PASS FILTERING
+
+Activation functions used in neural networks and apply a non-linearity to a weighted sum of input signals. However, ANNs assume that when the input changes, the internal state of the neuron or dendrites can also change immediately to reflect the new input. This behaviour ignores the fact that biological neuronal channels are LPFs (Gerstner and Kistler, 2002). Modelling the inertial or low-pass filtering property is essential to implement and study recurrent neural networks in any neuromorphic system as the transitional dynamics deviate completely in its absence. The $\Delta \Sigma$ neuron models the filtering behaviour with a first-order low pass filter. We argue that not only is this modelling essential, it is also a useful constraint to impose on RNNs.
+
+# A.3 CHANNEL NOISE AND RECONSTRUCTION ACCURACY IN A SPIKING NEURON
+
+The $\Sigma \Delta$ scheme encodes the information in the relative timing of the spikes. This implies that any noise in the spike timing, i.e. jitter, introduced during transmission of the spikes will result in distortion of the reconstructed signal, for example, in situations when the transmitting and receiving neurons are on separate chips. The distortions are modelled by a random variable $\Delta _ { t }$ , which is sampled from a normal random distribution, $\Delta _ { t } \sim \mathcal { N } ( 0 , j _ { \sigma } ^ { 2 } )$ with probability distribution function $P r ( \bar { \Delta } _ { t } )$ . Note that a fixed delay does not contribute to distortion and is ignored. To compute the effect of spike timing noise, we calculate the Laplace domain representation of the transmitted signal as follows. If $I _ { D } ( t )$ is the Dirac delta function, the transmitted spike train $y ( t )$ , jitter-affected spike train, $y ^ { \prime } ( t )$ , the desired filtered spike train, $s ( t )$ , and the filtered version of the jitter-affected spike-train,
+
+![](images/9f9d9d63de22b35d0ac3bced7f49b5dc2590cbc420985ca30219c57792527226.jpg)  
+Figure A.1: The different transfer function of the $\Sigma \Delta$ neuron model. Red: Signal transfer function, Blue: noise transfer function, Green: Signal transfer function with spike timing noise.
+
+$r ( t )$ can be expressed as,
+
+$$
+\begin{array} { c } { y ( t ) = \displaystyle \sum _ { k = 0 } ^ { N } I _ { D } ( t - k _ { k } ) } \\ { y ^ { \prime } ( t ) = \displaystyle \sum _ { k = 0 } ^ { N } I _ { D } ( t - k _ { k } - \Delta _ { t } ) } \\ { s ( t ) = y ( t ) \star h ( t ) = \displaystyle \sum _ { k = 0 } ^ { N } h ( t - t _ { k } ) } \\ { \implies S ( s ) = \displaystyle \sum _ { k = 0 } ^ { N } H ( s ) e ^ { - \alpha t _ { k } } } \\ { r ( t ) = y ^ { \prime } ( t ) \star h ( t ) = \displaystyle \sum _ { k = 0 } ^ { N } h ( t - t _ { k } - \Delta _ { t } ) } \end{array}
+$$
+
+The mean value of $r ( t )$ can then be computed as
+
+$$
+\begin{array} { l } { \displaystyle \bar { r } ( t ) = E [ r ( t ) ] = \sum _ { k = 0 } ^ { N } \int _ { \Delta _ { t } = - \infty } ^ { \infty } P r ( \Delta _ { t } ) \cdot h ( t - t _ { k } - \Delta _ { t } ) } \\ { \displaystyle = \sum _ { k = 0 } ^ { N } P r \star h ( t - t _ { k } ) } \\ { \displaystyle \Longrightarrow \ \overline { { R } } ( s ) = \mathcal { L } \{ \bar { r } ( t ) \} = \sum _ { k = 0 } ^ { N } P ( s ) H ( s ) e ^ { - s t _ { k } } = P ( s ) S ( s ) } \end{array}
+$$
+
+where, $P ( s ) = \mathcal { L } \{ \mathrm { P r } ( t ) \} = e ^ { \frac { s ^ { 2 } j _ { \sigma } ^ { 2 } } { 2 } }$ . $\overline { { R } } ( s )$ is plotted in Figure A.1 as the recovery transfer function $j _ { \sigma } = 1 m s$   
+affect the signal transmission accuracy.
+
+# B COMPARISON TO OTHER RNN MODELS
+
+The low pass filtering behaviour of neurons is well-known in neuro-scientific literature (and in other fields) and has been studied in the past with RNNs as well(Beer, 1995; Mozer, 1992; Jaeger et al., 2007). For example, ESNs as proposed by Herbert Jaeger (Jaeger et al., 2007) has an identical formulation to the lpRNN where the recurrent layer uses leaky integration units. In ESNs, the spectral radius of the initialization values of the recurrent kernel is constrained to confers an “echo-state property” to the network. The recurrent or input connectivity weights are not trained during the learning process. Instead, only the read-out linear classifier is trained. In the lpRNN model, the spectral radius of the recurrent kernel is not constrained and all the weight matrices, including the retention ratios if required, are trained. lpRNN also shares similarities with recurrent residual networks proposed by Yiren Wang (Wang and Tian, 2016), which are described by the following equations
+
+$$
+y _ { t } = f ( g ( y _ { t - 1 } ) ) + \sigma ( y _ { t - 1 } , x _ { t } , W )
+$$
+
+where $W$ denotes input and recurrent kernels, and other symbols have the same meaning as equation 6. In equation 16, $g$ and $f$ are identity and a hyperbolic tangent functions, respectively. A comparison can also be made with the LT-RNN model proposed by Mikael Henaff (Henaff et al., 2016), whose update equations are:
+
+$$
+\begin{array} { l } { h _ { t } = \sigma ( W _ { i n } \cdot x + b ) + V \cdot h _ { t - 1 } } \\ { y _ { t } = W \cdot h _ { t } } \end{array}
+$$
+
+where $W$ and $V$ are 2-D transition matrices that are learned during the training process. In this case, it is possible that the LT-RNN cell reduces to an lpRNN, but is unlikely to occur in practice. Similar analogies can also be made to the IndRNN model (Li et al., 2018) and recurrent identity networks (Hu et al., 2018). Generally speaking, the main difference between the lpRNN cells and popular RNN models in use today is the(re)indroduction of the filtering term into the RNN model with impositions on boundary and train-ability conditions. We see that in addition to enabling their use in neuromorphic platforms, this results in more stable convergence properties due to a temporal regularization effect, as described in the Section C.
+
+# C MEMORY IN AN LPRNN
+
+We can analyze the evolution of an lpRNN cell by using an approach similar to the power iteration method, described by Razvan Pascanu (Pascanu et al., 2013). To do this analysis, we approximate the lpRNN update equation as:
+
+$$
+y _ { t } = \alpha \odot y _ { t - 1 } + ( 1 - \alpha ) \odot ( W _ { r e c } \cdot y _ { t - 1 } + W _ { i n } \cdot x _ { t } + b )
+$$
+
+where, for simplicity, we also make the added assumption that all units of the lpRNN layer have the same retention factor, $\alpha$ . The gradient terms during back-propagation through time can now be expressed as a product of several terms that have the form:
+
+$$
+\frac { \delta y _ { t } } { \delta y _ { k } } = [ ( 1 - \alpha ) W _ { r e c } ^ { T } + \alpha ] ^ { l }
+$$
+
+where, $t$ and $k$ , are time step indices with $t > k$ and $l = t - k$ . If an eigenvalue of the $W _ { r e c } ^ { T }$ matrix is , then the corresponding eigenvalue of the matrix $[ ( 1 - \alpha ) W _ { r e c } ^ { T } + \alpha ]$ re can be written as
+
+$$
+( 1 - \alpha ) \lambda + \alpha
+$$
+
+Looking at the eigenvalue of the gradient terms as computed in equation 21, we note that $\alpha$ acts like a temporal regularizer on the eigenvalues of the recurrent network. It can also be seen that by scaling $\alpha$ to lie between 0 and 1, the operation of the network shifts between that of purely non-inertial recurrent to a completely inertial network stuck in its initial state, respectively. This insight helps us understand why lpRNNs perform well in long memory tasks.
+
+Hochreiter (Hochreiter and Schmidhuber, 1997) defined the constant error carousel (CEC) as a central feature of the LSTM networks that allowed it to remember past events. In a crude sense, this corresponds to setting the retention ratio, $\alpha = 1$ . Forget gates were subsequently added by Felix A. Gers (Gers et al., 2000) to the original LSTM structure, that allowed the network to also erase unnecessary events that were potentially trapped in the CEC. This means that the average effective weight of the self-connection in the CEC was made $< 1$ . A randomly initialized set of $\alpha$ values with a reasonably large number of cells appears to have similar functionality. By setting $\alpha < 1$ , the network is guaranteed to lose memory over time, but if some of the $\alpha \mathbf { s }$ are close to 1, it may retain the information for a longer time frame. Moreover, the regularization effect of $\alpha \mathbf { s }$ also prevents the eigenvalues of the recurrent network from becoming too small, ensuring that memory is never lost immediately. We expect that the lpRNN model has a reduced representational power than gated RNN cells, not simply because it has $4 \mathbf { x }$ fewer parameters, but because the lpRNN state is guaranteed to fade with time whereas a gated cell can potentially store a state indefinitely.
+
+# D THE NEUROMORPHIC SIGNAL CHAIN
+
+The $\Delta \Sigma$ mapping mechanism requires defining suitable time constants for the lpRNN cell being trained by backprop. This can be derived for continuous-time signals from sensors or real-world signals such as an audio input by taking into account the bandwidth of the incoming signals as described earlier. We illustrate a reference neuromorphic signal chain for processing audio input in Figure D.2. The data received from the audio sensor is first filtered by an audio filtering stage such as the cochlea chips (Chan et al., 2007; Sarpeshkar, 1998; Hamilton et al., 2008). These systems typically implement mel-spaced filter banks. A neural network processes the filter outputs and drives an actuator system. A minimal configuration of weights and connectivity required to implement the lpRNN cell in a neuromorphic platform is illustrated in Figure D.2. It is a memory array with spiking neurons attached to the periphery of the system. Each memory cell acts as a transconductance stage - it receives voltage spikes and generates a scaled output current. These currents are summed by the Kirchoff’s current law and integrated by the neurons. Readers familiar with memory design and computer architecture may identify this as an in-memory computational unit. An in-memory neural network accelerator is energy-efficient, primarily because it eliminates movement of synaptic weights (Ghose et al., 2018; Qiao et al., 2015) from the memory to a far-away processing module. Instead, the activations of the neurons are transmitted to the other nodes in the network. The computation is no longer memory-bound unlike RNN computation on von Neumann style architecture. Figure D.2 implements a single spiking RNN stage (equivalent to an lpRNN), with green and red boxes highlighting the input and recurrent kernels, respectively. The architecture can be modified to implement a fully connected layer by eliminating recurrent connections. Note that an equivalent configuration can be also set up in fully-digital neuromorphic systems such as (Frenkel et al., 2019; Davies et al., 2018; Akopyan et al., 2015) that do not suffer from noise and mismatch issues, but may consume more area and power.
+
+![](images/43a996e81d92a641cf63f51a1886e179e97863f04f765b8362475c704eca0ae5.jpg)  
+Figure D.2: Top: A neuromorphic signal chain. Bottom: Architecture of an SNN accelerator implementing an lpRNN.
+
+Spiker is a transient-simulator for simulating large networks of spiking neurons and synapses using the Basic Linear Algebra Subprogams (BLAS) libraries. It is written in Python and uses the
+
+Numpy (Oliphant, 2006) library. There is also a PyTorch (Paszke et al., 2017) version that supports Graphical Processing Unit (GPU)-acceleration. Unlike spiking simulation tools like Brian2 (Stimberg et al., 2019) or NEST (Gewaltig and Diesmann, 2007), which are general-purpose solvers of Ordnary Differential Equations (ODEs), Spiker is a highly-specific simulator for systems where the only differential equation implemented is that of a first-order LPFs. The simulator is not designed to solve any differential equation. Instead, it allows us to run massive simulations of large networks comprising neuron and synapse models whose building blocks include first-order LPFs.
+
+# E.1 HOW DOES SPIKER WORK?
+
+Key idea #1 Constraining the support to first-order LPFs has the advantage that it allows us to create closed-form solutions to the differential equations at all time-step resolutions without loss of accuracy. The differential equation corresponding to a first-order LPF is the following:
+
+$$
+\tau { \frac { d x } { d t } } = - x
+$$
+
+The closed-form solution to this, ignoring the initial conditions takes the form
+
+$$
+x = x _ { 0 } \cdot e ^ { \frac { - t } { \tau } }
+$$
+
+A useful property of the exponential function is that $e ^ { - t 1 + t 2 } = e ^ { - t 1 } \cdot e ^ { - t 2 }$ . Therefore, we have a simple closed-form method to compute the state of a LPF at any arbitrary time, given an initial condition. This implies that if all the building blocks of a system are made of modules which have an exponential solution, then, given their initial state, it is possible to compute the state of the entire system at some arbitrary time in the future, precisely. This is a well-known property of all LTI systems.
+
+Key idea #2 However, a spiking system is not LTI. Therefore, it is not possible to predict the state of a spiking neural network at an arbitrary time in the future. Instead, the Spiker simulator takes tiny temporal steps and computes the state of the network variables at each step using the closed-form solution. At the end of each time-step, the neuron models check if it should spike and then resets the corresponding variable to zero. The spiking input to the synapses is a train of 1-bit values corresponding to the presence or absence of an incident spike from an upstream neuron. This implies that the precision of the spike-event is limited to the resolution of the simulation time-step. However, the key insight here is that, if the signals being transmitted have a bandwidth much smaller than the simulation time-step, the higher-order effects can be safely assumed to be gone.
+
+Moreover, in spiking neurons, small amounts of jitter in the spike-timing is well-tolerated. This is because of the noise-cancelling property of the feedback loop. Therefore, the Spiker simulator allows the user to set the simulation time-step to a large value that offers fast transient simulations — a fast-simulation trades-off against the precision of the simulated spike-timing.
+
+Finally, the simulator also allows us to program and simulate noise and mismatch effects in the neuron parameters, such as mismatch in the spiking threshold and time-constants. The Spiker simulator was used to run all the SNN simulations in this paper.
+
+# F VISUALIZING MAPPING OF A RECURRENT SNN
+
+The top row of Figure F.3 shows the mapping mechanism in action for a single test case. We note that as the depth of the network increases, the quality of fit degrades, but is still close to perfect as measured by the NMSE metric. The bottom row of Figure F.3 shows the mapping mechanism in action for devices with a very large $c _ { v _ { p } } = 1$ . We note that even in such cases, the performance in lower layers remains fairly stable and only gradually degrades as the depth increases.
+
+# G CONVERGENCE PLOTS FOR THE GOOGLE SPOKEN COMMANDS TASK
+
+Figure G.4 shows the convergence plots for various values of $\alpha$ .
+
+![](images/9741ad2e14360d1f8b47b99c74c45d42f8de8e3ca7bab33a7db9f34c9b7745d3.jpg)  
+Figure F.3: Dynamics in a two-layer RNN with 51 units per layer. The SNN output shown in the figures is the trace obtain by filtering the spike trains. The NMSE measures the quality of fit with 1 indicating a perfect match and $- \infty$ a very bad fit as described in Equation 7.
+
+![](images/3d9a5d3506ea83508cbd5c1e6afa0d43b50f51e326501379db4ffabefc347ef0.jpg)  
+Figure G.4: Performance of the lpRNN cell on the Google commands detection task: Categorical accuracy (Left) and Cross entropy loss (Right). We note that as higher values of $\alpha$ and random sampling results in faster convergence and better accuracy.
+
+# H MAPPING THE GOOGLE SPOKEN COMMANDS NETWORK
+
+Each 1-second recording from the dataset is transformed using the Mel-spectrogram into 25 frequency and 128 temporal bins. This sequence represents a single speech command for the ANN. Mapping the trained ANN to an SNN is challenging because of the limitation described earlier; A short length sequence does not give the SNN enough time to generate the spikes required to transmit information. On the other hand, it is too difficult to train a longer length sequence that is several thousand samples long. To address this issue, we train the ANN using the short sequence with 128 bins and demonstrate the mapped SNN by feeding it the same spectrogram data that is up-sampled to $1 \ : \mathrm { M H z }$ . The quality of the mapped recurrent SNN is demonstrated using the weights from the trained recurrent ANN for a single case in Figure H.5. The bottom row of Figure H.5 also shows the mapping mechanism in action for RNN layers that are affected by mismatch with $c _ { v _ { p } } = 0 . 2$ . The results indicate an excellent fit between the mapped and the original networks, even with mismatch. The prediction made by the SNN also matched that of the ANN. Unfortunately, it is computationally prohibitive to compare the accuracy results of the SNN to the reference model on the full dataset. We only demonstrate the mapping accuracy for the two recurrent layers of the network in Figure H.5 for a single command in this paper. A complete analysis of the accuracy performance will require testing on a neuromorphic system and will be the focus of a follow-up work.
+
+![](images/bc6112ca2f29a2e84ad3b850b4d5f6ef45c36d1ab02ddf32fbe3120decdeabce.jpg)  
+Figure H.5: Mapping a 2-layer 128 unit recurrent ANN trained to discriminate commands from the Google speech dataset to an equivalent recurrent SNN. The top row shows the mapping in action for neuron models unaffected by mismatch and the bottom row demonstrates it for mismatched units. The lpRNN cells have $\alpha = 0 . 9 9$ .
+
+# I EXTENDING THE LOW-PASS FILTERING IDEA TO OTHER RNN MODELS
+
+Our goal with introducing lpRNN cell was to enable faster and better training of SNNs. However, the analysis performed here indicates that low pass filtering also provides temporal regularization features which can benefit ANN-RNNs such as LSTMs. Therefore, we propose to extend the LSTM formulation by applying a low pass filter at the output $( h )$ , and call it an lpLSTM cell:
+
+Forget gate: $f _ { t } = S i g m o i d ( W _ { f } x _ { t } + W _ { r e c _ { f } } h _ { t - 1 } + b _ { f } )$ Input gate: $i _ { t } = S i g m o i d ( W _ { i } x _ { t } + W _ { r e c _ { i } } h _ { t - 1 } + b _ { i } )$ Output gate: $o _ { t } = S i g m o i d ( W _ { o } x _ { t } + W _ { r e c _ { o } } h _ { t - 1 } + b _ { o } )$ $\mathrm { S t a t e : ~ } c _ { t } = f _ { t } \odot c _ { t - 1 } + i _ { t } \odot \mathit { R e l u } ( W _ { c } x _ { t } + W _ { r e c _ { c } } h _ { t - 1 } + b _ { c } )$ ${ \mathrm { O u t p u t : ~ } } { \bar { h } } _ { t } = o _ { t } \odot R e l u ( c _ { t } )$ Filtered Output : $\mathbf { \Phi } : h _ { t } = \alpha \odot h _ { t - 1 } + ( 1 - \alpha ) \odot \bar { h } _ { t }$
+
+where, $W _ { r e c _ { x } }$ , $W _ { x }$ , $b _ { x }$ indicate the recurrent kernel, input kernel, and bias for the corresponding gate or state. Similar formulations for other RNN cells such as GRU (Chung et al., 2014), IndRNN (Li et al., 2018), Phased-LSTMs (Neil et al., 2016), Convolutional LSTMs (Xingjian et al., 2015), etc can be easily made.
+
+# I.1 EXPERIMENTAL RESULTS FOR THE LPLSTM CELL
+
+In this section, we benchmark the Low-Pass Long Short-Term Memory (lpLSTM) cells to their unfiltered variants. In our experiments, the learning rate was set to 0.005 and normalized gradient was clipped to 1. Current works describe use of various task-specific initialization constraints to solve the addition and copying tasks better (Henaff et al., 2016; Le et al., 2015). Instead of that, we use a data-driven curriculum learning protocol in our experiments and are able to obtain dramatically improved performance on these tasks. The networks used for the copying and addition tasks are fairly small. We also test it on a character-level language modelling task with the Penn Treebank dataset (Marcus et al., 1994) using a large network with roughly 19M parameters(Kim et al., 2016). We swap the lpLSTM cells with an LSTM cells in our experiments and the network architecture and hyper-parameter settings were left unchanged from the values reported by the original authors. A summary of our observations are as follows: The lpRNN cell exhibits a dramatically improved performance over the SimpleRNN cell. The low pass filter appears to have a temporal stabilization effect even for LSTM cells. However, when other regularization and stabilization techniques such as Dropout(Srivastava et al., 2014) are introduced, the benefit appears muted. It is possible that the large networks with low-pass RNN layers require network architecture tweaks to benefit from the filtering property, but it was not investigated in this work.
+
+# I.1.1 TEMPORAL ADDITION TASK
+
+The addition task (Le et al., 2015) involves processing two parallel input data streams of equal length. The first stream comprises random numbers $\in ( 0 , 1 )$ and the second is full of zeros except at 2 time steps. At the end of the sequence, the network should output the sum of the two numbers in the first data stream corresponding to the time-steps when the second stream had non-zero entries. The baseline to beat is a mean square error (mse) of 0.1767, corresponding to a network that always generates 1.
+
+We first train the RNN cell being tested on a short sequence and progressively increase the length. Each curriculum used 10,000 training and 1000 test samples. The results are shown in Figures I.6, where each stage of the curriculum learning process is marked with bands of different colours. The width of the band indicates the number of epochs taken for convergence. The length of the task was incremented when the mse went below 0.001. With random initialization, the SimpleRNN cell failed to converge beyond sequence length 40, even with curriculum learning. On the other hand, both the lpRNN and LSTM cells benefit from the curriculum learning protocol. The lpRNN cell was able to transfer learning for sequences shorter than 150 steps. While, the benefits of curriculum learning appears to have reduced beyond that, the lpRNN cells were able to achieve better than 0.001 mse for sequences up to 642. The performance of the lpRNN cell is at par or slightly inferior to other works in literature (Hochreiter and Schmidhuber, 1997; Arjovsky et al., 2016; Le et al., 2015; Hu et al., 2018), we achieved this result purely by random initialization. Another interesting outcome of this experiment was the effectiveness of a 2-unit LSTM cell in solving this task. It was was able to add sequences much longer(we tested up to 100K) than any reported work (where the networks are only able to solve the task for about 1/100th of the sequence length).
+
+Given the effectiveness of the training protocol, we made the task more complex by allowing the second stream to have up to 10 unmasked entries during training. The trained cell was tested with a data stream having more than 10 masked entries. The LSTM cell was successful in solving this problem a mse less than 1e-3, indicating that it learnt a general add and accumulate operation. Figure I.6c shows the evolution of the gating functions, internal state, and the state variables of an LSTM cell that was trained only on a fixed length sequence of 100 with mse less than 0.001. Contrast this against the stable dynamics of the network trained by curriculum learning in Figure I.6d in a 100K sequence with mse less than 1e-3 (Figure I.6) indicating almost perfect long-term memory and addition. To our knowledge, this kind of generalized learning by an LSTM cell has not been shown before.
+
+# I.1.2 TEMPORAL COPYING TASK
+
+We train the RNN cells on a varying length copying task as defined in (Graves et al., 2014) instead of the original definition (Hochreiter and Schmidhuber, 1997; Arjovsky et al., 2016). This problem is harder to solve than the temporal addition task. The network receives a sequence of up to S symbols (in the original definition, S is fixed) drawn from an alphabet of size K. At the end of S symbols, a sequence of T blank symbols ending with a trigger symbol is passed. The trigger symbol indicates that the network should reproduce the first S symbols in the same order. We first train the network on a short sequence $\scriptstyle ( \mathrm { T } = 3 )$ ) and gradually increase it $( \mathrm { T } { \leq } 2 0 0 )$ . The sequence length is incremented when the categorical accuracy is better than $9 9 \%$ .
+
+![](images/7d68c4c2e9eb5f0683ecb077d607947bc19459d7dd502672e40beb172a94f5e2.jpg)  
+Figure I.6: Curriculum learning on the masked addition task. LSTM cell trained without curriculum learning results in unstable state variables (c). When trained with curriculum learning it looks much more stable (d). Stars in (c) and (d) indicate value of the add mask.
+
+![](images/ab2530a59e11e6bbc4ab8a9fda012ab25a181cd885ffbbe3530221084bd6257b.jpg)  
+Figure I.7: Curriculum learning on the variable length copying task for a 256 unit lpRNN (top left) and a 128 unit LSTM cell (top right) and a 128 unit lpLSTM cell(bottom left and right).
+
+The SimpleRNN cell failed at this task even for $\mathrm { T } { = } 3 0$ with categorical accuracy dropping to $84 \%$ when it predicted only $\mathrm { \Omega } _ { \mathrm { { S + T } } }$ blank symbols. The lpRNN cell was able to achieve $9 9 \%$ accuracy for up to 120 time steps. After that, it generates $\mathrm { T }$ blank entries accurately but the accuracy of the last S symbols drops (For ${ \mathrm { T } } { = } 2 0 0$ , it was $9 6 \%$ ). However, the LSTM cell achieves more than $9 9 . 5 \pm \%$ accuracy for all tested sequence lengths, highlighting the advantage of curriculum learning. This is a big improvement over reported results (Arjovsky et al., 2016; Graves et al., 2014; Bai et al., 2018) where LSTM cells solved the task for much smaller values of $S$ and $T$ .
+
+We observed stability issues when training an LSTM cell for sequences longer than 30, even if it eventually converged by using smaller learning rates and gradient norm scaling. This makes a good test case to validate the temporal regularization property of the lpLSTM cell. In our tests, the lpLSTM cell converged without instability with categorical accuracy higher than $9 9 . 5 \%$ for all tested values of $\mathrm { T } ( \in [ 3 , 5 0 0 ] )$ ). It also to generalized larger values of S than the other cells $( \leq 2 5 )$ . The lpLSTM cell exhibited a gradual degradation in performance for larger values of S. We stop our simulations when the categorical accuracy fell below $96 \%$ . These results are summarized in Figure I.7.
+
+# I.1.3 PENN TREEBANK (PTB) CHARACTER MODEL
+
+We studied temporal regularization in a network trained on the PTB dataset (Marcus et al., 1994) by replacing the LSTM cells by its low pass variants. We choose a model with 19M parameters (Kim et al., 2016) and trained all variants using the same settings as described in (Kim et al., 2016) for 25 epochs. We note that both lpLSTM cells converge to a better score on the training set and a marginally poorer score on the train/validation set (refer Table 6). The lpLSTM cell with relu activation also converges unlike the plain relu LSTM cell validating our claim on temporal regularization.
+
+Table 6: Impact of temporal regularization on the Penn Treebank model.   
+
+<table><tr><td></td><td>Activation</td><td>Train perplexity</td><td>Validation Perplexity</td><td>Test Perplexity</td></tr><tr><td>LSTM</td><td>relu</td><td>approx. 641</td><td>approx. 641</td><td>Fails to converge</td></tr><tr><td></td><td>tanh</td><td>46.0948</td><td>83.9807</td><td>80.0873</td></tr><tr><td>lpLSTM</td><td>tanh</td><td>41.0545</td><td>84.6127</td><td>81.7519</td></tr><tr><td></td><td>relu</td><td>43.0602</td><td>84.1484</td><td>80.6946</td></tr></table>
+
+# J ENERGY CONSUMPTION ESTIMATION
+
+In this section, we describe the procedure used for comparing the power consumption of the inmemory architecture against a Cortex-M4 processor. This processor was chosen as it is one of the most common low-power MCU platforms in use today.
+
+In our analysis, we make a highly-optimistic estimate for the performance of the Cortex-M4 (ARM, 2019). We assume that there are no cache misses, that multiply and add operations take one clock cycle, the read from DRAM only consumes 6 pJ/bit, and also assume that the MCU is fully available for RNN computation. In particular, note that the memory cost per DRAM access should also include the address and data bus power consumption. This has been completely ignored in this analysis to keep things highly optimal on the Cortex-M4 side. We see that in such a configuration, the Cortex-M4 consumes only a few mW of power. In practice, the active power consumption of such processors tend to be in hundreds of mW (Rethinagiri et al., 2014).
+
+We estimate the performance of the in-memory unit (also in $1 8 0 \mathrm { n m }$ technology for the known neuron implementation (Nair and Indiveri, 2019)). These results are then tabulated and system activity is modelled for two RNN models in Figure J.8a (2 layer RNN with 128 units/layer) and Figure J.8b (4 layer RNN with 500 units/layer).
+
+The energy cost for the Cortex-M4 is modelled by the following equation:
+
+$$
+E _ { t o t } = \left( C l k _ { m u l } \cdot N _ { m u l } + C l k _ { a d d } \cdot N _ { a d d } \right) \cdot E _ { c l k } + M \cdot E _ { m e m }
+$$
+
+# where
+
+• $E _ { t o t }$ : Total power consumed • $C l k _ { m u l }$ : Number of clocks for multiply • $N _ { m u l }$ : Number of multiply operations in the task. • $C l k _ { a d d }$ : Number of clocks for addition. • $N _ { a d d }$ : Number of add operations in the task. • $E _ { c l k }$ : Energy consumed by the processor per clock. • $M$ : Number of memory bit accesses • $E _ { m e m }$ : Energy cost of a accessing a single bit.
+
+The energy cost for the in-memory architecture is modelled by the following equation:
+
+$$
+E _ { t o t } = ( N \cdot E _ { s p i k e } + M ) \cdot N _ { s p i k e s }
+$$
+
+# where
+
+• N: Number of neurons   
+• $E _ { s p i k e }$ : Energy per spike   
+• $N _ { s p i k e s }$ : Total number of spikes. This is computed for the $\Sigma \Delta$ model by computing the average firing rate as a function of the desired bit precision. This is approximating by equating the desired firing rate of the $\Sigma \Delta$ neuron to that of an oversampled clock necessary to achieve a desired Signal to Noise Ratio (SNR) (Pavan et al., 2017).   
+• M: Memory access cost. This is modelled by the the product of the read current while a spike is active.
+
+Each of the terms in the computation of the power consumption of the Cortex and in-memory systems are in turn calculated based on a number of hardware and operational assumptions that are listed in the tables. We note an improved energy-efficiency of several hundred times across the board in both configurations. We also note that the energy-savings is much higher for the larger network. This is simply because the number of sequential compute operations increases quadratically.
+
+![](images/fe959b9956c95e32090026d380388ff532938eba4788c809cae13e661f454f27.jpg)
+
+# (a) For a two-layer RNN with 128 units per layer
+
+![](images/e710a915cd6ae155ca825ea8199482498f74b831c2dbf8747121c88643413fd4.jpg)  
+(b) For a four-layer RNN with 500 units per layer   
+Figure J.8: Energy consumption comparison between an in-memory RNN accelerator implementing the lpRNN model against a Cortex M4.

parse/train/P7GUAXxS3ym/P7GUAXxS3ym.md

@@ -0,0 +1,242 @@
+# Improving Coherence and Consistency in Neural Sequence Models with Dual-System, Neuro-Symbolic Reasoning
+
+# Maxwell Nye∗ MIT
+
+Joshua B. Tenenbaum MIT
+
+Michael Henry Tessler MIT DeepMind
+
+Brenden M. Lake NYU Facebook AI Research
+
+# Abstract
+
+Human reasoning can be understood as an interplay between two systems: the intuitive and associative (“System 1”) and the deliberative and logical (“System 2”). Neural sequence models—which have been increasingly successful at performing complex, structured tasks—exhibit the advantages and failure modes of System 1: they are fast and learn patterns from data, but are often inconsistent and incoherent. In this work, we seek a lightweight, training-free means of improving existing System 1-like sequence models by adding System 2-inspired logical reasoning. We explore several variations on this theme in which candidate generations from a neural sequence model are examined for logical consistency by a symbolic reasoning module, which can either accept or reject the generations. Our approach uses neural inference to mediate between the neural System 1 and the logical System 2. Results in robust story generation and grounded instruction-following show that this approach can increase the coherence and accuracy of neurally-based generations.
+
+# 1 Introduction
+
+Despite recent success, neural sequence models often fail to produce consistent and coherent generations. When generating stories, language models may forget the attributes of specific characters (such as personality and background information) (Welleck et al., 2018), ignore previously established relationships between characters (such as family relationships) (Sinha et al., 2019), or otherwise contradict prior statements (Brown et al., 2020). Similarly, neural models can make statements that contradict basic world knowledge or the logical entailment structure of known facts.
+
+Lake & Murphy (2020) illustrated several of these issues with GPT-2 (Radford et al., 2019). When given prompts of the form “A dolphin is a ”, GPT-2 predicts that the most likely answer is “mammal”, “fish”, or “bird” depending on small differences in the wording of the prompt. In another example, GPT-2 states that unicorns have “four horns,” directly after implying that unicorns only have one horn. Upon diagnosing such issues, it is unclear how to apply a targeted fix to the model, especially if retraining or fine-tuning is impractical.
+
+In this work, we draw on insights from cognitive science, especially from “dual process” theories of reasoning (Evans, 2003), to explore how neural sequence models can better interface with prior knowledge and be made more coherent and consistent. According to dual process theories, human cognition can be understood as an interplay between a more intuitive and associative “System 1” and a more deliberative and logical “System 2.” Within this broad framework, automatic actions are driven by System 1, whereas System 2 engages for more deliberative control: for example, judging the validity of a logical argument that requires multiple steps of reasoning (Kahneman, 2013).
+
+![](images/c20d75f1293a76956af17c66db3e3cec0efd21ca62aa27c08f823624b84353b6.jpg)  
+Figure 1: Schematic of dual-system approach to text generation. Conditioned on previous text, a “System $1 ^ { \circ }$ neural generation model produces candidate next sentences. Semantic parses for each candidate are generated via few-shot parsing from GPT-3 and compared to a minimal world model to check consistency. Only candidates consistent with the world model state are incorporated into the final generation.
+
+The prominent neural language models of today are single systems, with weaknesses akin to those exhibited by the human System 1. For example, the cognitive reflection test (CRT) (Frederick, 2005) is a classic probe of System 1 vs. System 2 reasoning in humans. Participants answer a set of simple questions that have superficially compelling, but logically invalid, answers. These incorrect answers are often generated as a first “gut” response (putatively, by System 1 intuitive thinking); upon reflection, however, participants often realize that their responses were not logically or mathematically consistent (via more explicit System 2 reasoning). Consider the CRT problem on the left below:
+
+A ball and a bat cost $\$ 10$ . The bat costs one dollar more than the ball. How much does the ball cost?
+
+<table><tr><td>Total cost in prompt</td><td>GPT-3 response</td></tr><tr><td>$1.10</td><td>10 cents</td></tr><tr><td>$1.20</td><td>20 cents</td></tr><tr><td>$1.30</td><td>$0.30</td></tr><tr><td>$1.70</td><td>$0.70</td></tr></table>
+
+Reading quickly, you might be tempted to say the ball costs 10 cents. Most participants give this response, in fact, especially if they are under time pressure or have limited attention (Kahneman, 2013). Of course, if the bat is $\$ 1.00$ more than the ball, and the ball costs 10 cents, then the total cost would be $\$ 120$ . The correct answer is that the ball costs 5 cents. Notably, in this and other classic CRT problems, GPT-3 (Brown et al., 2020) predicts the same “gut” response (prediction in red above; the table above shows that adjusting the price in the prompt also leads to similar effects; see Appendix Figure 8 for more CRT examples). GPT-3 appears vulnerable to the same sort of intuitive, unsystematic pattern recognition errors as humans—in this case, incorrectly subtracting one dollar from $\$ 1.10$ , without confirming that the answer satisfies each of the problem constraints.
+
+Numerous studies have shown that engagement of System 2-style effort can help “override or inhibit default responses emanating from System 1” (Evans, 2003), correcting inconsistent or un-systematic intuitive impulses. For example, when System 2 is engaged by asking people to take more time to respond, people’s accuracy improves on the CRT task above (Kahneman, 2013). It has been argued that integrating System 2 processing could similarly improve AI systems (Goyal & Bengio, 2020; Garcez & Lamb, 2020), and here we explore this idea as applied to neural sequence models.
+
+In this work, we take inspiration from dual process theories to explore a neuro-symbolic generation system, wherein predictions from a neural model are treated as System 1 proposals, and a logical, deliberative System 2 filters these proposals for consistency and soundness (see Figure 1). We further take inspiration from the fact that humans often do not need explicit supervision to reason about new problems or domains (e.g., see human evaluation task in Section 4.2) and require that the System 2 module not need additional problem-specific training, especially on example contradictions or commonsense violations. People can handle novelty by reconfiguring, rather than retraining, their internal models (Lake et al., 2017), and we strive to build machine systems capable of the same. We show how a lightweight, easy-to-implement System 2 model can help improve coherence and consistency by adding a small amount of symbolic reasoning.
+
+We tackle two kinds of domains: text generation and instruction following. In both cases, we construct generative models over sequences by using a neural generation model to propose candidate generations and a symbolic world model that can accept or reject the generations and resample proposals if necessary. We first illustrate the approach by generating short stories based on the bAbI dataset (Weston et al., 2015); this pedagogical, synthetic example illustrates how basic commonsense knowledge of objects, agents, and places can inform a text generation model. We then test our approach on rich, natural language vignettes based on CLUTRR (Sinha et al., 2019), focusing on ensuring consistency of family and interpersonal relationships. In both text generation domains, we interface between the explicit logical knowledge/reasoning of System 2 and generations of System 1 using a few-shot learning approach with state-of-the-art neural language models (GPT-3), which requires no additional training or fine-tuning. Even using off-the-shelf transformers and symbolic solvers, our dual-system model improves the consistency and coherence of text generations as measured by human judges. We test our approach also on instruction following, showing how goalprediction models and execution models can easily be combined to achieve improved performance in low-data regimes. We show improvements over previous work in the gSCAN grounded compositional challenge (Ruis et al., 2020); a dual-system model requires much less data to train than previous models, and achieves higher accuracy and stronger generalization. Overall, our findings indicate that neuro-symbolic, dual process models are a promising means of addressing longstanding problems of robustness and consistency in neural sequence models.
+
+# 2 Related Work
+
+Our approach incorporates semantic parsing (Liang, 2016) as a component of a generative process, where neural generation is used in conjunction with parsing techniques. In our text generation experiments, we employ GPT-3 to perform few-shot semantic parsing without fine-tuning. Related work includes few or zero-shot semantic parsing using pre-training techniques and paraphrasing (Su & Yan, 2017; Herzig & Berant, 2020). It also includes semantic parsing systems trained either without supervision (Liang et al., 2017; Mou et al., 2017; Muhlgay et al., 2019), or with synthetic language data (Marzoev et al., 2020; Xu et al., 2020b).
+
+One popular technique for improving neural generations is generate-and-rerank, wherein one model generates proposals and another reranks them. This broad approach has been used in image generation (Ramesh et al., 2021), text generation (Holtzman et al., 2018; Shen et al., 2019; Deng et al., 2020), dialogue systems (for control, coherence and safety (Welleck et al., 2018; Smith et al., 2020; Nie et al., 2020; Xu et al., 2020a)), and instruction following (Kurita & Cho, 2020). Reranking is generally used to improve outputs with respect to relatively broad, holistic criteria. Here, our goal is to make generation robust to particular types of logical errors by pruning with respect to explicit symbolic constraints. Our approach can thus be considered closely related to techniques which employ explicit search to find generations satisfying particular logical constraints. Similar methods, such as guess-and-check or beam search pruning, have had success in neural program synthesis (Devlin et al., 2017; Nye et al., 2020).
+
+Recent work in NLP has used template-based planning, in which a model generates text by first generating a plan or skeleton, and filling in the missing words to produce naturalistic text (Xu et al., 2018; Hua & Wang, 2020). To generate stories, Martin et al. (2018) parses previous sentences into events and does planning in event space. Our work extends previous entity/relation/event planning in that the world model is not used for planning, but rather for post-checking candidate generations. Structured parsing of this type is also related to dialog tracking techniques such as slot-filling (Pieraccini et al., 1992). In our work, fully compositional logical facts are extracted from utterances. It is therefore more closely related to systems which extract programs from dialogue, such as Andreas et al. (2020).
+
+Recent work has also studied incorporating symbolic constraints into a neural decoding strategy in the context of natural language. Miao et al. (2019) introduce an MCMC-based inference-time propose-and-reject strategy for satisfying constraints. They test on constraints such as paraphrase and grammatical error correction. Lu et al. (2020) introduces “NeuroLogic decoding,” which uses logical constraints on neural language models to produce generations which contain (or do not contain) required (or forbidden) keywords. In these works, the constraints are lexical or based on word/sentence similarity (and provided in the problem setup for Lu et al. (2020)), whereas we study logical constraints on the world state decoded directly from observations or generations at test time. Other approaches for solving reasoning tasks end-to-end include Goyal et al. (2021), Serafini & d’Avila Garcez (2016), and Schlag & Schmidhuber (2018).
+
+# 3 Integrating System 1 and System 2
+
+We introduce our dual-system approach using examples from the bAbI domain (Weston et al., 2015), which we also use to perform diagnostic experiments. Consider generating a simple story involving people, places and objects, such as (from Figure 1):
+
+Daniel went to the garden. Mary traveled to the office. Daniel grabbed the apple.
+
+A model tasked with generating such stories must juggle several simultaneous demands: staying on topic and maintaining consistency of style and other textural elements (for which people rely on System 1), as well as maintaining consistency with previous statements and commonsense knowledge (for which people rely on both systems). Consider continuing the story with one of the following:
+
+(a) Daniel went to the patio. (b) Mary dropped the apple there.
+
+Sentence (a) is reasonable; sentence (b) is not because it is Daniel, not Mary, who has the apple. During generation, how might a model distinguish between these candidates? Perhaps a well-trained neural language model could track constraints of these sorts. Neural language models to date, however, often violate these types of commonsense, hard constraints without a large high-quality corpus or explicit training on detecting violations of commonsense (Sinha et al., 2019).
+
+We address this problem by decomposing text generation into two parts: candidate generation facilitated by deep neural networks and a logical pruning process implemented via a separate symbolic module. Consider again the example above. To ensure consistency, our model would extract from the text the features of the world that are subject to the hard, logical constraints, such as the location of objects and who is holding them. These constraints can then be checked against an explicit representation of current state of the world. For sentences (a) and (b), the system would extract and go(Daniel, patio) and drop(Mary, apple), respectively. A minimal world model would track the state of the apple, such that it maintains apple.holder $=$ Daniel (or equivalently, Daniel.inventory $=$ [apple]). When such a model is given a parse of a candidate generation, drop(Mary, apple), the mismatch between the current state and the proposed change would cause a violation, and the candidate generation will be rejected.
+
+The main steps of our general approach are illustrated in Figure 1: generate proposals from a System 1 proposal model, extract facts with a fact extraction model, and filter proposed generations by ensuring that they satisfy the constraints given by the extracted facts and the minimal world model.
+
+System 1: Generation. We use neural sequence models to produce System 1 generations. In text generation domains, we use a large, pre-trained model that can be fine-tuned or conditioned via a short prompt to generate relevant text. Text sampled from the System 1 model will be treated as candidate utterances, which will be parsed and filtered by System 2 (described below). For the bAbI examples, we use GPT-3 as our System 1 proposal model through few-shot prompting with 10 example bAbI stories as context, generating a new story one candidate sentence at a time.
+
+System 2: Fact extraction. A fact extractor, or parser, is used to mediate between the System 1 candidate proposals and the minimal world model within System 2. In our text generation domains, we use a pre-trained GPT-3 model without fine-tuning to perform parsing.
+
+For bAbI, our prompt consist of an initial descriptive sentence “Please parse the following statements into commands. The available commands are pickup, drop, and go.” and a small set $( < 1 0 )$ of representative semantic parsing examples (input $=$ sentences; output $=$ correct parses, such as go(Bob, roof)). The parse of each utterance is produced via few-shot prompting (Brown et al., 2020): the utterance is added to the end of the prompt, and the subsequent GPT-3 generation is interpreted as the target parse. We found that this simple parsing technique works well and could easily be applied to other parsing-based tasks, as in Shin et al. (2021). The parsing prompts are reproduced in full in the Appendix. As discussed in Section 5, for the $\mathrm { g S C A N }$ instruction following domain, fact extraction is performed with a learned goal location prediction model.
+
+System 2: Minimal world model. We use a lightweight, incomplete description of the state of the world as a world model in each domain, e.g., commonsense information about the people, objects and locations (Figure 1). The goal is not to track and verify all the possible information; instead, we aim for minimalism, capturing just a few commonsense (or application-critical) variables that we want to ensure are correct. The world model facilitates tracking of long-range logical dependencies and logical consequences, especially those which are not readily decodable from surface forms. The world model also lets us integrate rule-based world-knowledge without retraining (and without the need for a large set of labeled examples).
+
+For the bAbI examples, the minimal world model keeps track of the people, locations and objects introduced in the story so far (Figure 1). This encodes constraints on possible actions related to human core knowledge competencies (objects, agents, places) present early in human development (Spelke & Kinzler, 2007); specifically, a person or object can only be in one place at a time, an object can only be possessed by a single person at a time, a person cannot “go” to a room they are already in, and a person cannot pick up an object if it is in a different room. See the Appendix for details.
+
+Search. At generation time, the interaction between System 1 generation and System 2 parsing yields a neuro-symbolic, guess-and-check search strategy. In a text generation scenario, where text is sampled from the model, our dual-system model improves upon a naive, neural-only sampling method by using the System 2 model to reject candidate utterances which are incompatible with the current state. When a candidate is rejected, a new candidate utterance is sampled from the System 1 model, which is again checked by System 2. This process repeats until a candidate utterance is accepted by System 2 (i.e., the utterance is compatible with the world state). This procedure allows the model to effectively search the space of candidate utterances, guided by the logical constraints from the minimal world model. In this work, we use straightforward probabilistic sampling to illustrate that the approach works with even a very simple search mechanism. We imagine that the search procedure could be further optimized by applying, for example, beam search or stochastic beam sampling.
+
+Diagnostic bAbI experiments. We use Task $\# 2$ from bAbI as a diagnostic test for our neuro-symbolic dual-system model. As shown above, this task consists of synthetically-generated short stories involving people, places and objects, and questions concerning the locations of objects in these stories. We investigate performance on both question answering (QA) tasks and story generation. For the QA tasks, we parse each sentence in the story to encode each fact into the world model and parse the final question to query the world model, returning the answer given by the world
+
+GPT-3 only: John went to the bedroom.   
+John picked up the apple there.   
+Mary took the apple there.   
+Mary travelled to the office.   
+Daniel went back to the garden.   
+Mary went to the bedroom.   
+John went to the bedroom.   
+Sandra went to the bedroom.   
+Sandra travelled to the office.   
+Mary went back to the office.   
+Where is the apple? A: office GPT-3 $^ +$ world model: John went to the bedroom.   
+John picked up the apple there.   
+Mary travelled to the office.   
+Daniel went back to the garden.   
+Mary went to the bedroom.   
+Sandra went to the bedroom.   
+Sandra travelled to the office.   
+Mary went back to the office.   
+Where is the apple? A: bedroom
+
+Figure 2: Example bAbI stories generated by GPT-3 only (left) and our dual-system model (right). Logically inconsistent lines are written in red text, and are removed from the story-so-far at generation time.
+
+model. We compare with two alternative models (Table 3 in the Appendix): GPT-3 by itself and a dual-system baseline that uses a neural Natural Language Inference (NLI) model as its System 2. The NLI-based dual-system model generates 10 candidates from GPT-3 and selects the candidate with the highest predicted probability of entailment under the NLI model given the context. We use the RoBERTa MNLI model as our off-the-shelf neural NLI model (Liu et al., 2019), which operates as a System 2 that does not use additional problem-specific data or fine-tuning.2 On 200 held-out tasks, our GPT-3-based “fact extractor” achieves $100 \%$ QA accuracy, far exceeding the performance of GPT-3 alone $( 2 9 . 0 \% )$ or GPT-3 generation with neural NLI scoring $( 3 2 . 5 \%$ ; also see Table 3 in the Appendix). These results show that GPT-3 can be made to answer questions successfully when used for parsing with a world model, even when GPT-3 alone does not achieve high QA accuracy.
+
+To test story generation, we use our GPT-3-based System 1 proposal model (few-shot prompted on 10 example stories) to sample a new bAbI story, line-by-line. If a generated utterance is inconsistent with the current state as indicated by the System 2 world model, a new utterance is sampled from System 1 (repeating until a consistent utterance is sampled). Figure 2 shows how the dual-system approach generates stories that mimic the statistical structure of bAbI stories, while remaining logically sound In contrast, GPT-3 alone was not able to maintain logical coherence. In a set of 50 generated stories, all stories required at least one sentence to be resampled to maintain coherence, and over half of the generated sentences $( 5 3 . 1 \% )$ were rejected by our System 2 model to maintain logical consistency. These results demonstrate that equipping GPT-3 with a minimal world model produces logically coherent stories that mimic the textural structure of the bAbI domain. In the next section, we apply this approach to mimicking human-generated short stories in natural language.
+
+# 4 Coherent Language Generation - CLUTRR
+
+We apply our dual-system approach to a dataset of natural language using the CLUTRR dataset. CLUTRR contains human-written stories about people and their family relationships (see example in Figure 3). As with bAbI, CLUTRR was originally designed as a Question Answering challenge; instead, we use it to evaluate coherent language generation by querying models to generate complete CLUTRR-style stories or to complete partially-generated stories. Our particular aim is to produce stories with coherent and logically consistent family relationships. As above, our language generation setup consists of pre-trained language models acting as our System 1 proposer, a minimal world model as System 2, and a neural semantic parser (implemented via few-shot GPT-3 prediction) as a bridge between the two systems. We use human judgments to assess whether our neuro-symbolic, dual-system model produces more consistent and coherent stories relative to a baseline.
+
+# 4.1 Model specification
+
+Kristin and her son Justin went to visit her mother Carol on a nice Sunday afternoon.They went out for a movie together and had a good time.
+
+Q:How is Carol related to Justin ?
+
+As our System 1 proposal model, we used pretrained neural models to produce candidate generations one sentence at a time. We experimented with GPT-3 as our System 1 model (which we used above for bAbI), but found generations too unreliable, often outputting the empty string. Instead, we used a BART model (Lewis et al., 2019) that was fine-tuned on the
+
+CLUTRR training corpus. This model also gives us an opportunity to compare against a best-case neural “single-system” baseline, specifically fine-tuned on story data. To maintain a state of family relations, we use a constraint solver in our “System $2 ^ { \circ }$ to encode family relationships (e.g., child(x, ${ \tt y } )$ , spouse $\mathbf { \Psi } ( \mathbf { x } , \mathbf { \Psi } z ) ,$ ) and check that the candidate utterances do not contradict the previous statements (e.g., a person cannot be their own child or married to their sibling). We implemented the world model as a set of logical relations and constraints using the Z3 solver (De Moura & Bjørner, 2008). For instance, we require that the parent of $\mathtt { x }$ cannot also be the uncle of x: For all x, y, $\mathtt { u n c l e ( x , y ) } \Rightarrow \neg \mathtt { c h i l d ( y , x ) }$ . To check a candidate utterance, we query the solver to determine if the set of constraints is satisfiable or if there is a contradiction. The full set of constraints and other details can be found in the Appendix. We again used GPT-3 as our semantic parser, extracting parses for each candidate utterance via few-shot learning. This parsing approach worked well, even for the natural language in this domain. We observed that parsing with GPT-3 was more successful when the target parse was naturalistic, i.e., “Bob is Joe’s father.” rather than “father(Bob, Joe)”. The parsing prompt is reproduced in full in the Appendix.
+
+![](images/ec4fa337894acae8383e081ea66d706994e95a5c4138459856cf540cc4c46a35.jpg)  
+Figure 4: Example trial from CLUTRR human judgement experiment. Participants were instructed to select which of two options makes the most sense given the prompt. One option was generated by the System 1 model only (“single-system”), while the other was generated by the dual-system model.
+
+![](images/23551b86728bcb3d12e87976cf8ca4400fe58d0284de9a84ef95c28f8e78effb.jpg)  
+Figure 3: Sample story from the CLUTRR dataset. Each story consists of a sequence of humangenerated sentences concerning family relationships. Adapted from Sinha et al. (2019).   
+Figure 5: CLUTRR human judgment experiment results. Bars denote proportions of dual-system generations selected as making more sense over single-system generations, in each of four conditions. Error-bars denote bootstrapped $9 5 \%$ confidence intervals of the item means. The points denote means for each individual item in the experiment and are jittered horizontally for clarity.
+
+Table 1: Statistics from CLUTRR story generation. We report the percentage of generations (on both a per-line and per-story basis) for which the System 2 world model did not detect an error. The dual-system model is able to detect many inconsistencies in the neural single-system generations, and most can be corrected by re-sampling new candidates (up to a limit of ten).   
+
+<table><tr><td rowspan="2"></td><td colspan="2">% w/out error detected (per line)</td><td colspan="2">% w/out error detected (per story)</td></tr><tr><td>single-system (neural gen. only)</td><td>dual-system (neural gen.+world model)</td><td>single-system (neural gen. only)</td><td>dual-system (neural gen.+world model)</td></tr><tr><td>prompt from dataset</td><td>82.8</td><td>97.1</td><td>60</td><td>96.1</td></tr><tr><td>prompt from model</td><td>71.9</td><td>96.3</td><td>36.4</td><td>93.5</td></tr></table>
+
+# 4.2 Human judgments
+
+We test our dual-system neural generation $^ +$ world model method in its ability to generate stories that are deemed by naive human participants to be more naturalistic and coherent than those generated from the baseline models. Specifically, we asked participants to select which of two continuations made the most sense to them, where one continuation was generated from the neural model alone (single-system) and the other from a dual-system model (either the world model System 2 or the neural NLI System 2).
+
+Participants. Participants $\mathbf { N } = 1 0 1$ ) were recruited on the crowd-sourcing platform Prolific and compensated $\$ 2$ for the task ( ${ \sim } 1 5$ minutes, so roughly $\$ 8/\mathrm{ h o u r }$ ). Participants gave informed consent, and the study was approved by MIT’s IRB. 21 participants were excluded for failing an instruction quiz, incorrectly answering more than one of five filler questions, or finishing the task too quickly. The data we collected contains no personally identifiable information or offensive content.
+
+Procedure. Participants began the experiment by reading a set of instructions and answering comprehension questions. On each main trial, participants were shown a prompt consisting of several sentences and were asked to choose which of two possible continuations made the most sense (an example trial is shown in Figure 4). Participants were instructed that if a name appeared multiple times within a trial, then it referred to the same person, whereas if a name appeared across trials, then it was not referring to the same person. For each trial, one continuation option was generated by the neural only single-system baseline, while the other was a dual-system generation. We selected generations from the neural only baseline that were rejected by the System 2 model in order to maximize the differences between the models’ generations; thus, human judgments pertain to generations that the models disagreed on. Each participant performed between 20 and 26 trials.
+
+Materials. Participants were randomly assigned to one of four between-participant conditions, which varied according to the kind of prompt and the kind of dual-system model. The prompt was either generated from the model (up to the point of disagreement between System 1 and System 2 models; “Prompts from model” condition) or taken completely from the length 4 CLUTRR systematic generalization test dataset (“Prompts from dataset” condition). To generate prompts for the “from model” condition, we took the first sentence of each story from the CLUTRR test dataset and generated subsequent prompt sentences from the dual-system model; sentences were generated until the two systems disagreed (i.e., System 1 generated a sentence that System 2 rejected), at which point the “rejected sentence” served as the neural only (single-system) baseline generation and the first resampled sentence that System 2 accepted served as the dual-system generation. Prompts were sampled to a maximum length of four sentences. The dual-system model shown to participants used a System 2 based on either our constraint-based “world model” or the neural NLI baseline.
+
+Table 1 catalogs critical statistics from the stimulus generation process. We generated vignettes from the System 1 model and report the percentage of System 1 generations which are deemed correct by the System 2 model.3 We also report the percentage of generations corrected by the System 2 model (i.e., if System 1 made an error, could System 2 fix it within 10 attempts?). We report these statistics on both a per-story and per-line basis. According to System 2, the System 1 generation model makes a lot of errors (only $3 6 . 4 \%$ of stories and $7 1 . 9 \%$ of lines were error-free, in the “from model" condition). In most instances, re-sampling new generations yields stories that, according to
+
+Table 2: Accuracy on $\mathrm { g } \mathrm { S C A N }$ splits. Models were trained on 5000 examples (only $2 . 5 \%$ of the gSCAN training data). See Appendix Table 4 for additional results.)   
+
+<table><tr><td>Test split:</td><td>single-system5</td><td>dual-system</td></tr><tr><td>dev</td><td>71.7</td><td>83.3</td></tr><tr><td>random</td><td>57.2</td><td>74.7</td></tr><tr><td>yellow squares</td><td>68.1</td><td>81.3</td></tr><tr><td>red squares</td><td>64.9</td><td>78.1</td></tr><tr><td>novel direction</td><td>0.0</td><td>0.01</td></tr><tr><td>relativity</td><td>41.0</td><td>53.6</td></tr><tr><td>class inference</td><td>68.1</td><td>76.2</td></tr><tr><td>adverb (k=1)</td><td>0.0</td><td>0.0</td></tr><tr><td>adverb to verb</td><td>20.8</td><td>21.8</td></tr><tr><td colspan="3"></td></tr><tr><td colspan="3">³From Heinze-Deml &amp; Bouchacourt (2020)</td></tr></table>
+
+![](images/6b309f49955634199fe29a9959b4f5d1362ff58d0f63e41b64e1e429d4876dcf.jpg)  
+Figure 6: Schematic of our dual-system approach to $\mathrm { g S C A N }$ . We train a neural sequence model to predict both a distribution over action sequences, and a distribution over target locations. At test time, we decode candidate action sequences from the model, execute them on the gridworld, and only accept a sequence that brings the agent to the predicted target location (shown in green).
+
+System 2, no longer contain logical errors within a budget of 10 samples $9 3 . 5 \%$ of stories and $9 6 . 3 \%$ of lines were error-free, respectively).
+
+Results. The human evaluation indicates that System 2 is indeed correcting genuine errors in the stories. As summarized in Figure 5, participants strongly preferred the dual-system neural generation $^ +$ world model continuations in comparison to the neural only single-system continuations (proportion preferring dual-system $= 0 . 8 4$ ; bootstrapped $9 5 \%$ confidence interval [0.77, 0.89] and 0.79 [0.77, 0.89] for the “from dataset” and “from model” prompt conditions, respectively). The dual-system approach, however, did not improve generation quality when the System 2 was based on an off-the-shelf neural NLI model (Proportion preferring dual-system $= 0 . 5 1$ ; [0.40, 0.64] for “from dataset”; 0.58 [0.48, 0.68] for “from model”). Thus, when using a minimal world model, the dual-system approach dramatically improves logical consistency without any need for additional training or fine-tuning. People clearly prefer neuro-symbolic generations from the dual-system model over purely neural generations from a single-system model.4
+
+# 5 Grounded Instruction Following
+
+The dual-system approach offers a general-purpose means of improving upon generative, neural sequence models by incorporating logical constraints. To highlight its generality, we examine how the dual-system perspective can be deployed in a very different domain: grounded instruction following. In Heinze-Deml & Bouchacourt (2020), a learned target location predictor was used to increase the accuracy of a neural action sequence generation model. Here, we show how to increase performance further by enforcing consistency between the target location predictor and the action sequence generator in our dual-system framework.
+
+We use the gSCAN benchmark (Ruis et al., 2020), a recently proposed grounded instruction following dataset designed to measure compositional generalization in neural systems. Given an initial gridworld state and an instruction, e.g., “walk to the big square,” an agent must predict the sequence of low-level actions which achieve the goal, e.g., “TURN LEFT, WALK, TURN LEFT, WALK” (See Figure 6). The dataset contains several test splits, each testing different aspects of compositional generalization.
+
+Our model builds on Heinze-Deml & Bouchacourt (2020) by using an LSTM to predict the correct action sequence and target location. Given a command $c$ and an initial gridworld state $s$ , the neural network defines two distributions: a distribution over action sequences $q _ { a } ( a | c , s )$ and a distribution over target grid locations $q _ { l o c } ( l | c , s )$ . Heinze-Deml & Bouchacourt (2020) showed that when these distributions share parameters, using location prediction as an auxiliary loss improves the accuracy of the action sequence prediction model. We can further exploit these two models by noticing that when a predicted action sequence is not consistent with a predicted target location, then either the action sequence or the target location must be incorrect. Since the target location is much simpler to predict, and thus much more likely to be correctly predicted, if a predicted action sequence is not consistent with the predicted target location, then the action sequence is most likely incorrect. Our dual-system framework can use this property to increase action sequence prediction accuracy. Consider the initial state and command in Figure 6. Our model predicts candidate action sequences, and also predicts that the most likely target location is the grid containing the bigger yellow square (highlighted in red). The model then executes the candidate action sequences, and only accepts a sequence which results in the agent standing in the target location.
+
+In the language of our dual-system approach, we treat the distribution over actions $q _ { a } ( a | c , s )$ as our System 1 proposal model. The distribution over target locations $q _ { l o c } ( l | c , s )$ serves as a fact extractor model, which extract a location constraint $l$ . As a minimal world model, we use a deterministic gridworld execution model $T ( a , s _ { 0 } ) \to s _ { f }$ , which takes a state and action and predicts the resulting state. At test time, we first extract the predicted location as $l = \arg \operatorname* { m a x } _ { l ^ { \prime } } q _ { l o c } ( l ^ { \prime } | c )$ We then search through the possible action sequences from $q _ { a } ( \cdot | c )$ , conditioned on agreement with $l$ . In our experiments, we use a sample-based search with a maximum budget of 50 samples. We trained models on random subsets of the gSCAN training set of varying sizes: 5000 datapoints, 8000 datapoints, and 20000 datapoints $2 . 5 \%$ , $4 \%$ and $10 \%$ of the original training set, respectively).
+
+Results. The results show that the System 2 execution model improves performance without the need for any additional training (see Table 2 for results training on 5000 examples). In contrast to the single-system model, the dual-system model allows for sampling many candidate action sequences from the neural network, accepting only consistent sequences. This guess-and-check approach greatly increases the evaluation accuracy, improving upon prior work on gSCAN, particularly in low-data regimes.
+
+# 6 Limitations
+
+In its current form, our approach is most useful in domains where naturalistic, learned generation is necessary and where a small number of mission-critical logical constraints can be explicitly articulated. Our system will be less useful when constraints are more difficult to articulate (e.g., creative domains such as writing poetry) or when there are many constraints, since the minimal world model must be hand-engineered. Enforcing strict constraints may also pose risks: if the constraints are not only logical but cultural, they may be harmful if misapplied. However, these constraints must be articulated explicitly in a symbolic model, and are thus easier to identify and correct.
+
+The current few-shot parsing technique may also suffer from a limited capacity. For more complex domains, the number of examples required to specify the desired parsing behavior may be too large (i.e., they may not fit in the input window) or too complex for a model to perform parsing accurately. While some tasks may not be suitable, the complexity of the world model need not necessarily increase hand-in-hand with the complexity of the application domain. A dual-system model will be most successful when tracking just a few critical variables (e.g., tracking consistency in family relations, as in our experiments, or tracking scheduling constraints when discussing a team plan).
+
+A promising direction for future work is to incorporate learning into the System 2 world model. Currently, the minimal world knowledge that exists in System 2 can be easily modified, but changes must be made by hand. Improvements would come from automatically learning and updating this structured knowledge, possibly by incorporating neuro-symbolic learning techniques (Ellis et al., 2020; Mao et al., 2019), or other neuro-symbolic integration work such as Tsamoura et al. (2021); Michael & Valiant (2008).
+
+Learning could improve our dual-system approach in other ways, e.g., by training a neural module to mimic the actions of a symbolic System 2. The symbolic System 2 judgments could be used as a source of supervision; candidate utterances rejected by the symbolic System 2 model could be used as examples of contradictory sentences, and accepted utterances could be used as examples of noncontradictory statements. This oversight could help train a neural System 2 contradiction-detection model capable of more subtleties than its symbolic counterpart, especially in domains where labeled examples are otherwise unavailable. This approach may also help us understand aspects of human learning, where certain tasks that require slower, logical reasoning can be habitualized over time and tackled by faster, more intuitive reasoning.
+
+Recent work (Li et al., 2021) has shown that large pre-trained neural models learn to approximately represent certain types of structured semantic information. However, it is not yet clear how representational fidelity translates to logical coherence during generative tasks. Our current approach allows us to explicitly fix logical errors in generation, which may ultimately be caused by representational errors. Understanding how we might leverage our approach to improve the representation of structured knowledge within neural models is a promising direction for future work, which could lead to increased generation consistency and coherence.
+
+# 7 Conclusion
+
+Inspired by dual process theories from cognitive science, we combine the respective strengths of neural and symbolic approaches to build more robust models that can more effectively incorporate domain knowledge. For language generation, we showed that equipping neural generation with a minimal symbolic world model increased language coherence and consistency. For grounded instruction following, we showed that requiring test-time consistency between predicted action sequences and goal locations led to improved performance, especially in low-data regimes. Our neuro-symbolic approach can readily be applied to other domains and types of prior knowledge, as a lightweight way of improving the coherence and consistency of powerful neural sequence models.
+
+This paper just scratches the surface of how structured knowledge can make neural systems more robust; we hope to inspire further work into neuro-symbolic systems which possess the robustness and commonsense necessary for human-level intelligence.
+
+# Acknowledgments
+
+We thank Laura Ruis, Jacob Andreas, Yewen (Evan) Pu, Joe O’Connor and Guy Davidson for helpful comments on an earlier version of this manuscript. MN is supported by a NSF Graduate Research Fellowship.
+
+# References
+
+Andreas, J., Bufe, J., Burkett, D., Chen, C., Clausman, J., Crawford, J., Crim, K., DeLoach, J., Dorner, L., Eisner, J., et al. Task-oriented dialogue as dataflow synthesis. Transactions of the Association for Computational Linguistics, 8:556–571, 2020.   
+Brown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   
+De Moura, L. and Bjørner, N. Z3: An efficient smt solver. In Tools and Algorithms for the Construction and Analysis of Systems, pp. 337–340. Springer, 2008.   
+Deng, Y., Bakhtin, A., Ott, M., Szlam, A., and Marc’Aurelio Ranzato. Residual energy-based models of text generation. In International Conference on Learning Representations (ICLR), pp. 1–18, 2020.   
+Devlin, J., Uesato, J., Bhupatiraju, S., Singh, R., Mohamed, A.-r., and Kohli, P. Robustfill: Neural program learning under noisy i/o. ICML, 2017.   
+Ellis, K., Wong, C., Nye, M., Sable-Meyer, M., Cary, L., Morales, L., Hewitt, L., Solar-Lezama, A., and Tenenbaum, J. B. Dreamcoder: Growing generalizable, interpretable knowledge with wake-sleep bayesian program learning. arXiv preprint arXiv:2006.08381, 2020.   
+Evans, J. S. B. In two minds: dual-process accounts of reasoning. Trends in cognitive sciences, 7(10): 454–459, 2003.   
+Frederick, S. Cognitive reflection and decision making. Journal of Economic perspectives, 19(4): 25–42, 2005.   
+Garcez, A. d. and Lamb, L. C. Neurosymbolic ai: The 3rd wave. arXiv preprint arXiv:2012.05876, 2020.   
+Goyal, A. and Bengio, Y. Inductive biases for deep learning of higher-level cognition. arXiv preprint arXiv:2011.15091, 2020.   
+Goyal, A., Didolkar, A., Ke, N. R., Blundell, C., Beaudoin, P., Heess, N., Mozer, M., and Bengio, Y. Neural production systems. CoRR, abs/2103.01937, 2021. URL https://arxiv.org/abs/ 2103.01937.   
+Heinze-Deml, C. and Bouchacourt, D. Think before you act: A simple baseline for compositional generalization. arXiv preprint arXiv:2009.13962, 2020.   
+Herzig, J. and Berant, J. Span-based semantic parsing for compositional generalization. arXiv preprint arXiv:2009.06040, 2020.   
+Holtzman, A., Buys, J., Forbes, M., Bosselut, A., Golub, D., and Choi, Y. Learning to write with cooperative discriminators. arXiv preprint arXiv:1805.06087, 2018.   
+Hua, X. and Wang, L. Pair: Planning and iterative refinement in pre-trained transformers for long text generation. In EMNLP, 2020.   
+Kahneman, D. Thinking, fast and slow. kindle ed, 2013.   
+Kurita, S. and Cho, K. Generative language-grounded policy in vision-and-language navigation with bayes’ rule. arXiv preprint arXiv:2009.07783, 2020.   
+Lake, B. M. and Murphy, G. L. Word meaning in minds and machines. arXiv preprint arXiv:2008.01766, 2020.   
+Lake, B. M., Ullman, T. D., Tenenbaum, J. B., and Gershman, S. J. Building machines that learn and think like people. Behavioral and Brain Sciences, 40:E253, 2017.   
+Lewis, M., Liu, Y., Goyal, N., Ghazvininejad, M., Mohamed, A., Levy, O., Stoyanov, V., and Zettlemoyer, L. Bart: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. arXiv preprint arXiv:1910.13461, 2019.   
+Li, B. Z., Nye, M., and Andreas, J. Implicit representations of meaning in neural language models. arXiv preprint arXiv:2106.00737, 2021.   
+Liang, C., Berant, J., Le, Q. V., Forbus, K., and Lao, N. Neural symbolic machines: Learning semantic parsers on freebase with weak supervision. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 23–33, Vancouver, Canada, 2017. URL http://aclanthology.coli.uni-saarland.de/pdf/P/P17/P17-1003.pdf.   
+Liang, P. Learning executable semantic parsers for natural language understanding. Communications of the ACM, 59(9):68–76, 2016.   
+Liu, Y., Ott, M., Goyal, N., Du, J., Joshi, M., Chen, D., Levy, O., Lewis, M., Zettlemoyer, L., and Stoyanov, V. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   
+Loshchilov, I. and Hutter, F. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101, 2017.   
+Lu, X., West, P., Zellers, R., Bras, R. L., Bhagavatula, C., and Choi, Y. Neurologic decoding:(un) supervised neural text generation with predicate logic constraints. arXiv preprint arXiv:2010.12884, 2020.   
+Mao, J., Gan, C., Kohli, P., Tenenbaum, J. B., and Wu, J. The neuro-symbolic concept learner: Interpreting scenes, words, and sentences from natural supervision. arXiv preprint arXiv:1904.12584, 2019.   
+Martin, L. J., Ammanabrolu, P., Hancock, W., Singh, S., Harrison, B., and Riedl, M. O. Event representations for automated story generation with deep neural nets. In AAAI, 2018.   
+Marzoev, A., Madden, S., Kaashoek, M. F., Cafarella, M., and Andreas, J. Unnatural language processing: Bridging the gap between synthetic and natural language data. arXiv preprint arXiv:2004.13645, 2020.   
+Miao, N., Zhou, H., Mou, L., Yan, R., and Li, L. Cgmh: Constrained sentence generation by metropolis-hastings sampling. In AAAI, 2019.   
+Michael, L. and Valiant, L. G. A first experimental demonstration of massive knowledge infusion. 2008.   
+Mou, L., Lu, Z., Li, H., and Jin, Z. Coupling distributed and symbolic execution for natural language queries. In Precup, D. and Teh, Y. W. (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 2518–2526. PMLR, 06–11 Aug 2017. URL http://proceedings.mlr.press/v70/mou17a.html.   
+Muhlgay, D., Herzig, J., and Berant, J. Value-based search in execution space for mapping instructions to programs. pp. 1942–1954, 01 2019. doi: 10.18653/v1/N19-1193.   
+Nie, Y., Williamson, M., Bansal, M., Kiela, D., and Weston, J. I like fish, especially dolphins: Addressing contradictions in dialogue modelling. arXiv preprint arXiv:2012.13391, 2020.   
+Nye, M. I., Solar-Lezama, A., Tenenbaum, J. B., and Lake, B. M. Learning compositional rules via neural program synthesis. arXiv preprint arXiv:2003.05562, 2020.   
+Pieraccini, R., Tzoukermann, E., Gorelov, Z., Gauvain, J.-L., Levin, E., Lee, C.-H., and Wilpon, J. A speech understanding system based on statistical representation of semantics. In [Proceedings] ICASSP-92: 1992 IEEE International Conference on Acoustics, Speech, and Signal Processing, volume 1, pp. 193–196 vol.1, 1992. doi: 10.1109/ICASSP.1992.225939.   
+Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., and Sutskever, I. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9, 2019.   
+Ramesh, A., Pavlov, M., Goh, G., Gray, S., Voss, C., Radford, A., Chen, M., and Sutskever, I. Zero-shot text-to-image generation. arXiv preprint arXiv:2102.12092, 2021.   
+Ruis, L., Andreas, J., Baroni, M., Bouchacourt, D., and Lake, B. M. A benchmark for systematic generalization in grounded language understanding. arXiv preprint arXiv:2003.05161, 2020.   
+Schlag, I. and Schmidhuber, J. Learning to reason with third-order tensor products. CoRR, abs/1811.12143, 2018. URL http://arxiv.org/abs/1811.12143.   
+Serafini, L. and d’Avila Garcez, A. S. Logic tensor networks: Deep learning and logical reasoning from data and knowledge. CoRR, abs/1606.04422, 2016. URL http://arxiv.org/abs/1606. 04422.   
+Shen, S., Fried, D., Andreas, J., and Klein, D. Pragmatically informative text generation. arXiv preprint arXiv:1904.01301, 2019.   
+Shin, R., Lin, C. H., Thomson, S., Chen, C., Roy, S., Platanios, E. A., Pauls, A., Klein, D., Eisner, J., and Van Durme, B. Constrained language models yield few-shot semantic parsers. arXiv preprint arXiv:2104.08768, 2021.   
+Sinha, K., Sodhani, S., Dong, J., Pineau, J., and Hamilton, W. L. Clutrr: A diagnostic benchmark for inductive reasoning from text. arXiv preprint arXiv:1908.06177, 2019.   
+Smith, E. M., Gonzalez-Rico, D., Dinan, E., and Boureau, Y.-L. Controlling style in generated dialogue. arXiv preprint arXiv:2009.10855, 2020.   
+Spelke, E. S. and Kinzler, K. D. Core knowledge. Developmental Science, 10(1):89–96, 2007.   
+Su, Y. and Yan, X. Cross-domain semantic parsing via paraphrasing. arXiv preprint arXiv:1704.05974, 2017.   
+Tsamoura, E., Hospedales, T., and Michael, L. Neural-symbolic integration: A compositional perspective. Proceedings of the AAAI Conference on Artificial Intelligence, 35(6):5051–5060, May 2021. URL https://ojs.aaai.org/index.php/AAAI/article/view/16639.   
+Welleck, S., Weston, J., Szlam, A., and Cho, K. Dialogue natural language inference. arXiv preprint arXiv:1811.00671, 2018.   
+Weston, J., Bordes, A., Chopra, S., Rush, A. M., van Merriënboer, B., Joulin, A., and Mikolov, T. Towards ai-complete question answering: A set of prerequisite toy tasks. arXiv preprint arXiv:1502.05698, 2015.   
+Xu, J., Ren, X., Zhang, Y., Zeng, Q., Cai, X., and Sun, X. A skeleton-based model for promoting coherence among sentences in narrative story generation. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 4306–4315, Brussels, Belgium, OctoberNovember 2018. Association for Computational Linguistics. doi: 10.18653/v1/D18-1462. URL https://www.aclweb.org/anthology/D18-1462.   
+Xu, J., Ju, D., Li, M., Boureau, Y.-L., Weston, J., and Dinan, E. Recipes for safety in open-domain chatbots. arXiv preprint arXiv:2010.07079, 2020a.   
+Xu, S., Semnani, S. J., Campagna, G., and Lam, M. S. Autoqa: From databases to qa semantic parsers with only synthetic training data. arXiv preprint arXiv:2010.04806, 2020b.

parse/train/P7GUAXxS3ym/P7GUAXxS3ym_content_list.json

@@ -0,0 +1,1025 @@
+[
+    {
+        "type": "text",
+        "text": "Improving Coherence and Consistency in Neural Sequence Models with Dual-System, Neuro-Symbolic Reasoning ",
+        "text_level": 1,
+        "bbox": [
+            204,
+            122,
+            795,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Maxwell Nye∗ MIT ",
+        "text_level": 1,
+        "bbox": [
+            187,
+            251,
+            284,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Joshua B. Tenenbaum MIT ",
+        "bbox": [
+            483,
+            251,
+            637,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Michael Henry Tessler MIT DeepMind ",
+        "bbox": [
+            303,
+            251,
+            459,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Brenden M. Lake NYU Facebook AI Research ",
+        "bbox": [
+            658,
+            251,
+            810,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            329,
+            535,
+            345
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Human reasoning can be understood as an interplay between two systems: the intuitive and associative (“System 1”) and the deliberative and logical (“System 2”). Neural sequence models—which have been increasingly successful at performing complex, structured tasks—exhibit the advantages and failure modes of System 1: they are fast and learn patterns from data, but are often inconsistent and incoherent. In this work, we seek a lightweight, training-free means of improving existing System 1-like sequence models by adding System 2-inspired logical reasoning. We explore several variations on this theme in which candidate generations from a neural sequence model are examined for logical consistency by a symbolic reasoning module, which can either accept or reject the generations. Our approach uses neural inference to mediate between the neural System 1 and the logical System 2. Results in robust story generation and grounded instruction-following show that this approach can increase the coherence and accuracy of neurally-based generations. ",
+        "bbox": [
+            232,
+            359,
+            766,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            312,
+            592
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite recent success, neural sequence models often fail to produce consistent and coherent generations. When generating stories, language models may forget the attributes of specific characters (such as personality and background information) (Welleck et al., 2018), ignore previously established relationships between characters (such as family relationships) (Sinha et al., 2019), or otherwise contradict prior statements (Brown et al., 2020). Similarly, neural models can make statements that contradict basic world knowledge or the logical entailment structure of known facts. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            689
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lake & Murphy (2020) illustrated several of these issues with GPT-2 (Radford et al., 2019). When given prompts of the form “A dolphin is a ”, GPT-2 predicts that the most likely answer is “mammal”, “fish”, or “bird” depending on small differences in the wording of the prompt. In another example, GPT-2 states that unicorns have “four horns,” directly after implying that unicorns only have one horn. Upon diagnosing such issues, it is unclear how to apply a targeted fix to the model, especially if retraining or fine-tuning is impractical. ",
+        "bbox": [
+            173,
+            695,
+            825,
+            779
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we draw on insights from cognitive science, especially from “dual process” theories of reasoning (Evans, 2003), to explore how neural sequence models can better interface with prior knowledge and be made more coherent and consistent. According to dual process theories, human cognition can be understood as an interplay between a more intuitive and associative “System 1” and a more deliberative and logical “System 2.” Within this broad framework, automatic actions are driven by System 1, whereas System 2 engages for more deliberative control: for example, judging the validity of a logical argument that requires multiple steps of reasoning (Kahneman, 2013). ",
+        "bbox": [
+            174,
+            785,
+            826,
+            882
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c20d75f1293a76956af17c66db3e3cec0efd21ca62aa27c08f823624b84353b6.jpg",
+        "image_caption": [
+            "Figure 1: Schematic of dual-system approach to text generation. Conditioned on previous text, a “System $1 ^ { \\circ }$ neural generation model produces candidate next sentences. Semantic parses for each candidate are generated via few-shot parsing from GPT-3 and compared to a minimal world model to check consistency. Only candidates consistent with the world model state are incorporated into the final generation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            50,
+            820,
+            205
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The prominent neural language models of today are single systems, with weaknesses akin to those exhibited by the human System 1. For example, the cognitive reflection test (CRT) (Frederick, 2005) is a classic probe of System 1 vs. System 2 reasoning in humans. Participants answer a set of simple questions that have superficially compelling, but logically invalid, answers. These incorrect answers are often generated as a first “gut” response (putatively, by System 1 intuitive thinking); upon reflection, however, participants often realize that their responses were not logically or mathematically consistent (via more explicit System 2 reasoning). Consider the CRT problem on the left below: ",
+        "bbox": [
+            174,
+            295,
+            825,
+            393
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A ball and a bat cost $\\$ 10$ . The bat costs one dollar more than the ball. How much does the ball cost? ",
+        "bbox": [
+            232,
+            414,
+            490,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/147fcf5aa32d30f5bf088fc4af7d5dccb6b0d68606a410f5491f0947b66f4845.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Total cost in prompt</td><td>GPT-3 response</td></tr><tr><td>$1.10</td><td>10 cents</td></tr><tr><td>$1.20</td><td>20 cents</td></tr><tr><td>$1.30</td><td>$0.30</td></tr><tr><td>$1.70</td><td>$0.70</td></tr></table>",
+        "bbox": [
+            509,
+            398,
+            774,
+            463
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Reading quickly, you might be tempted to say the ball costs 10 cents. Most participants give this response, in fact, especially if they are under time pressure or have limited attention (Kahneman, 2013). Of course, if the bat is $\\$ 1.00$ more than the ball, and the ball costs 10 cents, then the total cost would be $\\$ 120$ . The correct answer is that the ball costs 5 cents. Notably, in this and other classic CRT problems, GPT-3 (Brown et al., 2020) predicts the same “gut” response (prediction in red above; the table above shows that adjusting the price in the prompt also leads to similar effects; see Appendix Figure 8 for more CRT examples). GPT-3 appears vulnerable to the same sort of intuitive, unsystematic pattern recognition errors as humans—in this case, incorrectly subtracting one dollar from $\\$ 1.10$ , without confirming that the answer satisfies each of the problem constraints. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Numerous studies have shown that engagement of System 2-style effort can help “override or inhibit default responses emanating from System 1” (Evans, 2003), correcting inconsistent or un-systematic intuitive impulses. For example, when System 2 is engaged by asking people to take more time to respond, people’s accuracy improves on the CRT task above (Kahneman, 2013). It has been argued that integrating System 2 processing could similarly improve AI systems (Goyal & Bengio, 2020; Garcez & Lamb, 2020), and here we explore this idea as applied to neural sequence models. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we take inspiration from dual process theories to explore a neuro-symbolic generation system, wherein predictions from a neural model are treated as System 1 proposals, and a logical, deliberative System 2 filters these proposals for consistency and soundness (see Figure 1). We further take inspiration from the fact that humans often do not need explicit supervision to reason about new problems or domains (e.g., see human evaluation task in Section 4.2) and require that the System 2 module not need additional problem-specific training, especially on example contradictions or commonsense violations. People can handle novelty by reconfiguring, rather than retraining, their internal models (Lake et al., 2017), and we strive to build machine systems capable of the same. We show how a lightweight, easy-to-implement System 2 model can help improve coherence and consistency by adding a small amount of symbolic reasoning. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We tackle two kinds of domains: text generation and instruction following. In both cases, we construct generative models over sequences by using a neural generation model to propose candidate generations and a symbolic world model that can accept or reject the generations and resample proposals if necessary. We first illustrate the approach by generating short stories based on the bAbI dataset (Weston et al., 2015); this pedagogical, synthetic example illustrates how basic commonsense knowledge of objects, agents, and places can inform a text generation model. We then test our approach on rich, natural language vignettes based on CLUTRR (Sinha et al., 2019), focusing on ensuring consistency of family and interpersonal relationships. In both text generation domains, we interface between the explicit logical knowledge/reasoning of System 2 and generations of System 1 using a few-shot learning approach with state-of-the-art neural language models (GPT-3), which requires no additional training or fine-tuning. Even using off-the-shelf transformers and symbolic solvers, our dual-system model improves the consistency and coherence of text generations as measured by human judges. We test our approach also on instruction following, showing how goalprediction models and execution models can easily be combined to achieve improved performance in low-data regimes. We show improvements over previous work in the gSCAN grounded compositional challenge (Ruis et al., 2020); a dual-system model requires much less data to train than previous models, and achieves higher accuracy and stronger generalization. Overall, our findings indicate that neuro-symbolic, dual process models are a promising means of addressing longstanding problems of robustness and consistency in neural sequence models. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            327,
+            321,
+            343
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our approach incorporates semantic parsing (Liang, 2016) as a component of a generative process, where neural generation is used in conjunction with parsing techniques. In our text generation experiments, we employ GPT-3 to perform few-shot semantic parsing without fine-tuning. Related work includes few or zero-shot semantic parsing using pre-training techniques and paraphrasing (Su & Yan, 2017; Herzig & Berant, 2020). It also includes semantic parsing systems trained either without supervision (Liang et al., 2017; Mou et al., 2017; Muhlgay et al., 2019), or with synthetic language data (Marzoev et al., 2020; Xu et al., 2020b). ",
+        "bbox": [
+            173,
+            380,
+            825,
+            477
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One popular technique for improving neural generations is generate-and-rerank, wherein one model generates proposals and another reranks them. This broad approach has been used in image generation (Ramesh et al., 2021), text generation (Holtzman et al., 2018; Shen et al., 2019; Deng et al., 2020), dialogue systems (for control, coherence and safety (Welleck et al., 2018; Smith et al., 2020; Nie et al., 2020; Xu et al., 2020a)), and instruction following (Kurita & Cho, 2020). Reranking is generally used to improve outputs with respect to relatively broad, holistic criteria. Here, our goal is to make generation robust to particular types of logical errors by pruning with respect to explicit symbolic constraints. Our approach can thus be considered closely related to techniques which employ explicit search to find generations satisfying particular logical constraints. Similar methods, such as guess-and-check or beam search pruning, have had success in neural program synthesis (Devlin et al., 2017; Nye et al., 2020). ",
+        "bbox": [
+            174,
+            484,
+            825,
+            636
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recent work in NLP has used template-based planning, in which a model generates text by first generating a plan or skeleton, and filling in the missing words to produce naturalistic text (Xu et al., 2018; Hua & Wang, 2020). To generate stories, Martin et al. (2018) parses previous sentences into events and does planning in event space. Our work extends previous entity/relation/event planning in that the world model is not used for planning, but rather for post-checking candidate generations. Structured parsing of this type is also related to dialog tracking techniques such as slot-filling (Pieraccini et al., 1992). In our work, fully compositional logical facts are extracted from utterances. It is therefore more closely related to systems which extract programs from dialogue, such as Andreas et al. (2020). ",
+        "bbox": [
+            174,
+            642,
+            825,
+            767
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recent work has also studied incorporating symbolic constraints into a neural decoding strategy in the context of natural language. Miao et al. (2019) introduce an MCMC-based inference-time propose-and-reject strategy for satisfying constraints. They test on constraints such as paraphrase and grammatical error correction. Lu et al. (2020) introduces “NeuroLogic decoding,” which uses logical constraints on neural language models to produce generations which contain (or do not contain) required (or forbidden) keywords. In these works, the constraints are lexical or based on word/sentence similarity (and provided in the problem setup for Lu et al. (2020)), whereas we study logical constraints on the world state decoded directly from observations or generations at test time. Other approaches for solving reasoning tasks end-to-end include Goyal et al. (2021), Serafini & d’Avila Garcez (2016), and Schlag & Schmidhuber (2018). ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Integrating System 1 and System 2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            496,
+            107
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We introduce our dual-system approach using examples from the bAbI domain (Weston et al., 2015), which we also use to perform diagnostic experiments. Consider generating a simple story involving people, places and objects, such as (from Figure 1): ",
+        "bbox": [
+            174,
+            125,
+            826,
+            167
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Daniel went to the garden. Mary traveled to the office. Daniel grabbed the apple. ",
+        "bbox": [
+            233,
+            172,
+            766,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A model tasked with generating such stories must juggle several simultaneous demands: staying on topic and maintaining consistency of style and other textural elements (for which people rely on System 1), as well as maintaining consistency with previous statements and commonsense knowledge (for which people rely on both systems). Consider continuing the story with one of the following: ",
+        "bbox": [
+            174,
+            194,
+            825,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(a) Daniel went to the patio. (b) Mary dropped the apple there. ",
+        "bbox": [
+            276,
+            256,
+            720,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Sentence (a) is reasonable; sentence (b) is not because it is Daniel, not Mary, who has the apple. During generation, how might a model distinguish between these candidates? Perhaps a well-trained neural language model could track constraints of these sorts. Neural language models to date, however, often violate these types of commonsense, hard constraints without a large high-quality corpus or explicit training on detecting violations of commonsense (Sinha et al., 2019). ",
+        "bbox": [
+            174,
+            276,
+            826,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We address this problem by decomposing text generation into two parts: candidate generation facilitated by deep neural networks and a logical pruning process implemented via a separate symbolic module. Consider again the example above. To ensure consistency, our model would extract from the text the features of the world that are subject to the hard, logical constraints, such as the location of objects and who is holding them. These constraints can then be checked against an explicit representation of current state of the world. For sentences (a) and (b), the system would extract and go(Daniel, patio) and drop(Mary, apple), respectively. A minimal world model would track the state of the apple, such that it maintains apple.holder $=$ Daniel (or equivalently, Daniel.inventory $=$ [apple]). When such a model is given a parse of a candidate generation, drop(Mary, apple), the mismatch between the current state and the proposed change would cause a violation, and the candidate generation will be rejected. ",
+        "bbox": [
+            173,
+            353,
+            825,
+            505
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The main steps of our general approach are illustrated in Figure 1: generate proposals from a System 1 proposal model, extract facts with a fact extraction model, and filter proposed generations by ensuring that they satisfy the constraints given by the extracted facts and the minimal world model. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            553
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "System 1: Generation. We use neural sequence models to produce System 1 generations. In text generation domains, we use a large, pre-trained model that can be fine-tuned or conditioned via a short prompt to generate relevant text. Text sampled from the System 1 model will be treated as candidate utterances, which will be parsed and filtered by System 2 (described below). For the bAbI examples, we use GPT-3 as our System 1 proposal model through few-shot prompting with 10 example bAbI stories as context, generating a new story one candidate sentence at a time. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "System 2: Fact extraction. A fact extractor, or parser, is used to mediate between the System 1 candidate proposals and the minimal world model within System 2. In our text generation domains, we use a pre-trained GPT-3 model without fine-tuning to perform parsing. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For bAbI, our prompt consist of an initial descriptive sentence “Please parse the following statements into commands. The available commands are pickup, drop, and go.” and a small set $( < 1 0 )$ of representative semantic parsing examples (input $=$ sentences; output $=$ correct parses, such as go(Bob, roof)). The parse of each utterance is produced via few-shot prompting (Brown et al., 2020): the utterance is added to the end of the prompt, and the subsequent GPT-3 generation is interpreted as the target parse. We found that this simple parsing technique works well and could easily be applied to other parsing-based tasks, as in Shin et al. (2021). The parsing prompts are reproduced in full in the Appendix. As discussed in Section 5, for the $\\mathrm { g S C A N }$ instruction following domain, fact extraction is performed with a learned goal location prediction model. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "System 2: Minimal world model. We use a lightweight, incomplete description of the state of the world as a world model in each domain, e.g., commonsense information about the people, objects and locations (Figure 1). The goal is not to track and verify all the possible information; instead, we aim for minimalism, capturing just a few commonsense (or application-critical) variables that we want to ensure are correct. The world model facilitates tracking of long-range logical dependencies and logical consequences, especially those which are not readily decodable from surface forms. The world model also lets us integrate rule-based world-knowledge without retraining (and without the need for a large set of labeled examples). ",
+        "bbox": [
+            174,
+            827,
+            823,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the bAbI examples, the minimal world model keeps track of the people, locations and objects introduced in the story so far (Figure 1). This encodes constraints on possible actions related to human core knowledge competencies (objects, agents, places) present early in human development (Spelke & Kinzler, 2007); specifically, a person or object can only be in one place at a time, an object can only be possessed by a single person at a time, a person cannot “go” to a room they are already in, and a person cannot pick up an object if it is in a different room. See the Appendix for details. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Search. At generation time, the interaction between System 1 generation and System 2 parsing yields a neuro-symbolic, guess-and-check search strategy. In a text generation scenario, where text is sampled from the model, our dual-system model improves upon a naive, neural-only sampling method by using the System 2 model to reject candidate utterances which are incompatible with the current state. When a candidate is rejected, a new candidate utterance is sampled from the System 1 model, which is again checked by System 2. This process repeats until a candidate utterance is accepted by System 2 (i.e., the utterance is compatible with the world state). This procedure allows the model to effectively search the space of candidate utterances, guided by the logical constraints from the minimal world model. In this work, we use straightforward probabilistic sampling to illustrate that the approach works with even a very simple search mechanism. We imagine that the search procedure could be further optimized by applying, for example, beam search or stochastic beam sampling. ",
+        "bbox": [
+            173,
+            215,
+            825,
+            367
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Diagnostic bAbI experiments. We use Task $\\# 2$ from bAbI as a diagnostic test for our neuro-symbolic dual-system model. As shown above, this task consists of synthetically-generated short stories involving people, places and objects, and questions concerning the locations of objects in these stories. We investigate performance on both question answering (QA) tasks and story generation. For the QA tasks, we parse each sentence in the story to encode each fact into the world model and parse the final question to query the world model, returning the answer given by the world ",
+        "bbox": [
+            174,
+            375,
+            452,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "GPT-3 only: John went to the bedroom.   \nJohn picked up the apple there.   \nMary took the apple there.   \nMary travelled to the office.   \nDaniel went back to the garden.   \nMary went to the bedroom.   \nJohn went to the bedroom.   \nSandra went to the bedroom.   \nSandra travelled to the office.   \nMary went back to the office.   \nWhere is the apple? A: office GPT-3 $^ +$ world model: John went to the bedroom.   \nJohn picked up the apple there.   \nMary travelled to the office.   \nDaniel went back to the garden.   \nMary went to the bedroom.   \nSandra went to the bedroom.   \nSandra travelled to the office.   \nMary went back to the office.   \nWhere is the apple? A: bedroom ",
+        "bbox": [
+            465,
+            372,
+            611,
+            493
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            642,
+            373,
+            792,
+            474
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2: Example bAbI stories generated by GPT-3 only (left) and our dual-system model (right). Logically inconsistent lines are written in red text, and are removed from the story-so-far at generation time. ",
+        "bbox": [
+            464,
+            501,
+            825,
+            555
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "model. We compare with two alternative models (Table 3 in the Appendix): GPT-3 by itself and a dual-system baseline that uses a neural Natural Language Inference (NLI) model as its System 2. The NLI-based dual-system model generates 10 candidates from GPT-3 and selects the candidate with the highest predicted probability of entailment under the NLI model given the context. We use the RoBERTa MNLI model as our off-the-shelf neural NLI model (Liu et al., 2019), which operates as a System 2 that does not use additional problem-specific data or fine-tuning.2 On 200 held-out tasks, our GPT-3-based “fact extractor” achieves $100 \\%$ QA accuracy, far exceeding the performance of GPT-3 alone $( 2 9 . 0 \\% )$ or GPT-3 generation with neural NLI scoring $( 3 2 . 5 \\%$ ; also see Table 3 in the Appendix). These results show that GPT-3 can be made to answer questions successfully when used for parsing with a world model, even when GPT-3 alone does not achieve high QA accuracy. ",
+        "bbox": [
+            173,
+            566,
+            825,
+            704
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To test story generation, we use our GPT-3-based System 1 proposal model (few-shot prompted on 10 example stories) to sample a new bAbI story, line-by-line. If a generated utterance is inconsistent with the current state as indicated by the System 2 world model, a new utterance is sampled from System 1 (repeating until a consistent utterance is sampled). Figure 2 shows how the dual-system approach generates stories that mimic the statistical structure of bAbI stories, while remaining logically sound In contrast, GPT-3 alone was not able to maintain logical coherence. In a set of 50 generated stories, all stories required at least one sentence to be resampled to maintain coherence, and over half of the generated sentences $( 5 3 . 1 \\% )$ were rejected by our System 2 model to maintain logical consistency. These results demonstrate that equipping GPT-3 with a minimal world model produces logically coherent stories that mimic the textural structure of the bAbI domain. In the next section, we apply this approach to mimicking human-generated short stories in natural language. ",
+        "bbox": [
+            173,
+            712,
+            825,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Coherent Language Generation - CLUTRR ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            89,
+            558,
+            107
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We apply our dual-system approach to a dataset of natural language using the CLUTRR dataset. CLUTRR contains human-written stories about people and their family relationships (see example in Figure 3). As with bAbI, CLUTRR was originally designed as a Question Answering challenge; instead, we use it to evaluate coherent language generation by querying models to generate complete CLUTRR-style stories or to complete partially-generated stories. Our particular aim is to produce stories with coherent and logically consistent family relationships. As above, our language generation setup consists of pre-trained language models acting as our System 1 proposer, a minimal world model as System 2, and a neural semantic parser (implemented via few-shot GPT-3 prediction) as a bridge between the two systems. We use human judgments to assess whether our neuro-symbolic, dual-system model produces more consistent and coherent stories relative to a baseline. ",
+        "bbox": [
+            173,
+            123,
+            825,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Model specification ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            282,
+            346,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Kristin and her son Justin went to visit her mother Carol on a nice Sunday afternoon.They went out for a movie together and had a good time. ",
+        "bbox": [
+            500,
+            314,
+            650,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Q:How is Carol related to Justin ? ",
+        "bbox": [
+            679,
+            319,
+            816,
+            328
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As our System 1 proposal model, we used pretrained neural models to produce candidate generations one sentence at a time. We experimented with GPT-3 as our System 1 model (which we used above for bAbI), but found generations too unreliable, often outputting the empty string. Instead, we used a BART model (Lewis et al., 2019) that was fine-tuned on the ",
+        "bbox": [
+            174,
+            310,
+            483,
+            420
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CLUTRR training corpus. This model also gives us an opportunity to compare against a best-case neural “single-system” baseline, specifically fine-tuned on story data. To maintain a state of family relations, we use a constraint solver in our “System $2 ^ { \\circ }$ to encode family relationships (e.g., child(x, ${ \\tt y } )$ , spouse $\\mathbf { \\Psi } ( \\mathbf { x } , \\mathbf { \\Psi } z ) ,$ ) and check that the candidate utterances do not contradict the previous statements (e.g., a person cannot be their own child or married to their sibling). We implemented the world model as a set of logical relations and constraints using the Z3 solver (De Moura & Bjørner, 2008). For instance, we require that the parent of $\\mathtt { x }$ cannot also be the uncle of x: For all x, y, $\\mathtt { u n c l e ( x , y ) } \\Rightarrow \\neg \\mathtt { c h i l d ( y , x ) }$ . To check a candidate utterance, we query the solver to determine if the set of constraints is satisfiable or if there is a contradiction. The full set of constraints and other details can be found in the Appendix. We again used GPT-3 as our semantic parser, extracting parses for each candidate utterance via few-shot learning. This parsing approach worked well, even for the natural language in this domain. We observed that parsing with GPT-3 was more successful when the target parse was naturalistic, i.e., “Bob is Joe’s father.” rather than “father(Bob, Joe)”. The parsing prompt is reproduced in full in the Appendix. ",
+        "bbox": [
+            173,
+            421,
+            826,
+            613
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec4fa337894acae8383e081ea66d706994e95a5c4138459856cf540cc4c46a35.jpg",
+        "image_caption": [
+            "Figure 4: Example trial from CLUTRR human judgement experiment. Participants were instructed to select which of two options makes the most sense given the prompt. One option was generated by the System 1 model only (“single-system”), while the other was generated by the dual-system model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            638,
+            459,
+            782
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/23551b86728bcb3d12e87976cf8ca4400fe58d0284de9a84ef95c28f8e78effb.jpg",
+        "image_caption": [
+            "Figure 3: Sample story from the CLUTRR dataset. Each story consists of a sequence of humangenerated sentences concerning family relationships. Adapted from Sinha et al. (2019). ",
+            "Figure 5: CLUTRR human judgment experiment results. Bars denote proportions of dual-system generations selected as making more sense over single-system generations, in each of four conditions. Error-bars denote bootstrapped $9 5 \\%$ confidence intervals of the item means. The points denote means for each individual item in the experiment and are jittered horizontally for clarity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            626,
+            795,
+            780
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/4ba28e7b17b17987d160c543b82e1a018ff9c6ce24889db658739cb519cac8b4.jpg",
+        "table_caption": [
+            "Table 1: Statistics from CLUTRR story generation. We report the percentage of generations (on both a per-line and per-story basis) for which the System 2 world model did not detect an error. The dual-system model is able to detect many inconsistencies in the neural single-system generations, and most can be corrected by re-sampling new candidates (up to a limit of ten). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">% w/out error detected (per line)</td><td colspan=\"2\">% w/out error detected (per story)</td></tr><tr><td>single-system (neural gen. only)</td><td>dual-system (neural gen.+world model)</td><td>single-system (neural gen. only)</td><td>dual-system (neural gen.+world model)</td></tr><tr><td>prompt from dataset</td><td>82.8</td><td>97.1</td><td>60</td><td>96.1</td></tr><tr><td>prompt from model</td><td>71.9</td><td>96.3</td><td>36.4</td><td>93.5</td></tr></table>",
+        "bbox": [
+            171,
+            159,
+            825,
+            231
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Human judgments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            247,
+            343,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We test our dual-system neural generation $^ +$ world model method in its ability to generate stories that are deemed by naive human participants to be more naturalistic and coherent than those generated from the baseline models. Specifically, we asked participants to select which of two continuations made the most sense to them, where one continuation was generated from the neural model alone (single-system) and the other from a dual-system model (either the world model System 2 or the neural NLI System 2). ",
+        "bbox": [
+            173,
+            275,
+            825,
+            359
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Participants. Participants $\\mathbf { N } = 1 0 1$ ) were recruited on the crowd-sourcing platform Prolific and compensated $\\$ 2$ for the task ( ${ \\sim } 1 5$ minutes, so roughly $\\$ 8/\\mathrm{ h o u r }$ ). Participants gave informed consent, and the study was approved by MIT’s IRB. 21 participants were excluded for failing an instruction quiz, incorrectly answering more than one of five filler questions, or finishing the task too quickly. The data we collected contains no personally identifiable information or offensive content. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            434
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Procedure. Participants began the experiment by reading a set of instructions and answering comprehension questions. On each main trial, participants were shown a prompt consisting of several sentences and were asked to choose which of two possible continuations made the most sense (an example trial is shown in Figure 4). Participants were instructed that if a name appeared multiple times within a trial, then it referred to the same person, whereas if a name appeared across trials, then it was not referring to the same person. For each trial, one continuation option was generated by the neural only single-system baseline, while the other was a dual-system generation. We selected generations from the neural only baseline that were rejected by the System 2 model in order to maximize the differences between the models’ generations; thus, human judgments pertain to generations that the models disagreed on. Each participant performed between 20 and 26 trials. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Materials. Participants were randomly assigned to one of four between-participant conditions, which varied according to the kind of prompt and the kind of dual-system model. The prompt was either generated from the model (up to the point of disagreement between System 1 and System 2 models; “Prompts from model” condition) or taken completely from the length 4 CLUTRR systematic generalization test dataset (“Prompts from dataset” condition). To generate prompts for the “from model” condition, we took the first sentence of each story from the CLUTRR test dataset and generated subsequent prompt sentences from the dual-system model; sentences were generated until the two systems disagreed (i.e., System 1 generated a sentence that System 2 rejected), at which point the “rejected sentence” served as the neural only (single-system) baseline generation and the first resampled sentence that System 2 accepted served as the dual-system generation. Prompts were sampled to a maximum length of four sentences. The dual-system model shown to participants used a System 2 based on either our constraint-based “world model” or the neural NLI baseline. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            751
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 catalogs critical statistics from the stimulus generation process. We generated vignettes from the System 1 model and report the percentage of System 1 generations which are deemed correct by the System 2 model.3 We also report the percentage of generations corrected by the System 2 model (i.e., if System 1 made an error, could System 2 fix it within 10 attempts?). We report these statistics on both a per-story and per-line basis. According to System 2, the System 1 generation model makes a lot of errors (only $3 6 . 4 \\%$ of stories and $7 1 . 9 \\%$ of lines were error-free, in the “from model\" condition). In most instances, re-sampling new generations yields stories that, according to ",
+        "bbox": [
+            174,
+            757,
+            825,
+            854
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d21556f194dd69a45e77703bda990cd49f2741ef73361dbb4797e172924c1aa8.jpg",
+        "table_caption": [
+            "Table 2: Accuracy on $\\mathrm { g } \\mathrm { S C A N }$ splits. Models were trained on 5000 examples (only $2 . 5 \\%$ of the gSCAN training data). See Appendix Table 4 for additional results.) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Test split:</td><td>single-system5</td><td>dual-system</td></tr><tr><td>dev</td><td>71.7</td><td>83.3</td></tr><tr><td>random</td><td>57.2</td><td>74.7</td></tr><tr><td>yellow squares</td><td>68.1</td><td>81.3</td></tr><tr><td>red squares</td><td>64.9</td><td>78.1</td></tr><tr><td>novel direction</td><td>0.0</td><td>0.01</td></tr><tr><td>relativity</td><td>41.0</td><td>53.6</td></tr><tr><td>class inference</td><td>68.1</td><td>76.2</td></tr><tr><td>adverb (k=1)</td><td>0.0</td><td>0.0</td></tr><tr><td>adverb to verb</td><td>20.8</td><td>21.8</td></tr><tr><td colspan=\"3\"></td></tr><tr><td colspan=\"3\">³From Heinze-Deml &amp; Bouchacourt (2020)</td></tr></table>",
+        "bbox": [
+            174,
+            142,
+            504,
+            296
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b309f49955634199fe29a9959b4f5d1362ff58d0f63e41b64e1e429d4876dcf.jpg",
+        "image_caption": [
+            "Figure 6: Schematic of our dual-system approach to $\\mathrm { g S C A N }$ . We train a neural sequence model to predict both a distribution over action sequences, and a distribution over target locations. At test time, we decode candidate action sequences from the model, execute them on the gridworld, and only accept a sequence that brings the agent to the predicted target location (shown in green). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            516,
+            65,
+            838,
+            193
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "System 2, no longer contain logical errors within a budget of 10 samples $9 3 . 5 \\%$ of stories and $9 6 . 3 \\%$ of lines were error-free, respectively). ",
+        "bbox": [
+            171,
+            318,
+            823,
+            347
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. The human evaluation indicates that System 2 is indeed correcting genuine errors in the stories. As summarized in Figure 5, participants strongly preferred the dual-system neural generation $^ +$ world model continuations in comparison to the neural only single-system continuations (proportion preferring dual-system $= 0 . 8 4$ ; bootstrapped $9 5 \\%$ confidence interval [0.77, 0.89] and 0.79 [0.77, 0.89] for the “from dataset” and “from model” prompt conditions, respectively). The dual-system approach, however, did not improve generation quality when the System 2 was based on an off-the-shelf neural NLI model (Proportion preferring dual-system $= 0 . 5 1$ ; [0.40, 0.64] for “from dataset”; 0.58 [0.48, 0.68] for “from model”). Thus, when using a minimal world model, the dual-system approach dramatically improves logical consistency without any need for additional training or fine-tuning. People clearly prefer neuro-symbolic generations from the dual-system model over purely neural generations from a single-system model.4 ",
+        "bbox": [
+            173,
+            352,
+            826,
+            503
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Grounded Instruction Following ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            525,
+            477,
+            542
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The dual-system approach offers a general-purpose means of improving upon generative, neural sequence models by incorporating logical constraints. To highlight its generality, we examine how the dual-system perspective can be deployed in a very different domain: grounded instruction following. In Heinze-Deml & Bouchacourt (2020), a learned target location predictor was used to increase the accuracy of a neural action sequence generation model. Here, we show how to increase performance further by enforcing consistency between the target location predictor and the action sequence generator in our dual-system framework. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            654
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use the gSCAN benchmark (Ruis et al., 2020), a recently proposed grounded instruction following dataset designed to measure compositional generalization in neural systems. Given an initial gridworld state and an instruction, e.g., “walk to the big square,” an agent must predict the sequence of low-level actions which achieve the goal, e.g., “TURN LEFT, WALK, TURN LEFT, WALK” (See Figure 6). The dataset contains several test splits, each testing different aspects of compositional generalization. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            731
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our model builds on Heinze-Deml & Bouchacourt (2020) by using an LSTM to predict the correct action sequence and target location. Given a command $c$ and an initial gridworld state $s$ , the neural network defines two distributions: a distribution over action sequences $q _ { a } ( a | c , s )$ and a distribution over target grid locations $q _ { l o c } ( l | c , s )$ . Heinze-Deml & Bouchacourt (2020) showed that when these distributions share parameters, using location prediction as an auxiliary loss improves the accuracy of the action sequence prediction model. We can further exploit these two models by noticing that when a predicted action sequence is not consistent with a predicted target location, then either the action sequence or the target location must be incorrect. Since the target location is much simpler to predict, and thus much more likely to be correctly predicted, if a predicted action sequence is not consistent with the predicted target location, then the action sequence is most likely incorrect. Our dual-system framework can use this property to increase action sequence prediction accuracy. Consider the initial state and command in Figure 6. Our model predicts candidate action sequences, and also predicts that the most likely target location is the grid containing the bigger yellow square (highlighted in red). The model then executes the candidate action sequences, and only accepts a sequence which results in the agent standing in the target location. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            848
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the language of our dual-system approach, we treat the distribution over actions $q _ { a } ( a | c , s )$ as our System 1 proposal model. The distribution over target locations $q _ { l o c } ( l | c , s )$ serves as a fact extractor model, which extract a location constraint $l$ . As a minimal world model, we use a deterministic gridworld execution model $T ( a , s _ { 0 } ) \\to s _ { f }$ , which takes a state and action and predicts the resulting state. At test time, we first extract the predicted location as $l = \\arg \\operatorname* { m a x } _ { l ^ { \\prime } } q _ { l o c } ( l ^ { \\prime } | c )$ We then search through the possible action sequences from $q _ { a } ( \\cdot | c )$ , conditioned on agreement with $l$ . In our experiments, we use a sample-based search with a maximum budget of 50 samples. We trained models on random subsets of the gSCAN training set of varying sizes: 5000 datapoints, 8000 datapoints, and 20000 datapoints $2 . 5 \\%$ , $4 \\%$ and $10 \\%$ of the original training set, respectively). ",
+        "bbox": [
+            173,
+            194,
+            825,
+            319
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results. The results show that the System 2 execution model improves performance without the need for any additional training (see Table 2 for results training on 5000 examples). In contrast to the single-system model, the dual-system model allows for sampling many candidate action sequences from the neural network, accepting only consistent sequences. This guess-and-check approach greatly increases the evaluation accuracy, improving upon prior work on gSCAN, particularly in low-data regimes. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            409
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Limitations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            446,
+            302,
+            464
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In its current form, our approach is most useful in domains where naturalistic, learned generation is necessary and where a small number of mission-critical logical constraints can be explicitly articulated. Our system will be less useful when constraints are more difficult to articulate (e.g., creative domains such as writing poetry) or when there are many constraints, since the minimal world model must be hand-engineered. Enforcing strict constraints may also pose risks: if the constraints are not only logical but cultural, they may be harmful if misapplied. However, these constraints must be articulated explicitly in a symbolic model, and are thus easier to identify and correct. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The current few-shot parsing technique may also suffer from a limited capacity. For more complex domains, the number of examples required to specify the desired parsing behavior may be too large (i.e., they may not fit in the input window) or too complex for a model to perform parsing accurately. While some tasks may not be suitable, the complexity of the world model need not necessarily increase hand-in-hand with the complexity of the application domain. A dual-system model will be most successful when tracking just a few critical variables (e.g., tracking consistency in family relations, as in our experiments, or tracking scheduling constraints when discussing a team plan). ",
+        "bbox": [
+            174,
+            593,
+            825,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A promising direction for future work is to incorporate learning into the System 2 world model. Currently, the minimal world knowledge that exists in System 2 can be easily modified, but changes must be made by hand. Improvements would come from automatically learning and updating this structured knowledge, possibly by incorporating neuro-symbolic learning techniques (Ellis et al., 2020; Mao et al., 2019), or other neuro-symbolic integration work such as Tsamoura et al. (2021); Michael & Valiant (2008). ",
+        "bbox": [
+            174,
+            696,
+            825,
+            780
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Learning could improve our dual-system approach in other ways, e.g., by training a neural module to mimic the actions of a symbolic System 2. The symbolic System 2 judgments could be used as a source of supervision; candidate utterances rejected by the symbolic System 2 model could be used as examples of contradictory sentences, and accepted utterances could be used as examples of noncontradictory statements. This oversight could help train a neural System 2 contradiction-detection model capable of more subtleties than its symbolic counterpart, especially in domains where labeled examples are otherwise unavailable. This approach may also help us understand aspects of human learning, where certain tasks that require slower, logical reasoning can be habitualized over time and tackled by faster, more intuitive reasoning. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Recent work (Li et al., 2021) has shown that large pre-trained neural models learn to approximately represent certain types of structured semantic information. However, it is not yet clear how representational fidelity translates to logical coherence during generative tasks. Our current approach allows us to explicitly fix logical errors in generation, which may ultimately be caused by representational errors. Understanding how we might leverage our approach to improve the representation of structured knowledge within neural models is a promising direction for future work, which could lead to increased generation consistency and coherence. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            208,
+            299,
+            224
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Inspired by dual process theories from cognitive science, we combine the respective strengths of neural and symbolic approaches to build more robust models that can more effectively incorporate domain knowledge. For language generation, we showed that equipping neural generation with a minimal symbolic world model increased language coherence and consistency. For grounded instruction following, we showed that requiring test-time consistency between predicted action sequences and goal locations led to improved performance, especially in low-data regimes. Our neuro-symbolic approach can readily be applied to other domains and types of prior knowledge, as a lightweight way of improving the coherence and consistency of powerful neural sequence models. ",
+        "bbox": [
+            174,
+            239,
+            825,
+            351
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This paper just scratches the surface of how structured knowledge can make neural systems more robust; we hope to inspire further work into neuro-symbolic systems which possess the robustness and commonsense necessary for human-level intelligence. ",
+        "bbox": [
+            176,
+            356,
+            825,
+            398
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            414,
+            303,
+            428
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Laura Ruis, Jacob Andreas, Yewen (Evan) Pu, Joe O’Connor and Guy Davidson for helpful comments on an earlier version of this manuscript. MN is supported by a NSF Graduate Research Fellowship. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            500,
+            266,
+            515
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andreas, J., Bufe, J., Burkett, D., Chen, C., Clausman, J., Crawford, J., Crim, K., DeLoach, J., Dorner, L., Eisner, J., et al. Task-oriented dialogue as dataflow synthesis. Transactions of the Association for Computational Linguistics, 8:556–571, 2020.   \nBrown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   \nDe Moura, L. and Bjørner, N. Z3: An efficient smt solver. In Tools and Algorithms for the Construction and Analysis of Systems, pp. 337–340. Springer, 2008.   \nDeng, Y., Bakhtin, A., Ott, M., Szlam, A., and Marc’Aurelio Ranzato. Residual energy-based models of text generation. In International Conference on Learning Representations (ICLR), pp. 1–18, 2020.   \nDevlin, J., Uesato, J., Bhupatiraju, S., Singh, R., Mohamed, A.-r., and Kohli, P. Robustfill: Neural program learning under noisy i/o. ICML, 2017.   \nEllis, K., Wong, C., Nye, M., Sable-Meyer, M., Cary, L., Morales, L., Hewitt, L., Solar-Lezama, A., and Tenenbaum, J. B. Dreamcoder: Growing generalizable, interpretable knowledge with wake-sleep bayesian program learning. arXiv preprint arXiv:2006.08381, 2020.   \nEvans, J. S. B. In two minds: dual-process accounts of reasoning. Trends in cognitive sciences, 7(10): 454–459, 2003.   \nFrederick, S. Cognitive reflection and decision making. Journal of Economic perspectives, 19(4): 25–42, 2005.   \nGarcez, A. d. and Lamb, L. C. Neurosymbolic ai: The 3rd wave. arXiv preprint arXiv:2012.05876, 2020.   \nGoyal, A. and Bengio, Y. Inductive biases for deep learning of higher-level cognition. arXiv preprint arXiv:2011.15091, 2020.   \nGoyal, A., Didolkar, A., Ke, N. R., Blundell, C., Beaudoin, P., Heess, N., Mozer, M., and Bengio, Y. Neural production systems. CoRR, abs/2103.01937, 2021. URL https://arxiv.org/abs/ 2103.01937.   \nHeinze-Deml, C. and Bouchacourt, D. Think before you act: A simple baseline for compositional generalization. arXiv preprint arXiv:2009.13962, 2020.   \nHerzig, J. and Berant, J. Span-based semantic parsing for compositional generalization. arXiv preprint arXiv:2009.06040, 2020.   \nHoltzman, A., Buys, J., Forbes, M., Bosselut, A., Golub, D., and Choi, Y. Learning to write with cooperative discriminators. arXiv preprint arXiv:1805.06087, 2018.   \nHua, X. and Wang, L. Pair: Planning and iterative refinement in pre-trained transformers for long text generation. In EMNLP, 2020.   \nKahneman, D. Thinking, fast and slow. kindle ed, 2013.   \nKurita, S. and Cho, K. Generative language-grounded policy in vision-and-language navigation with bayes’ rule. arXiv preprint arXiv:2009.07783, 2020.   \nLake, B. M. and Murphy, G. L. Word meaning in minds and machines. arXiv preprint arXiv:2008.01766, 2020.   \nLake, B. M., Ullman, T. D., Tenenbaum, J. B., and Gershman, S. J. Building machines that learn and think like people. Behavioral and Brain Sciences, 40:E253, 2017.   \nLewis, M., Liu, Y., Goyal, N., Ghazvininejad, M., Mohamed, A., Levy, O., Stoyanov, V., and Zettlemoyer, L. Bart: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. arXiv preprint arXiv:1910.13461, 2019.   \nLi, B. Z., Nye, M., and Andreas, J. Implicit representations of meaning in neural language models. arXiv preprint arXiv:2106.00737, 2021.   \nLiang, C., Berant, J., Le, Q. V., Forbus, K., and Lao, N. Neural symbolic machines: Learning semantic parsers on freebase with weak supervision. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 23–33, Vancouver, Canada, 2017. URL http://aclanthology.coli.uni-saarland.de/pdf/P/P17/P17-1003.pdf.   \nLiang, P. Learning executable semantic parsers for natural language understanding. Communications of the ACM, 59(9):68–76, 2016.   \nLiu, Y., Ott, M., Goyal, N., Du, J., Joshi, M., Chen, D., Levy, O., Lewis, M., Zettlemoyer, L., and Stoyanov, V. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   \nLoshchilov, I. and Hutter, F. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101, 2017.   \nLu, X., West, P., Zellers, R., Bras, R. L., Bhagavatula, C., and Choi, Y. Neurologic decoding:(un) supervised neural text generation with predicate logic constraints. arXiv preprint arXiv:2010.12884, 2020.   \nMao, J., Gan, C., Kohli, P., Tenenbaum, J. B., and Wu, J. The neuro-symbolic concept learner: Interpreting scenes, words, and sentences from natural supervision. arXiv preprint arXiv:1904.12584, 2019.   \nMartin, L. J., Ammanabrolu, P., Hancock, W., Singh, S., Harrison, B., and Riedl, M. O. Event representations for automated story generation with deep neural nets. In AAAI, 2018.   \nMarzoev, A., Madden, S., Kaashoek, M. F., Cafarella, M., and Andreas, J. Unnatural language processing: Bridging the gap between synthetic and natural language data. arXiv preprint arXiv:2004.13645, 2020.   \nMiao, N., Zhou, H., Mou, L., Yan, R., and Li, L. Cgmh: Constrained sentence generation by metropolis-hastings sampling. In AAAI, 2019.   \nMichael, L. and Valiant, L. G. A first experimental demonstration of massive knowledge infusion. 2008.   \nMou, L., Lu, Z., Li, H., and Jin, Z. Coupling distributed and symbolic execution for natural language queries. In Precup, D. and Teh, Y. W. (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 2518–2526. PMLR, 06–11 Aug 2017. URL http://proceedings.mlr.press/v70/mou17a.html.   \nMuhlgay, D., Herzig, J., and Berant, J. Value-based search in execution space for mapping instructions to programs. pp. 1942–1954, 01 2019. doi: 10.18653/v1/N19-1193.   \nNie, Y., Williamson, M., Bansal, M., Kiela, D., and Weston, J. I like fish, especially dolphins: Addressing contradictions in dialogue modelling. arXiv preprint arXiv:2012.13391, 2020.   \nNye, M. I., Solar-Lezama, A., Tenenbaum, J. B., and Lake, B. M. Learning compositional rules via neural program synthesis. arXiv preprint arXiv:2003.05562, 2020.   \nPieraccini, R., Tzoukermann, E., Gorelov, Z., Gauvain, J.-L., Levin, E., Lee, C.-H., and Wilpon, J. A speech understanding system based on statistical representation of semantics. In [Proceedings] ICASSP-92: 1992 IEEE International Conference on Acoustics, Speech, and Signal Processing, volume 1, pp. 193–196 vol.1, 1992. doi: 10.1109/ICASSP.1992.225939.   \nRadford, A., Wu, J., Child, R., Luan, D., Amodei, D., and Sutskever, I. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9, 2019.   \nRamesh, A., Pavlov, M., Goh, G., Gray, S., Voss, C., Radford, A., Chen, M., and Sutskever, I. Zero-shot text-to-image generation. arXiv preprint arXiv:2102.12092, 2021.   \nRuis, L., Andreas, J., Baroni, M., Bouchacourt, D., and Lake, B. M. A benchmark for systematic generalization in grounded language understanding. arXiv preprint arXiv:2003.05161, 2020.   \nSchlag, I. and Schmidhuber, J. Learning to reason with third-order tensor products. CoRR, abs/1811.12143, 2018. URL http://arxiv.org/abs/1811.12143.   \nSerafini, L. and d’Avila Garcez, A. S. Logic tensor networks: Deep learning and logical reasoning from data and knowledge. CoRR, abs/1606.04422, 2016. URL http://arxiv.org/abs/1606. 04422.   \nShen, S., Fried, D., Andreas, J., and Klein, D. Pragmatically informative text generation. arXiv preprint arXiv:1904.01301, 2019.   \nShin, R., Lin, C. H., Thomson, S., Chen, C., Roy, S., Platanios, E. A., Pauls, A., Klein, D., Eisner, J., and Van Durme, B. Constrained language models yield few-shot semantic parsers. arXiv preprint arXiv:2104.08768, 2021.   \nSinha, K., Sodhani, S., Dong, J., Pineau, J., and Hamilton, W. L. Clutrr: A diagnostic benchmark for inductive reasoning from text. arXiv preprint arXiv:1908.06177, 2019.   \nSmith, E. M., Gonzalez-Rico, D., Dinan, E., and Boureau, Y.-L. Controlling style in generated dialogue. arXiv preprint arXiv:2009.10855, 2020.   \nSpelke, E. S. and Kinzler, K. D. Core knowledge. Developmental Science, 10(1):89–96, 2007.   \nSu, Y. and Yan, X. Cross-domain semantic parsing via paraphrasing. arXiv preprint arXiv:1704.05974, 2017.   \nTsamoura, E., Hospedales, T., and Michael, L. Neural-symbolic integration: A compositional perspective. Proceedings of the AAAI Conference on Artificial Intelligence, 35(6):5051–5060, May 2021. URL https://ojs.aaai.org/index.php/AAAI/article/view/16639.   \nWelleck, S., Weston, J., Szlam, A., and Cho, K. Dialogue natural language inference. arXiv preprint arXiv:1811.00671, 2018.   \nWeston, J., Bordes, A., Chopra, S., Rush, A. M., van Merriënboer, B., Joulin, A., and Mikolov, T. Towards ai-complete question answering: A set of prerequisite toy tasks. arXiv preprint arXiv:1502.05698, 2015.   \nXu, J., Ren, X., Zhang, Y., Zeng, Q., Cai, X., and Sun, X. A skeleton-based model for promoting coherence among sentences in narrative story generation. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 4306–4315, Brussels, Belgium, OctoberNovember 2018. Association for Computational Linguistics. doi: 10.18653/v1/D18-1462. URL https://www.aclweb.org/anthology/D18-1462.   \nXu, J., Ju, D., Li, M., Boureau, Y.-L., Weston, J., and Dinan, E. Recipes for safety in open-domain chatbots. arXiv preprint arXiv:2010.07079, 2020a.   \nXu, S., Semnani, S. J., Campagna, G., and Lam, M. S. Autoqa: From databases to qa semantic parsers with only synthetic training data. arXiv preprint arXiv:2010.04806, 2020b. ",
+        "bbox": [
+            171,
+            523,
+            828,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            41,
+            828,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            32,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            377
+        ],
+        "page_idx": 12
+    }
+]

parse/train/SJgw51HFDr/SJgw51HFDr.md

@@ -0,0 +1,455 @@
+# SPARSE WEIGHT ACTIVATION TRAINING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Training convolutional neural networks (CNNs) is time consuming. Prior work has explored how to reduce the computational demands of training by eliminating gradients with relatively small magnitude. We show that eliminating small magnitude components has limited impact on the direction of high-dimensional vectors. However, in the context of training a CNN, we find that eliminating small magnitude components of weight and activation vectors allows us to train deeper networks on more complex datasets versus eliminating small magnitude components of gradients. We propose Sparse Weight Activation Training (SWAT), an algorithm that embodies these observations. SWAT reduces computations by $50 \%$ to $80 \%$ with better accuracy at a given level of sparsity versus the Dynamic Sparse Graph algorithm. SWAT also reduces memory footprint by $23 \%$ to $37 \%$ for activations and $50 \%$ to $80 \%$ for weights.
+
+# 1 INTRODUCTION
+
+The usage of convolutional neural networks (CNNs) has dominated a wide variety of complex computer vision tasks, such as object recognition (Krizhevsky et al., 2012; Szegedy et al., 2015), object detection (Szegedy et al., 2013; Ren et al., 2015), and image restoration (Dong et al., 2014; Zhang et al., 2017). However, CNNs are compute and memory intensive; even a moderately sized CNN model, like ResNet-50 with tens of millions of parameters, requires billions of floating-point operations and consumes tens of gigabytes to store weights and activations during training.
+
+Previous works propose techniques for reducing computations and memory consumption during CNN training. Such techniques include quantization where every operation is quantized in lowprecision during training such a (Zhou et al., 2016; Choi et al., 2018; Wu et al., 2016; Wang et al., 2018), or, use fixed-point integers instead of floating-point numbers (Wu et al., 2018; Das et al., 2018).
+
+An orthogonal approach to reduce computations is sparsification, a process in which we eliminate computations involving small values. meProp (Sun et al., 2017; Wei et al., 2017) sparsifies backpropagating by selecting a subset of output gradients in each layer. Using only the top $5 \%$ of the gradients (ranked by magnitude), meProp can train a CNN and MLP on MNIST dataset without accuracy loss. The computational flow of meProp is shown in Figure 1a and 1b. meProp does not modify the forward pass. In the backward pass meProp performs a “Top-K” operation on the output activation gradients which sets components not ranked in the Top-K by magnitude to zero. It then uses the sparsified output activation gradients to (potentially more efficiently) compute the input activation and weight gradients. Our experiments suggest meProp fails to converge on larger networks and datasets.
+
+Recently, Liu et al. (2019) proposed a method of reducing computation during training and inference by constructing a dynamic sparse graph (DSG) using random projection for dimensionality reduction. DSG loses accuracy on ImageNet dataset.
+
+In this work, we propose an alternative technique, Sparse Weight Activation Training (SWAT), that can train deep CNNs on complex data sets like ImageNet. Compared to DSG, SWAT is a straightforward technique which uses less expensive Top-K operation, inspired by meProp, while achieving better accuracy than DSG on ImageNet.
+
+This paper provides the following contributions:
+
+• It shows that dropping gradients during back-propagation is harmful to network convergence especially when training a deeper model on a complex dataset. In this case the model suffers high accuracy loss.   
+• It proposes SWAT, a sparse training algorithm that can train a broad range of deep CNNs with minimal accuracy loss on complex datasets like CIFAR10, CIFAR100, and ImageNet. SWAT reduces the total number of operations during training by $50 \% - 8 0 \%$ . It also achieves $23 \% - 3 7 \%$ activation and $50 \% - 8 0 \%$ weight footprint reduction during the backward pass. SWAT algorithm uses sparse weight both in the forward and backward passes, and therefore model learns sparse weights, i.e., a pruned architecture; If the model has been trained using SWAT with $S \%$ sparsity during training, then during inference, weight can be pruned to $S \%$ without sacrificing any loss in accuracy.   
+• We perform empirical studies to provide insight into why ‘SWAT performs well; we showed that Top-K sparsification in general preserves direction in high-dimensional space.
+
+# 2 SPARSITY INDUCED TRAINING
+
+# 2.1 PRELIMINARIES
+
+Let us consider a deep CNN with $\mathrm { L }$ convolutional layers trained using mini-batch stochastic gradient descent, where the $l ^ { t h }$ layer maps the input activation $\left( a _ { l - 1 } \right)$ using function $f _ { l }$ from $\large \mathbf { \large { R } } ^ { N \times C _ { l - 1 } \times H _ { l - 1 } \times W _ { l - 1 } }  R ^ { N \times C _ { l } \times \large { H _ { l } \times W _ { l } } }$ . $f _ { l }$ computes $C _ { l }$ channel of output feature maps, each of dimension $R ^ { H _ { l } \times W _ { l } }$ , using $C _ { l - 1 }$ channels of input feature maps of dimension $R ^ { H _ { l - 1 } \times \hat { W } _ { l - 1 } }$ fo r each of the $N$ samples in the mini-batch. The ${ { l } ^ { t h } }$ layer has weights $w _ { l } \in R ^ { C _ { l } \times C _ { l - 1 } \times H _ { f } \times W _ { f } }$ . The forward pass of the $l ^ { t h }$ layer can be defined as:
+
+$$
+a _ { l } = f _ { l } ( a _ { l - 1 } , w _ { l } )
+$$
+
+During back-propagation the ${ { l } ^ { t h } }$ layer receives the gradient of the loss $L$ w.r.t its output activation $( \bigtriangledown a _ { l } )$ . This is used to compute the gradient of the loss w.r.t its input activation $( \bigtriangledown a _ { l - 1 } )$ and weight $( \bigtriangledown _ { w _ { l } } )$ . Thus, the backward pass for the $l ^ { t h }$ layer can be defined as:
+
+$$
+\begin{array} { r } { \nabla _ { a _ { l - 1 } } = F _ { l } ( \nabla _ { a _ { l } } , w _ { l } ) } \\ { \nabla _ { w _ { l } } = F _ { l } ( \nabla _ { a _ { l } } , a _ { l - 1 } ) } \end{array}
+$$
+
+![](images/ba3d9650b4e5f209b4269c6a80d95d3f16f2350290c727c7227b88d8b8f071da.jpg)  
+Figure 1: meProp versus SWAT (a) Shows the forward and backward pass of MeProp and SWAT for a fully connected layer. (b) Computational flow of meProp for any layer $l$ (c) Computational flow of SWAT for any layer $l$ .
+
+# 2.2 SPARSE WEIGHT ACTIVATION TRAINING
+
+Our goal is to reduce the computations required during the training process. SWAT does this by effectively transforming small magnitude components of vectors into zero values. Since multiplication of any number by zero results in zero the multiplication is not necessary. Such a sparsification process can be applied in a number of ways in the context of the backpropagation algorithm. Ideally, the modified training algorithm will retain both model accuracy and rate of convergence.
+
+We explore the sensitivity to applying this sparsification process at different points. We look at the sensitivity of the model convergence to sparse input i.e. weight $( w _ { l } )$ and input activation $( a _ { l } )$ for forward pass and weights $( w _ { l } )$ , input activation $( a _ { l } )$ and output activation gradient $( \bigtriangledown a _ { l } )$ for the backward pass as shown in Equation 1 , 2 and 3.
+
+Figure 2a shows the result of our analysis of sparsification in the forward pass. Here we train ResNet-18 on CIFAR-100 after modifying the forward pass to use sparse inputs in Equation 1 for weights $( w _ { l } )$ and separately activations $( a _ { l } )$ while keeping the backward pass unchanged (i.e., only the forward pass computation is sparse). The results show that network convergence is more tolerant to sparse weights $( w _ { l } )$ compared to sparse activations $( a _ { l } )$ . Thus, as shown in Figure 1a and 1c, SWAT uses sparse weights in the forward pass.
+
+Figure 2b shows the result of our analysis of sparsification in the backward pass. We modify Equation 2 and Equation 3 to sparsify either output gradient $( \bigtriangledown a _ { l } )$ , as in meProp (see Figure 1b), or sparsify activations $( a _ { l } )$ and weights $( w _ { l } )$ . The results show accuracy is extremely sensitive to sparsification of output gradients. Such sparsity consistently results in networks converging to lower accuracy compared to using sparse activations and weights. Thus, as shown in Figure 1a and 1c, SWAT uses sparse weights and activations in the backward pass. The overall SWAT training algorithm is presented in Algorithm 1.
+
+SWAT uses sparse computation in both the forward and the backward passes, while meProp (Sun et al., 2017) uses sparse computation only in the backward pass. SWAT uses sparse weights and activations in the backward pass allowing compression of weights and activations in the forward pass1. Effectively, reducing overall memory access overhead of fetching weights in the backward pass and activation storage overhead because only Top- $K \%$ are saved. This memory benefit is not present for meProp since dense weights and activations are needed in the backward pass, whereas there is no storage benefit of sparsifying the output gradients since they are temporary values generated during back-propagation.
+
+![](images/ccfda83983e0af2bd303f71da6a1d03acbcf4fdb512b1826523e1958b87bb22e.jpg)  
+Figure 2: Convergence Analysis: (a) Sensitivity Analysis of ResNet18 for the Forward Pass on the CIFAR100 dataset. (b) Sensitivity Analysis of ResNet18 for the Backward Pass on the CIFAR100 dataset. (c) Shows the training curve of ResNet18 on ImageNet for meProp and SAW algorithm. Learning rate is reduced by $\frac { 1 } { 1 0 } ^ { \mathit { \bar { t } h } }$ at $3 0 ^ { t h }$ and $4 0 ^ { t h }$ epoch.
+
+To compare SWAT’s approach to that of meProp, we use a variant of SWAT that only sparsifies the backward pass; we shall refer to this version of SWAT as SAW (Sparse Activation and Weight back-propagation). We compare the performance of the meProp and SAW with deep networks, and complex datasets2. Figure 2c shows SAW and meProp convergence of ResNet18 with the ImageNet dataset; it compares the performance of meProp at $30 \%$ and $50 \%$ sparsity to SAW $80 \%$ sparsity. As we can see, meProp converges to a good solution at sparsity of $30 \%$ . However, at $50 \%$ sparsity, meProp suffers from overfitting and fails to generalize (between epochs 5 to 30), and at the same time, it is unable to reach an accuracy level above $45 \%$ . These results suggest that dropping output activation gradient $( \bigtriangledown a _ { l } )$ is generally harmful during back-propagation. On the other hand, SAW succeeds to converge to an accuracy of $64 \%$ even at a much higher sparsity of $80 \%$ .
+
+Algorithm 1: Training an $L$ layer network using SWAT or SAW Algorithm   
+
+<table><tr><td colspan="3">The data: A mini-batch of inputs &amp; targets (ao,a*), training iteration t, previous weights wt, learning rate n. The result: Update weights wt+1.</td></tr><tr><td colspan="3">Step 1.Forward Computation; end forl=1 toL do</td></tr><tr><td>if l==‘ConvolutionLayer&#x27; or‘LinearLayer&#x27; then</td><td></td><td>Step 2.Backward Computation;</td></tr><tr><td>if algorithm ==‘SWAT&#x27; then</td><td>aL</td><td>Compute the gradient of the output layer aloss(aL,a*). daL</td></tr><tr><td>at← forward(wt,at-1);</td><td>wt↑ frOPk(wt);</td><td>for l=L to 1 do</td></tr><tr><td>at-1fTOPK(at-1);</td><td></td><td>wt,al-1 ← save_for_backwardl;</td></tr><tr><td>else</td><td></td><td>Val-1 ← backward_input(Va,wt);</td></tr><tr><td></td><td></td><td>Vw-介</td></tr><tr><td></td><td>// algorithm == `SAW&#x27;;</td><td>backward_weight(Va,at-1);</td></tr><tr><td>at ↔ forward(wt,at-1)</td><td></td><td></td></tr><tr><td>wt← frOPK(wt);</td><td>end</td><td></td></tr><tr><td>a-1←fTOPk(a-1);</td><td></td><td></td></tr><tr><td>end</td><td></td><td>Step 3.Parameter Update;</td></tr><tr><td>save_for_backwardl ← wt,al-1;</td><td></td><td>for l=1 to L do</td></tr><tr><td></td><td></td><td>wt+1 ← Optimizer(wt,Vw,n);</td></tr><tr><td>else</td><td></td><td></td></tr><tr><td></td><td>end</td><td></td></tr><tr><td>al ↑ forward(wt,al-1);</td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>save for_backwardl ← wt,al-1;</td><td></td><td></td></tr></table>
+
+Top-K Selection: Given CNNs operate on tensors with many dimensions, there are several options for how to select which components are set to zero during sparsification. Our CNNs operate on fourth-order tensors, $T ~ \in ~ \hat { R } ^ { N \times C \times H \times W }$ . Below we evaluate three variants of the Top-K operation illustrated in the right side of Figure 3. We also compared against a null hypothesis in which randomly selected components of a tensor are set to zero.
+
+![](images/14cd671983fadedc7ffaafcfd88451a8fbdba2c709fd162b0fe849788be6258f.jpg)  
+Figure 3: Different ways of performing top- $\mathbf { \delta } \cdot \mathbf { k }$ operation. ‘N’ denotes the #samples in the minibatch or filters in the layer, ‘C’ denotes the #channels in the layer. $\mathbf { \hat { H } } ^ { \prime }$ and ‘W’ denote the height and width of the filter/activation map in the layer. Color represent the selected activations/weights by the Top-K operation.
+
+The first variant, labeled TOPK-NCHW in Figure 3, selects activations and weights to set to zero by considering the entire mini-batch. This variant performs Top-K operation over the entire tensor, $\bar { f } _ { T O P K } ^ { \{ N , C , H , W \} } ( \bar { T } )$ , where the superscript represents the dimension along which the Top-K operation is performed. The second variant (TOPK-CHW) performs Top-K operation over the dimensions $C , H$ and W i.e., f {C,H,W }T OP K (T ) , i.e., selects K % of input activations from every mini-batch sample and $K \%$ of weights from every filter in the layer. The third variant (TOPK-HW) is the strictest form of
+
+Top-K operation. It select $K \%$ of activations or weights from all channels, and thereby performing the Top-K operation over the dimension $H$ and $W$ , i.e., $f _ { T O P K } ^ { \{ H , W \} } ( T _ { H , W } )$ .
+
+The left side of Figure 3 shows the accuracy achieved on ResNet-18 for CIFAR100 when using SAW configured with each of these Top-K variants along with a variant where a random subset of components is set to zero. The results show, first, that randomly selecting works only for low sparsity. At high sparsity all variants of Top- $\mathbf { \nabla } \cdot \mathbf { K }$ outperform random selection by a considerable margin. Second, they show that the more constrainted the Top-K operation the less accuracy achieved. Constraining Top-K results in selecting some activations or weights which are quite small. Similarly, some essential activations and weights are discarded just to satisfy the constraint.
+
+# 3 RESULTS
+
+In this section, we present our experimental results of SWAT algorithm on different architectures and datasets and we quantify the theoretical reduction in compute and memory bandwidth achievable using SWAT.
+
+# 3.1 EXPERIMENTAL SETUP
+
+We implement SWAT and SAW algorithms in PyTorch Framework (Paszke et al., 2017); models are trained on three different datasets: CIFAR10, CIFAR100 (Krizhevsky et al., 2009) and ImageNet ILSVRC2012 (Deng et al., 2009) and are evaluated on four different architectures ResNet18, 34, 50, 101 (He et al., 2016), Wide Residual Networks (Zagoruyko & Komodakis, 2016), DenseNet-BC-121 (Huang et al., 2017), and VGG-16 (Simonyan & Zisserman, 2014) with batchnormalization (Ioffe & Szegedy, 2015). Batch-Normalization statistics are computed using the running average (with momentum 0.9). We use SGD with momentum as our optimization algorithm with an initial learning rate of 0.1, momentum of 0.9 and weight decay $\lambda$ of 0.0001.
+
+For CIFAR10 and CIFAR100 dataset, ResNet, VGG, and DenseNet models are trained for 150 epochs, and learning rate are reduced by $( 1 / 1 0 ) ^ { t h }$ at the 50-th and the 100-th epoch whereas WRN is trained for 200 epochs and the learning rate is annealed by a factor of $( 1 / 5 ) ^ { t h }$ at 60-th, 120-th and 160-th epoch. ResNet, VGG, and WRN are trained using a batch-size of 128 whereas DenseNet is trained with a batch-size of 64. We run each experiment with three different seeds and use the average value for all the plots.
+
+For training on ImageNet dataset, we use $2 2 4 \times 2 2 4$ random crops from the input images or its horizontal flip and the input image is normalized by the per-color mean and standard deviation. Networks are trained for 50 epochs with the mini batch-size of 256 samples, and the learning rate are reduced by $( 1 / 1 0 ) ^ { t h }$ after 30-th and 40-th epoch.
+
+# 3.2 ACCURACY ANALYSIS
+
+In this section, we provide a comprehensive analysis of SWAT and SAW algorithms and show the influence of sparsity on validation accuracy; thereby showing the potential of reducing computation during training with negligible accuracy loss. We furthermore discuss the impact on rate of convergence and the robustness of the algorithm on a wide range of models with different depths and widths. Last, we provide an alternative to Top-K for efficient software/hardware implementation.
+
+Accuracy on CIFAR10 and CIFAR100: Figure 4 shows the accuracy of the SWAT and SAW algorithms at different sparsity budgets on CIFAR10 and CIFAR100 dataset. From the graph, we can conclude that models can be trained using SWAT and SAW algorithm up to $6 0 \%$ sparsity with almost zero accuracy loss and suffer only a slight accuracy loss at $7 0 \%$ sparsity. For CIFAR10 dataset at $7 0 \%$ sparsity, VGG-16 and DenseNet-121 have an accuracy loss of around $0 . 5 7 \%$ for SWAT $( 0 . 2 6 \%$ for SAW) and $0 . 4 \%$ for SWAT $( 0 . 2 3 \%$ for SAW) whereas ResNet-18 gains an accuracy of $0 . 0 2 \%$ for SWAT ( $0 . 1 \%$ for SAW). For CIFAR100 dataset at $7 0 \%$ sparsity, ResNet-18, VGG-16 and DenseNetBC-121 lose an accuracy of around $0 . 5 \%$ , $0 . 4 1 \%$ and $0 . 6 8 \%$ for SAW and $0 . 4 \%$ , $0 . 9 9 \%$ and $1 . 7 8 \%$ for SWAT respectively. At $8 0 \%$ sparsity the accuracy loss on CIFAR10 and 100 is less than $1 . 8 \%$ for SAW and less than $2 . 5 \%$ for SWAT.
+
+![](images/604d623cb34e8f5aff617d312f4e4e12d0b017c4d97c11792fd79f52ee369960.jpg)  
+Figure 4: Comprehensive analysis of sparsity vs accuracy trade-off: (a) Accuracy of SWAT and SAW algorithms on CIFAR10 dataset. (b) Accuracy of SWAT and SAW algorithms on CIFAR100 dataset. The dashed line represents the baseline accuracy for the corresponding model. Datapoints for SAW algorithm are represented as dots whereas for SWAT algorithm they are represented as stars.
+
+![](images/017f5f4984817d8b3cda8e93aa258c45bb847be2ac3d1f48eacba50d70939fbd.jpg)  
+Figure 5: Trend of SWAT algorithm on ImageNet dataset: (a) Validation curve of SWAT algorithm (b) Validation Accuracy of SWAT, SAW and DSG algorithms at different sparsity constraints. Dotted line represents the baseline back-propagation algorithm. ‘RN18’ represent ResNet18, ‘DN121’ represent DenseNet-BC-121 and ‘DSG’ denote the results reported by the Dynamic Sparse Graph(Liu et al., 2019) algorithm.
+
+Accuracy on ImageNet: Figure 5a shows the validation curve of the SWAT algorithm on ImageNet dataset for three different architectures and Figure 5b shows the accuracy obtained by the SWAT and SAW algorithms. The result shows that the SWAT and SAW algorithms lose negligible accuracy at $5 0 \%$ sparsity for all three architectures. The solution is within an accuracy loss of $0 . 2 6 - 1 . 0 1 \dot { \% }$ compared to the baseline solution. For high sparsity of $7 0 \%$ , ResNet-18, VGG-16 and DenseNet-BC-121 lose only around $1 . 5 2 \%$ , $1 . 6 \%$ and $2 . 2 6 \%$ accuracy for the SWAT and $1 . 4 2 \%$ , $1 . 2 8 \%$ and $1 . 8 2 \%$ for the SAW algorithm respectively. Both the algorithms perform better than the DSG algorithm proposed by (Liu et al., 2019), which accelerates training by performing dimensionality reduction search and performing the forward and backward passes in low dimensional space. The accuracy loss of DSG at $5 0 \%$ sparsity is around $2 . 8 3 \%$ for ResNet-18 and $1 . 5 4 \%$ for VGG-16 compared to the SWAT accuracy loss of $0 . 2 7 \%$ and $0 . 8 6 \%$ for ResNet-18 and VGG-16 respectively.
+
+Impact on rate of Convergence: We define the rate of convergence is the number of epochs it takes to reach the saturation accuracy. Figure 5a shows the validation curve of SWAT algorithm when training ResNet-18, VGG-16 and DenseNet-BC-121 on ImageNet dataset. As shown in Figure, when the learning rate is 0.1 (i.e. between epoch 0 and 30) the SWAT algorithm reaches the saturation accuracy around the 15th epoch approximately the same epoch when the baseline algorithm also reaches saturation. Similarly, when the learning rate is 0.01 (i.e. between epoch 0-40th) both SWAT and the baseline saturate at epoch $3 5 \mathrm { t h }$ . The experiment at $5 0 \%$ and $7 0 \%$ sparsity shows that SWAT algorithm converges with slight accuracy loss but at the same rate compared to the baseline algorithm.
+
+Influence of Depth and Width: Network depth (#layers) and width (#channels) are two important design criteria. Previous studies (Lu et al., 2017; Raghu et al., 2017; Sharir & Shashua, 2018) have found that both depth and width affect network expressivity. Increasing network depth helps in learning complex abstraction, whereas increasing width helps in learning more features. Ideally, we want SWAT and SAW algorithms to work with models of varying depth and width. Therefore, we study the influence of depth and width on the SWAT and SAW algorithms. Figure 6a shows the accuracy of ResNet-50, ResNet-101 and WRN-28-10 on CIFAR100 datasets at four different sparsities $0 \%$ , $5 0 \%$ , $7 0 \%$ and $8 0 \%$ . The result for deeper networks shows that enforcing sparsity up to $7 0 \%$ is beneficial for training as the ResNet-50 and ResNet-100 converged to an accuracy higher than the baseline training. At $8 0 \%$ sparsity, ResNet-101 loses accuracy of a mere $0 . 1 8 \%$ whereas ResNet-50 still has an accuracy advantage of $0 . 1 9 \%$ over the baseline. WRN-28-10 lose accuracy on training with SWAT and SAW algorithm, but the accuracy loss is only $0 . 6 7 \%$ for SAW and $0 . 4 9 \%$ for SWAT at $7 0 \%$ sparsity.
+
+![](images/6f1dab809928ae8a17fa6b80636011d5e9e261229c75389f46d58d369e085d55.jpg)  
+Figure 6: (a) Influence of Depth and Width: Accuracy of SAW and SWAT algorithms on CI FAR100 dataset for ResNet-50,101 and WRN-28-10 (b) Threshold value (K-th largest values) in Top-K operation of different layers during training
+
+Efficient Top-K Implementation: Top- $K ^ { 3 }$ operation on 1 dimensional array of size $n$ can be naively implemented using sorting. The computational complexity of a naive Top- $\mathbf { \nabla } \cdot \mathbf { K }$ operation is $O ( n \log n )$ . The computational complexity can be reduced to $O ( n )$ , if the $\mathbf { k }$ -th largest element can be found in $O ( n )$ time, since for this case the Top-K operation can be implemented by a threshold operation. The K-th largest element can be computed in $O ( n )$ average time using quickselect (Hoare, 1961) or in $\theta ( n )$ time using BFPRT (Blum et al., 1973) or introselect (Musser, 1997). The computation can be further reduced since we found experimentally that for a given layer, the K-th largest elements is almost constant during training as shown in Figure 6b. So we don’t need to compute the K-th largest elements during every training iteration and can be computed once in a while after multiple iterations.
+
+3.3 COMPUTATIONAL AND MEMORY OVERHEAD REDUCTION DURING TRAINING
+
+In this section, we will quantify the reduction in computational and memory overhead, using SWAT, over the baseline training algorithm.
+
+Computation Reduction: SWAT sparsifying the computation in During CNN training, most of the computation is in the convolution and fully connected layer, therefore sparsifying the computation in both of these layers can result in linear speed-up during training. Figure 7 shows the computational reduction possible by SWAT for three different architecture while training on ImageNet dataset. SWAT achieves a computation reduction of $2 \mathbf { x }$ , $3 . 3 \mathrm { x }$ , and $5 \mathbf { x }$ at $50 \%$ , $70 \%$ , and $80 \%$ sparsity respectively. Note that the overall overhead of implementing efficient Top-K operation using BFRT/introselect $^ +$ thresholding, as described in the pre
+
+algorithm is accelerating CNN training by both the forward and the backward pass.
+
+![](images/14d5999dc1121539f17c5df4d6d7a1526a5229d59585cbb4688d96655ef101e3.jpg)  
+Figure 7: Computational reduction in SWAT at different sparsity. “RN” denotes ResNet, “DN” denote DenseNet (Dataset: ImageNet)
+
+vious section, is only $1 \%$ additional computation during training. Another benefit of using SWAT
+
+is that the model learns a sparse architecture and therefore, sparse weights are used during Inference.   
+Thus, the same computational benefit of $2 { - } 5 \mathbf { x }$ is possible for Inference as well.
+
+![](images/d72652428a8f7bbbedb5ecc749213c3799bbe70df71dd85458b494101f721607.jpg)  
+Figure 8: Reduction in memory accesses during the backward pass. (a) Reduction in parameter access (b) Reduction in activation access per sample (Dataset: ImageNet)
+
+Memory Overhead Reduction: During training, most of the weights and activations are stored in DRAM and accessing DRAM consumes three orders of magnitude more energy consumption than computation (Horowitz). So reducing the memory access during training will directly reduce the energy consumption. SWAT algorithm uses sparse input activation $\left( a _ { l - 1 } \right)$ and weight $( w _ { l - 1 } )$ in the backward, so input activation and weight can be compressed and stored in the memory in sparse format thereby reducing the DRAM access in the backward pass. Figure 8a shows the reduction of $2 \mathbf { x }$ , $3 . 3 \mathrm { x }$ , and ${ 5 } \mathbf { x }$ at sparsity of $50 \%$ , $70 \%$ and $80 \%$ in the parameters access in the backward pass. The other significant memory overhead is saving the activation, and this overhead is dependent not only on the model size but also on the batch-size used during training. Figure 8b shows the activation memory overhead for different architectures for a mini-batch size of 1. The graph only shows the activation of batch-normalization and convolutional layer since memory overhead for the activations of the linear layer is negligible compared to them. Note that SWAT algorithm sparsifies the computation of the linear, and convolutional layers, so full input activation of the batch-normalization layer are saved for the backward pass. Thus, SWAT algorithm achieves activation compression of around 1.3x, 1.5x, and $1 . 7 \mathbf { x }$ at sparsity of around $50 \%$ , $70 \%$ , and $80 \%$ . The activation of batch-normalization layer limits the overall activation compression.
+
+# 4 EXPERIMENTAL ANALYSIS OF SWAT BEHAVIOUR
+
+In this section, we will give some experimental evidence which explains why the SWAT algorithm is working so well in practice. The experiment shows the general behavior of vector sparsification in high dimensional space. Let us first define two new terminologies which we are going to use in this section: “Top-K sparsification” and “Sparsification Angle”4. Top-K sparsification of a vector $v$ selects $K \%$ of the highest magnitude component and set the rest of the component to zero. Sparsification angle is the angle between the original and the Top-K sparsified instance of that vector.
+
+# 4.1 VECTOR SPARSIFICATION IN HIGH-DIMENSIONAL SPACE
+
+A vector in high-dimensional space behaves differently from their low dimensional counterpart. It is well known that in high-dimension, two independent isotropic vectors tend to be orthogonal. Recently Anderson & Berg (2017) extended the analysis of the geometry of high-dimensional vectors to binary vectors. They proved that the angle between any random vector, drawn from a rotationally invariant distribution, and its binarized version would be concentrated around $3 7 ^ { \circ }$ . Thus, binarization of high dimensional vector approximately preserves their direction. We apply a similar kind of geometry analysis to high dimensional sparsified vectors. We show that sparsification indeed preserves direction in high-dimensional space, which is contrary to our low-dimensional intuition.
+
+The first question we need to answer is how should we sparsify a vector $v ~ \in ~ R ^ { d }$ such that the sparsification angle is minimum between the original and the sparsified instance of the original vector (has only $K \%$ non-zero component). We found that the cosine angle is minimum when the $K \%$ non-zero component corresponds to the $K \%$ highest magnitude component, i.e., Top K sparsification. The proof is in the appendix.
+
+We did an experiment for analyzing how Top K sparsification affect angle as shown in Figure 9a, Here we are showing the sparsification angle distribution for a 1000 dimensional vector drawn from standard normal distribution at different sparsity. The peak of sparsification angle at $9 0 \%$ sparsity is concentrated around $4 8 ^ { \circ }$ which is much less than peak of random vectors which is concentrated around $9 0 ^ { \circ }$ . Similarly, the peak up to $8 0 \%$ sparsity is concentrated at an angle of $3 6 . 4 ^ { \circ }$ only. This suggest that deviation caused by sparsification is indeed small in high-dimension.
+
+For our next experiment shown in Figure 9b, we study how much a vector of a given dimension, drawn from standard normal distribution, can be maximally sparsified such that the sparsification angle is less than $\delta$ . We can see that the percentage of Top-K components needed for $\delta = \{ 2 0 ^ { \circ } , \bar { 3 } 0 ^ { \circ } , 4 0 ^ { \circ } \}$ is around only $4 3 \%$ , $2 9 \%$ and $1 8 \%$ respectively with a variance less than $3 \%$ as shown in Figure ${ 9 \mathrm { c } }$ . Thus, these experiment suggest that a high-dimensional vector can be sparsified up to $7 0 \%$ , which will lead a deviation $( \delta )$ of only $3 0 ^ { \circ }$ . All the above experimental results are dependent on the distribution from which random vectors are drawn, in Figure 9e, we calculate the sparsification angle during training ResNet18 on CIFAR100 dataset at $7 0 \%$ Sparsity. Here the sparsification angle for weight and activation is less than $3 6 ^ { \circ }$ for all the layer in the network. So the experiment suggests that the above analysis is applicable during training.
+
+![](images/ead5b43fd2c3498f2e9e04ad83a1602a0e8f149779c2427b2252b3550e3bda24.jpg)  
+Figure 9: Vector sparsification in high-dimension approximately preserves the direction:(a) Shows the sparsification angle distribution at different Top-K percentage for a 1000 dimensional vector in 10, 000 trials. Random represents the angle distribution between 2 random vectors. (b) and (c) Shows the percentage of Top-K components needed for sparsification angle to be within $\delta$ in 1000 trials and the variance in those trials. (d) Shows the relation between Top-K sparsification and the sparsification angle in 1000 trials. (e) Shows how the sparsification angle (at $7 0 \%$ sparsification) varies during training for ResNet-18 architecture on CIFAR100 dataset.
+
+# 5 RELATED WORK
+
+We can classify most of the previous studies which focus on accelerating training or inference in the following broad categories:
+
+Pruning: Most of the pruning work focuses on inference optimization. Weight pruning can be classified into two broad categories of structured and unstructured pruning. The idea of unstructured pruning can be traced back to LeCun et al. (1990); Hassibi & Stork (1993), which prune the network using the saliency of parameters derived from the second-order information of loss function. Han et al. (2015b;a) pruned network parameters using a magnitude based method. There are several other unstructured pruning methods such as Molchanov et al. (2017); Louizos et al. (2017), but the drawback of all these methods is that it is difficult to extract parallelism on hardware. In contrast, structured pruning such as Liu et al. (2017); Li et al. (2016b); He et al. (2017); Luo et al. (2017); Wen et al. (2016); Molchanov et al. (2016) removes entire channels or filters at a time which preserves the inherent regular computation structure, and therefore it is easy to extract parallelism on hardware.
+
+Quantization: Quantized networks can be used to accelerate both training and inference since energy consumption in the hardware is directly proportional to bit-width of the operands. There are many works which focus on quantizing weights for efficient inference such as McDonnell (2018); Wu et al. (2016); Zhu et al. (2016); Li et al. (2016a); Courbariaux et al. (2015) whereas much other work focuses on accelerating training as well, such as Banner et al. (2018); Choi et al. (2018); Wang et al. (2018); Lin et al. (2017a); Zhou et al. (2016); Courbariaux et al. (2016); Rastegari et al. (2016); Gupta et al. (2015). Some of the other work such as Zhao et al. (2019); McKinstry et al. (2018); Zhou et al. (2017); Mellempudi et al. (2017) shows that training from scratch is not necessary for finding the quantized model, but one can find a quantized model from pre-trained full precision models. Other work focuses on discrete training and inference using Integers such as Wu et al. (2018); Das et al. (2018); Jacob et al. (2018); Lin et al. (2016) since integer added/multiplier is more efficient than floating-point adder/multiplier. Few studies such as Louizos et al. (2019); Jung et al. (2019); Zhang et al. (2018); Zhou et al. (2018); Hou & Kwok (2018); Hou et al. (2016) formulate the quantization as an optimization problem to minimize the accuracy loss due to quantization. Few other work such as Yang et al. (2019); De Sa et al. (2018) focus on improving the learning algorithm by proposing novel stochastic averaging of the low precision iterates or using SVRG to reduce the variance and by dynamically adjusting the precision representation using bit centering. Few works instead of quantizing the entire model to a fixed bit-width focus on per tensor or parameter quantization such as Sakr & Shanbhag (2019); Khoram & Li (2018). Compared to all these works, our work is orthogonal as we eliminate the computation instead of reducing the computation precision.
+
+Tensor Decomposition and Dimentionality Reduction: There are few works on compressing the models by performing tensor decomposition or by learning compact structure. Alvarez & Salzmann (2017) introduce a regularizer that promotes the parameter matrix to have a low rank. Thus the algorithm encourages the model to learn a compact structure by accounting for compression during the training itself. Novikov et al. (2015) showed that tensor decomposition could be used to compress a fully connected layer by using only a few parameters. Later, Garipov et al. (2016) extended it for the convolutional layer. The idea was to reshape the kernel into a tensor of higher-order and then to factorize it.
+
+Distributed Training: There are few works (Stich et al., 2018; Lin et al., 2017b) which look at reducing the communication overhead in distributed training by transferring only sparse gradients during gradient aggregation step but these works are accumulating the rest of the gradients locally for subsequent iterations. Compared to all these works, our work objective is different as we are concerned with accelerating single node training, whereas their objective is minimizing communication during distributed training.
+
+# 6 CONCLUSION
+
+In this work, we propose SWAT, a robust training algorithm based on the insight that sparsifying weights and activation during training has little impact on convergence. SWAT sparsify both the forward and the backward passes, thereby eliminating lots of redundant computation such as addition and multiplication by zero. SWAT is a simpler technique and performs better than the recently proposed dimensionality reduction (DSG) technique for accelerating training. Our experiments over various benchmarks demonstrate significant computation reduction of up to $2 { - } 5 \mathbf { x }$ for training and inference and provides a memory footprint reduction of activation by $1 . 3 – 1 . 7 \mathrm { x }$ and reduction in memory access overhead for weight by $2 { - } 5 \mathbf { x }$ in the backward pass.
+
+# REFERENCES
+
+Jorge Albericio, Patrick Judd, Tayler Hetherington, Tor Aamodt, Natalie Enright Jerger, and Andreas Moshovos. Cnvlutin: Ineffectual-neuron-free deep neural network computing. ACM SIGARCH Computer Architecture News, 44(3):1–13, 2016.
+
+Jose M Alvarez and Mathieu Salzmann. Compression-aware training of deep networks. In Advances in Neural Information Processing Systems, pp. 856–867, 2017.
+
+Alexander G Anderson and Cory P Berg. The high-dimensional geometry of binary neural networks. arXiv preprint arXiv:1705.07199, 2017.
+
+Ron Banner, Itay Hubara, Elad Hoffer, and Daniel Soudry. Scalable methods for 8-bit training of neural networks. In Advances in Neural Information Processing Systems, pp. 5145–5153, 2018.
+
+Manuel Blum, Robert W. Floyd, Vaughan Pratt, Ronald L. Rivest, and Robert E. Tarjan. Time bounds for selection. Journal of Computer and System Sciences, 7(4):448 – 461, 1973. ISSN 0022-0000. doi: https://doi.org/10.1016/S0022-0000(73)80033-9. URL http://www. sciencedirect.com/science/article/pii/S0022000073800339.
+
+Jungwook Choi, Pierce I-Jen Chuang, Zhuo Wang, Swagath Venkataramani, Vijayalakshmi Srinivasan, and Kailash Gopalakrishnan. Bridging the accuracy gap for 2-bit quantized neural networks (qnn). arXiv preprint arXiv:1807.06964, 2018.
+
+Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In Advances in neural information processing systems, pp. 3123–3131, 2015.
+
+Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained $\mathrm { t o } + 1$ or-1. arXiv preprint arXiv:1602.02830, 2016.
+
+Dipankar Das, Naveen Mellempudi, Dheevatsa Mudigere, Dhiraj Kalamkar, Sasikanth Avancha, Kunal Banerjee, Srinivas Sridharan, Karthik Vaidyanathan, Bharat Kaul, Evangelos Georganas, Alexander Heinecke, Pradeep Dubey, Jesus Corbal, Nikita Shustrov, Roma Dubtsov, Evarist Fomenko, and Vadim Pirogov. Mixed precision training of convolutional neural networks using integer operations. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $_ { \cdot } =$ H135uzZ0-.
+
+Christopher De Sa, Megan Leszczynski, Jian Zhang, Alana Marzoev, Christopher R Aberger, Kunle Olukotun, and Christopher Re. High-accuracy low-precision training. ´ arXiv preprint arXiv:1803.03383, 2018.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Chao Dong, Chen Change Loy, Kaiming He, and Xiaoou Tang. Learning a deep convolutional network for image super-resolution. In European conference on computer vision, pp. 184–199. Springer, 2014.
+
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. arXiv preprint arXiv:1803.03635, 2018.
+
+Timur Garipov, Dmitry Podoprikhin, Alexander Novikov, and Dmitry Vetrov. Ultimate tensorization: compressing convolutional and fc layers alike. arXiv preprint arXiv:1611.03214, 2016.
+
+Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. In International Conference on Machine Learning, pp. 1737–1746, 2015.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015a.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In Advances in neural information processing systems, pp. 1135–1143, 2015b.
+
+Babak Hassibi and David G Stork. Second order derivatives for network pruning: Optimal brain surgeon. In Advances in neural information processing systems, pp. 164–171, 1993.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1389–1397, 2017.
+
+C. A. R. Hoare. Algorithm 65: Find. Commun. ACM, 4(7):321–322, July 1961. ISSN 0001-0782. doi: 10.1145/366622.366647. URL http://doi.acm.org/10.1145/366622.366647.
+
+Mark Horowitz. Energy table for $4 5 \mathrm { n m }$ process, Stanford VLSI wiki.
+
+Lu Hou and James T. Kwok. Loss-aware weight quantization of deep networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum? id=BkrSv0lA-.
+
+Lu Hou, Quanming Yao, and James T Kwok. Loss-aware binarization of deep networks. arXiv preprint arXiv:1611.01600, 2016.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko. Quantization and training of neural networks for efficient integer-arithmetic-only inference. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2704–2713, 2018.
+
+Sangil Jung, Changyong Son, Seohyung Lee, Jinwoo Son, Jae-Joon Han, Youngjun Kwak, Sung Ju Hwang, and Changkyu Choi. Learning to quantize deep networks by optimizing quantization intervals with task loss. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4350–4359, 2019.
+
+Soroosh Khoram and Jing Li. Adaptive quantization of neural networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $=$ SyOK1Sg0W.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Alex Krizhevsky et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems, pp. 598–605, 1990.
+
+Fengfu Li, Bo Zhang, and Bin Liu. Ternary weight networks. arXiv preprint arXiv:1605.04711, 2016a.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016b.
+
+Darryl Lin, Sachin Talathi, and Sreekanth Annapureddy. Fixed point quantization of deep convolutional networks. In International Conference on Machine Learning, pp. 2849–2858, 2016.
+
+Xiaofan Lin, Cong Zhao, and Wei Pan. Towards accurate binary convolutional neural network. In Advances in Neural Information Processing Systems, pp. 345–353, 2017a.
+
+Yujun Lin, Song Han, Huizi Mao, Yu Wang, and William J Dally. Deep gradient compression: Reducing the communication bandwidth for distributed training. arXiv preprint arXiv:1712.01887, 2017b.
+
+Liu Liu, Lei Deng, Xing Hu, Maohua Zhu, Guoqi Li, Yufei Ding, and Yuan Xie. Dynamic sparse graph for efficient deep learning. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $=$ H1goBoR9F7.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2736–2744, 2017.
+
+Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through l 0 regularization. arXiv preprint arXiv:1712.01312, 2017.
+
+Christos Louizos, Matthias Reisser, Tijmen Blankevoort, Efstratios Gavves, and Max Welling. Relaxed quantization for discretized neural networks. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id ${ . } =$ HkxjYoCqKX.
+
+Zhou Lu, Hongming Pu, Feicheng Wang, Zhiqiang Hu, and Liwei Wang. The expressive power of neural networks: A view from the width. In Advances in neural information processing systems, pp. 6231–6239, 2017.
+
+Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. Thinet: A filter level pruning method for deep neural network compression. In Proceedings of the IEEE international conference on computer vision, pp. 5058–5066, 2017.
+
+Mark D. McDonnell. Training wide residual networks for deployment using a single bit for each weight. In International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id $=$ rytNfI1AZ.
+
+Jeffrey L McKinstry, Steven K Esser, Rathinakumar Appuswamy, Deepika Bablani, John V Arthur, Izzet B Yildiz, and Dharmendra S Modha. Discovering low-precision networks close to fullprecision networks for efficient embedded inference. arXiv preprint arXiv:1809.04191, 2018.
+
+Naveen Mellempudi, Abhisek Kundu, Dheevatsa Mudigere, Dipankar Das, Bharat Kaul, and Pradeep Dubey. Ternary neural networks with fine-grained quantization. arXiv preprint arXiv:1705.01462, 2017.
+
+Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2498–2507. JMLR. org, 2017.
+
+Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference. arXiv preprint arXiv:1611.06440, 2016.
+
+David R. Musser. Introspective sorting and selection algorithms. Software: Practice and Experience, 27(8):983–993, 1997. doi: 10.1002/(SICI)1097-024X(199708)27:8h983:: AID-SPE117i3.0.CO;2-\#. URL https://onlinelibrary.wiley.com/doi/ abs/10.1002/%28SICI%291097-024X%28199708%2927%3A8%3C983%3A% 3AAID-SPE117%3E3.0.CO%3B2-%23.
+
+Alexander Novikov, Dmitrii Podoprikhin, Anton Osokin, and Dmitry P Vetrov. Tensorizing neural networks. In Advances in neural information processing systems, pp. 442–450, 2015.
+
+Angshuman Parashar, Minsoo Rhu, Anurag Mukkara, Antonio Puglielli, Rangharajan Venkatesan, Brucek Khailany, Joel Emer, Stephen W Keckler, and William J Dally. Scnn: An accelerator for compressed-sparse convolutional neural networks. In 2017 ACM/IEEE 44th Annual International Symposium on Computer Architecture (ISCA), pp. 27–40. IEEE, 2017.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.
+
+Maithra Raghu, Ben Poole, Jon Kleinberg, Surya Ganguli, and Jascha Sohl Dickstein. On the expressive power of deep neural networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2847–2854. JMLR. org, 2017.
+
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, pp. 525–542. Springer, 2016.
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 91–99. Curran Associates, Inc., 2015.
+
+Charbel Sakr and Naresh Shanbhag. Per-tensor fixed-point quantization of the back-propagation algorithm. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $=$ rkxaNjA9Ym.
+
+Or Sharir and Amnon Shashua. On the expressive power of overlapping architectures of deep learning. In International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id $=$ HkNGsseC-.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Sebastian U Stich, Jean-Baptiste Cordonnier, and Martin Jaggi. Sparsified sgd with memory. In Advances in Neural Information Processing Systems, pp. 4447–4458, 2018.
+
+Xu Sun, Xuancheng Ren, Shuming Ma, and Houfeng Wang. meprop: Sparsified back propagation for accelerated deep learning with reduced overfitting. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3299–3308. JMLR. org, 2017.
+
+Christian Szegedy, Alexander Toshev, and Dumitru Erhan. Deep neural networks for object detection. In C. J. C. Burges, L. Bottou, M. Welling, Z. Ghahramani, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 26, pp. 2553–2561. Curran Associates, Inc., 2013. URL http://papers.nips.cc/paper/ 5207-deep-neural-networks-for-object-detection.pdf.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015.
+
+Naigang Wang, Jungwook Choi, Daniel Brand, Chia-Yu Chen, and Kailash Gopalakrishnan. Training deep neural networks with 8-bit floating point numbers. In Advances in neural information processing systems, pp. 7675–7684, 2018.
+
+Bingzhen Wei, Xu Sun, Xuancheng Ren, and Jingjing Xu. Minimal effort back propagation for convolutional neural networks. arXiv preprint arXiv:1709.05804, 2017.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in neural information processing systems, pp. 2074–2082, 2016.
+
+Jiaxiang Wu, Cong Leng, Yuhang Wang, Qinghao Hu, and Jian Cheng. Quantized convolutional neural networks for mobile devices. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4820–4828, 2016.
+
+Shuang Wu, Guoqi Li, Feng Chen, and Luping Shi. Training and inference with integers in deep neural networks. In International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id=HJGXzmspb.
+
+Guandao Yang, Tianyi Zhang, Polina Kirichenko, Junwen Bai, Andrew Gordon Wilson, and Chris De Sa. Swalp: Stochastic weight averaging in low precision training. In International Conference on Machine Learning, pp. 7015–7024, 2019.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+Dongqing Zhang, Jiaolong Yang, Dongqiangzi Ye, and Gang Hua. Lq-nets: Learned quantization for highly accurate and compact deep neural networks. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 365–382, 2018.
+
+Kai Zhang, Wangmeng Zuo, Shuhang Gu, and Lei Zhang. Learning deep cnn denoiser prior for image restoration. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3929–3938, 2017.
+
+Shijin Zhang, Zidong Du, Lei Zhang, Huiying Lan, Shaoli Liu, Ling Li, Qi Guo, Tianshi Chen, and Yunji Chen. Cambricon-x: An accelerator for sparse neural networks. In The 49th Annual IEEE/ACM International Symposium on Microarchitecture, pp. 20. IEEE Press, 2016.
+
+Ritchie Zhao, Yuwei Hu, Jordan Dotzel, Christopher De Sa, and Zhiru Zhang. Improving neural network quantization using outlier channel splitting. arXiv preprint arXiv:1901.09504, 2019.
+
+Aojun Zhou, Anbang Yao, Yiwen Guo, Lin Xu, and Yurong Chen. Incremental network quantization: Towards lossless cnns with low-precision weights. arXiv preprint arXiv:1702.03044, 2017.
+
+Aojun Zhou, Anbang Yao, Kuan Wang, and Yurong Chen. Explicit loss-error-aware quantization for low-bit deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9426–9435, 2018.
+
+Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016.
+
+Chenzhuo Zhu, Song Han, Huizi Mao, and William J Dally. Trained ternary quantization. arXiv preprint arXiv:1612.01064, 2016.
+
+# APPENDIX A PROOF SHOWING TOP-K IS THE BEST SPARSIFICATION FUNCTION
+
+Definition 1 Sparsifying Function $( f _ { S } )$ : Given a parameter $1 < k \leq d$ , let $f _ { S } \colon  { \mathbb { R } ^ { d } } \to  { \mathbb { R } ^ { d } }$ be a function that selects $\mathbf { k }$ component of vector and sets the rest of the component to zero. For a vector $v \in \mathbb { R } ^ { d } , f _ { S } ( v ) = \mathbb { I } _ { k } ( \mathbf { v } ) \odot \bar { \mathbf { v } }$ , where $\mathbb { I } _ { k } ( \mathbf { v } )$ is an indicator vector having $\mathbf { k }$ non-zero values determined by input vector $v$ .
+
+Definition 2 Top-K Sparsifying Function $( f _ { T O P K } )$ : Given a parameter $1 < k \leq d$ , let $f _ { T O P K }$ $: \mathbb { R } ^ { d }  \mathbb { R } ^ { d }$ is a special sparsifying function that sets all but the $\mathbf { k }$ highest component of input vector in absolute value to zero. More precisely, for a vector $v \in \mathbb { R } ^ { d }$ , $f _ { T O P K } ( v ) = \mathbb { I } _ { t o p k } ( \mathbf { v } ) \odot \mathbf { v }$ where $\mathbb { I } _ { t o p k }$ is an indicator function, $\mathbb { I } ( \bar { i } \in \{ \pi _ { 1 } , \cdot \cdot \cdot , \pi _ { k } \} )$ , and $\pi$ is a permutation of $[ d ]$ such that $| v | _ { \pi _ { i } } \geq | \bar { v } | _ { \pi _ { i + 1 } }$ for $i = 1 , \ldots , d - 1$ .
+
+Definition 3 Sparsification Angle $\mathbf { \eta } ^ { ( \theta ) }$ : For a vector $v \in \mathbb { R } ^ { d }$ , the deviation in the direction caused by sparsification $f _ { S } ( . )$ is defined as the sparsification angle, i.e., it is the angle between the vector $v$ and sparse vector $f _ { S } ( v )$ .
+
+Lemma A.1. For any vector $\boldsymbol { v } ~ \in ~ \mathbb { R } ^ { d }$ and of all the sparsifying function $f _ { S }$ , Top- $K$ sparsifying function $( f _ { T O P K } )$ causes the minimum deviation in direction i.e. minimum sparsification angle.
+
+Proof. Given a parameter $k ~ \in ~ [ 1 , d ]$ , for a vector $\textbf { v } = \mathbf { \Omega } ( v _ { 1 } , \cdot \cdot \cdot , v _ { n } ) ^ { \mathrm { T } } ~ \in ~ \mathbb { R } ^ { d }$ let ${ \bf f } _ { \bf S } ( { \bf v } ) { \bf \rho } = { \bf \rho }$ $( m _ { 1 } \bar { v } _ { 1 } , \cdot \cdot \cdot , m _ { d } \bar { v _ { d } } ) ^ { \mathrm { T } } \in \mathbb R ^ { d }$ such that $\dot { m } _ { i } \in \{ 0 , 1 \} \ \forall i$ , be the Top-K indicator mask i.e., $m _ { i } = 1$ only if $i ^ { t h }$ component of $v$ is selected by the sparsifying function.
+
+$$
+\begin{array} { r } { \cos \langle f _ { S } ( \mathbf { v } ) , \mathbf { v } \rangle = \frac { f _ { S } ( \mathbf { v } ) \cdot \mathbf { v } } { \| f _ { S } ( \mathbf { v } ) \| \| \mathbf { v } \| } = \frac { \displaystyle \frac { \frac { d } { \sum } ( m _ { i } v _ { i } ^ { 2 } ) } { i = 1 } = } { \sqrt { \displaystyle \sum _ { i = 1 } ^ { d } ( m _ { i } v _ { i } ) ^ { 2 } } \displaystyle \sqrt { \displaystyle \sum _ { i = 1 } ^ { d } v _ { i } ^ { 2 } } } = \frac { \displaystyle \frac { \sum _ { i = 1 } ^ { d } ( m _ { i } v _ { i } ) ^ { 2 } } { i = 1 } } { \displaystyle \sqrt { \displaystyle \sum _ { i = 1 } ^ { d } ( m _ { i } v _ { i } ) ^ { 2 } } \displaystyle \sqrt { \displaystyle \sum _ { i = 1 } ^ { d } v _ { i } ^ { 2 } } } } \\ { = \frac { \displaystyle \sqrt { \displaystyle \sum _ { i = 1 } ^ { d } ( m _ { i } v _ { i } ) ^ { 2 } } } { \displaystyle \sqrt { \displaystyle \sum _ { i = 1 } ^ { d } v _ { i } ^ { 2 } } } = \frac { \displaystyle \frac { \| f _ { S } ( \mathbf { v } ) \| } { \displaystyle \| \mathbf { v } \| } } { \displaystyle \| \mathbf { v } \| } } \end{array}
+$$
+
+In other words,
+
+$$
+{ \mathrm { S p a r s i f y i n g ~ A n g l e } } ( \theta ) = \operatorname { a r c c o s } { \frac { \| f _ { S } ( \mathbf { v } ) \| } { \| \mathbf { v } \| } }
+$$
+
+arccos is a strictly decreasing function, so to minimize $\theta$ , $\| f _ { S } ( \mathbf { v } ) \|$ must be maximized. Therefore Top-K component of the vector $v$ magnitude wise should be selected. □
+
+# APPENDIX B PERIODIC TOP-K & EFFECT OF BATCH-NORMALIZATION
+
+Periodic Top-K For Efficient Implementation: In section 3.2, we have shown there is a little variation in the $^ { 6 } \mathrm { K }$ -th’ largest element during training, and it remains approximately constant as training proceed. Therefore, the Top-K does not need to be computed every iteration and can be periodically computed after some iterations. We define the number of iterations between computing the threshold for Top-K as the “Top-K period.
+
+<table><tr><td rowspan=1 colspan=1>Top-K Period</td><td rowspan=1 colspan=1>70% Sparsity</td><td rowspan=1 colspan=1>90% Sparsity</td></tr><tr><td rowspan=1 colspan=1>Default Top-K</td><td rowspan=1 colspan=1>76.41</td><td rowspan=1 colspan=1>73.81</td></tr><tr><td rowspan=1 colspan=1>10 Iteration</td><td rowspan=1 colspan=1>76.59</td><td rowspan=1 colspan=1>73.64</td></tr><tr><td rowspan=1 colspan=1>20 Iteration</td><td rowspan=1 colspan=1>76.03</td><td rowspan=1 colspan=1>73.45</td></tr><tr><td rowspan=1 colspan=1>50 Iteration</td><td rowspan=1 colspan=1>76.06</td><td rowspan=1 colspan=1>74.09</td></tr><tr><td rowspan=1 colspan=1>100 Iteration</td><td rowspan=1 colspan=1>76.52</td><td rowspan=1 colspan=1>73.29</td></tr></table>
+
+We have empirically confirmed that the periodic Top-K performs equally well as the default Top-K implementation. The table above shows top1 validation accuracy from single runs of ResNet-18 on CIFAR 100 with different Top-K periods (i.e., Top-K is computed after every 10, 25, 50, and 100 iterations respectively). This data suggests the converged accuracy is indeed not significantly impacted when employing our proposed Periodic Top K implementation.
+
+![](images/6681c63a5cb021438794c588f4611acfec9a8c05eb36c6712280bb4adcec7d64.jpg)  
+Figure 10: Sparsity Variation using Periodic Top-K Implementation. Network: ResNet-18, Dataset: CIFAR100, Top-K period: 100 iterations, Target Sparsity: $90 \%$
+
+Since the periodic Top-K used the same threshold during the entire period, therefore, it is crucial to confirm that periodic Top-K implementation does not adversely affect the sparsity during training. We dumped the amount of sparsity obtained in weights and activation using periodic Top-K with period 100 iteration with target sparsity of $90 \%$ . Figure10 shows the sparsity during training using periodic Top-K implementation is concentrated around our targeted sparsity, and the fluctuation decreases as training proceeds confirming our hypothesis that chosen Top-K parameter stabilizes i.e. the Top-K threshold converge to a fixed value during the latter epochs.
+
+The Top-K periods need not to be fixed throughout the training. The Top-K period can be increased as the training proceeds because the chosen Top-K parameters are unlikely to change at the later training iterations. To demonstrate this we perform a new experiment. We train ResNet-18 on CIFAR 100 for 150 epochs (learning rate decayed at epoch 50,100) using a version of SWAT which computes Top-K periodically but with increasing Top-K period for later epochs. The Top-K schedule used during training is shown below:
+
+<table><tr><td rowspan=1 colspan=2>Scheduled Top-K</td><td rowspan=2 colspan=1>Top-KImplementation</td><td rowspan=1 colspan=2>Top-1 Accuracy</td></tr><tr><td rowspan=1 colspan=1>Epoch 0-50</td><td rowspan=1 colspan=1>3 times per epoch</td><td rowspan=1 colspan=1>70% Sparsity</td><td rowspan=1 colspan=1>90% Sparsity</td></tr><tr><td rowspan=1 colspan=1>Epoch 50-100</td><td rowspan=1 colspan=1>1 time per epoch</td><td rowspan=1 colspan=1>once per iteration</td><td rowspan=1 colspan=1>76.36</td><td rowspan=1 colspan=1>73.63</td></tr><tr><td rowspan=1 colspan=1>Epoch 100-150</td><td rowspan=1 colspan=1>1 time per 5 epoch</td><td rowspan=1 colspan=1>Scheduled Top-K</td><td rowspan=1 colspan=1>76.41</td><td rowspan=1 colspan=1>73.81</td></tr></table>
+
+Note: 1 epoch has 392 iterations.
+
+Sparsification of Batch-Normalization Layer: The activations and weights of BN layers are not sparsified in SWAT. Empirically, we found that sparsifying weights and activations are harmful to convergence. This is because the weight (gamma) of BN layers is a scaling factor for an entire output channel, therefore, making even a single BN weight (gamma) zero makes the entire output channel zero. Similarly, dropping activations affects the mean and variance computed by BN. Empirically we found that the BN layer is extremely sensitive to changes in the per channel mean and variance. For example, when ResNet18 is trained on CIFAR 100 using SWAT with $70 \%$ sparsity and we sparsify the BN layer activations, accuracy is degraded by $4 . 9 \%$ compared to training with SWAT without sparsifying the BN layers. Therefore, the activations of batch-normalization layer are not sparsified.
+
+The parameters in a BN layer constitute less than $1 . 0 1 \%$ to the total parameters in the network and the total computation in the BN layer is less than $0 . 8 \%$ of the total computation in one forward and backward pass. Therefore, not sparsifying batch-normalization layers only affects the activation overhead in the backward pass.
+
+Comparision with Lottery Ticket Hypothesis: The Lottery Ticket Hypothesis (Frankle & Carbin, 2018) showed the difficulty of training with a sparse architecture and that sparse training is very sensitive to initial conditions. The Lottery Ticket showed if one could pick the right initial conditions for the weights, one can train with a sparse network. SWAT is interesting in that it does train a sparse network without the need for oracle information about initialization values.
+
+We believe the crucial difference that enables SWAT to work despite the observation in the Lottery Ticket Hypothesis paper is the following. SWAT updates which weights are part of the sparse network rather than attempting to train a single unchanging sparse network. SWAT may work because it dynamically searches for the sparse architecture that will work with a given set of initial conditions.
+
+# APPENDIX C INDEXING OVERHEAD
+
+To estimate the indexing overhead, we need to understand the generic architecture of the sparse CNN accelerator, the sparse format in which data is stored, and how the computations are mapped to the accelerator.
+
+![](images/ef351ba5656058fb42144de01a98f18aa2cf776f322732889d9d34bdcfa41ced.jpg)  
+(a) Generic Architecture of Sparse CNN Accelerator
+
+![](images/c28a707c2acdbaff4706994adb29dc82a7d4648f87a1e0363b6909471ee0a997.jpg)  
+(b) Each PEs is responsible for creating a portion of the output (Parashar et al., 2017)
+
+Sparse Accelerator: At a high-level of abstraction, all the sparse accelerators (Parashar et al., 2017; Zhang et al., 2016; Albericio et al., 2016) have a 2D array of processing units (PEs) where each processing unit has an array of multipliers and have a dedicated weight, activation, and accumulation buffer. They have an indexing unit for enabling the sparse multiplication. The computations are spatially mapped and scheduled to these processing units by a control and scheduling logic. Each of the PE generates partial products which get accumulated to compute the output values and finally stored in the DRAM.
+
+Mapping Computations: Let us consider a convolutional layer, which maps the input activations in $\hat { ( R ^ { N \times C \times H _ { I } \times W _ { I } } ) }$ to out $( R ^ { N \times F \times H _ { O } \times W _ { O } } )$ . The layer computes $F$ channels of output feature maps, each of dimension $R ^ { H _ { O } \times W _ { O } }$ , using $C$ channel of input feature maps of dimension $R ^ { H _ { I } \times W _ { I } }$ for each of the $N$ samples in the mini-batch. The layer has parameter $w \in R ^ { F \times C \times H _ { K } \times W _ { K } }$ .
+
+The data: w,in   
+The result: out   
+for $h _ { o } = I$ to $H _ { O }$ do for $w _ { o } = I$ to $W _ { O }$ do for $f = I$ to $F$ do for $c = l$ to $C$ do for $h _ { k } = I$ to $H _ { K }$ do for $w _ { k } = { \cal I }$ to $W _ { K }$ do c ∗ = c ; $h ^ { * } = h _ { o } + h _ { k }$ ; $\boldsymbol { w ^ { * } } = \boldsymbol { w _ { o } } + \boldsymbol { w _ { k } }$ ; $\mathbf { o u t } [ f ] [ h _ { o } ] [ w _ { o } ] + = \mathbf { w } [ f ] [ c ] [ h _ { k } ] [ w _ { k } ] \times \mathbf { i n } [ c ^ { * } ] [ h ^ { * } ] [ w ^ { * } ] ) ;$ end end end end end   
+end
+
+Thus, as shown in algorithm 1, each activation is reused $F \times C \times H _ { K } \times W _ { K }$ times, each weight is reused $N \times C \times \times H _ { K } \times W _ { K }$ times and the total computation is as follow:
+
+The first three ‘for’ loops are independent and can be mapped independently to the PEs, whereas the inner three ‘for’ loop generate the partial products. The different sparse accelerators have different ways of mapping the ‘for’ loops spatially over the PEs for maximizing reuse and minimizing the data transfer to and from the DRAM.
+
+From now onwards, we are assuming the mapping of the algorithm over the PEs inspired by the SCNN architecture (Parashar et al., 2017). Each PEs is responsible for generating a chunk of output values, as shown in Figure 11b. The control unit is responsible for partitioning and transferring the corresponding input activations to each PE, whereas each PE has the entire sparse weights. Depending on the buffer size, either the entire index offset or only a block of index offset can be computed and distributed to the PEs.
+
+Sparse Storage Format: In the forward pass, only weights are sparse. Each filter weights are independently stored in sparse format i.e. weights are sparsified along the dimension $R ^ { C \times { \breve { H _ { K } } } \times W _ { K } }$ . Figure 12a shows the storage of a single filter in a sparse format. The value is stored in 2 vectors; data vector and index vector. The data vectors contain only the non-zero data values, whereas the index vector contains the number of zero values before the corresponding data values.
+
+![](images/61cff31003c4937d0b261594a954d6ecf3b09821c0437e7ea597bd7cf984ee85.jpg)  
+(a) Storage format for sparse weights
+
+Storage Overhead for Index: Bits required for storing weights in dense format: (Assuming each weight value is stored in 32 bits)
+
+$$
+D e n s e W e i g h t S t o r a g e = F \times C \times H \times W \times 3 2
+$$
+
+Let the weights have sparsity $S$ . The number of non-zero values present in the data vector is $( 1 - S ) \times$ $F \times C \times H \times W$ , and the number of zero values present in the data vector is $S \times F \times C \times H \times W$ . Assuming the sparsity is uniformly distributed, the number of zero values between 2 consecutive non-zero values is $\begin{array} { r } { \frac { \check { S } \times F \times C \times H \times \check { W } } { ( 1 - S ) \times F \times C \times H \times W } = \frac { S } { 1 - S } } \end{array}$ . Therefore, the number of bits used for encoding the index vector is $\mathit { m a x } ( \lceil \log _ { 2 } \frac { S } { 1 - S } \rceil , 1 )$ bits. Taking the maximum is required when the ratio is less than one. In this case 1 bit indicates whether the next value is zero or not. The bits required for storing weights in the sparse format:
+
+$$
+d a t a \ v e c t o r = ( 1 - S ) \times F \times C \times H \times W \times 3 2 \ b i t
+$$
+
+$$
+i n d e x \ v e c t o r = ( 1 - S ) \times F \times C \times H \times W \times m a x ( \lceil { \log _ { 2 } \frac { S } { 1 - S } } \rceil , 1 )
+$$
+
+$$
+S p a r s e W e i g h t S t o r a g e = ( 1 - S ) \times F \times C \times H \times W \times [ 3 2 + m a x ( \lceil \log _ { 2 } \frac { S } { 1 - S } \rceil , 1 ) ]
+$$
+
+Therefore, storage is decreased by a factor of 32(1−S)×[32+max(dlog2 S1−S e,1)] . For 70% sparsity the reduction in storage space is $3 . 1 3 X$ .
+
+Index Computation Overhead: The computation performed by each PE is shown in algorithm 1.
+
+Algorithm 1: Sparse Forward Pass Computation for a input sample on P Ei(Assuming Stride=1)
+
+The data: w, $P E _ { i }$ (in) The result: $P E _ { i }$ (out)
+
+//STEP-1: Data-Structure Initialization Phase; $c [ F ] [ l e n ( \mathbf { i n d e x . v e c t o r } ) ] = 0 ;$ h[F ][len(index vector)] = 0; $w [ F ] [ l e n ( { \bf i n d e x . v e c t o r } ) ] = 0 $ ;
+
+//STEP-2: Index Offset Calculation Phase;   
+for $f = I$ to $F$ do accumulated index $= 0$ ; for ind $= I$ :len(index vector) do accumulated index $; + =$ index vector[ind]; c[f ][ind], h[f ][ind], $w [ f ] [ i n d ] =$ computeIndex(accumulated index); end   
+end   
+//STEP-3: Computations Phase;   
+for $h _ { o } = I$ to $P \bar { E _ { i } } ( H _ { O } )$ do for $w _ { o } = I$ to $P E _ { i } ( W _ { O } )$ do for $f = I$ to $F$ do for ind = 1:len(index vector) do $c ^ { * } = c [ f ] [ i n d ]$ ; $h ^ { * } = h _ { o } + h [ f ] [ i n d ]$ ; $w ^ { * } = w _ { o } + w [ f ] [ i n d ]$ ; $\mathbf { o u t } [ f ] [ h _ { o } ] [ w _ { o } ] + = \mathbf { d a t a . v e c t o r } [ i n d ] \times { P E _ { i } ( \mathbf { i n } ) [ c ^ { * } ] [ h ^ { * } ] [ w ^ { * } ] } ;$ end end end   
+end
+
+The indexing involved during the Computation Phase is just a base $^ +$ offset addition. The same kind of index computation is present in dense convolution(algorithm 1). Therefore, the only additional indexing computation is during the Indexing Offset Calculation Phase. Let the weights have sparsity $S$ .
+
+where $\alpha$ is the overhead of the computeIndex function. computeIndex function is accumulating the current index and calculating the 3 offset $( c [ f ] [ i n d ] , h [ f ] [ i n \dot { d } ] , w [ f ] [ i n d ] )$ . Therefore, the value of $\alpha$ will be approximately around 4.
+
+Therefore,
+
+$$
+T o t a l ~ O p e r a t i o n ~ f o r ~ S p a r s e ~ C o n v o l u t i o n = S \times F \times C \times H _ { K } \times W _ { K } \times ( \alpha + H _ { O } \times W _ { O } )
+$$
+
+Since the $H _ { O } \times W _ { O } > > \alpha$ , the indexing overhead is minimal compared to the benefit obtained by performing sparse convolution.
+
+Chip Area Consideration: Considering the chip area (#T ransistors available) is very critical when designing a custom accelerator since it decides the number of the computational units that can be fabricated on a given area. Generally, the number of transistors needed for a dense computation unit is less than that of the sparse computation unit. This is because of the extra chip area required for the indexing, arbitration, and controlling logic. Based on the area value mentioned in the SCNN paper(Parashar et al., 2017), the scaling factor for adjusting the performance of the sparse CNN accelerator is 0.75 i.e., On a given area, we can have almost $1 . 3 3 \times$ more dense computation units compared to sparse computation units.
+
+Backward Pass: The computation in the backward pass is the deconvolution operation. Since deconvolution operation is very similar to the convolution operation therefore the overhead of index computation in the backward pass would be of the same order compared to the computation in the forward pass.

parse/train/SkA-IE06W/SkA-IE06W.md

@@ -0,0 +1,595 @@
+# WHEN IS A CONVOLUTIONAL FILTER EASY TO LEARN?
+
+Simon S. Du Carnegie Mellon University ssdu@cs.cmu.edu
+
+Jason D. Lee University of Southern California jasonlee@marshall.usc.edu
+
+Yuandong Tian Facebook AI Research yuandong@fb.com
+
+# ABSTRACT
+
+We analyze the convergence of (stochastic) gradient descent algorithm for learning a convolutional filter with Rectified Linear Unit (ReLU) activation function. Our analysis does not rely on any specific form of the input distribution and our proofs only use the definition of ReLU, in contrast with previous works that are restricted to standard Gaussian input. We show that (stochastic) gradient descent with random initialization can learn the convolutional filter in polynomial time and the convergence rate depends on the smoothness of the input distribution and the closeness of patches. To the best of our knowledge, this is the first recovery guarantee of gradient-based algorithms for convolutional filter on non-Gaussian input distributions. Our theory also justifies the two-stage learning rate strategy in deep neural networks. While our focus is theoretical, we also present experiments that justify our theoretical findings.
+
+# 1 INTRODUCTION
+
+Deep convolutional neural networks (CNN) have achieved the state-of-the-art performance in many applications such as computer vision (Krizhevsky et al., 2012), natural language processing (Dauphin et al., 2016) and reinforcement learning applied in classic games like Go (Silver et al., 2016). Despite the highly non-convex nature of the objective function, simple first-order algorithms like stochastic gradient descent and its variants often train such networks successfully. On the other hand, the success of convolutional neural network remains elusive from an optimization perspective.
+
+When the input distribution is not constrained, existing results are mostly negative, such as hardness of learning a 3-node neural network (Blum & Rivest, 1989) or a non-overlap convolutional filter (Brutzkus & Globerson, 2017). Recently, Shamir (2016) showed learning a simple one-layer fully connected neural network is hard for some specific input distributions.
+
+These negative results suggest that, in order to explain the empirical success of SGD for learning neural networks, stronger assumptions on the input distribution are needed. Recently, a line of research (Tian, 2017; Brutzkus & Globerson, 2017; Li & Yuan, 2017; Soltanolkotabi, 2017; Zhong et al., 2017) assumed the input distribution be standard Gaussian $N ( 0 , { \bf I } )$ and showed (stochastic) gradient descent is able to recover neural networks with ReLU activation in polynomial time.
+
+One major issue of these analysis is that they rely on specialized analytic properties of the Gaussian distribution (c.f. Section 1.1) and thus cannot be generalized to the non-Gaussian case, in which real-world distributions fall into. For general input distributions, new techniques are needed.
+
+In this paper we consider a simple architecture: a convolution layer, followed by a ReLU activation function, and then average pooling. Formally, we let $\mathbf { x } \in \mathbb { R } ^ { d }$ be an input sample, e.g., an image, we generate $k$ patches from $\mathbf { x }$ , each with size $p$ : $\mathbf { Z } \in \mathbb { R } ^ { p \times k }$ where the $i$ -th column is the $i$ -th patch generated by some known function ${ \bf Z } _ { i } = { \bf Z } _ { i } ( { \bf x } )$ . For a filter with size 2 and stride 1, $\mathbf { Z } _ { i } ( \mathbf { x } )$ is the $i$ -th and $( i + 1 )$ -th pixels. Since for convolutional filters, we only need to focus on the patches instead of the input, in the following definitions and theorems, we will refer $\mathbf { Z }$ as input and let $\mathcal { Z }$ as the distribution of $\mathbf { Z }$ : $( \sigma ( x ) = \operatorname* { m a x } ( x , 0 )$ is the ReLU activation function)
+
+![](images/9c11c56ecf92560ef47cabf7e139d11fcf4913edfe31e2d1fd827982f271ea38.jpg)  
+Figure 1: (a) Architecture of the network we are considering. Given input $X$ , we extract its patches $\{ \bar { Z } _ { i } \}$ and send them to a shared weight vector w. The outputs are then sent to ReLU and then summed to yield the final label (and its estimation). (b)-(c) Two conditions we proposed for convergence. We want the data to be (b) highly correlated and (c) concentrated more on the direction aligned with the ground truth vector $\mathbf { w } ^ { * }$ .
+
+$$
+f ( \mathbf { w } , \mathbf { Z } ) = \frac { 1 } { k } \sum _ { i = 1 } ^ { k } \sigma \left( \mathbf { w } ^ { \top } \mathbf { Z } _ { i } \right) .
+$$
+
+See Figure 1 (a) for a graphical illustration. Such architectures have been used as the first layer of many works in computer vision (Lin et al., 2013; Milletari et al., 2016). We address the realizable case, where training data are generated from (1) with some unknown teacher parameter $\mathbf { w } _ { \ast }$ under input distribution $\mathcal { Z }$ . Consider the $\ell _ { 2 }$ loss $\ell ( \mathbf { w } , \mathbf { Z } ) = \frac { 1 } { 2 } \left( f ( \mathbf { w } , \mathbf { Z } ) - f ( \mathbf { w } _ { * } , \mathbf { Z } ) \right) ^ { 2 }$ . We learn by (stochastic) gradient descent, i.e.,
+
+$$
+\mathbf { w } _ { t + 1 } = \mathbf { w } _ { t } - \eta _ { t } g ( \mathbf { w } _ { t } )
+$$
+
+where $\eta _ { t }$ is the step size which may change over time and $g ( \mathbf { w } _ { t } )$ is a random function where its expectation equals to the population gradient $\begin{array} { r } { \mathbb { E } \left[ g ( \mathbf { w } ) \right] = \mathbb { E } _ { \mathbf { Z } \sim \mathcal { Z } } \left[ \nabla \ell \left( \mathbf { w } , \mathbf { Z } \right) \right] . } \end{array}$ The goal of our analysis is to understand the conditions where $\mathbf { w } \to \mathbf { w } _ { * }$ , if w is optimized under (stochastic) gradient descent.
+
+In this setup, our main contributions are as follows:
+
+• Learnability of Filters: We show if the input patches are highly correlated (Section 3), i.e., $\theta \left( \mathbf { Z } _ { i } , \mathbf { Z } _ { j } \right) \leq \rho$ for some small $\rho > 0$ , then gradient descent and stochastic gradient descent with random initialization recovers the filter in polynomial time.1 Furthermore, strong correlations imply faster convergence. To the best of our knowledge, this is the first recovery guarantee of randomly initialized gradient-based algorithms for learning filters (even for the simplest one-layer one-neuron network) on non-Gaussian input distribution, answering an open problem in (Tian, 2017).
+
+• Distribution-Aware Convergence Rate. We formally establish the connection between the smoothness of the input distribution and the convergence rate for filter weights recovery where the smoothness in our paper is defined as the ratio between the largest and the least eigenvalues of the second moment of the activation region (Section 2). We show that a smoother input distribution leads to faster convergence, and Gaussian distribution is a special case that leads to the tightest bound. This theoretical finding also justifies the twostage learning rate strategy proposed by (He et al., 2016; Szegedy et al., 2017) if the step size is allowed to change over time.
+
+# 1.1 RELATED WORKS
+
+In recent years, theorists have tried to explain the success of deep learning from different perspectives. From optimization point of view, optimizing neural network is a non-convex optimization problem. Pioneered by Ge et al. (2015), a class of non-convex optimization problems that satisfy strict saddle property can be optimized by perturbed (stochastic) gradient descent in polynomial time (Jin et al., 2017).2 This motivates the research of studying the landscape of neural networks (Soltanolkotabi et al., 2017; Kawaguchi, 2016; Choromanska et al., 2015; Hardt & Ma, 2016; Haeffele & Vidal, 2015; Mei et al., 2016; Freeman & Bruna, 2016; Safran & Shamir, 2016; Zhou & Feng, 2017; Nguyen & Hein, 2017) However, these results cannot be directly applied to analyzing the convergence of gradient-based methods for ReLU activated neural networks.
+
+From learning theory point of view, it is well known that training a neural network is hard in the worst cases (Blum & Rivest, 1989; Livni et al., 2014; Sˇ´ıma, 2002; Shalev-Shwartz et al., 2017a;b) and recently, Shamir (2016) showed either “niceness” of the target function or of the input distribution alone is sufficient for optimization algorithms used in practice to succeed. With some additional assumptions, many works tried to design algorithms that provably learn a neural network with polynomial time and sample complexity (Goel et al., 2016; Zhang et al., 2016; 2015; Sedghi & Anandkumar, 2014; Janzamin et al., 2015; Gautier et al., 2016; Goel & Klivans, 2017). However, these algorithms are tailored for certain architecture and cannot explain why (stochastic) gradient based optimization algorithms work well in practice.
+
+Focusing on gradient-based algorithms, a line of research analyzed the behavior of (stochastic) gradient descent for Gaussian input distribution. Tian (2017) showed population gradient descent is able to find the true weight vector with random initialization for one-layer one-neuron model. Brutzkus & Globerson (2017) showed population gradient descent recovers the true weights of a convolution filter with non-overlapping input in polynomial time. Li & Yuan (2017) showed SGD can recover the true weights of a one-layer ResNet model with ReLU activation under the assumption that the spectral norm of the true weights is bounded by a small constant. All the methods use explicit formulas for Gaussian input, which enable them to apply trigonometric inequalities to derive the convergence. With the same Gaussian assumption, Soltanolkotabi (2017) shows that the true weights can be exactly recovered by projected gradient descent with enough samples in linear time, if the number of inputs is less than the dimension of the weights.
+
+Other approaches combine tensor approaches with assumptions of input distribution. Zhong et al. (2017) proved that with sufficiently good initialization, which can be implemented by tensor method, gradient descent can find the true weights of a 3-layer fully connected neural network. However, their approach works with known input distributions. Soltanolkotabi (2017) used Gaussian width (c.f. Definition 2.2 of (Soltanolkotabi, 2017)) for concentrations and his approach cannot be directly extended to learning a convolutional filter.
+
+In this paper, we adopt a different approach that only relies on the definition of ReLU. We show as long as the input distribution satisfies weak smoothness assumptions, we are able to find the true weights by SGD in polynomial time. Using our conclusions, we can justify the effectiveness of large amounts of data (which may eliminate saddle points), two-stage and adaptive learning rates used by He et al. (2016); Szegedy et al. (2017), etc.
+
+# 1.2 ORGANIZATION
+
+This paper is organized as follows. In Section 2, we analyze the simplest one-layer one-neuron model where we state our key observation and establish the connection between smoothness and convergence rate. In Section 3, we discuss the performance of (stochastic) gradient descent for learning a convolutional filter. We provide empirical illustrations in Section 4 and conclude in Section 5. We place most of our detailed proofs in the Appendix.
+
+# 1.3 NOTATIONS
+
+Let $\left\| \cdot \right\| _ { 2 }$ denote the Euclidean norm of a finite-dimensional vector. For a matrix A, we use $\lambda _ { \mathrm { m a x } }$ (A) to denote its largest singular value and $\lambda _ { \operatorname* { m i n } } \left( \mathbf { A } \right)$ its smallest singular value. Note if A is a positive semidefinite matrix, $\lambda _ { \operatorname* { m a x } } \left( \mathbf { A } \right)$ and $\lambda _ { \operatorname* { m i n } } \left( \mathbf { A } \right)$ represent the largest and smallest eigenvalues of $\mathbf { A }$ , respectively. Let $O ( \cdot )$ and $\Theta ( \cdot )$ denote the standard Big-O and Big-Theta notations that hide absolute constants. We assume the gradient function is uniformly bounded, i.e., There exists $B > 0$ such that $\| g ( \mathbf { w } ) \| _ { 2 } \leq B$ . This condition is satisfied as long as patches, w and noise are all bounded.
+
+![](images/eb4e768c57b8bc1369f9963e232b94aed2f3ecafa03a8be66610a7c3ab2e5572.jpg)  
+Figure 2: (a) The four regions considered in our analysis. $\mathbf { ( b ) }$ Illustration of $L \left( \phi \right) , \gamma ( \phi )$ and $L _ { - \mathbf { w } _ { * } } ( \phi )$ defined in Definition 2.1 and Assumption 2.1.
+
+# 2 WARM UP: ANALYZING ONE-LAYER ONE-NEURON MODEL
+
+Before diving into the convolutional filter, we first analyze the special case for $k = 1$ , which is equivalent to the one-layer one-neuron architecture. The analysis in this simple case will give us insights for the fully general case. For the ease of presentation, we define following two events and corresponding second moments
+
+$$
+\begin{array} { r l } & { S ( \mathbf { w } , \mathbf { w } _ { * } ) = \left\{ \mathbf { Z } : \mathbf { w } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \geq 0 \right\} , \quad S ( \mathbf { w } , - \mathbf { w } _ { * } ) = \left\{ \mathbf { Z } : \mathbf { w } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \leq 0 \right\} , } \\ & { \qquad \mathbf { A } _ { \mathbf { w } , \mathbf { w } _ { * } } = \mathbb { E } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \mathbb { I } \left\{ S ( \mathbf { w } , \mathbf { w } _ { * } ) \right\} \right] , \quad \mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } = \mathbb { E } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \mathbb { I } \left\{ S ( \mathbf { w } , - \mathbf { w } _ { * } ) \right\} \right] . } \end{array}
+$$
+
+where $\mathbb { I } \left\{ \cdot \right\}$ is the indicator function. Intuitively, $S ( \mathbf { w } , \mathbf { w } _ { * } )$ is the joint activation region of w and $\mathbf { w } _ { \ast }$ and $S ( \mathbf { w } , - \mathbf { w } _ { * } )$ is the joint activation region of w and $- \mathbf { w } _ { \ast }$ . See Figure 2 (a) for the graphical illustration. With some simple algebra we can derive the population gradient.
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \nabla \ell \left( \mathbf { w } , \mathbf { Z } \right) \right] = \mathbf { A } _ { \mathbf { w } , \mathbf { w } _ { * } } \left( \mathbf { w } - \mathbf { w } _ { * } \right) + \mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } \mathbf { w } . } \end{array}
+$$
+
+One key observation is we can write the inner product $\left. \nabla _ { \mathbf { w } } \ell \left( \mathbf { w } \right) , \mathbf { w } - \mathbf { w } _ { * } \right.$ as the sum of two non-negative terms (c.f. Lemma A.1). This observation directly leads to the following Theorem 2.1.
+
+Theorem 2.1. Suppose for any $\mathbf { w } _ { 1 } , \mathbf { w } _ { 2 }$ with $\theta \left( \mathbf { w } _ { 1 } , \mathbf { w } _ { 2 } \right) < \pi$ , E $\mathbf { \sigma } _ { : } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \mathbb { I } \left\{ S ( \mathbf { w } , \mathbf { w } _ { * } ) \right\} \right] \succ 0$ and the initialization $\mathbf { w } _ { 0 }$ satisfies $\ell \left( \mathbf { w } _ { 0 } \right) < \ell \left( \mathbf { 0 } \right)$ then gradient descent algorithm recovers $\mathbf { w } _ { \ast }$ .
+
+The first assumption is about the non-degeneracy of input distribution. For $\theta \left( \mathbf { w } _ { 1 } , \mathbf { w } _ { 2 } \right) < \pi$ , one case that the assumption fails is that the input distribution is supported on a low-dimensional space, or degenerated. The second assumption on the initialization is to ensure that gradient descent does not converge to ${ \bf w } = { \bf 0 }$ , at which the gradient is undefined. This is a general convergence theorem that holds for a wide class of input distribution and initialization points. In particular, it includes Theorem 6 of (Tian, 2017) as a special case. If the input distribution is degenerate, i.e., there are holes in the input space, the gradient descent may stuck around saddle points and we believe more data are needed to facilitate the optimization procedure This is also consistent with empirical evidence in which more data are helpful for optimization.
+
+# 2.1 CONVERGENCE RATE OF ONE-LAYER ONE-NEURON MODEL
+
+In the previous section we showed if the distribution is regular and the weights are initialized appropriately, gradient descent recovers the true weights when it converges. In practice we also want to know how many iterations are needed. To characterize the convergence rate, we need some quantitative assumptions. We note that different set of assumptions will lead to a different rate and ours is only one possible choice. In this paper we use the following quantities.
+
+Definition 2.1 (The Largest/Smallest eigenvalue Values of the Second Moment on Intersection of two Half Spaces). For $\phi \in [ 0 , \pi ]$ , define
+
+$$
+\gamma ( \phi ) = \operatorname* { m i n } _ { \mathbf { w } : \mathcal { L } \mathbf { w } , \mathbf { w } _ { * } = \phi } \lambda _ { \operatorname* { m i n } } \left( \mathbf { A } _ { \mathbf { w } , \mathbf { w } _ { * } } \right) , \quad L ( \phi ) = \operatorname* { m a x } _ { \mathbf { w } : \mathcal { L } \mathbf { w } , \mathbf { w } _ { * } = \phi } \lambda _ { \operatorname* { m a x } } \left( \mathbf { A } _ { \mathbf { w } , \mathbf { w } _ { * } } \right) ,
+$$
+
+These two conditions quantitatively characterize the angular smoothness of the input distribution. For a given angle $\phi$ , if the difference between $\gamma ( \phi )$ and $L ( \phi )$ is large then there is one direction has large probability mass and one direction has small probability mass, meaning the input distribution is not smooth. On the other hand, if $\gamma ( \phi )$ and $L ( \phi )$ are close, then all directions have similar probability mass, which means the input distribution is smooth. The smoothest input distributions are rotationally invariant distributions (e.g. standard Gaussian) which have $\gamma ( \phi ) \ : = \ : L ( \phi )$ . For analogy, we can think of $L ( \phi )$ as Lipschitz constant of the gradient and $\gamma ( \phi )$ as the strong convexity parameter in the optimization literature but here we also allow they change with the angle. Also observe that when $\phi = \pi$ , $\gamma ( \phi ) = L ( \phi ) = 0$ because the intersection has measure 0 and both $\gamma ( \phi )$ and $L ( \phi )$ are monotonically decreasing.
+
+Our next assumption is on the growth of $\mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } }$ . Note that when $\boldsymbol { \theta } \left( \mathbf { w } , \mathbf { w } _ { * } \right) = 0$ , then ${ \bf A } _ { { \bf w } , - { \bf w } _ { * } } =$ 0 because the intersection between w and $- \mathbf { w } _ { \ast }$ has 0 measure. Also, $\mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } }$ grows as the angle between w and $\mathbf { w } _ { \ast }$ becomes larger.
+
+In the following, we assume the operator norm of $\mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } }$ increases smoothly with respect to the angle. The intuition is that as long as input distribution bounded probability density with respect to the angle, the operator norm of $\mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } }$ is bounded. We show in Theorem A.1 that $\beta = 1$ for rotational invariant distribution and in Theorem A.2 that $\beta = p$ for standard Gaussian distribution.
+
+Assumption 2.1. We assume there exists $\beta ~ > ~ 0$ that for $0 ~ \leq ~ \phi ~ \leq ~ \pi / 2 ,$ , $L _ { - w _ { * } } ( \phi )$ , $\begin{array} { r } { \operatorname* { m a x } _ { \mathbf { w } , \theta ( \mathbf { w } , \mathbf { w } _ { * } ) \leq \phi } \lambda _ { \operatorname* { m a x } } \left( \mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } \right) \leq \beta \phi } \end{array}$ .
+
+Now we are ready to state the convergence rate.
+
+Theorem 2.2. Suppose the initialization $\mathbf { w } _ { 0 }$ satisfies $\left\| \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \right\| _ { 2 } ~ < ~ \left\| \mathbf { w } _ { * } \right\| _ { 2 }$ . Denote $\phi _ { t } ~ =$ $\begin{array} { r } { \arcsin \left( \frac { \| \mathbf { w _ { t } } - \mathbf { w _ { * } } \| _ { 2 } } { \| \mathbf { w _ { * } } \| _ { 2 } } \right) } \end{array}$ then if step size is set as $\begin{array} { r } { 0 \leq \eta _ { t } \leq \operatorname* { m i n } _ { 0 \leq \phi \leq \phi _ { t } } \frac { \gamma ( \phi ) } { 2 ( L ( \phi ) + 4 \beta ) ^ { 2 } } } \end{array}$ , we have for $t = 1 , 2 , \dots$
+
+$$
+\left\| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } \leq \left( 1 - \frac { \eta _ { t } \gamma \left( \phi _ { t } \right) } { 2 } \right) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } .
+$$
+
+Note both $\gamma ( \phi )$ and $L ( \phi )$ increases as $\phi$ decreases so we can choose a constant step size $\begin{array} { r } { \eta _ { t } \ = \ \Theta \left( \frac { \gamma ( \phi _ { 0 } ) } { ( L ( 0 ) + \beta ) ^ { 2 } } \right) } \end{array}$ This theorem implies that we can find the $\epsilon$ -close solution of $\mathbf { w } _ { \ast }$ in $\begin{array} { r } { O \left( \frac { ( L ( 0 ) + \beta ) ^ { 2 } } { \gamma ^ { 2 } ( \phi _ { 0 } ) } \log \left( \frac { 1 } { \epsilon } \right) \right) } \end{array}$ iterations. It also suggests a direct relation between the smoothness of the distribution and the convergence rate. For smooth distribution where $\gamma ( \phi )$ and $L ( \phi )$ are close and $\beta$ is small then $\frac { ( L ( 0 ) + \beta ) ^ { 2 } } { \gamma ^ { 2 } ( \phi _ { 0 } ) }$ is relatively small and we need fewer iterations. On the other hand, if $L ( \phi )$ or $\beta$ is much larger than $\gamma ( \phi )$ , we will need more iterations. We verify this intuition in Section 4.
+
+If we are able to choose the step sizes adaptively $\begin{array} { r } { \eta _ { t } \ = \ \Theta \left( \frac { \gamma ( \phi _ { t } ) } { ( L ( \phi _ { t } ) + \beta ) ^ { 2 } } \right) } \end{array}$  γ(φt)(L(φt)+β)2 , like using methods proposed by Lin & Xiao (2014), we may improve the computational complexity to $\begin{array} { r } { O \left( \operatorname* { m a x } _ { \phi \leq \phi _ { 0 } } \frac { \left( L \left( \phi \right) + \beta \right) ^ { 2 } } { \gamma ^ { 2 } \left( \phi \right) } \log \left( \frac { 1 } { \epsilon } \right) \right) , } \end{array}$ 0 (L(φ)+β)2γ2(φ) log  1 
. This justifies the use of two-stage learning rate strategy proposed by He et al. (2016); Szegedy et al. (2017) where at the beginning we need to choose learning to be small because $\frac { \gamma ( \phi _ { 0 } ) } { 2 ( L ( \phi _ { 0 } ) + 2 \beta ) ^ { 2 } }$ is small and later we can choose a large learning rate because as the angle between $\mathbf { w } _ { t }$ and $\mathbf { w } _ { \ast }$ becomes smaller, $\frac { \gamma ( \phi _ { t } ) } { 2 ( L ( \phi _ { t } ) + 2 \beta ) ^ { 2 } }$ becomes bigger.
+
+The theorem requires the initialization satisfying $\left\| \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \right\| _ { 2 } < \left\| \mathbf { w } _ { * } \right\| _ { 2 }$ , which can be achieved by random initialization with constant success probability. See Section 3.2 for a detailed discussion.
+
+# 3 MAIN RESULTS FOR LEARNING A CONVOLUTIONAL FILTER
+
+In this section we generalize ideas from the previous section to analyze the convolutional filter. First, for given w and $\mathbf { w } _ { \ast }$ we define four events that divide the input space of each patch $\mathbf { Z } _ { i }$ . Each event
+
+corresponds to a different activation region induced by w and $\mathbf { w } _ { \ast }$ , similar to (3).
+
+$$
+\begin{array} { r } { { \cal S } ( { \bf w } , { \bf w } _ { \ast } ) _ { i } = \left\{ { \bf Z } _ { i } : { \bf w } ^ { \top } { \bf Z } _ { i } \geq 0 , { \bf w } _ { \ast } ^ { \top } { \bf Z } _ { i } \geq 0 \right\} , \quad { \cal S } ( { \bf w } , - { \bf w } _ { \ast } ) _ { i } = \left\{ { \bf Z } _ { i } : { \bf w } ^ { \top } { \bf Z } _ { i } \geq 0 , { \bf w } _ { \ast } ^ { \top } { \bf Z } _ { i } \leq 0 \right\} , } \\ { \left. \right\} ( - { \bf w } , - { \bf w } _ { \ast } ) _ { i } = \left\{ { \bf Z } _ { i } : { \bf w } ^ { \top } { \bf Z } _ { i } \leq 0 , { \bf w } _ { \ast } ^ { \top } { \bf Z } _ { i } \leq 0 \right\} , \quad { \cal S } ( - { \bf w } , { \bf w } _ { \ast } ) _ { i } = \left\{ { \bf Z } _ { i } : { \bf w } ^ { \top } { \bf Z } _ { i } \leq 0 , { \bf w } _ { \ast } ^ { \top } { \bf Z } _ { i } \geq 0 \right\} . } \end{array}
+$$
+
+Please check Figure 2 (a) again for illustration. For the ease of presentation we also define the average over all patches in each region
+
+$$
+\begin{array} { r l r } {  { \mathbf { Z } _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) } = \frac { 1 } { k } \sum _ { i = 1 } ^ { k } \mathbf { Z } _ { i } \mathbb { I } \{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \} , \mathbf { Z } _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) } = \frac { 1 } { k } \sum _ { i = 1 } ^ { k } \mathbf { Z } _ { i } \mathbb { I } \{ S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { i } \} , } } \\ & { } & { \mathbf { Z } _ { S ( - \mathbf { w } , \mathbf { w } _ { * } ) } = \frac { 1 } { k } \sum _ { i = 1 } ^ { k } \mathbf { Z } _ { i } \mathbb { I } \{ S ( - \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \} . } \end{array}
+$$
+
+Next, we generalize the smoothness conditions analogue to Definition 2.1 and Assumption 2.1. Here the smoothness is defined over the average of patches.
+
+Assumption 3.1. For $\phi \in [ 0 , \pi ]$ , define
+
+$$
+\begin{array} { r } { \gamma ( \phi ) = \underset { \mathbf { w } : \theta ( \mathbf { w } , \mathbf { w } _ { * } ) = \phi } { \operatorname* { m i n } } \lambda _ { \operatorname* { m i n } } \left( \mathbb { E } \left[ \mathbf { Z } _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) } \mathbf { Z } _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) } ^ { \top } \right] \right) , } \\ { L ( \phi ) = \underset { \mathbf { w } : \theta ( \mathbf { w } , \mathbf { w } _ { * } ) = \phi } { \operatorname* { m a x } } \lambda _ { \operatorname* { m a x } } \left( \mathbb { E } \left[ \mathbf { Z } _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) } \mathbf { Z } _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) } ^ { \top } \right] \right) . } \end{array}
+$$
+
+We assume for all $0 \leq \phi \leq \pi / 2 , \operatorname* { m a x } _ { \mathbf { w } : \theta ( \mathbf { w } , \mathbf { w } _ { * } ) = \phi } \lambda _ { \operatorname* { m a x } } \left( \mathbb { E } \left[ \mathbf { Z } _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) } \mathbf { Z } _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) } ^ { \top } \right] \right) \leq \beta \phi$ for some $\beta > 0$ .
+
+The main difference between the simple one-layer one-neuron network and the convolution filter is two patches may appear in different regions. For a given sample, there may exists patch $\mathbf { Z } _ { i }$ and $\mathbf { Z } _ { j }$ such that $\mathbf { Z } _ { i } \in S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i }$ and $\mathbf Z _ { j } \in \bar { S } ( \mathbf w , - \mathbf w _ { * } ) _ { j }$ and their interaction plays an important role in the convergence of (stochastic) gradient descent. Here we assume the second moment of this interaction, i.e., cross-covariance, also grows smoothly with respect to the angle.
+
+Assumption 3.2. We assume there exists $L _ { c r o s s } > 0$ such that
+
+$$
+\begin{array} { r l r } { \displaystyle \operatorname* { m a x } _ { \mathbf { w } : \boldsymbol { \theta } ( \mathbf { w } , \mathbf { w } _ { * } ) \leq \boldsymbol { \phi } } \lambda _ { \operatorname* { m a x } } \left( \mathbb { E } \left[ \mathbf { Z } _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) } \mathbf { Z } _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) } ^ { \top } \right] \right) + \lambda _ { \operatorname* { m a x } } \left( \mathbb { E } \left[ \mathbf { Z } _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) } \mathbf { Z } _ { S ( - \mathbf { w } , \mathbf { w } _ { * } ) } ^ { \top } \right] \right) } & \\ & { } & { + \lambda _ { \operatorname* { m a x } } \left( \mathbb { E } \left[ \mathbf { Z } _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) } \mathbf { Z } _ { S ( - \mathbf { w } , \mathbf { w } _ { * } ) } ^ { \top } \right] \right) \leq L _ { c r o s s } \boldsymbol { \phi } . } \end{array}
+$$
+
+First note if $\phi = 0$ , then ${ \mathbf { Z } } _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) }$ and ${ \mathbf { Z } } _ { S ( - \mathbf { w } , \mathbf { w } _ { * } ) }$ has measure 0 and this assumption models the growth of cross-covariance. Next note this $L _ { c r o s s }$ represents the closeness of patches. If $\mathbf { Z } _ { i }$ and $\mathbf { Z } _ { j }$ are very similar, then the joint probability density of $\mathbf Z _ { i } \in S ( \mathbf w , \mathbf w _ { * } ) _ { i }$ and $\mathbf Z _ { j } \in S ( \mathbf w , - \mathbf w _ { * } ) _ { j }$ is small which implies $L _ { c r o s s }$ is small. In the extreme setting, $\mathbf { Z } _ { 1 } = \ldots = \mathbf { Z } _ { k }$ , we have $L _ { \mathrm { c r o s s } } \doteq 0$ because in this case the events $\{ \mathbf { Z } _ { i } \in S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \} \cap \{ \mathbf { Z } _ { j } \in S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { j } \}$ , $\{ \mathbf { Z } _ { i } \in S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \} \cap$ $\{ \mathbf { Z } _ { j } \in S ( - \mathbf { w } , \mathbf { w } _ { * } ) _ { j } \}$ and $\{ \mathbf { Z } _ { i } \in S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { i } \} \cap \{ \mathbf { Z } _ { j } \in S ( - \mathbf { w } , \mathbf { w } _ { * } ) _ { j } \}$ all have measure 0.
+
+Now we are ready to present our result on learning a convolutional filter by gradient descent.
+
+Theorem 3.1. If the initialization satisfies $\begin{array} { r l r } { \| \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \| _ { 2 } } & { { } < } & { \| \mathbf { w } _ { * } \| _ { 2 } } \end{array}$ and denote $\begin{array} { r l } { \phi _ { t } } & { { } = } \end{array}$ $\begin{array} { r } { \arcsin \left( \frac { \| \mathbf { w } _ { t } - \mathbf { w } _ { * } \| _ { 2 } } { \| \mathbf { w } _ { * } \| _ { 2 } } \right) } \end{array}$ tisfies , we ha $\begin{array} { r l r } { \gamma ( \phi _ { 0 } ) } & { { } > } & { 6 L _ { \mathrm { c r o s s } } } \end{array}$ $i f$ $\eta _ { t }$ ≤ $\begin{array} { r } { \operatorname* { m i n } _ { 0 \leq \phi \leq \phi _ { t } } \frac { \gamma ( \phi ) - 6 L _ { \mathrm { c r o s s } } } { 2 ( L ( \phi ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta ) ^ { 2 } } } \end{array}$ $t = 1 , 2 , \dots$ $\begin{array} { r } { \phi _ { t } \triangleq \arcsin \left( \frac { \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } } { \left\| \mathbf { w } _ { * } \right\| _ { 2 } } \right) } \end{array}$
+
+$$
+\| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } \leq \left( 1 - \frac { \eta ( \gamma ( \phi _ { t } ) - 6 L _ { \mathrm { c r o s s } } ) } { 2 } \right) \| \mathbf { w } _ { t } - \mathbf { w } _ { * } \| _ { 2 } ^ { 2 }
+$$
+
+Our theorem suggests if the initialization satisfies $\gamma ( \phi _ { 0 } ) ~ > ~ 6 L _ { \mathrm { c r o s s } }$ , we obtain linear convergence rate. In Section 3.1, we give a concrete example showing closeness of patches implies large $\gamma ( \phi )$ and small $L _ { \mathrm { c r o s s } }$ . Similar to Theorem 2.2, if the step size is chosen so that $\eta _ { t } =$ find the  γ(φ0)−6Lcross(LS(w,w∗)(0)+10Lcross+4β)2 , in O  γ(φ0)−6LcrossLS(w,w∗)(0)+10Lcross+4β 2 log  1 
 iterations, we can
+
+In practice,we never get a true population gradient but only stochastic gradient $g ( \mathbf { w } )$ (c.f. Equation (2)). The following theorem shows SGD also recovers the underlying filter.
+
+Theorem 3.2. Let $\phi _ { * } ~ = ~ \mathrm { a r g m a x } _ { \phi } \gamma ( \phi ) ~ \ge ~ 6 L _ { \mathrm { c r o s s } }$ . Denote ${ r _ { 0 } } ~ = ~ \left\| { \bf w } _ { 0 } - { \bf w } _ { * } \right\| _ { 2 } , ~ \phi _ { 0 } ~ =$ $\arcsin { \left( \frac { r _ { 0 } } { \left\| \mathbf { w } _ { * } \right\| _ { 2 } } \right) }$ $\begin{array} { r } { \phi _ { 1 } = \frac { \phi _ { * } + \phi _ { 0 } } { 2 } } \end{array}$ $\epsilon$ $\begin{array} { r } { \eta _ { t } = \Theta \left( \frac { \epsilon ^ { 2 } ( \gamma ( \phi _ { 1 } ) - 6 L _ { \mathrm { c r o s s } } ) ^ { 2 } \| \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } } { B ^ { 2 } } \right) } \end{array}$ , then we have in T = O  B22(γ(φ1)−6Lcross)2kw∗k22 l   
+least $1 - \delta$ we have $\left\| \mathbf { w } _ { T } - \mathbf { w } _ { * } \right\| \leq \epsilon \left\| \mathbf { w } _ { * } \right\| _ { 2 }$ .
+
+Unlike the vanilla gradient descent case, here the convergence rate depends on $\phi _ { 1 }$ instead of $\phi _ { 0 }$ . This is because of the randomness in SGD and we need a more robust initialization. We choose $\phi _ { 1 }$ to be the average of $\phi _ { 0 }$ and $\phi _ { * }$ for the ease of presentation. As will be apparent in the proof we only require $\phi _ { 0 }$ not very close to $\phi _ { * }$ . The proof relies on constructing a martingale and use Azuma-Hoeffding inequality and this idea has been previously used by Ge et al. (2015).
+
+3.1 WHAT DISTRIBUTION IS EASY FOR SGD TO LEARN A CONVOLUTIONAL FILTER?
+
+Different from One-Layer One-Neuron model, here we also requires the Lipschitz constant for closeness $L _ { \mathrm { c r o s s } }$ to be relatively small and $\gamma ( \phi _ { 0 } )$ to be relatively large. A natural question is: What input distributions satisfy this condition?
+
+Here we give an example. We show if (1) patches are close to each other (2) the input distribution has small probability mass around the decision boundary then the assumption in Theorem 3.1 is satisfied. See Figure 1 (b)-(c) for the graphical illustrations.
+
+Theorem 3.3. Denote $\begin{array} { r } { { \bf Z } _ { a v g } = \frac { 1 } { k } \sum _ { i = 1 } ^ { k } { \bf Z } _ { i } } \end{array}$ . Suppose all patches have unit norm 3 and for all for all $i , \theta \left( { \bf Z } _ { i } , { \bf Z } _ { a v g } \right) \leq \rho .$ . Further assume there exists $L \geq 0$ such that for any $\phi \le \rho$ and for all $\mathbf { Z } _ { i }$
+
+$$
+\mathbb { P } \left[ \theta \left( \mathbf { Z } _ { i } , \mathbf { w } _ { * } \right) \in \left[ \frac { \pi } { 2 } - \phi , \frac { \pi } { 2 } + \phi \right] \right] \leq \mu \phi , \quad \mathbb { P } \left[ \theta \left( \mathbf { Z } _ { i } , \mathbf { w } _ { * } \right) \in - \left[ \frac { \pi } { 2 } - \phi , - \frac { \pi } { 2 } + \phi \right] \right] \leq \mu \phi ,
+$$
+
+then we have
+
+$$
+\begin{array} { c } { \gamma \left( \phi _ { 0 } \right) \geq \gamma _ { a v g } \left( \phi _ { 0 } \right) - 4 \left( 1 - \cos \rho \right) a n d L _ { \mathrm { c r o s s } } \leq 3 \mu . } \\ { { \mathrm { } } } \\ { \gamma _ { a v g } ( \phi _ { 0 } ) = \sigma _ { \operatorname* { m i n } } \left( \mathbb { E } \left[ { \mathbf Z } { \mathbf Z } ^ { \top } \mathbb { I } \left\{ { \mathbf w } _ { 0 } ^ { \top } { \mathbf Z } \geq 0 , { \mathbf w } _ { * } ^ { \top } { \mathbf Z } \geq 0 \right\} \right] \right) , a n a l o g u e t o D e f i n i t i o n 2 . I . } \end{array}
+$$
+
+Several comments are in sequel. We view $\rho$ as a quantitative measure of the closeness between different patches, i.e., $\rho$ small means they are similar. This lower bound is monotonically decreasing as a function of $\rho$ and note when $\rho = 0$ , $\dot { \sigma } _ { \mathrm { m i n } } \left( \mathbb { E } \left[ \mathbf { Z } _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) } \mathbf { Z } _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) } ^ { \top } \right] \right) = \gamma _ { a v g } ( \phi _ { 0 } )$ which recovers Definition 2.1.
+
+For the upper bond on $L _ { \mathrm { c r o s s } }$ , $\mu$ represents the upper bound of the probability density around the decision boundary. For example if $\mathbb { P } \left[ \theta \left( \mathbf { Z } _ { i } , \mathbf { w } _ { * } \right) ^ { \star } \in \left[ \frac { \pi } { 2 } - \phi , \frac { \pi } { 2 } + \phi \right] \right] \propto \phi ^ { 2 }$ , then for $\phi$ in a small neighborhood around $\pi / 2$ , say radius $\epsilon$ , we have $\begin{array} { r } { \mathbb { P } \left[ \theta \left( \mathbf { Z } _ { i } , \mathbf { w } _ { * } \right) \in \left[ \frac { \pi } { 2 } - \phi , \frac { \pi } { 2 } + \phi \right] \right] \lesssim \epsilon \phi } \end{array}$ . This assumption is usually satisfied in real world examples like images because the image patches are not usually close to the decision boundary. For example, in computer vision, the local image patches often form clusters and is not evenly distributed over the appearance space. Therefore, if we use linear classifier to separate their cluster centers from the rest of the clusters, near the decision boundary the probability mass should be very low.
+
+# 3.2 THE POWER OF RANDOM INITIALIZATION
+
+For one-layer one-neuron model, we need initialization $\left\| \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \right\| _ { 2 } < \left\| \mathbf { w } _ { * } \right\| _ { 2 }$ and for the convolution filter, we need a stronger initialization $\lVert \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \rVert _ { 2 } < \lVert \mathbf { w } _ { * } \rVert _ { 2 } \cos \left( \phi _ { * } \right)$ . The following theorem
+
+shows with uniformly random initialization we have constant probability to obtain a good initialization. Note with this theorem at hand, we can boost the success probability to arbitrary close to 1 by random restarts. The proof is similar to (Tian, 2017).
+
+Theorem 3.4. If we uniformly sample $\mathbf { w } _ { 0 }$ from a $p$ -dimensional ball with radius $\alpha \Vert \mathbf { w } _ { * } \Vert$ so that $\alpha \leq \sqrt { \frac { 1 } { 2 \pi p } }$ , then with probability at least $\begin{array} { r } { { \frac { 1 } { 2 } } - { \sqrt { \frac { \pi p } { 2 } } } \alpha } \end{array}$ , we have $\| \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \| _ { 2 } \leq \sqrt { 1 - \alpha ^ { 2 } } \| \mathbf { w } _ { * } \|$ .
+
+To apply this general initialization theorem to our convolution filter case, we can choose $\alpha = \cos \phi _ { * }$ Therefore, with some simple algebra we have the following corollary.
+
+Corollary 3.1. Suppose $\begin{array} { r } { \cos \left( \phi _ { * } \right) < \frac { 1 } { \sqrt { 8 \pi p } } } \end{array}$ , then $i f \mathbf { w } _ { 0 }$ is uniformly sampled from a ball with center 0 and radius $\left\| \mathbf { w } _ { * } \right\| \cos \left( \phi _ { * } \right)$ , we have with probability at least $\begin{array} { r } { \frac { 1 } { 2 } - \cos \left( \phi _ { * } \right) \sqrt { \frac { \pi p } { 2 } } > \frac { 1 } { 4 } } \end{array}$ .
+
+The assumption of this corollary is satisfied if the patches are close to each other as discussed in the previous section.
+
+# 4 EXPERIMENTS
+
+In this section we use simulations to verify our theoretical findings. We first test how the smoothness affect the convergence rate in one-layer one-neuron model described in Section 2 To construct input distribution with different $L ( \phi ) , \gamma ( \phi )$ and $\beta$ (c.f. Definition 2.1 and Assumption 2.1), we fix the patch to have unit norm and use a mixture of truncated Gaussian distribution to model on the angle around $\mathbf { w } _ { \ast }$ and around the $- \mathbf { w } _ { \ast }$ Specifically, the probability density of $\angle \mathbf { Z } , \mathbf { w } _ { \ast }$ is sampled from $\begin{array} { r } { \frac { 1 } { 2 } N ( 0 , \sigma ) \mathbb { I } _ { [ - \pi / 2 , \pi / 2 ] } + \frac { 1 } { 2 } N ( - \pi , \sigma ) \mathbb { \hat { I } } _ { [ - \pi / 2 , \pi / 2 ] } } \end{array}$ . Note by definitions of $L ( \phi )$ and $\gamma ( \phi )$ if $\sigma  0$ the probability mass is centered around $\mathbf { w } _ { \ast }$ , so the distribution is very spiky and $L ( \phi ) / \gamma ( \phi )$ and $\beta$ will be large. On the other hand, if $\sigma  \infty$ , then input distribution is close to the rotation invariant distribution and $L ( \phi ) / \gamma ( \phi )$ and $\beta$ will be small. Figure 3a verifies our prediction where we fix the initialization and step size.
+
+Next we test how the closeness of patches affect the convergence rate in the convolution setting. We first generate a single patch $\widetilde { \mathbf { Z } }$ using the above model with $\sigma = 1$ , then generate each unit norm $\mathbf { Z } _ { i }$ whose angle with $\bar { \bf z }$ , $\angle \mathbf { Z } _ { i } , \tilde { \mathbf { Z } }$ is sampled from $\mathcal { L } \mathbf { Z } _ { i } , \widetilde { \mathbf { Z } } \sim N ( 0 , \sigma _ { 2 } ) \mathbb { I } _ { [ - \pi , \pi ) }$ . Figure 3b shows as variance between patches becomes smaller, we obtain faster convergence rate, which coincides with Theorem 3.1.
+
+We also test whether SGD can learn a filter on real world data. Here we choose MNIST data and generate labels using two filters. One is random filter where each entry is sampled from a standard Gaussian distribution (Figure 4a) and the other is a Gabor filter (Figure 4b). Figure 3a and Figure 3c show convergence rates of SGD with different initializations. Here, better initializations give faster rates, which coincides our theory. Note that here we report the relative loss, logarithm of squared error divided by the square of mean of data points instead of the difference between learned filter and true filter because we found SGD often cannot converge to the exact filter but rather a filter with near zero loss. We believe this is because the data are approximately lying in a low dimensional manifold in which the learned filter and the true filter are equivalent. To justify this conjecture, we try to interpolate the learned filter and the true filter linearly and the result filter has similar low loss (c.f. Figure 5). Lastly, we visualize the true filters and the learned filters in Figure 4 and we can see that the they have similar patterns.
+
+# 5 CONCLUSIONS AND FUTURE WORKS
+
+In this paper we provide the first recovery guarantee of (stochastic) gradient descent algorithm with random initialization for learning a convolution filter when the input distribution is not Gaussian. Our analyses only used the definition of ReLU and some mild structural assumptions on the input distribution. Here we list some future directions.
+
+One possibility is to extend our result to deeper and wider architectures. Even for two-layer fullyconnected network, the convergence of (stochastic) gradient descent with random initialization is not known. Existing results either requires sufficiently good initialization (Zhong et al., 2017) or relies on special architecture (Li & Yuan, 2017). However, we believe the insights from this paper is helpful to understand the behaviors of gradient-based algorithms in these settings.
+
+![](images/ae47ea68319568cc4ca1014015dab89cb358c25287b90f21f42f5f9e937ed839.jpg)  
+Figure 3: Convergence rates of SGD (a) with different smoothness where larger $\sigma$ is smoother; (b) with different closeness of patches where smaller $\sigma _ { 2 }$ is closer; (c) for a learning a random filter with different initialization on MNIST data; ${ \bf \Pi } ( { \bf d } )$ for a learning a Gabor filter with different initialization on MNIST data.
+
+![](images/588ce1ebd6ca4f73eee423e2a4ccd63515f7693b897873521826f77a26a8277a.jpg)  
+Figure 4: Visualization of true and learned filters. For each pair, the left one is the underlying truth and the right is the filter learned by SGD.
+
+Another direction is to consider the agnostic setting, where the label is not equal to the output of a neural network. This will lead to different dynamics of (stochastic) gradient descent and we may need to analyze the robustness of the optimization procedures. This problem is also related to the expressiveness of the neural network (Raghu et al., 2016) where if the underlying function is not equal bot is close to a neural network. We believe our analysis can be extend to this setting.
+
+# REFERENCES
+
+Avrim Blum and Ronald L Rivest. Training a 3-node neural network is np-complete. In Advances in neural information processing systems, pp. 494–501, 1989.
+
+Alon Brutzkus and Amir Globerson. Globally optimal gradient descent for a convnet with gaussian inputs. arXiv preprint arXiv:1702.07966, 2017.
+
+Anna Choromanska, Mikael Henaff, Michael Mathieu, Gerard Ben Arous, and Yann LeCun. The´ loss surfaces of multilayer networks. In Artificial Intelligence and Statistics, pp. 192–204, 2015.
+
+Yann N Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated convolutional networks. arXiv preprint arXiv:1612.08083, 2016.
+
+Simon S Du, Chi Jin, Jason D Lee, Michael I Jordan, Barnabas Poczos, and Aarti Singh. Gradient descent can take exponential time to escape saddle points. arXiv preprint arXiv:1705.10412, 2017.
+
+C Daniel Freeman and Joan Bruna. Topology and geometry of half-rectified network optimization. arXiv preprint arXiv:1611.01540, 2016.
+
+Antoine Gautier, Quynh N Nguyen, and Matthias Hein. Globally optimal training of generalized polynomial neural networks with nonlinear spectral methods. In Advances in Neural Information Processing Systems, pp. 1687–1695, 2016.
+
+Rong Ge, Furong Huang, Chi Jin, and Yang Yuan. Escaping from saddle pointsonline stochastic gradient for tensor decomposition. In Proceedings of The 28th Conference on Learning Theory, pp. 797–842, 2015.
+
+Surbhi Goel and Adam Klivans. Learning depth-three neural networks in polynomial time. arXiv preprint arXiv:1709.06010, 2017.
+
+Surbhi Goel, Varun Kanade, Adam Klivans, and Justin Thaler. Reliably learning the relu in polynomial time. arXiv preprint arXiv:1611.10258, 2016.
+
+Benjamin D Haeffele and Rene Vidal. Global optimality in tensor factorization, deep learning, and ´ beyond. arXiv preprint arXiv:1506.07540, 2015.
+
+Moritz Hardt and Tengyu Ma. Identity matters in deep learning. arXiv preprint arXiv:1611.04231, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Majid Janzamin, Hanie Sedghi, and Anima Anandkumar. Beating the perils of non-convexity: Guaranteed training of neural networks using tensor methods. arXiv preprint arXiv:1506.08473, 2015.
+
+Chi Jin, Rong Ge, Praneeth Netrapalli, Sham M Kakade, and Michael I Jordan. How to escape saddle points efficiently. arXiv preprint arXiv:1703.00887, 2017.
+
+Kenji Kawaguchi. Deep learning without poor local minima. In Advances in Neural Information Processing Systems, pp. 586–594, 2016.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Jason D Lee, Max Simchowitz, Michael I Jordan, and Benjamin Recht. Gradient descent only converges to minimizers. In Conference on Learning Theory, pp. 1246–1257, 2016.
+
+Yuanzhi Li and Yang Yuan. Convergence analysis of two-layer neural networks with relu activation. arXiv preprint arXiv:1705.09886, 2017.
+
+Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. arXiv preprint arXiv:1312.4400, 2013.
+
+Qihang Lin and Lin Xiao. An adaptive accelerated proximal gradient method and its homotopy continuation for sparse optimization. In International Conference on Machine Learning, pp. 73– 81, 2014.
+
+Roi Livni, Shai Shalev-Shwartz, and Ohad Shamir. On the computational efficiency of training neural networks. In Advances in Neural Information Processing Systems, pp. 855–863, 2014.
+
+Song Mei, Yu Bai, and Andrea Montanari. The landscape of empirical risk for non-convex losses. arXiv preprint arXiv:1607.06534, 2016.
+
+Fausto Milletari, Nassir Navab, and Seyed-Ahmad Ahmadi. V-net: Fully convolutional neural networks for volumetric medical image segmentation. In 3D Vision (3DV), 2016 Fourth International Conference on, pp. 565–571. IEEE, 2016.
+
+Quynh Nguyen and Matthias Hein. The loss surface of deep and wide neural networks. arXiv preprint arXiv:1704.08045, 2017.
+
+Maithra Raghu, Ben Poole, Jon Kleinberg, Surya Ganguli, and Jascha Sohl-Dickstein. On the expressive power of deep neural networks. arXiv preprint arXiv:1606.05336, 2016.
+
+Itay Safran and Ohad Shamir. On the quality of the initial basin in overspecified neural networks. In International Conference on Machine Learning, pp. 774–782, 2016.
+
+Hanie Sedghi and Anima Anandkumar. Provable methods for training neural networks with sparse connectivity. arXiv preprint arXiv:1412.2693, 2014.
+
+Shai Shalev-Shwartz, Ohad Shamir, and Shaked Shammah. Failures of gradient-based deep learning. In International Conference on Machine Learning, pp. 3067–3075, 2017a.
+
+Shai Shalev-Shwartz, Ohad Shamir, and Shaked Shammah. Weight sharing is crucial to succesful optimization. arXiv preprint arXiv:1706.00687, 2017b.
+
+Ohad Shamir. Distribution-specific hardness of learning neural networks. arXiv preprint arXiv:1609.01037, 2016.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+Jiˇr´ı Sˇ´ıma. Training a single sigmoidal neuron is hard. Neural Computation, 14(11):2709–2728, 2002.
+
+Mahdi Soltanolkotabi. Learning relus via gradient descent. arXiv preprint arXiv:1705.04591, 2017.
+
+Mahdi Soltanolkotabi, Adel Javanmard, and Jason D Lee. Theoretical insights into the optimization landscape of over-parameterized shallow neural networks. arXiv preprint arXiv:1707.04926, 2017.
+
+Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, inception-resnet and the impact of residual connections on learning. In AAAI, pp. 4278–4284, 2017.
+
+Yuandong Tian. An analytical formula of population gradient for two-layered relu network and its applications in convergence and critical point analysis. arXiv preprint arXiv:1703.00560, 2017.
+
+Yuchen Zhang, Jason D Lee, Martin J Wainwright, and Michael I Jordan. Learning halfspaces and neural networks with random initialization. arXiv preprint arXiv:1511.07948, 2015.
+
+Yuchen Zhang, Jason D Lee, and Michael I Jordan. l1-regularized neural networks are improperly learnable in polynomial time. In International Conference on Machine Learning, pp. 993–1001, 2016.
+
+Kai Zhong, Zhao Song, Prateek Jain, Peter L Bartlett, and Inderjit S Dhillon. Recovery guarantees for one-hidden-layer neural networks. arXiv preprint arXiv:1706.03175, 2017.
+
+Pan Zhou and Jiashi Feng. The landscape of deep learning algorithms. arXiv preprint arXiv:1705.07038, 2017.
+
+# A PROOFS AND ADDITIONAL THEOREMS
+
+A.1 PROOFS OF THE THEOREM IN SECTION 2
+
+# Lemma A.1.
+
+$$
+\begin{array} { r } { \left. \nabla _ { \mathbf { w } } \ell \left( \mathbf { w } \right) , \mathbf { w } - \mathbf { w } _ { * } \right. = \left( \mathbf { w } - \mathbf { w } _ { * } \right) ^ { \top } \mathbf { A } _ { \mathbf { w } , \mathbf { w } _ { * } } \left( \mathbf { w } - \mathbf { w } _ { * } \right) + \left( \mathbf { w } - \mathbf { w } _ { * } \right) ^ { \top } \mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } \mathbf { w } . } \end{array}
+$$
+
+and both terms are non-negative.
+
+Proof. Since $\mathbf { A } _ { \mathbf { w } , \mathbf { w } _ { * } } \succeq 0$ and $\mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } \succeq 0$ (positive-semidefinite), both the first term and one part of the second term $\mathbf { w } ^ { \top } \mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } \mathbf { w }$ are non-negative. The other part of the second term is
+
+$$
+- \mathbf { w } _ { \ast } ^ { \intercal } \mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { \ast } } \mathbf { w } = - \mathbb { E } \left[ \left( \mathbf { w } _ { \ast } ^ { \intercal } \mathbf { Z } \right) \left( \mathbf { w } ^ { \intercal } \mathbf { Z } \right) \mathbb { I } \left\{ \mathbf { w } ^ { \intercal } \mathbf { Z } \geq 0 , \mathbf { w } _ { \ast } ^ { \intercal } \mathbf { Z } \leq 0 \right\} \right] \geq 0 .
+$$
+
+Proof of Theorem 2.1. The assumption on the input distribution ensures when $\theta \left( \mathbf { w } , \mathbf { w } _ { * } \right) \ \ne \ \pi .$ , $\mathbf { A } _ { \mathbf { w } , \mathbf { w } _ { * } } \ \succ \ \mathbf { 0 }$ and when $\theta \left( \mathbf { w } , \mathbf { w } _ { * } \right) \neq \ 0$ , $\mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } \ \succ \ \mathbf { 0 }$ . Now when gradient descent converges we have $\nabla _ { \mathbf { w } } \ell \left( \mathbf { w } \right) = \mathbf { 0 }$ . We have the following theorem. By assumption, since $\ell \left( \mathbf { w } \right) < \ell \left( \mathbf { 0 } \right)$ and gradient descent only decreases function value, we will not converge to $\mathbf { w } = \mathbf { 0 }$ . Note that at any critical points, $\left. \nabla _ { \mathbf { w } } \ell \left( \mathbf { w } \right) , \mathbf { w } - \mathbf { w } _ { * } \right. = 0$ , from Lemma A.1, we have:
+
+$$
+\begin{array} { r l } { \left( \mathbf { w } - \mathbf { w } _ { * } \right) ^ { \top } \mathbf { A } _ { \mathbf { w } , \mathbf { w } _ { * } } \left( \mathbf { w } - \mathbf { w } _ { * } \right) } & { = 0 } \\ { \left( \mathbf { w } - \mathbf { w } _ { * } \right) ^ { \top } \mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } \mathbf { w } } & { = 0 . } \end{array}
+$$
+
+Suppose we are converging to a critical point $\mathbf { w } \neq \mathbf { w } _ { * }$ . There are two cases:
+
+• If $\theta \left( \mathbf { w } , \mathbf { w } _ { * } \right) \neq \pi$ , then we have $\left( \mathbf { w } - \mathbf { w } _ { * } \right) ^ { \top } \mathbf { A } _ { \mathbf { w } , \mathbf { w } _ { * } } \left( \mathbf { w } - \mathbf { w } _ { * } \right) > 0$ , which contradicts with Eqn. 6. • If $\theta \left( \mathbf { w } , \mathbf { w } _ { * } \right) ~ = ~ \pi$ , without loss of generality, let $\textbf { w } = \mathbf { \Gamma } - \alpha \mathbf { w } _ { * }$ for some $\alpha \ > \ 0$ . By the assumption we know $\mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } \quad \succ \quad 0$ . Now the second equation becomes $( \mathbf { w } - \mathbf { w } _ { * } ) ^ { \top } \mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } \mathbf { w } = ( 1 + \gamma ) \mathbf { w } _ { * } \mathbf { A } _ { \mathbf { w } , - \mathbf { w } _ { * } } \mathbf { w } _ { * } > 0$ , which contradicts with Eqn. 7.
+
+Therefore we have $\mathbf { w } = \mathbf { w } _ { * }$ .
+
+Proof of Theorem 2.2. Our proof relies on the following simple but crucial observation: if $\left\| \mathbf { w } - \mathbf { w } _ { * } \right\| _ { 2 } < \left\| \mathbf { w } _ { * } \right\| _ { 2 }$ , then
+
+$$
+\theta \left( \mathbf { w } , \mathbf { w } _ { * } \right) \leq \arcsin \left( \frac { \left\| \mathbf { w } - \mathbf { w } _ { * } \right\| _ { 2 } } { \left\| \mathbf { w } _ { * } \right\| _ { 2 } } \right) .
+$$
+
+We denote $\boldsymbol { \theta } \left( \mathbf { w } _ { t } , \mathbf { w } _ { * } \right) = \boldsymbol { \theta } _ { t }$ and by the observation we have $\theta _ { t } \leq \phi _ { t }$ . Recall the gradient descent dynamics,
+
+$$
+\begin{array} { r l } & { w _ { t + 1 } = \mathbf { w } _ { t } - \eta \nabla _ { \mathbf { w } _ { t } } \ell ( \mathbf { w } _ { t } ) } \\ & { \qquad = \mathbf { w } _ { t } - \eta \left( \mathbb { E } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \mathbb { I } \left\{ \mathbf { w } _ { t } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { \star } ^ { \top } \mathbf { Z } \geq 0 \right\} \right] ( \mathbf { w } _ { t } - \mathbf { w } _ { \star } ) - \mathbb { E } \left[ \mathbf { w } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { \star } ^ { \top } \mathbf { Z } \leq 0 \right] \mathbf { w } _ { t } \right) . } \end{array}
+$$
+
+Consider the squared distance to the optimal weight
+
+$$
+\begin{array} { r l } & { \left\| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } } \\ & { = \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } } \\ & { \quad - \eta \left( \mathbf { w _ { t } } - \mathbf { w } _ { * } \right) ^ { \top } \left( \mathbb { E } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \mathbb { I } \left\{ \mathbf { w } _ { t } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \geq 0 \right\} \right] \left( \mathbf { w } _ { t } - \mathbf { w } _ { * } \right) - \mathbb { E } \left[ \mathbf { w } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \leq 0 \right] \mathbf { w } _ { t } \right) } \\ & { \quad + \eta ^ { 2 } \left\| \mathbb { E } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \mathbb { I } \left\{ \mathbf { w } _ { t } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \geq 0 \right\} \right] \left( \mathbf { w } _ { t } - \mathbf { w } _ { * } \right) - \mathbb { E } \left[ \mathbf { w } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \leq 0 \right] \mathbf { w } _ { t } \right\| _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+By our analysis in the previous section, the second term is smaller than
+
+$$
+\begin{array} { r } { - \eta \left( \mathbf { w _ { t } } - \mathbf { w _ { * } } \right) ^ { \top } \mathbb { E } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \mathbb { I } \left\{ \mathbf { w } _ { t } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \geq 0 \right\} \right] \left( \mathbf { w } _ { t } - \mathbf { w } _ { * } \right) \leq - \eta \gamma ( \theta _ { t } ) \left. \mathbf { w } _ { t } - \mathbf { w } _ { * } \right. _ { 2 } ^ { 2 } } \end{array}
+$$
+
+where we have used our assumption on the angle. For the third term, we expand it as
+
+$$
+\begin{array} { r l } & { \left\| \mathbb { E } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \mathbb { I } \left\{ \mathbf { w } _ { t } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \geq 0 \right\} \right] ( \mathbf { w } _ { t } - \mathbf { w } _ { * } ) - \mathbb { E } \left[ \mathbf { w } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \leq 0 \right] \mathbf { w } _ { t } \right\| _ { 2 } ^ { 2 } } \\ & { = \left\| \mathbb { E } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \mathbb { I } \left\{ \mathbf { w } _ { t } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \geq 0 \right\} \right] ( \mathbf { w } _ { t } - \mathbf { w } _ { * } ) \right\| _ { 2 } ^ { 2 } } \\ & { \quad - 2 \left( \mathbb { E } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \mathbb { I } \left\{ \mathbf { w } _ { t } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \geq 0 \right\} \right] ( \mathbf { w } _ { t } - \mathbf { w } _ { * } ) \right) ^ { \top } \mathbb { E } \left[ \mathbf { w } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \leq 0 \right] \mathbf { w } _ { t } } \\ & { \quad + \left\| \mathbb { E } \left[ \mathbf { w } ^ { \top } \mathbf { Z } \geq 0 , \mathbf { w } _ { * } ^ { \top } \mathbf { Z } \leq 0 \right] \mathbf { w } _ { t } \right\| _ { 2 } ^ { 2 } } \\ &  \leq L ^ { 2 } ( \theta _ { t } ) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } + 2 L ( \theta _ { t } ) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } \cdot 2 \beta \frac { \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| } { \left\| \mathbf { w } _ { * } \right\| _ { 2 } } + \left( 2 \beta \frac { \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } } { \left\| \mathbf { w } _ { * } \right\| _ { 2 } } \right)  \end{array}
+$$
+
+Therefore, in summary,
+
+$$
+\begin{array} { r l } { \left\| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } \leq \left( 1 - \eta \gamma ( \theta _ { t } ) + \eta ^ { 2 } \left( L ( \theta _ { t } ) + 4 \beta \right) ^ { 2 } \right) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } } & { } \\ { \leq \left( 1 - \frac { \eta \gamma ( \theta _ { t } ) } { 2 } \right) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } } & { } \\ { \leq \left( 1 - \frac { \eta \gamma ( \phi _ { t } ) } { 2 } \right) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } } & { } \end{array}
+$$
+
+where the first inequality is by our assumption of the step size and second is because $\theta _ { t } \leq \phi _ { t }$ and $\gamma ( \cdot )$ is monotonically decreasing. □
+
+Theorem A.1 (Rotational Invariant Distribution). For any unit norm rotational invariant input distribution, we have $\beta = 1$ .
+
+Proof of Theorem A.1. Without loss of generality, we only need to focus on the plane spanned by w and $\mathbf { w } _ { \ast }$ and suppose $\mathbf { w } _ { * } = ( 1 , 0 ) ^ { \top }$ . Then
+
+$$
+{ \boldsymbol { \mathrm { ? } } } \left[ \mathbf { Z } \mathbf { Z } ^ { \mathsf { T } } \mathbb { I } \left\{ S ( \mathbf { w } , - \mathbf { w } _ { * } ) \right\} \right] = \int _ { - { \boldsymbol { \pi } } / 2 } ^ { - { \boldsymbol { \pi } } / 2 + { \boldsymbol { \phi } } } { \binom { \cos \theta } { \sin \theta } } \left( \cos \theta , \sin \theta \right) \mathrm { d } \theta = { \frac { 1 } { 2 } } \left( { \boldsymbol { \phi } } - \sin \phi \cos \phi \qquad - \sin ^ { 2 } \phi \cos \theta \right) { \boldsymbol { \phi } } = { \frac { \sin ^ { 2 } \phi } { \sin \phi } } { \boldsymbol { \phi } } = { \frac { \sin ^ { 2 } \phi } { \cos \phi } } { \boldsymbol { \phi } } .
+$$
+
+It has two eigenvalues
+
+$$
+\lambda _ { 1 } ( \phi ) = { \frac { \phi + \sin \phi } { 2 } } \operatorname { a n d } \lambda _ { 2 } ( \phi ) = { \frac { \phi - \sin \phi } { 2 } } .
+$$
+
+Theorem A.2. If $\mathbf { Z } \sim N ( 0 , \mathbf { I } )$ , then $\beta \leq p$
+
+Proof. Note in previous theorem we can integrate angle and radius separately then multiply them together. For Gaussian distribution, we have $\begin{array} { r } { \mathbb { E } \left[ \left. \mathbf { Z } \right. _ { 2 } ^ { 2 } \right] \leq p } \end{array}$ . The result follows. □
+
+# A.2 PROOFS OF THEOREMS IN SECTION 3
+
+Proof of Theorem 3.1. The proof is very similar to Theorem 2.2. Notation-wise, for two events $S _ { 1 } , S _ { 2 }$ we use $S _ { 1 } S _ { 2 }$ as a shorthand for $S _ { 1 } \cap S _ { 2 }$ and $S _ { 1 } + S _ { 2 }$ as a shorthand for $S _ { 1 } \cup S _ { 2 }$ . Denote $\boldsymbol { \theta } _ { t } = \boldsymbol { \theta } \left( \mathbf { w } _ { t } , \mathbf { w } _ { * } \right)$ . First note with some routine algebra, we can write the gradient as
+
+$$
+\begin{array} { r l } & { \nabla _ { \mathbf { w } _ { t } } \ell \left( \mathbf { w } _ { t } \right) } \\ & { = \mathbb { E } \left[ \sum _ { ( i , j ) = ( 1 , 1 ) } ^ { ( d , d ) } \mathbf { Z } _ { i } \mathbf { Z } _ { j } ^ { \top } \mathbb { I } \left\{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { j } \right\} \right] \left( \mathbf { w } - \mathbf { w } _ { * } \right) } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { + \mathbb { E } \left[ \underset { ( i , j ) = ( 1 , 1 ) } { \overset { ( d , d ) } { \sum } } \mathbf { Z } _ { i } \mathbf { Z } _ { j } ^ { \top } { \mathbb { I } \left\{ { S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { j } + S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { i } S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { j } } \right\} } \right] \mathbf { w } } \\ & { + \mathbb { E } \left[ \underset { ( i , j ) = ( 1 , 1 ) } { \overset { ( d , d ) } { \sum } } \mathbf { Z } _ { i } \mathbf { Z } _ { j } ^ { \top } { \mathbb { I } \left\{ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { i } S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { j } } \right\} } \right] \mathbf { w } } \\ & { - \mathbb { E } \left[ \underset { ( i , j ) = ( 1 , 1 ) } { \overset { ( d , d ) } { \sum } } \mathbf { Z } _ { i } \mathbf { Z } _ { j } ^ { \top } { \mathbb { I } \left\{ { S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } S ( - \mathbf { w } , \mathbf { w } _ { * } ) _ { j } + S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { i } S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { j } + S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { i } S ( - \mathbf { w } , \mathbf { w } _ { * } ) _ { j } } \right\} } \right] \mathbf { w } } \end{array}
+$$
+
+We first examine the inner product between the gradient and $\mathbf { w } - \mathbf { w } _ { * }$ .
+
+h∇wt \`(w), w − w∗i   
+= (w − w )> E (Xd,d) ZiZj I nS(w, w∗)iS(w, w∗)j o (w − w∗) $\begin{array} { r l } &  \quad + ( \textbf { v } - \textbf { v } ^ { 2 } ) ^ { 2 } ( \displaystyle \sum _ { j = 0 } ^ { N } \alpha ^ { 2 } \textbf {  { S u p p e r } } + \beta ^ { 2 } ) ^ { 2 } + ( \textbf { v } - \textbf { v } ^ { 2 } ) ^ { 2 } ( \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } + \beta ^ { 2 } \\ \end{array}$ ∗)iS(w, −w∗)j o w ∗)iS(−w, w∗)j o w∗   
+$\begin{array} { r l } & { \begin{array} { r l } & { \mathrm { i } } \\ & { = \left( \nu - \nu \right) ^ { 2 } , } \\ { \nu \left( \frac { \nu } { 2 } \right) ^ { 2 } , } \\ { = \left( \nu - \nu \right) ^ { 4 } , } \\ { \nu \left( \frac { \nu } { 2 } \right) ^ { 4 } , } \end{array} } \end{array}$ ∗)iS(−w, w∗)j o w∗ ( − w , w ∗ ) j o  op
+
+$$
+\begin{array} { l }  { + \| { \mathbb { E } [ \begin{array} { c } { ( { d , d } ) } \\ { ( { i , j } ) = ( { 1 , 1 } ) } \end{array} { \mathbf { Z } } _ { i } { \mathbf { Z } } _ { j } { \mathbb { I } \{ { S } ( { \mathbf { w } } , - { \mathbf { w } } _ { * } ) _ { i } S ( { \mathbf { w } } , { \mathbf { w } } _ { * } ) _ { j } \} } ] } \| _ { \sigma _ { p } } + \| { \mathbb { E } [ \begin{array} { c } { ( { d , d } ) } \\ { \displaystyle { \sum _ { i , j = ( { 1 , 1 } ) } ^ { { d } } { \mathbf { Z } } _ { i } { \mathbf { Z } } _ { j } { \mathbb { I } \{ { S } ( { \mathbf { w } } , - { \mathbf { w } } _ { * } ) _ { i } S ( - { \mathbf { w } } , { \mathbf { w } } _ { * } ) _ { j } \} } } \end{array} ] } { S ( - \mathbf { w } _ { * } ) _ { i } { \mathbf { Z } } _ { j } } } } \\ { \geq \gamma ( \theta _ { t } ) \| { \mathbf { w } } _ { t } - { \mathbf { w } } _ { * } \| _ { 2 } ^ { 2 } - 3 L _ { \mathrm { c r o s s } } \phi _ { t } \| { \mathbf { w } } _ { * } \| _ { 2 } \| { \mathbf { w } } _ { t } - { \mathbf { w } } _ { * } \| _ { 2 } } \\ { \geq \gamma ( \theta _ { t } ) \| { \mathbf { w } } _ { t } - { \mathbf { w } } _ { * } \| _ { 2 } ^ { 2 } - 6 L _ { \mathrm { c r o s s } } \frac { \| { \mathbf { w } } _ { t } - { \mathbf { w } } _ { * } \| _ { 2 } } { \| { \mathbf { w } } _ { * } \| _ { 2 } } \cdot \| { \mathbf { w } } _ { * } \| _ { 2 } \| { \mathbf { w } } _ { t } - { \mathbf { w } } _ { * } \| _ { 2 } } \\ { \geq ( \gamma ( \theta _ { t } ) - 6 L _ { \mathrm { c r o s s } } ) \| { \mathbf { w } } _ { t } - { \mathbf { w } } _ { * } \| _ { 2 } ^ { 2 } } \end{array}
+$$
+
+where the first inequality we used the definitions of the regions; the second inequality we used the definition of operator norm; the third inequality we used the fact $\left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } \leq \left\| \mathbf { w } _ { * } \right\| _ { 2 }$ ; the fourth inequality we used the definition of $L _ { \mathrm { c r o s s } }$ and the fifth inequality we used $\phi \leq 2 \sin \phi$ for any $0 \leq \phi \leq \pi / 2$ . Next we can upper bound the norm of the gradient using similar argument
+
+$$
+\begin{array} { r l } & { \| \nabla _ { \mathbf { w } _ { t } } \ell ( \mathbf { w } _ { t } ) \| _ { 2 } \leq L \left( \theta _ { t } \right) \| \mathbf { w } _ { t } - \mathbf { w } _ { * } \| _ { 2 } + 1 0 L _ { \mathrm { c r o s s } } \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| + 2 \beta \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } } \\ & { \qquad = ( L ( \theta _ { t } ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta ) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } . } \end{array}
+$$
+
+Therefore, using the dynamics of gradient descent, putting the above two bounds together, we have
+
+$$
+\begin{array} { r l } & { \left\| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } \leq \left( 1 - \eta \left( \gamma ( \theta _ { t } ) - 6 L _ { \mathrm { c r o s s } } \right) + \eta ^ { 2 } ( L ( \theta _ { t } ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta ) ^ { 2 } \right) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } } \\ & { \qquad \leq \left( 1 - \frac { \eta \left( \gamma \left( \theta _ { t } \right) - 6 L _ { \mathrm { c r o s s } } \right) } { 2 } \right) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } } \\ & { \qquad \leq \left( 1 - \frac { \eta \left( \gamma \left( \phi _ { t } \right) - 6 L _ { \mathrm { c r o s s } } \right) } { 2 } \right) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } } \end{array}
+$$
+
+where the last step we have used our choice of $\eta _ { t }$ and $\theta _ { t } \leq \phi _ { t }$ .
+
+The proof of Theorem 3.2 consists of two parts. First we show if $\eta$ is chosen properly and $T$ is not to big, then for all $1 \leq t \leq T$ , with high probability the iterates stat in a neighborhood of $\mathbf { w } _ { \ast }$ . Next, conditioning on this, we derive the rate.
+
+Lemma A.2. Denote $r _ { 0 } = \left\| \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \right\| _ { 2 } < \left\| \mathbf { w } _ { * } \right\| _ { 2 } \sin \phi _ { * }$ . Given $0 < r _ { 1 } < \| \mathbf { w } _ { * } \| _ { 2 } \sin \phi _ { * }$ , number of iterations $T \in \mathbb { Z } _ { + + }$ and failure probability $\delta$ , denote $\begin{array} { r } { \phi _ { 1 } = \arcsin \left( \frac { r _ { 1 } } { \left\| \mathbf { w } _ { * } \right\| _ { 2 } } \right) } \end{array}$ then if the step size satisfies
+
+$$
+\begin{array} { c } { { 0 < 1 - \eta \gamma ( \phi _ { 1 } ) + \eta ^ { 2 } ( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta ) ^ { 2 } < 1 } } \\ { { \left( r _ { 1 } ^ { 2 } - r _ { 0 } ^ { 2 } \right) ^ { 2 } } } \\ { { { \cal T } \left( 1 + 2 \eta \alpha T \right) \left( 2 \eta B \left( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta \right) r _ { 1 } + \eta ^ { 2 } B ^ { 2 } \right) ^ { 2 } \log \left( \displaystyle \frac { T } { \delta } \right) } } \end{array}
+$$
+
+with $\alpha = \gamma ( \phi _ { 1 } ) - \eta ( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta )$ . Then with probability at least $1 - \delta$ , for all $t =$ $1 , \ldots , T$ , we have
+
+$$
+\left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| \leq r _ { 1 } .
+$$
+
+Proof of Lemma A.2. Let $g ( \mathbf { w } _ { t } ) = \mathbb { E } \left[ \nabla _ { \mathbf { w } _ { t } } \ell \left( \mathbf { w } _ { t } \right) \right] + \xi _ { t }$ . We denote $\mathcal { F } _ { t } = \sigma \left\{ \xi _ { 1 } , \ldots , \xi _ { t } \right\}$ , the sigmaalgebra generated by $\xi _ { 1 } , \ldots , \xi _ { t }$ and define the event
+
+$$
+\begin{array} { r } { \mathcal { C } _ { t } = \left\{ \forall \tau \leq t , \| \mathbf { w } _ { \tau } - \mathbf { w } _ { * } \| \leq r _ { 1 } \right\} . } \end{array}
+$$
+
+Consider
+
+$$
+\begin{array} { r l } & { \quad \mathbb { E } \left[ \left\| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } \mathbb { I } _ { C _ { t } } \big | \mathcal { F } _ { t } \right] } \\ & { = \mathbb { E } \left[ \left\| \mathbf { w } _ { t } - \eta \nabla _ { \mathbf { w } _ { t } } \ell ( \mathbf { w } _ { t } ) - \mathbf { w } _ { * } - \eta \xi _ { t } \right\| _ { 2 } ^ { 2 } \mathbb { I } _ { C _ { t } } \big | \mathcal { F } _ { t } \right] } \\ & { \leq \left( \left( 1 - \eta \gamma ( \phi _ { 1 } ) + \eta ^ { 2 } \left( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta \right) ^ { 2 } \right) \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } + \eta ^ { 2 } B ^ { 2 } \right) \mathbb { I } _ { C _ { t } } } \end{array}
+$$
+
+where the inequality follows by our analysis of gradient descent together with definition of $\mathcal { C } _ { t }$ and $\mathbb { E } \left[ \xi _ { t } | \mathcal { F } _ { t } \right] = 0$ . Define
+
+$$
+G _ { t } = \left( 1 - \eta \alpha \right) ^ { - t } \left( \left| \left| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right| \right| _ { 2 } ^ { 2 } - \frac { \eta B ^ { 2 } } { \alpha } \right) .
+$$
+
+By our analysis above, we have
+
+$$
+\mathbb { E } \left[ G _ { t + 1 } \mathbb { I } _ { { \mathcal { C } } _ { t } } | { \mathcal { F } } _ { t } \right] \leq G _ { t } \mathbb { I } _ { { \mathcal { C } } _ { t } } \leq G _ { t } \mathbb { I } _ { { \mathcal { C } } _ { t - 1 } }
+$$
+
+where the last inequality is because $\mathcal { C } _ { t }$ is a subset of $\mathcal { C } _ { t - 1 }$ . Therefore, $\boldsymbol { G } _ { t } \mathbb { I } _ { \boldsymbol { c } _ { t - 1 } }$ is a super-martingale and we may apply Azuma-Hoeffding inequality. Before that, we need to bound the difference between $G _ { t } \mathbb { I } _ { \boldsymbol { c } _ { t } }$ and its expectation. Note
+
+$$
+\begin{array} { r l } & { G _ { t } \mathbb { I } _ { \mathcal { C } _ { t - 1 } } - \mathbb { E } \left[ G _ { t } \mathbb { I } _ { \mathcal { C } _ { t - 1 } } \right] \left. \mathcal { F } _ { t - 1 } \right. = \left( 1 - \eta \alpha \right) ^ { - t } \left. \left. \mathbf { w } _ { t } - \mathbf { w } _ { * } \right. _ { 2 } ^ { 2 } - \mathbb { E } \left[ \left. \mathbf { w } _ { t } - \mathbf { w } _ { * } \right. _ { 2 } ^ { 2 } \right] \left. \mathcal { F } _ { t - 1 } \right. \mathbb { I } _ { \mathcal { C } _ { t - 1 } } \right. } \\ & { \qquad = \left( 1 - \eta \alpha \right) ^ { - t } \left. 2 \eta \langle \xi _ { t } , \mathbf { w } _ { t } - \eta \nabla _ { \mathbf { w } _ { t } } \ell ( \mathbf { w } _ { t } ) - \mathbf { w } _ { * } - \eta ^ { 2 } \mathbb { E } \left[ \left. \xi _ { t } \right. _ { 2 } ^ { 2 } \left. \mathcal { F } _ { t - 1 } \right] \right. \mathbb { I } _ { \mathcal { C } _ { t - 1 } } \right. } \\ & { \qquad \leq \left( 1 - \eta \alpha \right) ^ { - t } \left( 2 \eta B \left( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta \right) \left. \mathbf { w } _ { t } - \mathbf { w } _ { * } \right. _ { 2 } + \eta ^ { 2 } B ^ { 2 } \right) \mathbb { I } _ { \mathcal { C } _ { t - 1 } } } \\ & { \qquad \leq \left( 1 - \eta \alpha \right) ^ { - t } \left( 2 \eta B \left( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta \right) r _ { 1 } + \eta ^ { 2 } B ^ { 2 } \right) } \\ & { \qquad \triangleq d _ { t } . } \end{array}
+$$
+
+Therefore for all $t \leq T$
+
+$$
+\begin{array} { r l } & { c _ { t } ^ { 2 } \triangleq \displaystyle \sum _ { \tau = 1 } ^ { t } d _ { \tau } ^ { 2 } } \\ & { \quad = \displaystyle \sum _ { \tau = 1 } ^ { t } \left( 1 - \eta \alpha \right) ^ { - 2 t } \left( 2 \eta B \left( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta \right) r _ { 1 } + \eta ^ { 2 } B ^ { 2 } \right) ^ { 2 } } \\ & { \quad \le t \left( 1 - \eta \alpha \right) ^ { - 2 t } \left( 2 \eta B \left( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta \right) r _ { 1 } + \eta ^ { 2 } B ^ { 2 } \right) ^ { 2 } } \\ & { \quad \le T \left( 1 + 2 \eta \alpha T \right) \left( 2 \eta B \left( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta \right) r _ { 1 } + \eta ^ { 2 } B ^ { 2 } \right) ^ { 2 } } \end{array}
+$$
+
+where the first inequality we used $1 - \eta \alpha < 1$ , the second we used $t \leq T$ and the third we used our assumption on $\eta$ . Let us bound at $( t + 1 )$ -th step, the iterate goes out of the region,
+
+$$
+\begin{array} { r l } { \mathbb { P } \left[ \mathcal { G } _ { t } \cap \left\{ \left\| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { * } \right\| _ { 2 } > r _ { 1 } \right\} \right] = \mathbb { P } \left[ \mathcal { G } _ { t } \cap \left\{ \left\| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } > r _ { 1 } ^ { 2 } \right\} \right] } & { } \\ & { = \mathbb { P } \left[ C _ { t } \cap \left\{ \left\| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } > r _ { 0 } ^ { 2 } + \left( r _ { 1 } ^ { 2 } - r _ { 0 } ^ { 2 } \right) \right\} \right] } \\ & { = \mathbb { P } \left[ \mathcal { C } _ { t } \cap \left\{ G _ { t + 1 } \left( 1 - \eta \alpha \right) ^ { t } + \frac { \eta B ^ { 2 } } { \alpha } \geq G _ { 0 } + \frac { \eta B ^ { 2 } } { \alpha } + r _ { 1 } ^ { 2 } - r _ { 0 } ^ { 2 } \right\} \right] } \\ & { \leq \mathbb { P } \left[ \mathcal { C } _ { t } \cap \left\{ G _ { t + 1 } - G _ { 0 } \geq r _ { 1 } ^ { 2 } - r _ { 0 } ^ { 2 } \right\} \right] } \\ & { \leq \exp \left\{ - \frac { \left( r _ { 1 } ^ { 2 } - r _ { 0 } ^ { 2 } \right) ^ { 2 } } { 2 c _ { t } ^ { 2 } } \right\} } \\ & { \leq \frac { \delta } { T } } \end{array}
+$$
+
+where the second inequality we used Azuma-Hoeffding inequality, the last one we used our assumption of $\eta$ . Therefore for all $0 \leq t \leq T$ , we have with probability at least $1 - \delta , { \mathcal { C } } _ { t }$ happens. □
+
+Now we can derive the rate.
+
+Lemma A.3. Denote $r _ { 0 } = \left\| \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \right\| _ { 2 } < \left\| \mathbf { w } _ { * } \right\| _ { 2 } \sin \phi _ { * }$ . Given $0 < r _ { 1 } < \| \mathbf { w } _ { * } \| _ { 2 } \sin \phi _ { * }$ , number of iterations $T \in \mathbb { Z } _ { + + }$ and failure probability $\delta _ { i }$ , denote $\begin{array} { r } { \phi _ { 1 } = \arcsin \left( \frac { r _ { 1 } } { \left\| \mathbf { w } _ { * } \right\| _ { 2 } } \right) } \end{array}$ then if the step size satisfies
+
+$$
+\begin{array} { r l r } {  { 0 < 1 - \eta \gamma ( \phi _ { 1 } ) + \eta ^ { 2 } ( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta ) ^ { 2 } < 1 } } \\ & { } & { \frac { ( r _ { 1 } ^ { 2 } - r _ { 0 } ^ { 2 } ) ^ { 2 } } { T ( 1 + 2 \eta \alpha T ) ( 2 \eta B ( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta ) r _ { 1 } + \eta ^ { 2 } B ^ { 2 } ) ^ { 2 } } \ge \log ( \frac { T } { \delta } ) } \\ & { } & { \eta T ( \gamma ( \phi _ { 1 } ) - \eta ( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta ) ^ { 2 } ) \ge \log ( \frac { r _ { 0 } ^ { 2 } } { \epsilon ^ { 2 }  \mathbf { w } _ { * }  _ { 2 } ^ { 2 } \delta } ) } \end{array}
+$$
+
+$$
+\epsilon ^ { 2 } \left( \gamma ( \phi _ { 1 } ) - \eta \left( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta \right) ^ { 2 } \right) \left\| \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } \geq \eta B ^ { 2 }
+$$
+
+with $\alpha = \gamma \left( \phi _ { 1 } \right) - \eta \left( L ( 0 ) + 1 0 L _ { \mathrm { c r o s s } } + 4 \beta \right)$ , then we have with probability $1 - 2 \delta$ ,
+
+$$
+\left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } \leq 2 \epsilon \left\| \mathbf { w } _ { * } \right\| _ { 2 } .
+$$
+
+Proof of Lemma A.3. We use the same notations in the proof of Lemma A.2. By the analysis of Lemma A.2, we know
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } \mathbb { I } _ { \mathcal { C } _ { t } } \big | \mathcal { F } _ { t } \right] \leq \left( ( 1 - \eta \alpha ) \| \mathbf { w } _ { t } - \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } + \eta ^ { 2 } B ^ { 2 } \right) \mathbb { I } _ { \mathcal { C } _ { t } } . } \end{array}
+$$
+
+Therefore we have
+
+$$
+\mathbb { E } \left[ \left\| \mathbf { w } _ { t } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } \mathbb { I } _ { \mathcal { C } _ { t } } - \frac { \eta B ^ { 2 } } { \alpha } \right] \leq \left( 1 - \eta \alpha \right) ^ { t } \left( \left\| \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \right\| _ { 2 } ^ { 2 } - \frac { \eta B } { \alpha } \right) .
+$$
+
+Now we can bound the failure probability
+
+$$
+\begin{array} { r l } { \mathbb { P } [ \| \mathbf { w } _ { T } - \mathbf { w } _ { * } \| _ { 2 } \geq 2 \epsilon \| \mathbf { w } _ { * } \| _ { 2 } ] \leq \mathbb { P } [ \| \mathbf { w } _ { T } - \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } - \frac { \eta B ^ { 2 } } { \alpha } \geq \epsilon ^ { 2 } \| \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } ] } & { } \\ & { \leq \mathbb { P } [ \{ \| \mathbf { w } _ { T } - \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } \mathbb { T } _ { \epsilon _ { * } } - \frac { \eta B ^ { 2 } } { \alpha } \geq \epsilon ^ { 2 } \| \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } \} \cup \mathcal { C } _ { t } ^ { * } ] } \\ & { \leq \mathbb { P } [ \{ \| \mathbf { w } _ { T } - \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } \} \mathbb { I } _ { \epsilon _ { * } } - \frac { \eta B ^ { 2 } } { \alpha } \geq \epsilon ^ { 2 } \| \mathbf { w } \| _ { 2 } ^ { 2 } ] ] + \delta } \\ & { \leq \frac { \mathbb { E } [ \| \mathbf { w } _ { T } - \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } \mathbb { I } _ { \epsilon _ { * } } - \frac { \eta B ^ { 2 } } { \alpha } ] } { \epsilon ^ { 2 } \| \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } } + \delta } \\ & { \leq \frac { ( 1 - \eta \alpha ) ^ { 4 } ( \| \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } - \frac { \eta B } { \alpha } ) } { \epsilon ^ { 2 } \| \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } } + \frac { \eta B } { \alpha } } \\ & { \leq \frac { ( 1 - \eta \alpha ) ^ { 4 } ( \| \mathbf { w } _ { 0 } - \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } - \frac { \eta B } { \alpha } ) } { \epsilon ^ { 2 } \| \mathbf { w } _ { * } \| _ { 2 } ^ { 2 } } + \delta } \end{array}
+$$
+
+The first inequality we used the last assumption. The second inequality we used the probability of an event is upper bound by any superset of this event. The third one we used Lemma A.2 and the union bound. The fourth one we used Markov’s inequality. □
+
+Now we can specify the $T$ and $\eta$ and derive the convergence rate of SGD for learning a convolution filter.
+
+Proof of Theorem 3.2. With the choice of $\eta$ and $T$ , it is straightforward to check they satisfies conditions in Lemma A.3. □
+
+Proof of Theorem 3.3. We first prove the lower bound of $\gamma \left( \phi _ { 0 } \right)$ .
+
+$$
+\begin{array} { r l } & { \mathbb { E } \left[ \left( \displaystyle \sum _ { i = 1 } ^ { k } \mathbf { Z } _ { i } [ \left\{ \mathcal { S } ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \right\} \right) \left( \displaystyle \sum _ { i = 1 } ^ { k } \mathbf { Z } _ { i } [ \left\{ \mathcal { S } ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \right\} ^ { \top } ] \right) ^ { \top } \right] } \\ & { = \mathbb { E } \left[ k \mathbf { Z } + \displaystyle \sum _ { i = 1 } ^ { k } \left( \mathbf { Z } _ { i } \mathbf { I } \left\{ \mathcal { S } ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \right\} - \mathbf { Z } \right) \left( k \mathbf { Z } + \displaystyle \sum _ { i = 1 } ^ { k } \left( \mathbf { Z } _ { i } \mathbf { I } \left\{ \mathcal { S } ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \right\} - \mathbf { Z } \right) \right) ^ { \top } \right] } \\ & { = k ^ { 2 } \mathbb { E } \left[ \mathbf { Z } \mathbf { Z } ^ { \top } \right] + k \mathbb { E } \left[ \mathbf { Z } \left( \displaystyle \sum _ { i = 1 } ^ { k } \left( \mathbf { Z } _ { i } \mathbf { I } \left\{ \mathcal { S } ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \right\} - \mathbf { Z } \right) \right) ^ { \top } \right] } \\ & { \quad + k \mathbb { E } \left[ \left( \displaystyle \sum _ { i = 1 } ^ { k } \left( \mathbf { Z } _ { i } \mathbf { I } \left\{ \mathcal { S } ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \right\} - \mathbf { Z } \right) \right) \mathbf { Z } ^ { \top } \right] } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { + \mathbb { E } [ ( \displaystyle \sum _ { i = 1 } ^ { k } ( \mathbf { Z } _ { i } \mathbb { I } \{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \} - \mathbf { Z } _ { 1 } \mathbb { I } \{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { 1 } \} ) ) ( \displaystyle \sum _ { i = 1 } ^ { k } ( \mathbf { Z } _ { i } \mathbb { I } \{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \} - \mathbf { Z } _ { 1 } \mathbb { I } \{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { 1 } \} ) )  } \\ & { \displaystyle  \mathrm { ~ } \displaystyle \mathrm { ~ } \mathrm { ~ } \displaystyle \mathrm { ~ } z k ^ { 2 } \mathbb { E } [ \mathbf { Z } \mathbf { Z } ^ { \top } ] + k \mathbb { E } [ \mathbf { Z } ( \displaystyle \sum _ { i = 1 } ^ { k } ( \mathbf { Z } _ { i } \mathbb { I } \{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \} - \mathbf { Z } ) ) ^ { \top } ] } \\ & { + \displaystyle k \mathbb { E } [ ( \displaystyle \sum _ { i = 1 } ^ { k } ( \mathbf { Z } _ { i } \mathbb { I } \{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \} - \mathbf { Z } ) ) \mathbf { Z } ^ { \top } ] } \end{array}
+$$
+
+Note because $\mathbf { Z } _ { i } \mathbf { s }$ have unit norm and by law of cosines $\begin{array} { r } { \| \mathbf { Z } \left( \mathbf { Z } _ { i } \mathbb { I } \left\{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \right\} - \mathbf { Z } \right) \| _ { o p } \leq 2 ( 1 - \mathbf { \alpha } } \end{array}$ $\cos \rho )$ ). Therefore,
+
+$$
+r _ { \mathrm { m i n } } \left( \mathbb { E } \left[ \left( \sum _ { i = 1 } ^ { d } \mathbf { Z } _ { i } \mathbb { I } \left\{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \right\} \right) \left( \sum _ { i = 1 } ^ { d } \mathbf { Z } _ { i } \mathbb { I } \left\{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } \right\} \right) ^ { \top } \right] \right) \geq k ^ { 2 } ( \gamma _ { 1 } ( \phi _ { 0 } ) - 4 ( 1 - \cos \rho ) ) .
+$$
+
+Now we prove the upper bound of $L _ { \mathrm { c r o s s } }$ . Notice that
+
+$$
+\begin{array} { r } { \left\| \mathbb { E } \left[ \mathbf { Z } _ { i } \mathbf { Z } _ { j } ^ { \top } \mathbb { I } \left\{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { j } \right\} \right] \right\| _ { 2 } \leq \mathbb { E } \left[ \| \mathbf { Z } _ { i } \| _ { 2 } \| \mathbf { Z } _ { j } \| _ { 2 } \mathbb { I } \left\{ S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { j } \right\} \right] } \\ { = \int _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { j } } \left( \int _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } } \mathrm { d } \mathbb { P } \left( \mathbf { Z } _ { i } | \mathbf { Z } _ { j } \right) \right) \mathrm { d } \mathbb { P } \left( \theta _ { j } \right) . } \end{array}
+$$
+
+If $\phi \leq \psi$ , then by our assumption, we have
+
+$$
+\int _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { j } } \left( \int _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } } { \mathrm { d } } \mathbb { P } \left( \mathbf { Z } _ { i } | \mathbf { Z } _ { j } \right) \right) { \mathrm { d } } \mathbb { P } \left( \theta _ { j } \right) \leq \int _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { j } } { \mathrm { d } } \mathbb { P } \left( \mathbf { Z } _ { j } \right) \leq L \phi .
+$$
+
+On the other hand, if $\phi \geq \gamma$ , let $\theta _ { j }$ be the angle between $\mathbf { w } _ { \ast }$ and $\mathbf { Z } _ { j }$ , we have
+
+$$
+\begin{array} { r l } & { \displaystyle \int _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) _ { j } } \left( \int _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } } { \mathrm { d } \mathbb { P } } ( \mathbf { Z } _ { i } | \mathbf { Z } _ { j } ) \right) { \mathrm { d } \mathbb { P } } \left( \theta _ { j } \right) \leq \int _ { \frac { \pi } { 2 } } ^ { \frac { \pi } { 2 } + \gamma } \left( \int _ { S ( \mathbf { w } , \mathbf { w } _ { * } ) _ { i } } { \mathrm { d } \mathbb { P } } ( \mathbf { Z } _ { i } | \mathbf { Z } _ { j } ) \right) { \mathrm { d } \mathbb { P } } \left( \theta _ { j } \right) } \\ & { \qquad \leq L \gamma } \\ & { \qquad \leq L \phi . } \end{array}
+$$
+
+Therefore, $\begin{array} { r } { \sigma _ { \operatorname* { m a x } } \left( { \mathbb E } \left[ { \mathbf { Z } } _ { S ( { \mathbf { w } } , { \mathbf { w } } _ { \ast } ) } { \mathbf { Z } } _ { S ( { \mathbf { w } } , - { \mathbf { w } } _ { \ast } ) } ^ { \top } \right] \right) ~ \leq ~ L \phi } \end{array}$ . Using similar arguments we can show $\sigma _ { \operatorname* { m a x } } \left( { \mathbb E } \left[ { \mathbf Z } _ { S ( { \mathbf w } , { \mathbf w } _ { \ast } ) } { \mathbf Z } _ { S ( - { \mathbf w } , { \mathbf w } _ { \ast } ) } \right] \right) \leq L \phi$ and $\begin{array} { r } { \ ' \sigma _ { \operatorname* { m a x } } \left( \mathbb { E } \left[ \mathbf { Z } _ { S ( \mathbf { w } , - \mathbf { w } _ { * } ) } \mathbf { Z } _ { S ( - \mathbf { w } , \mathbf { w } _ { * } ) } \right] \right) \leq L \phi . } \end{array}$
+
+Proof of Theorem 3.4. We use the same argument by Tian (2017). Let $r _ { i n i t }$ be the initialization radius. The failure probability is lower bounded
+
+$$
+\frac { 1 } { 2 } \left( r _ { i n i t } \right) - \frac { \left( \frac { r _ { i n i t } ^ { 2 } } { 2 \left\| \mathbf { w } _ { * } \right\| _ { 2 } } + \frac { \left\| \mathbf { w } _ { * } \right\| _ { 2 } \cos \left( \phi _ { * } \right) } { 2 } \right) \delta V _ { k - 1 } \left( r _ { i n i t } \right) } { V _ { k } \left( r _ { i n i t } \right) } .
+$$
+
+Therefore, $r _ { i n i t } = \cos \left( \phi _ { * } \right) \left\| \mathbf { w } _ { * } \right\| _ { 2 }$ maximizes this lower bound. Plugging this optimizer in and using formula for the volume of the Euclidean ball, the failure probability is lower bounded by
+
+$$
+\frac { 1 } { 2 } - \cos \left( \phi _ { * } \right) \frac { \pi \Gamma \left( p / 2 + 1 \right) } { \Gamma \left( p / 2 + 1 / 2 \right) } \geq \frac { 1 } { 2 } - \cos \left( \phi _ { * } \right) \sqrt { \frac { \pi p } { 2 } }
+$$
+
+where we used Gautschi’s inequality for the last step.
+
+# B ADDITIONAL EXPERIMENTAL RESULTS
+
+Figure 5 show the loss of linear interpolation between the learned filter $w$ and ground truth filter $w _ { * }$ .   
+Our interpolation has the form $w _ { i n t e r } = \alpha w + ( 1 - \alpha ) w _ { * }$ where $\alpha \in [ 0 , 1 ]$ is the interpolation ratio.   
+Note that for all interpolation ratios, the loss remains very low.
+
+![](images/a5c0df32527337837c339d9b0f513d7729e8ae751b49ef02e7b20cf0c423ec1e.jpg)  
+Figure 5: Loss of linear interpolation between learned filter and the true filter.

parse/train/SkZxCk-0Z/SkZxCk-0Z.md

@@ -0,0 +1,452 @@
+# CAN NEURAL NETWORKS UNDERSTAND LOGICAL ENTAILMENT?
+
+Richard Evans∗
+
+David Saxton∗
+
+David Amos
+
+Pushmeet Kohli
+
+Edward Grefenstette∗   
+DeepMind   
+{richardevans,saxton,davidamos,pushmeet,etg}@google.com
+
+# ABSTRACT
+
+We introduce a new dataset of logical entailments for the purpose of measuring models’ ability to capture and exploit the structure of logical expressions against an entailment prediction task. We use this task to compare a series of architectures which are ubiquitous in the sequence-processing literature, in addition to a new model class—PossibleWorldNets—which computes entailment as a “convolution over possible worlds”. Results show that convolutional networks present the wrong inductive bias for this class of problems relative to LSTM RNNs, treestructured neural networks outperform LSTM RNNs due to their enhanced ability to exploit the syntax of logic, and PossibleWorldNets outperform all benchmarks.
+
+# 1 INTRODUCTION
+
+This paper seeks to answer two questions: “Can neural networks understand logical formulae well enough to detect entailment?”, and, more generally, “Which architectures are best at inferring, encoding, and relating features in a purely structural sequence-based problem?”. In answering these questions, we aim to better understand the inductive biases of popular architectures with regard to structure and abstraction in sequence data. Such understanding would help pave the road to agents and classifiers that reason structurally, in addition to reasoning on the basis of essentially semantic representations. In this paper, we provide a testbed for evaluating some aspects of neural networks’ ability to reason structurally and abstractly. We use it to compare a variety of popular network architectures and a new model we introduce, called PossibleWorldNet.
+
+Neural network architectures lie at the heart of a variety of applications. They are practically ubiquitous across vision tasks (LeCun et al., 1995; Krizhevsky et al., 2012; Simonyan & Zisserman, 2014) and natural language understanding, from machine translation (Kalchbrenner & Blunsom, 2013; Sutskever et al., 2014; Bahdanau et al., 2014) to textual entailment (Bowman et al., 2015; Rocktaschel et al., 2015) via sentiment analysis (Socher et al., 2013; Kalchbrenner et al., 2014) and ¨ reading comprehension (Hermann et al., 2015; Hill et al., 2015; Rajpurkar et al., 2016). They have been used to synthesise programs (Ling et al., 2016; Parisotto et al., 2016; Devlin et al., 2017) or internalise algorithms (Graves et al., 2016; Grefenstette et al., 2015; Joulin & Mikolov, 2015; Kaiser & Sutskever, 2015; Reed & De Freitas, 2015). They form the basis of reinforcement learning agents capable of playing video games (Mnih et al., 2015), difficult perfect information games (Silver et al., 2016; Tian & Zhu, 2015), and navigating complex environments from raw pixels (Mirowski et al., 2016). An important question in this context is to find the inductive and generalisation properties of different neural architectures, particularly towards the ability to capture structure present in the input, an ability that might be important for many language and reasoning tasks. However, there is little work on studying these inductive biases in isolation by running these models on tasks that are primarily or purely about sequence structure, which we intend to address.
+
+The paper’s contribution is three-fold. First, we introduce a new dataset for training and evaluating models. Second, we provide a thorough evaluation of the existing neural models on this dataset. Third, inspired by the semantic (model-theoretic) definition of entailment, we propose a variant of the TreeNet that evaluates the formulas in multiple different “possible worlds”, and which significantly outperforms the benchmarks. The structure of this paper is as follows. In Section 2, we introduce the new dataset and describe a generic data generation process for entailment datasets, which offers certain guarantees against the presence of superficial exploitable biases. In Section 3, we describe a series of baseline models used to validate the dataset, benchmarks from which we will derive our analyses of popular model architectures, and also introduce our new neural model, the PossibleWorldNet. In Section 4, we describe the structure of experiments, from which we obtained the results presented and discussed in Section 5. We offer a brief survey of related work in Section 6, before making concluding remarks in Section 7.
+
+# 2 DATASET CREATION
+
+Formal logics provide a symbolic toolkit for encoding and examining patterns of reasoning. They are structural calculi aiming to codify the norms of correct thought. The meanings of such statements are invariant to what the particular propositions stand for: to understand the entailment $( p \land q ) \models q$ , we only need to understand the semantics of—or related syntactic rules governing—a finite set of logical connectives, while $p$ and $q$ are meaningless arbitrary symbols selected to stand for distinct propositions. In other words, the problem of determining whether an entailment holds is a purely structural sequence-based problem: to evaluate whether an entailment is true, only the meaning of— or inference rules governing—the connectives is relevant. Everything else only has meaning via its place in the structure specified by an expression. These qualities suggest that detecting logical entailment is an excellent task for measuring the ability of models to capture, understand, or exploit structure. We present in this paper a generic process for generating entailment datasets, explained in detail in Appendix A, for any given logical system. In the specific dataset—generated through this process—presented in this section, we will focus on propositional logic, which is decidable but requires a worst case of $O ( 2 ^ { n } )$ operations (e.g. resolution steps, truth table rows), where $n$ is the number of unique propositional variables, to verify entailment.
+
+Our dataset∗ $\mathcal { D }$ is composed of triples of the form $( A , B , A \models B )$ , where $A$ and $B$ are formulas of propositional logic, and $A \models B$ is 1 if $A$ entails $B$ , and 0 otherwise. For example, the data point $( p \land q , q , 1 )$ is positive because $p \wedge q$ entails $q$ , whereas $( q \vee r , r , 0 )$ is negative because $q \vee r$ does not entail $r$ . Entailment is primarily a semantic notion: $A$ entails $B$ if every model in which $A$ is true is also a model in which $B$ is true.
+
+We impose various requirements on the dataset, to rule out superficial structural differences between $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ that can be easily exploited by “trivial” baselines†. We impose the following high level constraints on our data through the generative process, explained in detail in Appendix A: our classes must be balanced, and formulas in positive and negative examples must have the same distribution over length. Furthermore, we attempt to ensure that there are no recognisable differences in the distributions of lexical or syntactic features between the positive and negative examples. It would not be acceptable, for example, if a typical $B$ formula in a positive entailment $( A , B , 1 )$ had more disjunctions than a $B ^ { \prime }$ formula in a negative entailment $( A ^ { \prime } , B ^ { \prime } , 0 )$ .
+
+If we simply sample formulas $A$ and $B$ and evaluate whether $A \models B$ , there are significant differences between the distributions of formulas for the positive and negative examples, which models can learn to exploit without needing to understand the structure of the problem. To avoid these issues, we use a different approach, that satisfies the above requirements. We sample 4-tuples of formulas $\left( A _ { 1 } , B _ { 1 } , A _ { 2 } , B _ { 2 } \right)$ such that:
+
+$$
+A _ { 1 } \models B _ { 1 } \qquad A _ { 2 } \models B _ { 2 } \qquad A _ { 1 } \uplus B _ { 2 } \qquad A _ { 2 } \uplus B _ { 1 }
+$$
+
+Here, each of the four formulas appears in one positive entailment and one negative entailment. This way, we minimise crude structural differences between the positive and negative examples. Here is a simple example (although the actual dataset has much longer formulas) of such a 4-tuple of datapoints:
+
+$$
+p \models p \lor q \qquad \neg p \land \neg q \models \neg q \qquad p \nmid \nleftarrow q \qquad \neg p \land \neg q \nmid \nleftarrow p \lor q
+$$
+
+Table 1: Dataset Statistics   
+
+<table><tr><td></td><td>Size</td><td>Mean # Vars</td><td>Mean # Ops</td><td>Mean Length</td><td>Mean 2# Vars</td></tr><tr><td>Train</td><td>100,000</td><td>4.5</td><td>5.3</td><td>11.3</td><td>52.2</td></tr><tr><td>Validate</td><td>5,000</td><td>5.1</td><td>6.8</td><td>13.0</td><td>75.7</td></tr><tr><td>Test (easy)</td><td>5,000</td><td>5.2</td><td>6.9</td><td>13.1</td><td>81.0</td></tr><tr><td>Test (hard)</td><td>5,000</td><td>5.8</td><td>17.4</td><td>31.5</td><td>184.4</td></tr><tr><td>Test (big)</td><td>5,000</td><td>8.0</td><td>20.9</td><td>38.7</td><td>3310.8</td></tr><tr><td>Test (massive)</td><td>2,230</td><td>18.4</td><td>49.4</td><td>88.8</td><td>848,570.0</td></tr><tr><td>Test (exam)</td><td>100</td><td>2.4</td><td>3.9</td><td>8.6</td><td>5.8</td></tr></table>
+
+To generate these 4-tuples, we first generate pairs $( A , B )$ such that $A \models B$ . (To test if $A \models B$ , we test whether $A \land \lnot B$ is satisfiable, using minisat (Sorensson & Een, 2005)). Then we search through the set of pairs, looking for pairs of pairs, $( A _ { 1 } , B _ { 1 } )$ and $( A _ { 2 } , B _ { 2 } )$ , such that $A _ { 1 } \nvDash B _ { 2 }$ and $A _ { 2 } \nvDash B _ { 1 }$ . We present, in Appendix A, the full details of this generative process, its constraints and guarantees, and how we used particular baselines to validate the data.
+
+# 2.1 SPLITTING THE DATASET
+
+We produced train, validation, and test (easy) by generating one large set of 4-tuples, and splitting them into groups of sizes 100000, 5000, and 5000. The difficulty of evaluating an entailment depends on the number of propositional variables and the number of operators in the two formulas. In training, validation, and test (easy), we sample the number of propositional variables uniformly between 1 and 10 (there are 26 propositional variables in total: $a$ to $z$ ). In test (hard), we sample uniformly between 5 and 10. Our formula sampling method takes a parameter specifying the desired number of operators in the formula. In training, validation, and test (easy), the number of operators in a formula is sampled uniformly between 1 and 10. In our hard test set, the number of operators in a formula is sampled uniformly between 15 and 20.
+
+For the test (big) dataset, we sampled formulas using between 1 and 20 variables (uniformly), and between 10 and 30 operators (again, uniformly). For test (massive), we used a different generating mechanism. We first sampled pairs of formulas $A$ , $B$ such that $A \models B$ . These had between 20 and 26 variables, and between 20 and 30 operators each. Then we generated a $B ^ { * }$ by mutating $B$ and checking that $A \nvDash B ^ { * }$ . See Table 1 for detailed statistics of the dataset sections, including the average difficulty (based on a complexity of $O ( 2 ^ { \# \operatorname { V a r s } } ) )$ of sequents in each fold.
+
+The test (exam) dataset was assembled from 100 examples of logical entailment in the wild. We looked through various logic textbooks for classic examples of entailments. From these textbooks, we extracted true entailment triples $( A , B , 1 )$ where $A \models B$ . We added false triples $( A , B ^ { * } , 0 )$ , by mutating $B$ into $B ^ { * }$ and checking that $A \nvDash B ^ { * }$ .
+
+In order to test models’ ability to generalise to new unseen formulas, we pruned out cases where formulas seen in validation and test were $\alpha$ -equivalent (equivalent up to renaming of symbols) to formulas seen in training. So, for example, if it had seen $p \Vdash ( \neg q \land p )$ in training, we did not want $r \Vdash ( \neg s \land r )$ to appear in either the test or validation sets. To do this, we converted all formulas to de-Bruijn form (see Pierce (2002), Chapter 6), and filtered out formulas in validation and test whose de-Bruijn form was identical to one of those in training. This prevents the system from being able to simply memorise examples it has seen in training.
+
+# 2.2 DATA AUGMENTATION THROUGH SYMBOLIC VOCABULARY PERMUTATION
+
+As discussed above, the logical connectives $( \vee , \wedge , \dots )$ are the only elements of the language in each dataset that have consistent implicit semantics across expressions. In this sense, two entailments $p \wedge q \vdash q$ and $a \wedge b \mapsto b$ should ideally be treated as identical by the model. To encourage models to capture this invariance, we add an optional data processing layer during training (not testing) whereby symbols are consistently replaced by other symbols of the same type within individual entailments before being input to the network according to the process described below. This is achieved by randomly sampling a permutation of $a , \ldots , z$ (the propositional variables used) for every training example, and applying this permutation to the left and right sequents. This process is analogous to augmenting image classification training with random reflections and crops.
+
+# 3 MODELS
+
+In this section, we first describe a couple of baseline models that verify the basic difficulty of the dataset, followed by a description of benchmark models which are commonly used (with some variation) in a variety of problems, and finally by a description of our new model, PossibleWorldNet.
+
+# 3.1 BASELINES
+
+The classes in the dataset are balanced in training, validation, and both test sets, so a random baseline (and a constant, majority-class predicting baseline) will obtain an accuracy of $50 \%$ on the test sets.
+
+We define two neural baselines which, we believe, should not be able to perform competitively on this task, but may do better than random. The first is a linear bag of words (Linear BoW) model which embeds each symbol to a vector, and averages them, to produce a representation of each side of the sequent. These representations are then passed through a linear layer:
+
+$$
+P ( A \models B ) = \sigma \left( W \cdot \mathsf { c o n c a t } \left( g ( A ) , g ( B ) \right) + b \right) \quad \mathrm { w h e r e } \quad g ( X ) = \frac { 1 } { | X | } \sum _ { x \in X } \mathsf { e m b e d } ( x )
+$$
+
+The second is a similar architecture, where the final linear layer is replaced with a multi-layer perceptron (MLP BoW):
+
+$$
+P ( A \models B ) = \sigma ( { \mathrm { M L P } } ( \operatorname { c o n c a t } \left( g ( A ) , g ( B ) \right) ) ) \quad { \mathrm { w h e r e } } \quad g ( X ) = { \frac { 1 } { | X | } } \sum _ { x \in X } { \mathrm { e m b e d } } ( x )
+$$
+
+In both of these cases, the baselines are expected to have limited performance since they can only capture entailment by modelling the contribution of symbols individually, rather than by modelling structure, since the summation in $g$ destroys all structural information (including word order). We use these results to provide an indication of the difficulty of the dataset.
+
+# 3.2 BENCHMARKS
+
+We present here a series of benchmark models, not only to serve the purpose of being grounds for comparison for new models tested against this dataset, but also to compare and contrast the performance of fairly ubiquitous model architectures on this purely syntactic problem.
+
+We distinguish two categories of models: encoding models and relational models. Encoding models, with exceptions specified below, jointly learn an encoding function $f$ and an MLP, such that given a sequent $A \models B$ , the model expresses
+
+$$
+P ( A \models B ) = \sigma \left( \operatorname { M L P } ( \operatorname { c o n c a t } ( f ( A ) , f ( B ) ) ) \right) .
+$$
+
+In this sense $f$ produces a representation of each side of the sequent which contains all the information needed for the MLP to decide on entailment. In contrast, relational models will observe the pair of expressions and make a decision, perhaps by traversing both expressions, or by relating substructure of one expression to that of the other. These models express a more general formulation
+
+$$
+P ( A \models B ) = \sigma \left( f ( A , B ) \right) .
+$$
+
+# 3.2.1 ENCODER BENCHMARKS
+
+The first encoder benchmark implemented is a Deep Convolutional Network Encoder (ConvNet Encoders), akin to architectures described in the convolutional networks for text literature (Kalchbrenner et al., 2014; Zhang et al., 2015; Kim et al., 2016). Here, the encoder function $f$ is a stack of one dimensional convolutions over sequence symbols embedded by an embedding operation embedSeq, interleaved with max pooling layers every $k$ layers (which is a model hyperparameter), followed by $n$ (also a hyperparameter) fully connected layers:
+
+$$
+f ( X ) = \mathbf { M L P } ( \mathbf { C o n v 1 D } _ { n } ( . . . \mathbf { m a x P o o l } ( \mathbf { C o n v 1 D } _ { k } ( . . . \mathbf { C o n v 1 D } _ { 1 } ( \mathbf { e m b e d S e q } ( X ) ) ) . . . ) ) . . ) )
+$$
+
+The second and third encoder benchmarks are an LSTM (Hochreiter & Schmidhuber, 1997) encoder network (LSTM Encoders), and its bidirectional LSTM variant (BiDirLSTM Encoders). For the LSTM encoder, we embed the sequence symbols, and run an LSTM RNN over them, ignoring the output until the final state:
+
+$$
+f ( X ) = h _ { \mathrm { f i n a l } } \quad \mathrm { w h e r e } \quad h _ { \mathrm { f i n a l } } = \mathrm { L S T M } ( \mathrm { e m b e d S e q } ( X ) )
+$$
+
+For the bidirectional variant, two separate LSTM RNNs ${ \mathrm { L S T M } } ^ {  }$ and $\mathrm { L S T M } ^ {  }$ are run over the sequence in opposite directions. Their respective final states are concatenated to form a representation of the expression:
+
+$$
+\begin{array} { r } { \begin{array} { r l } { f ( X ) = \mathrm { c o n c a t } ( h _ { \mathrm { f i n a l } } ^ { \left. } , h _ { \mathrm { f i n a l } } ^ { \right. } ) } & { \mathrm { w h e r e } \quad h _ { \mathrm { f i n a l } } ^ { \left. } = \mathrm { L S T M } ^ { \left. } ( \mathrm { e m b e d S e q } ( X ) ) } \\ { \mathrm { a n d } \quad h _ { \mathrm { f i n a l } } ^ { \right. } = \mathrm { L S T M } ^ { \right. } ( \mathrm { e m b e d S e q } ( X ) ) } \end{array} } \end{array}
+$$
+
+The benchmarks described thus far do not explicitly condition on structure, even when it is known, as they are designed to traverse a sequence from left to right and model dependencies in the data implicitly. In contrast, we now consider encoder benchmarks which rely on the provision of the syntactic structure of the sequence they encode, and exploit it to determine the order of composition. This inductive bias, which may be incorrect in certain domains (e.g., where no syntax is defined) or difficult to achieve in domains such as natural language text (where syntactic structure is latent and ambiguous), is easy to achieve for logic (where the syntax is known). The experiments below will seek to demonstrate whether is a helpful inductive architectural bias.
+
+The fourth and fifth encoding benchmarks are (tree) recursive neural networks (Tai et al., 2015; Le & Zuidema, 2015; Zhu et al., 2015; Allamanis et al., 2016), also known as TreeRNNs. These recursively encode the logical expression using the parse structure‡, where leaf nodes of the tree (propositional variables) are embedded as learnable vectors, and each logical operator then combines one or more of these embedded values to produce a new embedding. For example, the expression $( \neg a ) \lor b$ is parsed as the tree with leaves $a$ and $b$ , a unary node $\neg$ (with input the embedding of $a$ ), and a binary node $\vee$ (with inputs the embeddings of $\neg a$ and $b$ ). Following Allamanis et al. (2016), the fourth encoding benchmark is a simple TreeRNN (TreeNet Encoders), where each operator ‘op’ concatenates its inputs to a vector $x$ , and produces the output
+
+$$
+p = { \frac { h } { \| h \| _ { 2 } } } \quad { \mathrm { w h e r e } } \quad h = W _ { 1 } ^ { \mathrm { o p } } x + W _ { 2 } ^ { \mathrm { o p } } \sigma ( W _ { 3 } ^ { \mathrm { o p } } x + b _ { 3 } ^ { \mathrm { o p } } ) + b _ { 1 } ^ { \mathrm { o p } } .
+$$
+
+The fifth and final encoding benchmark (TreeLSTM Encoders) is a variant of TreeRNNs which adapts LSTM cell updates. This helps capture long range dependencies and propagate gradient within the tree. Our implementation follows Tai et al. (2015), modified to have per-op parameters as per TreeRNNs (see, also, the work by Le & Zuidema (2015) and Zhu et al. (2015)).
+
+# 3.2.2 RELATIONAL BENCHMARKS
+
+In addition to these encoding benchmarks, we define a pair of relational benchmarks, following Rocktaschel et al. (2015). We will traverse the entire sequent with LSTM RNNs or bidirectional ¨ LSTM RNNs but concatenating the left hand side and right hand side sequences into a single sequence separated by a held-out symbol (effectively standing for $\vDash$ ). For the LSTM variant (LSTM Traversal), the model is:
+
+$$
+P ( A \models B ) = \sigma ( \mathbf { M L P } ( h _ { \mathrm { f i n a l } } ) ) \quad \mathrm { w h e r e } \quad h _ { \mathrm { f i n a l } } = \mathbf { L S T M } ( \mathrm { e m b e d S e q } ( \mathrm { j o i n } ( A , \mathrm { ^ { c } \vdash ^ { \circ } , } B ) ) )
+$$
+
+For the bidirectional case (BiDirLSTM Traversal), the extension is
+
+$$
+\begin{array} { r l } { P ( A \models B ) = \sigma ( \mathbf { M L P } ( h _ { \mathrm { f i n a l } } ^ {  } ) ) } & { \mathrm { w h e r e } \quad h _ { \mathrm { f i n a l } } ^ {  } = \mathrm { c o n c a t } ( h _ { \mathrm { f i n a l } } ^ {  } , h _ { \mathrm { f i n a l } } ^ {  } ) } \\ & { \mathrm { w i t h } \quad h _ { \mathrm { f i n a l } } ^ {  } = \mathbf { L S T M } ^ {  } ( \mathrm { e m b e d S e q } ( X ) ) } \\ & { \mathrm { a n d } \quad h _ { \mathrm { f i n a l } } ^ {  } = \mathbf { L S T M } ^ {  } ( \mathrm { e m b e d S e q } ( X ) ) } \end{array}
+$$
+
+# 3.2.3 THE TRANSFORMER BENCHMARK
+
+We also benchmark the Transformer model, also known as Attention Is All You Need (Vaswani et al., 2017), which is a sequence-to-sequence model achieving state-of-the-art results in machine translation. As in the relational LSTM models, we concatenate and embed the sequents, but instead of separating the sequents by a held-out symbol, we add a learnable bias to the right sequent in this embedding. This augments the Transformer’s method of adding timing signals to distinguishing symbols at different positions. We then decode a sequence of length 1 and apply a linear transformation to get the final entailment prediction logits.
+
+# 3.3 THE POSSIBLEWORLDNET
+
+In this section, we introduce our new model. Inspired by the semantic (model-theoretic) definition of entailment, we propose a variant on TreeNets that evaluates the pair of formulas in different “possible worlds”.
+
+Entailment is, first and foremost, a semantic notion. Given a set $\mathcal { W }$ of worlds,
+
+Here $s a t : W o r l d \times F o r m u l a  B o o l$ indicates whether a formula is satisfied in a particular world.
+
+We shall first define a variant of sat that produces integers, and then define another variant that operates on real values. First, define $s a t _ { 2 } : W o r l d \times F o r m u l a  \{ 0 , 1 \}$ :
+
+$$
+s a t _ { 2 } ( w , A ) = \mathbb { 1 } ( s a t ( w , A ) )
+$$
+
+Using $s a t _ { 2 }$ , we can redefine entailment as:
+
+$$
+A \models B \operatorname { i f f } \forall w \in \mathcal { W } s a t _ { 2 } ( w , A ) \leq s a t _ { 2 } ( w , B )
+$$
+
+Assume we have a finite set of worlds ${ \mathcal { W } } = \{ w _ { 1 } , . . . , w _ { n } \}$ ; then we can recast as:
+
+$$
+P ( A \mid = B ) = \prod _ { i = 1 } ^ { n } \mathbb { 1 } ( s a t _ { 2 } ( w _ { i } , A ) \leq s a t _ { 2 } ( w _ { i } , B ) )
+$$
+
+We are going to produce a relaxation of Proposition 1 by replacing $s a t _ { 2 }$ and $\leq$ with continuous functions. Assume we have a variant of $s a t _ { 2 }$ that produces vectors of real values:
+
+$$
+s a t _ { 3 } : W o r l d \times F o r m u l a  \mathbb { R } ^ { d }
+$$
+
+Assume we have a function $f : \mathbb { R } ^ { d } \times \mathbb { R } ^ { d }  [ 0 , 1 ]$ that generalises $\leq$ to vectors of real values. Now we can rewrite as:
+
+$$
+P ( A \left| = B \right. ) = \prod _ { i = 1 } ^ { n } f ( s a t _ { 3 } ( w _ { i } , A ) , s a t _ { 3 } ( w _ { i } , B ) )
+$$
+
+In our neural model, $f$ is implemented by a simple linear layer using learnable weights $W _ { f }$ and $b _ { f }$ :
+
+$$
+f ( x , y ) = \sigma ( W _ { f } \cdot \operatorname { c o n c a t } ( x , y ) + b _ { f } )
+$$
+
+We use a set of random vectors to represent our worlds $\{ w _ { 1 } , . . . , w _ { n } \}$ , where $w _ { i } \in \mathbb { R } ^ { k }$ is a vector of length $k$ of values drawn uniformly randomly. We implement $s a t _ { 3 }$ using a simplified TreeNN (see Section 3.2) as described below. Since $s a t _ { 3 }$ depends on the particular world $w _ { i }$ we are currently evaluating, we add an additional parameter to the TreeNN so that the embedder has access to the current world $w _ { i }$ . We add an additional weight matrix $W _ { 4 } ^ { o p }$ so that propositional variables can learn which aspect of the current world to focus on. If the formula is of the form $o p ( l , r )$ , where $o p$ is nullary (a propositional variable), unary (e.g., negation), or binary (e.g., conjunction), and $l$ and $r$ are the embeddings of the constituents of the expression, then
+
+$$
+s a t _ { 3 } ( w _ { i } , o p ( l , r ) ) = \frac { h } { \| h \| _ { 2 } } \quad \mathrm { w h e r e } \quad h = \left\{ \begin{array} { l l } { W _ { 4 } ^ { o p } w _ { i } } & { \mathrm { w h e r e ~ } o p \mathrm { ~ i s ~ n u l l a r y ~ ( l e a f ) } } \\ { W _ { 1 } ^ { o p } x + b _ { 1 } ^ { o p } } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+where $x = \mathrm { c o n c a t } ( l , r )$ .
+
+To evaluate whether $A \models B$ , the PossibleWorldNet generates a set of imagined “worlds”, and then evaluates $A$ and $B$ in each of those worlds. It is a form of “convolution over possible worlds”. As we will see in Section 5, the quality of the model increases steadily as we increase the number of imagined worlds.
+
+This architecture was inspired by semantic (model-theoretic) approaches to detecting entailment, but it does not encode any constraint on propositional logic in particular or formal logic in general. The procedure of evaluating sentences in multiple worlds, and combining those evaluations in one product, is just what “entailment” means; so we speculate that an architecture like this should, in principle, be equally applicable to other logics (e.g., intuitionistic logic, modal logics, first-order logic) and also to non-formal entailments in natural language sentences.
+
+Abstracting away from the particular interpretation of these vectors as “worlds”, this method generates $n$ copies of the model with shared weights, one for each vector $w _ { i }$ ; each nullary operator learns a different projection on $w _ { i }$ . It makes predictions via a linear layer combining two representations, and then takes the product of the predictions as the overall prediction.
+
+# 4 EXPERIMENTAL SETUP
+
+For each encoder benchmark architecture, the parameters of the encoders for the left and right hand sides of the sequent are shared. The MLP which performs binary classification to detect entailment based on the expression representations produced by the encoders is model-specific (re-initialised for each model) and jointly trained. Symbol embedding matrices are also model-specific, shared across encoders, and jointly trained.
+
+We implemented all architectures in TensorFlow (Abadi et al., 2016). We optimised all models with Adam (Kingma & Ba, 2014). We grid searched across learning rates in $[ 1 \mathrm { e } { - } 5 , 1 \mathrm { e } { - } 4 , 1 \mathrm { e } { - } 3 ]$ , minibatch sizes in [64, 128], and trained each model thrice with different random seeds. Per architecture, we grid-searched across specific hyperparameters as follows. We searched across 2 and 3 layer MLPs wherever an MLP existed in a benchmark, and across layer sizes in [32, 64] for MLP hidden layers, embedding sizes, and RNN cell size (where applicable). Additionally for convolutional networks, we searched across a number of convolutional layers in [4, 6, 8], across kernel size in [5, 7, 9], across number of channels in [32, 64], and across pooling interval in $[ 0 , 5 , 3 , 1 ]$ (where 0 indicates no pooling). For the Transformer model, we searched across the number of encoder and decoder layers in the range [6, 8, 10], dropout probability in the range $[ 0 , 0 . 1 , 0 . 5 ]$ , and filter size in the range [128, 256, 384]. Finally, for all models, we ran them with and without the symbol permutation data augmentation technique described in Section 2.2.
+
+As a result of the grid search, we selected the best model for each architecture against validation results, and record training, validation, and all test accuracies for the associated time step, which we present below.
+
+# 5 RESULTS AND DISCUSSION
+
+Experimental results are shown in Table 2. The test scores of the best performing overall model are indicated in bold. The test scores of the best performing model which does not have privileged access to the syntax or semantics of the logic (i.e. excluding TreeRNN-based models) are italicised. The best benchmark test results are underlined.
+
+We observe that the baselines are doing better than random (8.2 points above for the easy test set, for the MLP BoW, and 2.6 above random for the hard test set). This indicates that there are some small number of exploitable regularities at the symbolic level in this dataset, but that they do not provide significant information.
+
+The baseline results show that convolution networks and BiDirLSTMs encoders obtain relatively mediocre results compared to other models, as do LSTM and BiDirLSTM Traversal models. LSTM encoders is the best performing model which does not have privileged access to the syntax trees. Their success relative to BiDirLSTMs Encoders could be due to their reduced number of parameters guarding against overfitting, and rendering them easier to optimise, but it is plausible BiDirLSTMs Encoders would perform similarly with a more fine-grained grid search. Both tree-based models take the lead amongst the benchmarks, with the TreeLSTM being the best performing benchmark overall on both test sets. For most models except baselines, the symbol permutation data augmentation yielded 2–3 point increase in accuracy on weaker models (BiDirLSTM encoders and traversals, an convolutional networks) and between 7–15 point increases for the Tree-based models. This indicates that this data augmentation strategy is particularly well fitted for letting structure-aware models capture, at the representational level, the arbitrariness of symbols indicating unbound variables.
+
+Table 2: Propositional Logic Model Accuracy.   
+
+<table><tr><td colspan="2">model</td><td>valid</td><td>test (easy)</td><td>test (hard)</td><td>test (big)</td><td>test (massive)</td><td>test (exam)</td></tr><tr><td rowspan="2">baselines</td><td>Linear BoW</td><td>52.6</td><td>51.4</td><td>50.0</td><td>49.7</td><td>50.0</td><td>52.0</td></tr><tr><td>MLP BoW</td><td>57.8</td><td>57.1</td><td>51.0</td><td>55.8</td><td>49.9</td><td>56.0</td></tr><tr><td rowspan="8">benchmark models</td><td>Transformer</td><td>57.1</td><td>56.8</td><td>50.8</td><td>51.2</td><td>50.3</td><td>46.9</td></tr><tr><td>ConvNet Encoders</td><td>59.3</td><td>59.7</td><td>52.6</td><td>54.9</td><td>50.4</td><td>54.0</td></tr><tr><td>LSTM Encoders</td><td>68.3</td><td>68.3</td><td>58.1</td><td>61.1</td><td>52.7</td><td>70.0</td></tr><tr><td>BiDirLSTM Encoders</td><td>66.6</td><td>65.8</td><td>58.2</td><td>61.5</td><td>51.6</td><td>78.0</td></tr><tr><td>TreeNet Encoders</td><td>72.7</td><td>72.2</td><td>69.7</td><td>67.9</td><td>56.6</td><td>85.0</td></tr><tr><td>TreeLSTMEncoders</td><td>79.1</td><td>77.8</td><td>74.2</td><td>74.2</td><td>59.3</td><td>75.0</td></tr><tr><td>LSTMTraversal</td><td>62.5</td><td>61.8</td><td>56.2</td><td>57.3</td><td>50.6</td><td>61.0</td></tr><tr><td>BiDirLSTMTraversal</td><td>63.3</td><td>64.0</td><td>55.0</td><td>57.9</td><td>50.5</td><td>66.0</td></tr><tr><td>new model</td><td>PossibleWorldNet</td><td>98.7</td><td>98.6</td><td>96.7</td><td>93.9</td><td>73.4</td><td>96.0</td></tr></table>
+
+Overall, these results show clearly that models that exploit structure in problems where it is provided, unambiguous, and a central feature of the task, outperform models which must implicitly model the structure of sequences. LSTM-based encoders provide robust and competitive results, although bidirectionality is not necessarily always the obvious choice due to optimisation and overfitting problems. Perhaps counter-intuitively, given the results of Rocktaschel et al. (2015), traversal ¨ models do not outperform encoding models in this pair-of-sequences traversal problem, indicating that they may be better at capturing the sort of long-range dependencies need to recognise textual entailment better than they are at capturing structure in general.
+
+We conclude, from these benchmark results, that tree structured networks may be a better choice for domains with unambiguous syntax, such as analysing formal languages or programs. For domains such as natural language understanding, both convolutional and recurrent network architectures have had some success, but our experiments indicate that this may be due to the fact that existing tasks favour models which capture representational or semantic regularities, and do not adequately test for structural or syntactic reasoning. In particular, the poor performance of convolutional nets on this task serves as a useful indicator that while they present the right inductive bias for capturing structure in images, where topological proximity usually indicates a joint semantic contribution (pixels close by are likely to contribute to the same “part” of an image, such as an edge or pattern), this inductive bias does not carry over to sequences particularly well (where dependencies may be significantly more sparse, structured, and distant)§. The results for the transformer benchmark indicate that while this architecture can capture sufficient structure for machine translation, allowing for the appropriate word order in the output, and accounting for disambiguation or relational information where it exists within sentences, it does not capture with sufficient precision the more hierarchical structure which exists in logical expressions.
+
+The best performing model overall is the PossibleWorldNet, which achieves significantly higher results than the other models, with $9 9 . 3 \%$ accuracy on test (easy), and $9 7 . 3 \%$ accuracy on test (hard). This is as to be expected, as it has the strongest inductive bias. This inductive bias has two components. First, the model has knowledge of the syntactic structure of the expression, since it is a variant of a TreeNet. Second, inspired by the definition of semantic (model-theoretic) entailment in general, the model evaluates the pair of formulas in lots of different situations (“possible worlds”) and combines the various results together in a product¶.
+
+The quality of the PossibleWorldNet depends directly on the number of “possible worlds” it considers (see Figure 1). As we increase the number of possible worlds, the validation error rate goes down steadily. Note that the data-efficiency also increases as we increase the number of worlds. This is because adding worlds to the model does not increase the number of model parameters—it just increases the number of different “possibilities” that are considered.
+
+![](images/e921b10dbee0faa92a9a58e66237612a601ae653a0524dc405789eebc348dc65.jpg)  
+Figure 1: The quality of the PossibleWorldNet as we vary the number of possible worlds
+
+In propositional logic, of course, if we are allowed to generate every single truth-value assignment, then it is trivial to detect entailment by checking each one. In our big test set, there are on average more than 3,000 possible truth-value assignments. In our massive test set, there are on average over 800,000 possible assignments. (See Table 1). The PossibleWorldNet considers at most 256 different worlds, which is only $7 \%$ of the expected total number of rows needed in the big test set, and only $0 . 0 3 \%$ of the expected number of rows needed for the massive test set.
+
+To understand this result, we sample 32, 64, 128 and 256 truth table rows (variable truth-value assignments) for each pair of formulas in Test (hard), and reject entailment if a single evaluation for the formulas amongst these finds the left hand side to be true while the right hand side is false. This gives us an estimate of the accuracy of sampling a number of truth table rows equal to the number of possible worlds in our model. We estimate that these statistical methods have $7 5 . 9 \%$ , $8 6 . 5 \%$ , $9 3 . 4 \%$ and $9 7 . 2 \%$ chance of finding a countermodel, respectively. This seems to indicate that PossibleWorldNet is capable of exploiting repeated computation across projections of random noise in order to learn, solely based on the label likelihood objective, something akin to a modelbased solution to entailment by treating the random-noise as variable valuations.
+
+# 6 RELATED WORK
+
+Zaremba et al. (2014) show how a neural architecture can be used to optimise matrix expressions. They generate all expressions up to a certain depth, group them into equivalence classes, and train a recursive neural network classifier to detect whether two expressions are in the same equivalence class. They use a recursive neural network (Socher et al., 2012) to guide the search for an optimised equivalent expression. There are two major differences between this work and ours. First, the classifier is predicting whether two matrix expressions (e.g. $A$ and $( A ^ { T } ) ^ { T } ,$ ) compute the same values; this is an equivalence relation, while entailment is a partial order. Second, their dataset consists of matrix expressions containing at most one variable, while our formulas contain many variables.
+
+Allamanis et al. (2016) use a recursive neural network to learn whether two expressions are equivalent. They tested on two datasets: propositional logic and polynomials. There are two main differences between their approach and ours. First, we consider entailment while they consider equivalence; equivalence is a symmetric relation, while entailment is not symmetric. Second, we consider entailment as a relational classification problem: given a pair of expressions $A$ and $B$ , predict whether $A$ entails $B$ . In their paper, by contrast, they generate a set of $k$ equivalence-classes of formulas with the same truth-conditions, and ask the network to predict which of these $k$ classes a single formula falls into. Their task is more specific: their network is only able to classify a formula from a new equivalence class that has not been seen during training if it has additional auxiliary information about that class (e.g. exemplar members of the class).
+
+Recognizing textual entailment (RTE) between natural language sentences is a central task in natural language processing. (See Dagan et al. (2006); for a recent dataset, see Bowman et al. (2015)). Some approaches (e.g., Wang & Jiang (2015) and Rocktaschel et al. (2015)) use LSTMs with attention, ¨ while others (e.g., Yin et al. (2015)) use a convolutional neural network with attention. Of course, recognizing entailment between natural language sentences is a very different task from recognizing entailment between logical formulas. Evaluating an entailment between natural language sentences requires understanding the meaning of the non-logical terms in the sentence. For example, the inference from “An ice skating rink placed outdoors is full of people” to “A lot of people are in an ice skating park” requires knowing the non-logical semantic information that an outdoors ice skating rink is also an ice skating park.
+
+Current neural models do not always understand the structure of the sentences they are evaluating. In Bowman et al. (2015), all the neural models they considered wrongly claimed that “A man wearing padded arm protection is being bitten by a German shepherd dog” entails “A man bit a dog”. We believe that isolating the purely structural sub-problem will be useful because only networks that can reliably predict entailment in a purely formal setting, such as propositional (or first-order) logic, will be capable of getting these sorts of examples consistently correct.
+
+# 7 CONCLUSION
+
+In this paper, we have introduced a new process for generating datasets for the purpose of recognising logical entailment. This was used to compare benchmarks and a new model on a task which is primarily about understanding and exploiting structure. We have established two clear results on the basis of this task. First, and perhaps most intuitively, architectures which make explicit use of structure will perform significantly better than those which must implicitly capture it. Second, the best model is the one that has a strong architectural bias towards capturing the possible world semantics of entailment. In addition to these two points, experimental results also shed some light on the relative abilities of implicit structure models—namely LSTM and Convolution networkbased architectures—to capture structure, showing that convolutional networks may not present the right inductive bias to capture and exploit the heterogeneous and deeply structured syntax in certain sequence-based problems, both for formal and natural languages.
+
+This conclusion is to be expected: the most successful models are those with the most prior knowledge about the generic structure of the task at hand. But our dataset throws new light on this unsurprising thought, by providing a new data-point on which to evaluate neural models’ ability to understand structural sequence problems. Logical entailment, unlike textual entailment, depends only on the meaning of the logical operators, and of the place particular arbitrarily-named variables hold within a structure. Here, we have a task in which a network’s understanding of structure can be disentangled from its understanding of the meaning of words.
+
+# ACKNOWLEDGMENTS
+
+We thank our colleagues at DeepMind for their insightful comments during the preparation of this paper, and in particular Yujia Li, Chris Dyer, and Alex Graves.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016.
+
+Miltiadis Allamanis, Pankajan Chanthirasegaran, Pushmeet Kohli, and Charles Sutton. Learning continuous semantic representations of symbolic expressions. arXiv preprint arXiv:1611.01423, 2016.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
+
+Samuel R Bowman, Gabor Angeli, Christopher Potts, and Christopher D Manning. A large annotated corpus for learning natural language inference. arXiv preprint arXiv:1508.05326, 2015.
+
+Ido Dagan, Oren Glickman, and Bernardo Magnini. The pascal recognising textual entailment challenge. In Machine learning challenges. evaluating predictive uncertainty, visual object classification, and recognising tectual entailment, pp. 177–190. Springer, 2006.
+
+Jacob Devlin, Jonathan Uesato, Surya Bhupatiraju, Rishabh Singh, Abdel-rahman Mohamed, and Pushmeet Kohli. Robustfill: Neural program learning under noisy i/o. arXiv preprint arXiv:1703.07469, 2017.
+
+Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio G ´ omez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, ´ et al. Hybrid computing using a neural network with dynamic external memory. Nature, 538 (7626):471–476, 2016.
+
+Edward Grefenstette, Karl Moritz Hermann, Mustafa Suleyman, and Phil Blunsom. Learning to transduce with unbounded memory. In Advances in Neural Information Processing Systems, pp. 1828–1836, 2015.
+
+Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Advances in Neural Information Processing Systems, pp. 1693–1701, 2015.
+
+Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. arXiv preprint arXiv:1511.02301, 2015.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Armand Joulin and Tomas Mikolov. Inferring algorithmic patterns with stack-augmented recurrent nets. In Advances in neural information processing systems, pp. 190–198, 2015.
+
+Łukasz Kaiser and Ilya Sutskever. Neural gpus learn algorithms. arXiv preprint arXiv:1511.08228, 2015.
+
+Nal Kalchbrenner and Phil Blunsom. Recurrent continuous translation models. In EMNLP, volume 3, pp. 413, 2013.
+
+Nal Kalchbrenner, Edward Grefenstette, and Phil Blunsom. A convolutional neural network for modelling sentences. arXiv preprint arXiv:1404.2188, 2014.
+
+Yoon Kim, Yacine Jernite, David Sontag, and Alexander M Rush. Character-aware neural language models. In AAAI, pp. 2741–2749, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Phong Le and Willem Zuidema. Compositional distributional semantics with long short term memory. arXiv preprint arXiv:1503.02510, 2015.
+
+Yann LeCun, Yoshua Bengio, et al. Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, 3361(10):1995, 1995.
+
+Wang Ling, Edward Grefenstette, Karl Moritz Hermann, Toma´s Ko ˇ cisk ˇ y, Andrew Senior, Fumin \` Wang, and Phil Blunsom. Latent predictor networks for code generation. arXiv preprint arXiv:1603.06744, 2016.
+
+Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andy Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, et al. Learning to navigate in complex environments. arXiv preprint arXiv:1611.03673, 2016.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Emilio Parisotto, Abdel-rahman Mohamed, Rishabh Singh, Lihong Li, Dengyong Zhou, and Pushmeet Kohli. Neuro-symbolic program synthesis. arXiv preprint arXiv:1611.01855, 2016.
+
+Benjamin C Pierce. Types and programming languages. MIT press, 2002.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. arXiv preprint arXiv:1606.05250, 2016.
+
+Scott Reed and Nando De Freitas. Neural programmer-interpreters. arXiv preprint arXiv:1511.06279, 2015.
+
+Tim Rocktaschel, Edward Grefenstette, Karl Moritz Hermann, Tom ¨ a´s Ko ˇ cisk ˇ y, and Phil Blunsom. \` Reasoning about entailment with neural attention. arXiv preprint arXiv:1509.06664, 2015.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Richard Socher, Brody Huval, Christopher D Manning, and Andrew Y Ng. Semantic compositionality through recursive matrix-vector spaces. In Proceedings of the 2012 joint conference on empirical methods in natural language processing and computational natural language learning, pp. 1201–1211. Association for Computational Linguistics, 2012.
+
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew $\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pp. 1631–1642, 2013.
+
+Niklas Sorensson and Niklas Een. Minisat v1. 13-a sat solver with conflict-clause minimization. SAT, 2005(53):1–2, 2005.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.
+
+Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. arXiv preprint arXiv:1503.00075, 2015.
+
+Yuandong Tian and Yan Zhu. Better computer go player with neural network and long-term prediction. arXiv preprint arXiv:1511.06410, 2015.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 6000–6010, 2017.
+
+Shuohang Wang and Jing Jiang. Learning natural language inference with lstm. arXiv preprint arXiv:1512.08849, 2015.
+
+Wenpeng Yin, Hinrich Schutze, Bing Xiang, and Bowen Zhou. Abcnn: Attention-based convolu- ¨ tional neural network for modeling sentence pairs. arXiv preprint arXiv:1512.05193, 2015.
+
+Wojciech Zaremba, Karol Kurach, and Rob Fergus. Learning to discover efficient mathematical identities. In Advances in Neural Information Processing Systems, pp. 1278–1286, 2014.
+
+Xiang Zhang, Junbo Zhao, and Yann LeCun. Character-level convolutional networks for text classification. In Advances in neural information processing systems, pp. 649–657, 2015.
+
+Xiaodan Zhu, Parinaz Sobihani, and Hongyu Guo. Long short-term memory over recursive structures. In International Conference on Machine Learning, pp. 1604–1612, 2015.
+
+# A THE DATASET
+
+# A.1 DATASET REQUIREMENTS
+
+Our dataset $\mathcal { D }$ is composed of triples of the form $( A , B , A \models B )$ , where $A \models B$ is 1 if $A$ entailsk $B$ , and 0 otherwise. For example:
+
+$$
+\begin{array} { c } { { ( p \wedge q , q , 1 ) } } \\ { { ( q \vee r , r , 0 ) } } \end{array}
+$$
+
+We wanted to ensure that simple baseline models are unable to exploit simple statistical regularities to perform well in this task. We define a series of baseline models which, due to their structure or the information they have access to, should not be able to solve the entailment recognition problem described in this paper. We distinguish baselines for which we believe there is little chance of them detecting entailment, from those for which there categorically cannot be true modelling of entailment. The baselines which categorically cannot detect entailment are encoding models which only observe one side of the sequent:
+
+$$
+P ( A \models B ) = \sigma \left( \mathbf { M L P } ( f ( A ) ) \right) \quad { \mathrm { o r } } \quad P ( A \models B ) = \sigma \left( \mathbf { M L P } ( f ( B ) ) \right)
+$$
+
+where $f$ is a linear bag of words encoder, an MLP bag of words encoder, or a TreeNet.
+
+Because the dataset contains a roughly balanced number of positive and negative examples, it follows that we should expect any model which only sees part of the sequent to perform in line with a random classifier. If they outperform a random baseline on test, there is a structural or symbolic regularity on one side (or both) which is sufficient to identify some subset of positive or negative examples. We use these baselines to verify the soundness of the generation process.
+
+Let $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ be the positive and negative entailments:
+
+$$
+\begin{array} { c } { \mathcal { D } ^ { + } = \{ ( A , B ) \mid ( A , B , 1 ) \in \mathcal { D } \} } \\ { \mathcal { D } ^ { - } = \{ ( A , B ) \mid ( A , B , 0 ) \in \mathcal { D } \} } \end{array}
+$$
+
+We impose various requirements on the dataset, to rule out superficial syntactic differences between $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ that can be easily exploited by the simple baselines described above. We require that our classes are balanced:
+
+$$
+\begin{array} { r c l } { | \mathcal { D } ^ { + } | } & { = } & { | \mathcal { D } ^ { - } | } \end{array}
+$$
+
+We do not want there to be any obvious difference in the length of formulas in $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ :
+
+$$
+\begin{array} { r l r } { \underset { ( A , B ) \sim \mathcal { D } ^ { + } } { \mathbb { E } } l e n g t h ( A ) } & { = } & { \underset { ( A , B ) \sim \mathcal { D } ^ { - } } { \mathbb { E } } l e n g t h ( A ) } \\ { \underset { ( A , B ) \sim \mathcal { D } ^ { + } } { \mathbb { E } } l e n g t h ( B ) } & { = } & { \underset { ( A , B ) \sim \mathcal { D } ^ { - } } { \mathbb { E } } l e n g t h ( B ) } \end{array}
+$$
+
+We want there to be the same number of new free variables (variables appearing in $\mathbf { B }$ that do not appear in A) in both $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ :
+
+$$
+\begin{array} { r l r } { \underset { ( A , B ) \sim \mathcal { D } ^ { + } } { \mathbb { E } } | v a r s ( B ) - v a r s ( A ) | } & { = } & { \underset { ( A , B ) \sim \mathcal { D } ^ { - } } { \mathbb { E } } | v a r s ( B ) - v a r s ( A ) | } \end{array}
+$$
+
+Let $n u m ( A , o p )$ be the number of occurrences of operator $o p$ in formula $A$ . So, for example, $n u m ( \neg ( p \land \neg q ) , \neg ) = 2$ . We impose the constraint that for each operator $o p \in \{ \neg , \land , \lor , \to \}$ , that
+
+$$
+\begin{array} { r l r } { \underset { ( A , B ) \sim \mathcal { D } ^ { + } } { \mathbb { E } } { \pi } u m ( A , o p ) } & { = } & { \underset { ( A , B ) \sim \mathcal { D } ^ { - } } { \mathbb { E } } { \pi } u m ( A , o p ) } \\ { \underset { ( A , B ) \sim \mathcal { D } ^ { + } } { \mathbb { E } } { n u m } ( B , o p ) } & { = } & { \underset { ( A , B ) \sim \mathcal { D } ^ { - } } { \mathbb { E } } { n u m } ( B , o p ) } \end{array}
+$$
+
+kThroughout, we focus on classical propositional logic, and do not consider e.g., intuitionistic entailment.
+
+Furthermore, we require that the number of occurrences of an operator at each level in the abstract syntax tree is the same in $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ . It would not be acceptable if, for example, a typical $B ^ { + }$ from ${ \dot { \mathcal { D } } } ^ { + }$ had more disjunctions at the top of the syntax tree than $B ^ { - }$ from $\mathcal { D } ^ { - }$ . Let $n u m \_ a t ( B , l e v e l , o p )$ be the number of occurrences of operator $o p$ at level in the syntax tree for $B$ . We also require that, for each op and level:
+
+$$
+\begin{array} { r l r } { \underset { ( A , B ) \sim \mathcal { D } ^ { + } } { \mathbb { E } } n u m _ { - } a t ( A , l e v e l , o p ) } & { = } & { \underset { ( A , B ) \sim \mathcal { D } ^ { - } } { \mathbb { E } } n u m _ { - } a t ( A , l e v e l , o p ) } \\ { \underset { ( A , B ) \sim \mathcal { D } ^ { + } } { \mathbb { E } } n u m _ { - } a t ( B , l e v e l , o p ) } & { = } & { \underset { ( A , B ) \sim \mathcal { D } ^ { - } } { \mathbb { E } } n u m _ { - } a t ( B , l e v e l , o p ) } \end{array}
+$$
+
+# A.2 DATASET GENERATION
+
+# A.2.1 A NAIVE APPROACH TO DATASET GENERATION
+
+A simple way to generate an entailment dataset would be to alternate between first sampling formulas $A ^ { + }$ and $\dot { B } ^ { + }$ such that $A ^ { + } \models B ^ { + }$ , and second sampling formulas $A ^ { - }$ and $B ^ { - }$ such that $A ^ { \bar { - } } \nvDash B ^ { - }$ . Since we are alternating between $\vDash$ and $\nvDash$ , we are guaranteed to produce balanced classes. Unfortunately, this straightforward approach generates datasets that violate most of our requirements above. See Table 3 for the details.
+
+In particular, the mean number of negations, conjunctions, and disjunctions at the top of the syntax tree $( n u m . a t ( \cdot , 0 , o p ) )$ is markedly different. $A ^ { + }$ has significantly more conjunctions at the top of the syntax tree than $A ^ { - }$ , while $B ^ { + }$ has significantly fewer than $B ^ { - }$ . Conversely, $A ^ { + }$ has significantly fewer disjunctions at the top of the syntax tree than $A ^ { - }$ , while $B ^ { + }$ has significantly more than $B ^ { - }$ .
+
+The mean number of satisfying truth-value assignments $( s a t ( \cdot ) )$ is also markedly different: $A ^ { + }$ is true in on average 3.7 truth-value assignments (i.e. it is a very specific formula which is only true under very particular circumstances), while $A ^ { - }$ is true in 10.3 truth-value assignments (i.e. it is true in a wider range of circumstances).
+
+If we look at the mean number of variables appearing in $B$ that do not appear in $A$ , there is also a striking difference between $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ . The mean number of new variables in $\mathnormal { v a r s } ( B ^ { + } ) ~ -$ $v a r s ( A ^ { \ + } )$ is 0.80 while the mean number of new variables in var $s ( B ^ { - } ) - v a r s ( A ^ { - } )$ is 1.39 with a $\chi ^ { 2 }$ of 3308.1 and 8 degrees of freedom.
+
+We can use these statistics to develop simple heuristic baselines that will be unreasonably effective on the dataset described above: we can estimate whether $A \models B$ by comparing the lengths of $A$ and $B$ , or by looking at the number of variables in $B$ that do not appear in $A$ , or by looking at the topmost connective in $A$ and $B$ .
+
+Table 3: Requirement violations in the naive approach, with $\vert \mathcal { D } \vert = 5 0 , 0 0 0$   
+
+<table><tr><td></td><td>A+</td><td>A-</td><td>x²</td><td>x² df</td><td>B+</td><td>B-</td><td>x²</td><td>x² df</td></tr><tr><td>length(.)</td><td>6.62</td><td>6.45</td><td>70.6</td><td>9</td><td>8.33</td><td>8.28</td><td>304.9</td><td>16</td></tr><tr><td>num(.,-)</td><td>1.47</td><td>1.33</td><td>309.4</td><td>8</td><td>1.77</td><td>1.91</td><td>139.0</td><td>9</td></tr><tr><td>num(·, ^)</td><td>1.52</td><td>1.33</td><td>308.6</td><td>8</td><td>1.70</td><td>1.94</td><td>134.0</td><td>11</td></tr><tr><td>num(-,v)</td><td>1.30</td><td>1.40</td><td>86.9</td><td>8</td><td>1.95</td><td>1.69</td><td>127.0</td><td>10</td></tr><tr><td>num_at(·,0,-)</td><td>0.31</td><td>0.22</td><td>532.4</td><td>1</td><td>0.18</td><td>0.30</td><td>350.9</td><td>1</td></tr><tr><td>num_at(·,1,-)</td><td>0.32</td><td>0.31</td><td>7.5</td><td>2</td><td>0.39</td><td>0.41</td><td>3.2</td><td>2</td></tr><tr><td>num_at(·,2,-)</td><td>0.31</td><td>0.31</td><td>8.8</td><td>4</td><td>0.56</td><td>0.54</td><td>5.3</td><td>4</td></tr><tr><td>num_at(-,0, ^)</td><td>0.35</td><td>0.2</td><td>1382.9</td><td>1</td><td>0.13</td><td>0.33</td><td>1076.4</td><td>1</td></tr><tr><td>num_at(.,1, ^)</td><td>0.32</td><td>0.31</td><td>36.5</td><td>2</td><td>0.39</td><td>0.40</td><td>6.5</td><td>2</td></tr><tr><td>num_at(-,2,^)</td><td>0.31</td><td>0.32</td><td>3.2</td><td>4</td><td>0.56</td><td>0.53</td><td>16.5</td><td>4</td></tr><tr><td>num_at(.,0, v)</td><td>0.16</td><td>0.28</td><td>1070.3</td><td>1</td><td>0.34</td><td>0.16</td><td>752.4</td><td>1</td></tr><tr><td>num_at(.,1, ν)</td><td>0.30</td><td>0.32</td><td>66.0</td><td>2</td><td>0.42</td><td>0.34</td><td>141.1</td><td>2</td></tr><tr><td>num_at(-,2,ν)</td><td>0.32</td><td>0.31</td><td>12.9</td><td>4</td><td>0.57</td><td>0.52</td><td>39.7</td><td>4</td></tr><tr><td>#sat(.)</td><td>3.7</td><td>10.3</td><td>11265</td><td>174</td><td>22.1</td><td>11.7</td><td>3702.8</td><td>241</td></tr></table>
+
+# A.2.2 OUR PREFERRED APPROACH TO DATASET GENERATION
+
+In order to satisfy our requirements above, we took a different approach to dataset generation. In order to ensure that there are no crude statistical measurements that can detect differences between $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ , we change the generation procedure so that every formula appears in both $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ . We sample 4-tuples of formulas $\left( A _ { 1 } , B _ { 1 } , A _ { 2 } , B _ { 2 } \right)$ such that:
+
+$$
+\begin{array} { r l r } { A _ { 1 } } & { \mapsto } & { B _ { 1 } } \\ { A _ { 2 } } & { \mapsto } & { B _ { 2 } } \\ { A _ { 1 } } & { \mapsto } & { B _ { 2 } } \\ { A _ { 2 } } & { \mapsto } & { B _ { 1 } } \end{array}
+$$
+
+Here, each of the four formulas appears in one positive entailment and one negative entailment∗∗.
+
+Using this alternative approach, we are able to satisfy the requirements above. By construction, the mean length, number of operators at a certain level in the syntax tree, and the number of satisfying truth-value assignments is exactly the same for $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ . See Table 4.
+
+The only crude difference remaining is in the number of new variables. If we look at the number of variables appearing in $B$ that do not appear in $A$ , there is a noticeable difference between $\mathcal { D } ^ { + }$ and $\mathcal { D } ^ { - }$ . The mean number of new variables in var $s ( B ^ { + } ) - v a r s ( A ^ { + } )$ is 1.25 while the mean number of new variables in var $s ( B ^ { - } ) - v a r s ( A ^ { - } )$ is 1.60 with a $\chi ^ { 2 }$ of 922.1 and 8 degrees of freedom.
+
+Table 4: Statistics for the preferred approach that generates 4-tuples, with $\vert \mathcal { D } \vert = 5 0 , 0 0 0$   
+
+<table><tr><td></td><td>A+</td><td>A-</td><td>x²</td><td>x² df</td><td>B+</td><td>B-</td><td>X²</td><td>x² df</td></tr><tr><td>length(.)</td><td>6.33</td><td>6.33</td><td>0.0</td><td>9</td><td>6.38</td><td>6.38</td><td>0.0</td><td>16</td></tr><tr><td>num(-,-)</td><td>1.42</td><td>1.42</td><td>0.0</td><td>9</td><td>1.26</td><td>1.26</td><td>0.0</td><td>8</td></tr><tr><td>num(·,^)</td><td>1.63</td><td>1.63</td><td>0.0</td><td>7</td><td>1.16</td><td>1.16</td><td>0.0</td><td>7</td></tr><tr><td>num(., v)</td><td>1.14</td><td>1.14</td><td>0.0</td><td>7</td><td>1.53</td><td>1.53</td><td>0.0</td><td>8</td></tr><tr><td>num_at(·,0,-)</td><td>0.33</td><td>0.33</td><td>0.0</td><td>1</td><td>0.16</td><td>0.16</td><td>0.0</td><td>1</td></tr><tr><td>num_at(·,1,-)</td><td>0.29</td><td>0.29</td><td>0.0</td><td>2</td><td>0.32</td><td>0.32</td><td>0.0</td><td>2</td></tr><tr><td>num_at(·,2,-)</td><td>0.30</td><td>0.30</td><td>0.0</td><td>3</td><td>0.31</td><td>0.31</td><td>0.0</td><td>4</td></tr><tr><td>num_at(.,0, ^)</td><td>0.49</td><td>0.49</td><td>0.0</td><td>1</td><td>0.1</td><td>0.1</td><td>0.0</td><td>1</td></tr><tr><td>num_at(·,1,^)</td><td>0.34</td><td>0.34</td><td>0.0</td><td>2</td><td>0.31</td><td>0.31</td><td>0.0</td><td>2</td></tr><tr><td>num_at(.,2, ^)</td><td>0.30</td><td>0.30</td><td>0.0</td><td>4</td><td>0.30</td><td>0.30</td><td>0.0</td><td>4</td></tr><tr><td>num_at(.,0, v)</td><td>0.08</td><td>0.08</td><td>0.0</td><td>1</td><td>0.39</td><td>0.39</td><td>0.0</td><td>1</td></tr><tr><td>num_at(.,1, ν)</td><td>0.27</td><td>0.27</td><td>0.0</td><td>2</td><td>0.35</td><td>0.35</td><td>0.0</td><td>2</td></tr><tr><td>num_at(.,2,ν)</td><td>0.29</td><td>0.29</td><td>0.0</td><td>3</td><td>0.29</td><td>0.29</td><td>0.0</td><td>3</td></tr><tr><td>#sat(-)</td><td>3.86</td><td>3.86</td><td>0.0</td><td>86</td><td>14.42</td><td>14.42</td><td>0.0</td><td>157</td></tr></table>
+
+# A.3 DATASET EXAMPLE
+
+Our method generates 4-tuples such as the following:
+
+$$
+\begin{array} { r l r l } { p \vee p } & { \in } & { ( r  c )  ( ( r  v ) \vee p ) } \\ { ( ( g \vee p ) \vee s )  ( g  g ) \wedge r } & { \in } & { r \wedge ( r  r ) } \\ { p \vee p } & { \nvDash } & { r \wedge ( r  r ) } \\ { ( ( g \vee p ) \vee s )  ( g  g ) \wedge r } & { \nvDash } & { ( r  c )  ( ( r  v ) \vee p ) } \end{array}
+$$

parse/train/UcoXdfrORC/UcoXdfrORC.md

@@ -0,0 +1,413 @@
+# MODEL-BASED VISUAL PLANNING WITH SELF-SUPERVISED FUNCTIONAL DISTANCES
+
+Stephen $\mathbf { T i a n } ^ { 1 }$ , Suraj $\mathbf { N a i r ^ { 2 } }$ , Frederik Ebert1, Sudeep Dasari3, Benjamin Eysenbach3,   
+Chelsea $\mathbf { F i n n ^ { 2 } }$ , Sergey Levine1   
+1University of California, Berkeley   
+2Stanford University   
+3Carnegie Mellon University
+
+# ABSTRACT
+
+A generalist robot must be able to complete a variety of tasks in its environment. One appealing way to specify each task is in terms of a goal observation. However, learning goal-reaching policies with reinforcement learning remains a challenging problem, particularly when hand-engineered reward functions are not available. Learned dynamics models are a promising approach for learning about the environment without rewards or task-directed data, but planning to reach goals with such a model requires a notion of functional similarity between observations and goal states. We present a self-supervised method for model-based visual goal reaching, which uses both a visual dynamics model as well as a dynamical distance function learned using model-free reinforcement learning. Our approach learns entirely using offline, unlabeled data, making it practical to scale to large and diverse datasets. In our experiments, we find that our method can successfully learn models that perform a variety of tasks at test-time, moving objects amid distractors with a simulated robotic arm and even learning to open and close a drawer using a real-world robot. In comparisons, we find that this approach substantially outperforms both model-free and model-based prior methods. Videos and visualizations are available here: https://sites.google.com/berkeley.edu/mbold.
+
+# 1 INTRODUCTION
+
+Designing general-purpose robots that can perform a wide range of tasks remains an open problem in AI and robotics. Reinforcement learning (RL) represents a particularly promising tool for learning robotic behaviors when skills can be learned one at a time from user-defined reward functions. However, general-purpose robots will likely require large and diverse repertoires of skills, and learning individual tasks one at a time from manually-specified rewards is onerous and time-consuming. How can we design learning systems that can autonomously acquire general-purpose knowledge that allows them to solve many different downstream tasks?
+
+To address this problem, we must resolve three questions. (1) How can the robot be commanded to perform specific downstream tasks? A simple and versatile choice is to define tasks in terms of desired outcomes, such as an example observation of the completed task. (2) What types of data should this robot learn from? In settings where modern machine learning attains the best generalization results (Deng et al., 2009; Rajpurkar et al., 2016; Devlin et al., 2018), a common theme is that excellent generalization is achieved by learning from large and diverse task-agnostic datasets. In the context of RL, this means we need offline methods that can use all sources of prior data, even in the absence of reward labels. As collecting new experience on a physical robot is often expensive, offline data is often more practical to use in real-world settings (Levine et al., 2020). (3) What should the robot learn from this data to enable goal-reaching? Similar to prior work (Botvinick & Weinstein, 2014; Watter et al., 2015; Finn & Levine, 2017; Ebert et al., 2018b), we note that policies and value functions are specific to a particular task, while a predictive model captures the physics of the environment independently of the task, and thus can be used for solving almost any task. This makes model learning particularly effective for learning from large and diverse datasets, which do not necessarily contain successful behaviors.
+
+While model-based approaches have demonstrated promising results, including for vision-based tasks in real-world robotic systems (Ebert et al., 2018a; Finn & Levine, 2017), such methods face two major challenges. First, predictive models on raw images are only effective over short horizons, as uncertainty accumulates far into the future (Denton & Fergus, 2018; Finn et al., 2016; Hafner et al., 2019b; Babaeizadeh et al., 2017). Second, using such models for planning toward goals requires a notion of similarity between images. While prior methods have utilized latent variable models (Watter et al., 2015; Nair et al., 2018), $\ell _ { 2 }$ pixel-space distance (Nair & Finn, 2020), and other heuristic measures of similarity (Ebert et al., 2018b), these metrics only capture visual similarity. To enable reliable control with predictive models, we instead need distances that are aware of dynamics.
+
+In this paper, we propose Model-Based RL with Offline Learned Distances (MBOLD), which aims to address both of these challenges by learning predictive models together with image-based distance functions that reflect functionality, from offline, unlabeled data. The learned distance function estimates of the number of steps that the optimal policy would take to transition from one state to another, incorporating not just visual appearance, but also an understanding of dynamics. However, to learn dynamical distances from task-agnostic data, supervised regression will lead to overestimation, since the paths in the data are not all optimal for any task. Instead, we utilize approximate dynamic programming for distance estimation. While prior work has studied such methods to learn goal-conditioned policies in online model-free RL settings (Eysenbach et al., 2019; Florensa et al., 2019), we extend it to the offline setting and show that approximate dynamic programming techniques derived from Q-learning style Bellman updates can learn effective shortest path dynamical distances. Although this procedure resembles model-free reinforcement learning, we find empirically that it does not by itself produce useful policies. Instead, our method (Fig. 1) combines the strengths of dynamics models and distance functions, using the predictive model to plan over short horizons, and using the learned distances to provide a global cost that captures progress toward distant goals.
+
+![](images/2306a1c8be104b09193a0daec26daba5f116a39eb786bbc5b851c848b71288a0.jpg)  
+Figure 1: The robot must find actions that quickly achieve the desired goal. State transitions and the true optimal distances between states are unknown, so our method learns an approximate shortest distance function and dynamics model directly on images. These models allow the robot to find the shortest path to the goal at test-time.
+
+The primary contribution of this work is an offline, self-supervised approach for solving arbitrary goal-reaching tasks by combining planning with predictive models and learned dynamical distances. To our knowledge, our method is the first to directly combine predictive models on images with dynamical distance estimators on images, entirely from random, offline data without reward labels. Through our experimental evaluation on challenging robotic object manipulation tasks, including simulated object relocation and real-world drawer manipulation, we find that our method can outperform previously introduced reward specification methods for visual model-based control with a relative performance improvement of at least $50 \%$ across all tasks, and compares favorably to prior work in model-based and model-free RL. We also find that combining Q-functions with planning improves dramatically over policies directly learned with model-free RL.
+
+# 2 RELATED WORK
+
+Offline and Model-based RL: A number of prior works have studied the problem of learning behaviors from existing offline datasets. While recent progress has been made in applying model-free RL techniques to this problem of offline or batch RL (Fujimoto et al., 2019; Wu et al., 2019; Kumar et al., 2019; 2020; Nair et al., 2020b), one approach that has shown promise is offline model-based RL (Lowrey et al., 2019; Kidambi et al., 2020; Yu et al., 2020; Argenson & Dulac-Arnold, 2020), where the agent learns a predictive model of the world from data. Such model-based methods have seen success both in the offline and online RL settings, and have a rich history of being effective for planning (Deisenroth & Rasmussen, 2011; Watter et al., 2015; McAllister & Rasmussen, 2016; Chua et al., 2018; Amos et al., 2018; Hafner et al., 2019b; Nagabandi et al., 2018; Kahn et al., 2020; Dong et al., 2020) or policy optimization (Sutton, 1991; Weber et al., 2017; Ha & Schmidhuber, 2018; Janner et al., 2019; Wang & Ba, 2019; Hafner et al., 2019a). However, the vast majority of these prior works consider the single task setting where the agent aims to maximize a single task reward. In contrast, in this work we circumvent the need for task rewards by adopting a selfsupervised multi-task approach, where a single learned model is used to perform a variety of tasks, specified in a flexible and general way by desired outcomes – i.e., goal images.
+
+Self-supervised goal reaching: While the standard RL problem involves optimizing for a taskspecific reward, an alternative and potentially more general formulation involves learning a generic goal reaching policy, without task-specific reward labels. In fact, a number of prior works learn goal-conditioned policies using model-free RL (Kaelbling, 1993; Nair et al., 2018; Mandlekar et al., 2019; Nair et al., 2020a), or variants of goal-conditioned behavioral cloning (GCBC) (Ghosh et al., 2019; Ding et al., 2019; Lynch et al., 2020). In our experiments, we show that our method outperforms both model-free approaches and goal-conditioned behavioral cloning. A number of methods combine model-free and model-based elements by planning over a graph representation (Eysenbach et al., 2019; Nasiriany et al., 2019; Savinov et al., 2018; Liu et al., 2020). Such methods can struggle in higher dimensions, where constructing graphs that adequately cover the space may require an excessive number of samples. We compare to these methods in our experiments. Similarly to Finn & Levine (2017); Ebert et al. (2018b); Nair & Finn (2020); Yen-Chen et al. (2019); Suh & Tedrake (2020), our method uses an action-conditioned video prediction model to generate plans. However, these prior methods generally utilize hand-crafted image similarity reward measures such as $\ell _ { 2 }$ pixel-error (Ebert et al., 2018a; Nair & Finn, 2020) and pixel-flow prediction (Finn & Levine, 2017). In complex scenes, this can become a major bottleneck: predictions degrade rapidly further in the future, making an informative image similarity metric critical for effective planning. We propose to learn functional similarity metrics in terms of dynamical distances, which we find can be combined with predictive models to attain significantly improved results.
+
+Dynamical distance learning: Our method learns dynamical distances – distances that represent shortest paths – from offline data. In the literature, dynamical distances have been learned via direct regression using online data (Hartikainen et al., 2019), representation learning (Warde-Farley et al., 2018; Yu et al., 2019b), or via Q-learning by relabeling goals (Eysenbach et al., 2019; Florensa et al., 2019). While these last two works are most similar to ours, in that they also employ approximate dynamic programming to learn distances, our method directly combines these dynamical distances with visual predictive models and planning. Lastly, while prior work has also explored combining model-based planning with value functions (Zhong et al., 2013; Lowrey et al., 2019; Hafner et al., 2019a; Schrittwieser et al., 2019; Argenson & Dulac-Arnold, 2020), these works consider the single task domain with a reward function, while our learned value function considers the multi-task goal reaching domain from entirely random, offline data without reward labels.
+
+# 3 THE SELF-SUPERVISED OFFLINE RL PROBLEM STATEMENT
+
+In this section, we introduce notation and define the problem setting. We will employ a Markov decision process (MDP) with state observations $s _ { t } \in S$ and actions $a _ { t } \in \mathcal A$ , both indexed by time $t \in { 0 , 1 , \cdots , H }$ , where $H$ denotes the maximum episode length. The initial state is sampled from an initial state distribution $s _ { 0 } \sim p _ { 0 } ( s _ { 0 } )$ , and subsequent states are sampled according to Markovian dynamics: $s _ { t + 1 } \sim p ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) $ . Actions are sampled $a _ { t } \sim \pi ( a _ { t } \ \bar { | } \ s _ { t } , s _ { g } )$ from a policy that is conditioned on both the current state and a goal state $s _ { g } \in \mathcal S$ . In our experiments, both the state and goal are images (i.e., $\mathcal { S } = \mathbb { R } ^ { H \times W \times 3 } )$ ).
+
+We tackle offline learning in this setting, assuming access to a fixed dataset $\mathcal { D }$ consisting of trajectories $\left\{ s _ { 0 } , a _ { 0 } , s _ { 1 } , . . . s _ { T } \right\}$ of the agent interacting with the environment. This data can include any environment interactions, from expert demonstrations to trajectories which are not particularly successful at any task. In our experiments, we use data collected using a random policy, which is inexpensive to obtain. The agent does not have access to the environment to collect additional training data. Given this dataset, the objective is to determine the optimal goal-conditioned policy $\pi ^ { \star } ( a _ { t } \mid s _ { t } , s _ { g } )$ , under which the agent is able to transition to any goal state $s _ { g }$ from any starting state $s _ { t }$ in the minimum number of time steps possible. Note that unlike in the standard formulation of the RL problem, the agent does not receive any reward signal from its environment.
+
+![](images/339e56c9bdb6e5ee33497e2bd9ec1684f95e24aca278ed8b7b4ba712c39707c3.jpg)  
+Figure 2: Model-based visual goal reaching: (Left) During offline learning, we train an imagebased predictive model and distance function on the same random dataset. (Right) At test time, we use the learned distance model for MPC, plugging in the learned distance as a cost function.
+
+# 4 MODEL-BASED VISUAL GOAL-REACHING
+
+In this section we will introduce our method, MBOLD, for offline, goal-conditioned reinforcement learning. MBOLD, illustrated in Fig. 2, is composed of two neural networks: a predictive model and a learned distance function. The video-predictive dynamics model allows the agent to predict the result of hypothetical sequences of actions. However, this model cannot accurately predict far into the future, and has no notion of whether the predicted outcomes are desirable. Thus, we also learn a distance function, corresponding to a value function with a self-supervised goal-reaching reward, which will estimate the timestep length of the shortest path between a predicted state and a given goal. Both networks are trained on the same offline dataset.
+
+At test-time, we use the learned dynamics model and distance function for model-predictive control (MPC). MBOLD predicts future states for candidate action sequences using the learned dynamics model, and uses the learned distance function to determine which action sequence will lead the agent closest to the goal. The first of the actions is then executed, and planning repeats upon receiving the subsequent observation from the environment. The remainder of this section describes how we learn the dynamics model and distance function, and use them to perform control.
+
+Dynamics learning. Our method learns environment dynamics in order to solve for actions during test time, without an explicit task reward signal during training. MBOLD can use arbitrary imagebased forward models, including latent variable models (Hafner et al., 2019b; Lee et al., 2019). The particular choice of model is a design decision when implementing our method. In our implementation, we use a convolutional video prediction model adapted from SAVP (Lee et al., 2018). The network takes as input the current observation $s _ { t }$ and a sequence of $h$ actions $\scriptstyle a _ { t : t + h - 1 }$ and returns a prediction for the next $h$ image observations, $\hat { f } _ { \theta } ( s _ { t } , a _ { t : t + h - 1 } ) = \{ \hat { s } _ { t + 1 } , \dots , \hat { s } _ { t + h } \}$ . We train this model to minimize the $\ell _ { 2 }$ image reconstruction loss:
+
+$$
+\operatorname* { m i n } _ { \theta } \mathbb { E } _ { \mathcal { D } } \left[ \frac { 1 } { h } \sum _ { t ^ { \prime } = t } ^ { t + h } \| \hat { f } _ { \theta } ( s _ { t } , a _ { t : t + h - 1 } ) [ t ^ { \prime } - t ] - s _ { t ^ { \prime } } \| ^ { 2 } \right] .
+$$
+
+Distance learning. Our method also learns a dynamical distance function, so that it can evaluate a functional notion of distance from the predicted states to the goal state, for use as a planning cost. However, the environment does not provide a reward signal that might be used to deduce these distances. Indeed, the offline dataset is typically composed of highly suboptimal trajectories, so our method may not even have access to examples of shortest path trajectories between states. Our key observation is that a goal-conditioned Q-function trained on a modified MDP with an indicator cost function yields values that correspond to shortest path distances in the original environment. Thus, Q-learning-like methods can recover optimal distance functions even from sub-optimal data.
+
+We therefore formulate an MDP by augmenting environment trajectories with the reward function $r ( s _ { t } , a , s _ { t + 1 } , g ) = \mathbf { 1 } _ { \mathrm { s } _ { t + 1 } = \mathrm { s } _ { \mathrm { g } } }$ , adding a discount factor of $\gamma$ , and considering episodes terminated once they reach the goal state. Note that $s _ { t }$ , $s _ { t + 1 }$ , and $g$ all represent images, and the reward is only given when the next state and goal images exactly match. During training, goals are sampled according to a distribution on $s$ , which we will discuss later. If $\gamma < 1$ , the Q-values for a policy that maximizes expected discounted returns in this MDP can be directly mapped to shortest path distances. Specifically, in discrete state environments, the optimal $\mathbf { Q }$ -function can be written as $Q ( s , a , g ) = \gamma ^ { d ( s , a , g ) }$ , where $d ( s , a , g )$ is a shortest path distance between $s$ and $g$ after taking action $a$ . Similarly, we can recover $d ( s , a , g ) = \log _ { \gamma } Q ( s , a , g )$ . Ultimately, our Q-learning approach corresponds to the following Bellman error optimization objective:
+
+$$
+\operatorname* { m i n } _ { \phi } \mathbb { E } _ { s _ { t } , a _ { t } , s _ { t + 1 } \sim \mathcal { D } , g \sim \mathcal { S } } \left[ Q _ { \phi } ( s _ { t } , a _ { t } , g ) - ( { \bf 1 } _ { s _ { t + 1 } = g } + \gamma { \bf 1 } _ { s _ { t + 1 } \neq g } \operatorname* { m a x } _ { a _ { t + 1 } } Q _ { \phi } ( s _ { t + 1 } , a _ { t + 1 } , g ) ) \right] ^ { 2 } .
+$$
+
+In practice, we use a deep network to represent the $\mathrm { Q }$ -function. During training, we sample transitions $( s _ { t } , a _ { t } , s _ { t + 1 } , g )$ to optimize the objective in Equation 2. The first three components $( s _ { t } , a _ { t } , s _ { t + 1 } )$ can be sampled randomly from the dataset. However, trajectories in the offline dataset may not be directed towards any particular goals, so a key challenge lies in selecting which goals $g$ to choose. The next section describes our approach to sampling these goals.
+
+Selecting goals for relabeling transitions. Na¨ıvely choosing $g$ , say by sampling random states uniformly from the dataset, will provide an extremely sparse reward signal, as two random state images will almost never be exactly identical. The sparse reward problem can be mitigated by selectively sampling as goals the states that were actually reached in future time steps along the same trajectory as $s _ { t }$ (Kaelbling, 1993; Andrychowicz et al., 2017). More precisely, to sample goals for a transition at time step $t$ , we sample a discrete time offset $\Delta \sim \mathrm { G e o m } ( p )$ , where $p \in [ 0 , 1 ]$ is a hyper-parameter, and use the state at time $t + \Delta$ as the goal. Note that if $\Delta = 1$ , the reward for this transition is 1, avoiding the sparsity issue.
+
+However, relabeling all transitions in this way creates a major issue: since the distance function would only be trained on goals that were actually reached, it would systematically underestimate the distance to unreachable goals. Put another way, goals that were not reached from $s _ { t }$ would be out-of-distribution goals for the resulting Q-function. We found this to result in poor performance. In practice, prior work (Kaelbling, 1993; Andrychowicz et al., 2017) actually relabels with a mixture of reached goals and commanded but not necessarily reached goals.
+
+These prior methods can obtain such “negative” goals based on the goals that were commanded during online data collection. This is impossible in our setting, since our offline data may not even have been collected with a goal-directed policy. We therefore need a procedure to select such “negative” goals that are distant yet relevant. Randomly selecting dataset states will lead to pairs of images that are clearly distant with high probability (e.g., pairs in which all objects and the robot have been moved), but not necessarily relevant. We would like a goal sampling procedure that produces less obvious examples of distant states, which are more informative for training. Hard negative mining is one example of such a procedure, where pairs are selected based on the model’s predictions, but is computationally expensive with large datasets.
+
+Instead, we build upon the intuition that distance functions are likely to pay excessive attention to fully actuated factors in the state, such as the position of the robot’s arm, because they are strongly predictive of distances. We propose sampling “negative” goal states $g$ which have similar actuated components to reached states. When randomly sampling pairs of states under this constraint, the underactuated dimensions (e.g. the objects), which are generally not known, are likely to have distinct positions. Hence, these data points can serve as informative hard negatives that encourage the model to pay more attention to the difficult, underactuated parts of the state. Unlike hard negative mining, this sampling approach is computationally inexpensive, as it does not rely on the current distance function, and practical, as actuated components of the state can typically be measured through encoders on the actuator. In practice, we sample these “negative” goals from observations across all dataset trajectories via nearest-neighbors search, using arm joint $\ell _ { 2 }$ distance as the similarity key. Note that this does assume proprioceptive state information from the agent (e.g. robot joint angles), which is almost always available in real-world robotics settings, but does not require knowledge about object positions or other ground-truth environment information. While we use actuator information for generating training examples, the distance function and dynamics model use only image observations and actions as inputs. See Appendix A.1 for details.
+
+Control via MBOLD. At test-time, the learned distance function and dynamics model are used together to solve control tasks via MPC. In other words, the dynamics model predicts how candidate actions will affect the environment, and the distance model rates predicted sequences based on which bring the agent closest to the user-defined goal state. This mechanism works as follows: given the current state $s _ { t }$ , goal state $s _ { g }$ , candidate actions $a _ { t : t + h - 1 }$ , and predicted future states $\hat { f } _ { \theta } \big ( s _ { t } , a _ { t : t + h - 1 } \big )$ from the learned dynamics model, the learned distance function calculates
+
+![](images/b1d59cf4b4c446d136c4a42eaf4b97b19a8f7229430231bbc8ca89a89fd04a24.jpg)  
+Figure 3: Comparative evaluation results: (Left) Example initial states and task definitions for Sawyer object pushing and Franka door sliding simulated environments, as well as the real-world drawer closing task. Note that “hard” tasks require the arm to take detours from moving to the final arm position in order to relocate the object. Arrows indicate successful trajectories. (Right) MBOLD is consistently able to outperform prior methods on these harder manipulation tasks, and by a larger margin on the most difficult tasks (“hard” variants of object pushing and door sliding). Error bars show standard deviations over 5 seeds.
+
+$$
+V ( a _ { t : t + h - 1 } ) = \operatorname* { m a x } _ { \alpha } Q _ { \phi } ( \hat { f } _ { \theta } ( s _ { t } , a _ { t : t + h - 1 } ) [ t + h ] , \alpha , s _ { g } ) .
+$$
+
+In practice, the maximization over $\alpha$ is performed by an actor network learned simultaneously with the Q-function. $V \big ( a _ { t : t + h - 1 } \big )$ acts as an objective function for MPC. Plainly, the controller’s goal is to find candidate actions $a _ { t : t + h - 1 }$ which minimize the dynamical distance to the goal $h$ steps into the future. After this process completes, the best action is executed by the agent. Note that this controller re-plans after every action taken in the environment (i.e every timestep), in order to prevent errors in dynamics prediction from compounding.
+
+MPC Algorithm. MBOLD uses the CEM algorithm (De Boer et al., 2005) to optimize the objective in Equation 3. It begins by sampling $N$ random trajectories from a prior multi-variate Gaussian distribution. Then, the top $K$ actions which score highest according to $V \big ( a _ { t : t + h - 1 } \big )$ are selected as candidates. A new Gaussian distribution is fit on these candidates, and the loop starts over again by sampling fresh actions from this distribution. After $I$ iterations, the loop finishes and returns the best action found so far. See Appendix A.2 for full CEM implementation details.
+
+# 5 EXPERIMENTS
+
+Our experiments aim to answer three questions: (1) How does MBOLD compare to prior modelbased and model-free methods when learning to reach goals from task-agnostic offline data? (2) Can our method perform visual robotic manipulation in real-world settings? (3) How do different dynamical distance learning methods compare to MBOLD in terms of providing effective distance functions for planning?
+
+We first evaluate our method, prior methods, and baselines on three simulated tasks with visual observations: (1) a simple reaching task that requires moving a Sawyer 7-DoF arm to a goal location, which provides a way to validate implementations of all methods, (2) object pushing, in which a Sawyer arm must relocate an object to a particular goal location, in environments with 1 or 3 objects, and (3) door sliding, which requires repositioning a sliding door with a Franka 7-DoF arm. These tasks are challenging because they require long-horizon planning without access to intermediate rewards.
+
+For each task, we define the action space $\mathcal { A }$ such that actions control the Cartesian position of the robot’s end-effector, as well as the robot’s gripper. We randomly generate a set of 100 test goals, consisting of a goal image and starting state, for each task, on which all methods are tested. A trial is considered successful if the final distance to the goal of each relevant object, e.g. slide position for the door sliding task, ends below a given threshold. For the object relocation task, we evaluate each method on two scenes, containing one and three objects. All evaluation goals require the robot to move one of the objects, with the others serving as distractors. We also study two levels of difficulty: “regular,” where goals are generated from random trajectories in which the object moves a certain minimum distance, and “hard,” where the arm is additionally enforced to be distant from the object in the goal observation, requiring the robot to push the object and then withdraw the arm. We depict the tasks in Fig. 3 (left) and provide full experimental details in Appendix A.3.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>MBOLD(ours)</td><td rowspan=1 colspan=1>Visual Foresight(l2 pixel error)</td></tr><tr><td rowspan=1 colspan=1>Drawer openDrawer close</td><td rowspan=1 colspan=1>8/107/10</td><td rowspan=1 colspan=1>5/100/10</td></tr></table>
+
+![](images/14c5be2eba13f19f3a92ff9e7a2e2fb1eba3c98b298301060b95708137a616c1.jpg)  
+Figure 4: Real-world robot evaluation: (Left) Third-person view of an example task setting and (Right) results. Success rates are computed using 10 trials for each task. Each task is specified by a goal image, and as in previous experiments, the same trained models are used across tasks. Task success is determined by the final position of the drawer only.
+
+For all tasks, we generate an offline dataset by running random policies for 1e4 episodes of 30 timesteps each. We provide only this offline dataset to all methods, with no online training. At test time, the agent only receives the goal image and current observation at each step, and no intermediate rewards besides those that it computes itself.
+
+Comparative evaluation. We compare MBOLD to prior work in model-based and model-free RL. As MBOLD uses purely offline data and does not require rewards from the environment, we make modifications to these methods where necessary to provide a fair comparison. Many of these prior methods (though not all) require the environment to provide a ground truth reward signal. In this case, we provide these methods with simple “uninformative” rewards, following prior work (Nair et al., 2018), which consist of the MSE between the current and goal image. Many of these methods were initially presented in the online setting. The offline setting is harder for RL methods (Fujimoto et al., 2019; Wu et al., 2019; Kumar et al., 2019), partially explaining their poor performance.
+
+![](images/36eca5ec5a8f3d3aa7868b5a72ae88ffcadb761c5c29a42c10bdd705f74a3699.jpg)  
+Figure 5: Comparisons on the simple reaching task, where most methods attain good performance.
+
+See Appendix B for details on all baselines. We compare MBOLD to the following methods:
+
+• Reinforcement Learning with Imagined Goals (RIG) (Nair et al., 2018): RIG is a model-free RL method for visual goal-reaching. Unlike the other methods, we still allow RIG to collect additional online data to train its policy. Dreamer (Hafner et al., 2019a): Dreamer, a model-based method for image-based tasks, also uses a combination of value functions and planning, but uses online data collection and, crucially, ground truth reward signals. We adapt Dreamer for the offline, reward-free setting. Dreamer $\ell _ { 2 }$ arm distance: We additionally compare with an “oracle” version of Dreamer that uses privileged information about the ground-truth position of the arm.   
+• Search on the Replay Buffer (SoRB) (Eysenbach et al., 2019): SoRB performs planning on a graph constructed using learned distances, learned without a reward function.   
+• Goal-Conditioned Behavior Cloning: We train a behavior cloning model using goals sampled from observations achieved further in a given trajectory. This can be viewed as an offline variant of GCSL (Ghosh et al., 2019) or a non-recurrent version of Lynch et al. (2020).   
+• Visual Foresight (Ebert et al., 2018b): Visual Foresight also plans with an action-conditioned video prediction model, but uses (among other choices) $\ell _ { 2 }$ pixel error as a cost function.
+
+Since all methods are trained from offline data with no additional environment interaction, we present final performance on the test goals as a bar graph, rather than learning curves. The comparison on the simple reaching task is shown in Figure 5, and suggests that on this task, many of the methods perform quite well. However, on the substantially more complex tasks, shown in Figure 3, we see clearer differentiation between the different algorithms. On harder object pushing tasks, MBOLD attains the best performance, by a considerable margin. Interestingly, simple goalconditioned behavioral cloning actually represents one of the strongest baselines on this task. On the hardest simulated door sliding task, our method attains the best performance by a large margin.
+
+![](images/c1d8ef3d8acd9d193273207cec8e46e02d2f02d1f9be7be0f82b0b856e5f2017.jpg)  
+Figure 6: Heatmap visualizations of our distance functions. Each pixel in every heatmap represents the distance between a generated starting image containing the object at that $( x , y )$ coordinate and the fixed goal image (pictured on left). All three distance functions show a minimum when the object position is near the goal position of $( 0 . 1 , - 0 . 0 5 )$ . However, our Q-function produces a better-shaped signal than the direct regression model, and avoids occlusion errors - like the local minimum at high $_ y$ -values, which plague pixel-wise MSE.
+
+Real-world evaluation. We additionally evaluate MBOLD in a real-world drawer manipulation task using a 7-DoF Franka arm. We train the dynamics model and distance function on a preexisting dataset of 1000 trajectories collected by a weakly supervised batch exploration algorithm in prior work (Chen et al., 2020). As shown in Figure 4, MBOLD outperforms visual foresight on both manipulation tasks with visual inputs, particularly on drawer closing, for which simply matching the arm position in the goal image does not solve the task. The success of our method in this domain highlights that our method can be applied to offline datasets collected using different exploration strategies. While MBOLD performs well on manipulation tasks even with complex real-world visuals, we find that the negative sampling procedure we adopt limits precision in matching highly actuated components such as the arm position. We perform additional analysis through simulated experiments detailed in Appendix E.1. Videos of both simulated and real-world task execution can be found at the project website: https://sites.google.com/berkeley.edu/mbold.
+
+Qualitative analysis. In this section, we examine the distance functions learned by MBOLD, and show qualitatively that our learned distances better model the dependence of functional separation between two states on the relative positions of objects in their scenes. Figure 6 presents heatmaps of predicted distances for a fixed goal image on the object pushing task, as the initial observation is varied based on object position. The robot arm is set to the same position in each initial image. We see that the Qfunction is able to learn a relatively well-shaped distance which accounts for the object position.
+
+We additionally visualize baseline distance models for comparison. First, we look at an ablation of our distance model, which is trained via re
+
+![](images/ef8e09d5433e32ef67caac4de3646b991dc050f1f94e1ec84d893f940cf4bc89.jpg)  
+Figure 7: Our learned distance function yields higher success rates than alternative approaches from prior work, such as the $\ell _ { 2 }$ distance of a VAE latent space (Nair et al., 2018) and temporal distance regression (Hartikainen et al., 2019). We also see consistent improvements from using negative transition mining, especially on “hard” tasks.
+
+gression to map pairs of states randomly sampled from a given dataset trajectory to the number of timesteps separating them in that trajectory, and can be viewed as an offline variant of DDL (Hartikainen et al., 2019). We call this scheme that effectively predicts random walk distances “temporal distance regression.” The second baseline we compare to is pixel-wise mean-squared error.
+
+We find that the temporal distance regression model produces more sharply peaked distances than the Q-function, and performed worse as a reward signal during planning, as we find through our ablation experiments. The pixel-wise MSE metric produces low distances near the goal object position, but is impacted by occlusions of the objects as well as the position of the visually pronounced arm. While this analysis does not necessarily directly correspond to control performance, as it ignores the movement of the robot, it demonstrates that our learned distances are aware of the functional similarity of nearby object positions, despite the fact that they are learned entirely from images with actions corresponding to the movement of the arm, not the object.
+
+Ablations. Our ablation studies aim to answer three questions: (1) How does Q-learning for learning dynamical distances compare to alternative distance metrics, such as distance in the latent space of a VAE, or dynamical distances learned using direct regression on temporal distances found in random data? (2) How important is mining negative transitions to the performance of our method? (3) How beneficial is it to combine the learned distance function with planning through a predictive model, as compared to directly acting using the learned policy, as in standard model-free offline RL?
+
+To answer the first two questions, we perform experiments in the object pushing domain. We evaluate alternative distance metrics for visual planning, by duplicating the planning setup, using the same dynamics model, and only modifying the metric used for scoring candidate trajectories. The first distance we consider is Euclidean distance in the latent space of a VAE, that is, $d ( s , g ) = \lVert e ( s ) - e ( g ) \rVert _ { 2 }$ , where $e$ is a learned encoder, which resembles the reward function used in prior work on image-based goal reaching (Nair et al., 2018). The second is the direct temporal distance regression model described previously. As shown in Figure 7, Q-function distances outperform alternative distances on all of the object pushing tasks. While the temporal distance regression scheme provides competitive performance in some settings, it often provides overestimates of distances between states rather than shortest paths, as shown qualitatively in Figure 6.
+
+We also find that the negative transition mining scheme also consistently improves performance, and is particularly important for the “hard” tasks. We hypothesize this is because augmenting the training data in this way causes learned distance functions to better take into account the positions of objects in the scene, rather than just visually prominent components such as arm position.
+
+Table 1: Comparison of success rates $\pm$ standard deviation across 5 random training seeds for our method, which combines Q-functions and planning with a model, to a baseline that uses the Q-function to choose actions directly without planning.
+
+To address the third question, we compare our method, which uses learned distances for planning, to the policy discovered when performing Q-learning to learn dynamical distances. As shown in Table 1, the policy learned directly
+
+<table><tr><td></td><td>Q-function + planning</td><td>Q-function only</td></tr><tr><td>1 object push 3 object push Reach</td><td>55.2± 4.3% 44.8± 2.9% 94.4 ± 3.3%</td><td>19.2 ±3.6% 15.6 ± 3.6% 31.8± 5.2%</td></tr></table>
+
+from offline RL alone is greatly outperformed by MBOLD. We hypothesize that this is due to challenges in advantage learning from offline data with extremely sparse rewards.
+
+# 6 CONCLUSION
+
+We presented a self-supervised approach to tackling goal-reaching tasks, which learns to reach unseen visual goals given only an offline, random dataset without reward labels. Our method combines the strengths of predictive models and learned dynamical distances, where a predictive model can provide effective predictions for planning actions over short horizons, while dynamical distances can provide a useful planning cost that captures distance to goals over longer horizons. By performing visual model predictive control with a learned visual dynamics model and a goal conditioned Q-function as the planning cost, we find that our method is able to perform goal reaching tasks more effectively than model-based planning approaches that utilize other reward specification techniques, as well as purely model-free methods. We show that MBOLD can also scale to real-world manipulation settings and learn from offline datasets collected with various exploration strategies, outperforming visual foresight on a drawer manipulation task. By leveraging offline data collected without a specific goal in mind, our method may make it possible to utilize large, unstructured, openworld robotic manipulation datasets. Scaling up this method to more complex real-world systems and large data sources therefore represents a particularly exciting direction for future work, which may broaden the capabilities and generality of robotic systems.
+
+Acknowledgements. We thank students from the Robotic AI and Learning Lab for insightful feedback on earlier drafts of this paper and Aurick Zhou and Danijar Hafner for helpful discussions. This work was supported in part by Schmidt Futures, the Fannie and John Hertz Foundation, the Office of Naval Research (grants N00014-20-1-2675, N00014-16-1-2420, & N00014-19-1-2042), and the National Science Foundation (DGE-1745016 and through an NSF GRFP (GRFP 2018259676)). This research used the Savio computational cluster resource provided by the Berkeley Research Computing program at the University of California, Berkeley.
+
+# REFERENCES
+
+Brandon Amos, Laurent Dinh, Serkan Cabi, Thomas Rothorl, Sergio G ¨ omez Colmenarejo, Alistair ´ Muldal, Tom Erez, Yuval Tassa, Nando de Freitas, and Misha Denil. Learning awareness models, 2018.
+
+Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAI Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in neural information processing systems, pp. 5048–5058, 2017.
+
+Arthur Argenson and Gabriel Dulac-Arnold. Model-based offline planning. arXiv preprint arXiv:2008.05556, 2020.
+
+Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. arXiv preprint arXiv:1710.11252, 2017.
+
+Matthew Botvinick and Ari Weinstein. Model-based hierarchical reinforcement learning and human action control. Philosophical Transactions of the Royal Society B: Biological Sciences, 369 (1655):20130480, 2014.
+
+Annie S. Chen, HyunJi Nam, Suraj Nair, and Chelsea Finn. Batch exploration with examples for scalable robotic reinforcement learning, 2020.
+
+Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. In Advances in Neural Information Processing Systems, pp. 4754–4765, 2018.
+
+Pieter-Tjerk De Boer, Dirk P Kroese, Shie Mannor, and Reuven Y Rubinstein. A tutorial on the cross-entropy method. Annals of operations research, 134(1):19–67, 2005.
+
+M. Deisenroth and C. Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In ICML, 2011.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009.
+
+Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. arXiv preprint arXiv:1802.07687, 2018.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Yiming Ding, Carlos Florensa, Pieter Abbeel, and Mariano Phielipp. Goal-conditioned imitation learning. In Advances in Neural Information Processing Systems, pp. 15324–15335, 2019.
+
+Kefan Dong, Yuping Luo, Tianhe Yu, Chelsea Finn, and Tengyu Ma. On the expressivity of neural networks for deep reinforcement learning. In International Conference on Machine Learning, pp. 2627–2637. PMLR, 2020.
+
+Frederik Ebert, Sudeep Dasari, Alex X. Lee, S. Levine, and Chelsea Finn. Robustness via retrying: Closed-loop robotic manipulation with self-supervised learning. In Conference on Robot Learning, 2018a.
+
+Frederik Ebert, Chelsea Finn, Sudeep Dasari, Annie Xie, Alex Lee, and Sergey Levine. Visual foresight: Model-based deep reinforcement learning for vision-based robotic control. arXiv preprint arXiv:1812.00568, 2018b.
+
+Ben Eysenbach, Russ R Salakhutdinov, and Sergey Levine. Search on the replay buffer: Bridging planning and reinforcement learning. In Advances in Neural Information Processing Systems, pp. 15246–15257, 2019.
+
+Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In 2017 IEEE International Conference on Robotics and Automation (ICRA), pp. 2786–2793. IEEE, 2017.
+
+Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In Advances in neural information processing systems, pp. 64–72, 2016.
+
+Carlos Florensa, Jonas Degrave, Nicolas Heess, Jost Tobias Springenberg, and Martin Riedmiller. Self-supervised learning of image embedding for continuous control, 2019.
+
+Scott Fujimoto, Herke Hoof, and David Meger. Addressing function approximation error in actorcritic methods. In International Conference on Machine Learning, pp. 1582–1591, 2018.
+
+Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration. In International Conference on Machine Learning, pp. 2052–2062, 2019.
+
+Dibya Ghosh, Abhishek Gupta, Ashwin Reddy, Justin Fu, Coline Devin, Benjamin Eysenbach, and Sergey Levine. Learning to reach goals via iterated supervised learning, 2019.
+
+David Ha and Jurgen Schmidhuber. World models, 2018. ¨
+
+Danijar Hafner, Timothy Lillicrap, Jimmy Ba, and Mohammad Norouzi. Dream to control: Learning behaviors by latent imagination. arXiv preprint arXiv:1912.01603, 2019a.
+
+Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. In International Conference on Machine Learning, pp. 2555–2565. PMLR, 2019b.
+
+Kristian Hartikainen, Xinyang Geng, Tuomas Haarnoja, and Sergey Levine. Dynamical distance learning for semi-supervised and unsupervised skill discovery. In International Conference on Learning Representations, 2019.
+
+Michael Janner, Justin Fu, Marvin Zhang, and Sergey Levine. When to trust your model: Modelbased policy optimization. In Advances in Neural Information Processing Systems, pp. 12519– 12530, 2019.
+
+Jeff Johnson, Matthijs Douze, and Herve J ´ egou. Billion-scale similarity search with gpus. ´ arXiv preprint arXiv:1702.08734, 2017.
+
+Leslie Pack Kaelbling. Learning to achieve goals. In IN PROC. OF IJCAI-93, pp. 1094–1098. Morgan Kaufmann, 1993.
+
+Gregory Kahn, Pieter Abbeel, and Sergey Levine. Badgr: An autonomous self-supervised learningbased navigation system. arXiv preprint arXiv:2002.05700, 2020.
+
+Rahul Kidambi, Aravind Rajeswaran, Praneeth Netrapalli, and Thorsten Joachims. Morel: Modelbased offline reinforcement learning. In Advances in neural information processing systems, 2020.
+
+Aviral Kumar, Justin Fu, Matthew Soh, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning via bootstrapping error reduction. In Advances in Neural Information Processing Systems, pp. 11784–11794, 2019.
+
+Aviral Kumar, Aurick Zhou, George Tucker, and Sergey Levine. Conservative q-learning for offline reinforcement learning. arXiv preprint arXiv:2006.04779, 2020.
+
+Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine. Stochastic adversarial video prediction. arXiv preprint arXiv:1804.01523, 2018.
+
+Alex X. Lee, Anusha Nagabandi, Pieter Abbeel, and Sergey Levine. Stochastic latent actor-critic: Deep reinforcement learning with a latent variable model, 2019.
+
+Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643, 2020.
+
+Kara Liu, Thanard Kurutach, Christine Tung, Pieter Abbeel, and Aviv Tamar. Hallucinative topological memory for zero-shot visual planning. 2020.
+
+Kendall Lowrey, Aravind Rajeswaran, Sham Kakade, Emanuel Todorov, and Igor Mordatch. Plan Online, Learn Offline: Efficient Learning and Exploration via Model-Based Control. In International Conference on Learning Representations (ICLR), 2019.
+
+Corey Lynch, Mohi Khansari, Ted Xiao, Vikash Kumar, Jonathan Tompson, Sergey Levine, and Pierre Sermanet. Learning latent plans from play. In Conference on Robot Learning, pp. 1113– 1132, 2020.
+
+Ajay Mandlekar, Fabio Ramos, Byron Boots, Li Fei-Fei, Animesh Garg, and Dieter Fox. Iris: Implicit reinforcement without interaction at scale for learning control from offline robot manipulation data. arXiv preprint arXiv:1911.05321, 2019.
+
+Rowan McAllister and C. Rasmussen. Improving pilco with bayesian neural network dynamics models. 2016.
+
+Anusha Nagabandi, Gregory Kahn, Ronald S Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 7559–7566. IEEE, 2018.
+
+Anusha Nagabandi, Kurt Konolige, Sergey Levine, and Vikash Kumar. Deep dynamics models for learning dexterous manipulation. In Conference on Robot Learning, pp. 1101–1112, 2020.
+
+Ashvin Nair, Shikhar Bahl, Alexander Khazatsky, Vitchyr Pong, Glen Berseth, and Sergey Levine. Contextual imagined goals for self-supervised robotic learning. In Conference on Robot Learning, pp. 530–539, 2020a.
+
+Ashvin Nair, Murtaza Dalal, Abhishek Gupta, and Sergey Levine. Accelerating online reinforcement learning with offline datasets. arXiv preprint arXiv:2006.09359, 2020b.
+
+Ashvin V Nair, Vitchyr Pong, Murtaza Dalal, Shikhar Bahl, Steven Lin, and Sergey Levine. Visual reinforcement learning with imagined goals. In Advances in Neural Information Processing Systems, pp. 9191–9200, 2018.
+
+Suraj Nair and Chelsea Finn. Hierarchical foresight: Self-supervised learning of long-horizon tasks via visual subgoal generation. In International Conference on Learning Representations (ICLR), 2020.
+
+Soroush Nasiriany, Vitchyr Pong, Steven Lin, and Sergey Levine. Planning with goal-conditioned policies. In Advances in Neural Information Processing Systems, pp. 14843–14854, 2019.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. arXiv preprint arXiv:1606.05250, 2016.
+
+Nikolay Savinov, Alexey Dosovitskiy, and Vladlen Koltun. Semi-parametric topological memory for navigation. In International Conference on Learning Representations (ICLR), 2018.
+
+Julian Schrittwieser, Ioannis Antonoglou, Thomas Hubert, Karen Simonyan, Laurent Sifre, Simon Schmitt, Arthur Guez, Edward Lockhart, Demis Hassabis, Thore Graepel, Timothy Lillicrap, and David Silver. Mastering atari, go, chess and shogi by planning with a learned model, 2019.
+
+H. J. Terry Suh and Russ Tedrake. The surprising effectiveness of linear models for visual foresight in object pile manipulation, 2020.
+
+Richard S Sutton. Dyna, an integrated architecture for learning, planning, and reacting. ACM Sigart Bulletin, 2(4):160–163, 1991.
+
+Tingwu Wang and Jimmy Ba. Exploring model-based planning with policy networks, 2019.
+
+David Warde-Farley, Tom Van de Wiele, Tejas Kulkarni, Catalin Ionescu, Steven Hansen, and Volodymyr Mnih. Unsupervised control through non-parametric discriminative rewards, 2018.
+
+Manuel Watter, Jost Springenberg, Joschka Boedecker, and Martin Riedmiller. Embed to control: A locally linear latent dynamics model for control from raw images. In Advances in neural information processing systems, pp. 2746–2754, 2015.
+
+Theophane Weber, S ´ ebastien Racani ´ ere, David P. Reichert, Lars Buesing, Arthur Guez, \` Danilo Jimenez Rezende, Adria Puigdomenech Badia, Oriol Vinyals, Nicolas Heess, Yujia Li, \` Razvan Pascanu, Peter Battaglia, Demis Hassabis, David Silver, and Daan Wierstra. Imaginationaugmented agents for deep reinforcement learning, 2017.
+
+Yifan Wu, George Tucker, and Ofir Nachum. Behavior regularized offline reinforcement learning. arXiv preprint arXiv:1911.11361, 2019.
+
+Lin Yen-Chen, Maria Bauza, and Phillip Isola. Experience-embedded visual foresight. In Conference on Robot Learning, 2019.
+
+Tianhe Yu, Deirdre Quillen, Zhanpeng He, Ryan Julian, Karol Hausman, Chelsea Finn, and Sergey Levine. Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning. In Conference on Robot Learning (CoRL), 2019a. URL https://arxiv.org/abs/1910. 10897.
+
+Tianhe Yu, Gleb Shevchuk, Dorsa Sadigh, and Chelsea Finn. Unsupervised visuomotor control through distributional planning networks. Robotics: Science and Systems XV, Jun 2019b. doi: 10.15607/rss.2019.xv.020. URL http://dx.doi.org/10.15607/RSS.2019.XV.020.
+
+Tianhe Yu, Garrett Thomas, Lantao Yu, Stefano Ermon, James Zou, Sergey Levine, Chelsea Finn, and Tengyu Ma. Mopo: Model-based offline policy optimization. In Advances in neural information processing systems, 2020.
+
+Mingyuan Zhong, Mikala Johnson, Yuval Tassa, Tom Erez, and Emanuel Todorov. Value function approximation and model predictive control. In 2013 IEEE symposium on adaptive dynamic programming and reinforcement learning (ADPRL), pp. 100–107. IEEE, 2013.
+
+# A MBOLD IMPLEMENTATION DETAILS
+
+# A.1 DISTANCE FUNCTION
+
+This section explains the implementation details for our distance function. Following prior work (Fujimoto et al., 2018), we learn two independent Q-functions and use the minimum for performing Bellman backups. Recall that we sampled goals from two distributions: future states in the same trajectories, and states from different trajectories where the robot arm was in a similar position. To implement the second strategy, we fit a $k$ -nearest neighbors graph on 200000 (about $6 0 \%$ of total) dataset observations, and use the $\ell _ { 2 }$ arm joint distance as the similarity key. Each batch contains equal numbers of transitions generated from each goal sampling method. For computational efficiency, we implement the $k$ -NN search using the GPU-enabled FAISS library (Johnson et al., 2017).
+
+We relabel half of the transitions in each training batch with reached goals and the other half with “negative” goals with similar actuated components, finding through ablation experiments that this combination achieves stronger performance compared to using just reached goals in our evaluation environments. In other domains, more careful consideration is required to determine if the assumptions which motivate this “negative” goal sampling strategy are satisfied.
+
+We also modify the reward specification scheme by providing a small positive reward at each step where the goal is not reached, and then a large positive reward upon reaching the goal. Specifically, we choose to give a reward of 1 by default and 10 when the goal is reached (compared to 0 and 1 respectively as presented in the discussion in Section 4), although we do not extensively tune this parameter. We find that it does not affect performance in a statistically significant way (results for each reward choice are within 1 standard deviation of one another) to choose this reward over the $( 0 , 1 )$ rewards. Note that this does not change the interpretation of the Q-function as a shortest path distance, merely slightly complicating the conversion calculations from Q-values to distances in timesteps.
+
+Finally, we add an additional loss term to perform conservative Q-learning (CQL) (Kumar et al., 2020), a method for offline model-free RL, which penalizes Q-values of randomly selected actions and increases Q-values of in-dataset actions. We use the Lagrangian version of CQL to automatically tune the weighting term, and detail the parameters below. We find using CQL improves performance on the door sliding task from a mean success rate of $4 1 \%$ to $5 8 \%$ , but does not significantly impact performance on the others.
+
+The Q-function network architecture consists of convolutional and fully connected layers. We define a network called the convolutional encoder, which will be used throughout the appendix. This takes as input an image of shape $6 4 \times 6 4 \times 6$ , containing the starting and goal images concatenated channelwise, and consists of 4 2D convolutional layers, with [8, 16, 32, 64] filters, respectively, with all with kernel size $( 4 , 4 )$ and strides of $( 2 , 2 )$ . We use Leaky ReLU activations after each intermediate convolutional layer, and batch-norm layers after the second and third Leaky ReLUs.
+
+We flatten the output of the convolutional encoder, concatenate the inputted actions, and feed the features through 6 fully-connected linear layers of 128 units each, with the final layer outputting a single value. Each intermediate fully-connected layer is followed by a ReLU activation and a batch-norm layer.
+
+The actor network architecture first contains the above “convolutional encoder”, whose outputs are flattened and input into a 10 layer MLP with 128 fully connected units each, and ReLU activations and batch-norm layers in between. The final output, of dimension 4, is passed through a tanh activation to constrain it to the normalized action space $[ - 1 , 1 ]$ .
+
+Additional training hyperparameters are detailed in Table 2.
+
+# A.2 MODEL-PREDICTIVE CONTROL
+
+In Table 3, we describe the parameters for model-based planning in our experiments. These parameters are shared across all tasks and planning costs (in ablation experiments). Most values are selected based on prior work (Ebert et al., 2018b). We find that replanning every 6 steps produces slightly better performance than replanning every 13 steps, but not by a large margin, and we do not tune this further due to computation constraints. We sample actions using the filtering scheme described in Nagabandi et al. (2020) to make sequences smoother in time. We initialize sampling distributions using each environment’s data collection parameters, as shown in Table 4.
+
+Table 2: Hyperparameters for distance learning   
+
+<table><tr><td rowspan=1 colspan=1>Parameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=1 colspan=1>Dataset size</td><td rowspan=1 colspan=1>10000 trajectories</td></tr><tr><td rowspan=1 colspan=1>Train/test/val split</td><td rowspan=1 colspan=1>0.9/0.05/0.05</td></tr><tr><td rowspan=1 colspan=1>Trajectory length</td><td rowspan=1 colspan=1>30 steps</td></tr><tr><td rowspan=1 colspan=1>Observation dimensions</td><td rowspan=1 colspan=1>64×64×3</td></tr><tr><td rowspan=1 colspan=1>Stateobservations inkNN graph</td><td rowspan=1 colspan=1>200000</td></tr><tr><td rowspan=1 colspan=1>Goal relabeling sampling parameter (p)</td><td rowspan=1 colspan=1>0.3 (tuned over [0.2, 0.3])</td></tr><tr><td rowspan=1 colspan=1>Discount factor (y)</td><td rowspan=1 colspan=1>0.8</td></tr><tr><td rowspan=1 colspan=1>Learning rate</td><td rowspan=1 colspan=1>3e-4</td></tr><tr><td rowspan=1 colspan=1>Target network update Polyak factor</td><td rowspan=1 colspan=1>0.995</td></tr><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>64</td></tr><tr><td rowspan=1 colspan=1>Actor network noise o</td><td rowspan=1 colspan=1>0.1</td></tr><tr><td rowspan=1 colspan=1>Actor network maximum noise magnitude</td><td rowspan=1 colspan=1>0.2</td></tr><tr><td rowspan=1 colspan=1>Training iterations</td><td rowspan=1 colspan=1>93750 (300 epochs)</td></tr><tr><td rowspan=1 colspan=1>Optimizer</td><td rowspan=1 colspan=1>Adam</td></tr><tr><td rowspan=1 colspan=1>CQL Lagrange multiplier learning rate</td><td rowspan=1 colspan=1>1e-3</td></tr><tr><td rowspan=1 colspan=1>CQL slack parameter T (object pushing)</td><td rowspan=1 colspan=1>3.0</td></tr><tr><td rowspan=1 colspan=1>CQL slack parameter T (reaching)</td><td rowspan=1 colspan=1>3.0</td></tr><tr><td rowspan=1 colspan=1>CQL slack parameter 7 (door sliding)</td><td rowspan=1 colspan=1>10.0</td></tr><tr><td rowspan=1 colspan=1>CQL number of randomly selected actions</td><td rowspan=1 colspan=1>10</td></tr></table>
+
+To compute the planning cost described in Equation 3, we maximize over $\alpha$ by feeding in the final predicted state to the policy network learned by TD3, and using the outputted action as the maximizer.
+
+Table 3: Hyperparameters for model-based planning   
+
+<table><tr><td rowspan=1 colspan=1>Parameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=1 colspan=1>Planning horizon (h)</td><td rowspan=1 colspan=1>13 steps</td></tr><tr><td rowspan=1 colspan=1>Actions executed per planning step (k)</td><td rowspan=1 colspan=1>6 actions</td></tr><tr><td rowspan=1 colspan=1>CEMIterations</td><td rowspan=1 colspan=1>3iterations</td></tr><tr><td rowspan=1 colspan=1>Elite sample fraction</td><td rowspan=1 colspan=1>0.05 (10 samples)</td></tr><tr><td rowspan=1 colspan=1>Samplesper CEMiteration</td><td rowspan=1 colspan=1>200 samples</td></tr></table>
+
+# A.3 ENVIRONMENTS
+
+The Sawyer environments are adapted from the Meta-World benchmark (Yu et al., 2019a), and the door sliding environment is based off of the environment presented by Lynch et al. (2020). For each task, we define the 4-dimensional action space $\mathcal { A }$ such that actions control the Cartesian position of the robot’s end-effector, as well as the robot’s gripper.
+
+We randomly generate a set of 100 different test goals for each setting. Each task is defined by a goal image and starting state, on which all methods are tested. We define success for each task in terms of the final distance to the goal of each relevant object, e.g. object position for the object repositioning task. A trial is considered successful if the final distance is below a certain threshold $\epsilon$ manually chosen for each task, listed in the table below. We evaluate the success rate of each method over 5 different random training seeds.
+
+We generate offline datasets for each task by running random policies for $1 e 4$ episodes of 30 timesteps each. In the beginning of each episode, object positions are reset uniformly randomly over the range of possible positions across each joint. The random policy actions are drawn using a filtering technique, which smooths random zero-mean Gaussian samples across time. We apply the
+
+correlated noise scheme described by Nagabandi et al. (2020), setting the hyperparameter $\beta = 0 . 5$ .   
+The parameters of the multi-variate Gaussian samples in each dimension are listed in Table 4.
+
+Table 4: Environment and task details   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Reaching</td><td rowspan=1 colspan=1>Object pushing</td><td rowspan=1 colspan=1>Door sliding</td></tr><tr><td rowspan=1 colspan=1>Data colln. stdev (diag(Σ))</td><td rowspan=1 colspan=1>[0.6, 0.6, 0.3, 0.3]</td><td rowspan=1 colspan=1>[0.6, 0.6, 0.3, 0.3]</td><td rowspan=1 colspan=1>[0.3, 0.3, 0.3, 0.15]</td></tr><tr><td rowspan=1 colspan=1>Object compared in success threshold</td><td rowspan=1 colspan=1>Arm end effector</td><td rowspan=1 colspan=1>Block</td><td rowspan=1 colspan=1>Slide</td></tr><tr><td rowspan=1 colspan=1>Success distance threshold</td><td rowspan=1 colspan=1>0.05m</td><td rowspan=1 colspan=1>0.05m</td><td rowspan=1 colspan=1>0.075m</td></tr></table>
+
+# B COMPARATIVE EVALUATION IMPLEMENTATION DETAILS
+
+B.1 REINFORCEMENT LEARNING WITH IMAGINED GOALS (NAIR ET AL., 2018)
+
+In this section, we will discuss implementation details of our adaptation of Reinforcement Learning with Imagined Goals (RIG). We begin by training a $\beta$ -VAE with latent dimension 8. The VAE is trained on randomly sampled states from the entire offline dataset. For the loss, we use a combination of a maximum likelihood term and a KL divergence term which constrains the latent space to a unit Gaussian. In particular, we compute the mean pixel error, that is, $\frac { 1 } { H W } \| s - \hat { s } \| _ { 2 } ^ { 2 }$ , where $s$ is the original image, and $\hat { s }$ is the reconstruction, both normalized to be in $[ 0 , 1 ]$ . We add this to the KL divergence between the latent distribution and the unit Gaussian, with a weighting factor of $1 e ^ { - 3 }$ on the KL penalty.
+
+The architecture of the VAE encoder consists of the “convolutional encoder” described in section A.1, whose features are passed through two FC layers with 128 units with a ReLU activation and batch-norm layer in between. The VAE decoder takes as input latent states into two FC layers with 128 units with a batch-norm layer and ReLU activation after each. This is followed by the inverted architecture of the encoder, consisting of transposed 2D convolutions.
+
+Then, we perform model-free RL in a modified MDP, using encoded observations as a substitute for environment observations, and computing rewards as negative $\ell _ { 2 }$ distances in latent space. We sample random goals from the multivariate Gaussian prior $( \mathcal { N } ( 0 , I ) )$ at the beginning of every episode. We use the open-source implementation of soft actor-critic (SAC) in RLKit, and use the default SAC parameters and architecture found in the implementation, making the following modifications: We increase the number of layers of all MLP networks from 2 to 6. We use a maximum path length of 30 steps for consistency with our other experiments, and a discount factor of 0.95. Along with the goal sampled from the prior at the beginning of each episode, we find that relabeling goals with the achieved observation at the end of the trajectory improves performance, and add these transitions to the replay buffer as well. Note that unlike in the original RIG formulation, we do not update the weights of the learned VAE using data collected online. We evaluate the learned policy after 600 epochs of training, long after environment returns plateau.
+
+# B.2 DREAMER (HAFNER ET AL., 2019A)
+
+Dreamer, a model-based method for image-based tasks, also uses a combination of value functions and planning. We adapt Dreamer from its original single-task setting to learn a goal-conditioned policy, reward predictor, and value function; however, we do not condition the dynamics model on the goal. Dreamer has been previously demonstrated only in settings where the environment provides rewards to the agent, so we modify the method to learn from unlabeled, offline data by using experience replay. We find that using an indicator reward function as in our method or a heuristically defined reward function, image MSE, causes Dreamer to struggle to learn. We thus additionally demonstrate the performance of Dreamer using a manually specified arm distance reward for the Sawyer reaching task.
+
+We build off of the open source implementation of Dreamer by the original authors, written in TensorFlow2 and found at https://github.com/danijar/dreamer. Specifically, to modify the networks to support goal-conditioning, we add independent convolutional encoders which take the goal image as input to each network. Each encoder consists of 2D convolution layers with [32, 64, 128, 256] filters and kernel sizes of 4 to each network, and we concatenate the flattened features to the inputs of each network. We additionally increase the number of fully-connected layers for the value and actor networks from 3 and 2 respectively to 10. We use a discount factor of $\gamma = 0 . 9 5$ . All other hyperparameter values are defaults from the public implementation.
+
+For training, we relabel trajectories sampled from the fixed, offline dataset with a uniformly randomly selected observation from the trajectory as the goal. In most of our experiments, we compute the negative pixel-wise MSE as the reward, but in one reaching experiment, we use the negative $\ell _ { 2 }$ Euclidean distance between the arm end-effector position and the goal end-effector position. We train for 2000 iterations for each experiment, although initial experiments in which we trained for $2 0 \mathbf { x }$ longer did not yield improved results.
+
+# B.3 GOAL-CONDITIONED BEHAVIOR CLONING
+
+To train a goal-conditioned behavior cloning policy, we begin by relabeling random transitions from the dataset with goals which are later achieved in those trajectories. Specifically, we sample stategoal pairs from trajectories in the dataset by first selecting the initial state index $t _ { i }$ uniformly from all timesteps, and then selecting the goal state index $t _ { g }$ uniformly from timesteps greater than $t _ { i }$ . We then train a neural network to predict the transition action $a _ { i }$ given the state $s _ { i }$ and the relabeled goal $s _ { g }$ , using a mean-squared error loss.
+
+The network architecture is the same as that of the actor network used in Q-learning for MBOLD, described in Appendix A.1. We train the model for 3125000 iterations (1000 epochs) using a batch size of 32, and use the same optimizer and learning rate as the distance learned for MBOLD.
+
+B.4 SEARCH ON THE REPLAY BUFFER (EYSENBACH ET AL., 2019)
+
+For Search on the Replay Buffer (SoRB), we train a distributional Q-function to represent distances as in the original paper. Distributional RL discretizes possible value estimates into a set of bins – we use 10 for all of our experiments. We train this distributional Q-function for 300 epochs, as in the distance function training for MBOLD. We also use the same architecture and training scheme, altering the number of outputs to 10 bins and using the KL-divergence loss for the distributional Q-function as in Eysenbach et al. (2019). However, unlike in Eysenbach et al. (2019), we train on just the fixed, offline dataset. We then perform the planning portion of SoRB with the “maxdist” parameter set to 4, after manual tuning. We use a graph size of 2000 states for all experiments, due to computational constraints.
+
+We find that the policy learned through Q-learning performs very poorly at reaching subgoals, so we instead substitute the goal-conditioned behavior cloning policy for this purpose. We find that this greatly improves performance across all tasks.
+
+# B.5 VISUAL FORESIGHT (EBERT ET AL., 2018B)
+
+To compare MBOLD to visual foresight, we use the same dynamics model and planning setup as in MBOLD, however, we substitute the learned dynamical distance function with the $\ell _ { 2 }$ pixel error cost used in visual foresight.
+
+# C ABLATION EXPERIMENTS IMPLEMENTATION DETAILS
+
+# C.1 VAE DISTANCE
+
+We use the same architecture as the VAE used in the RIG comparison described in Appendix B. We set the latent space dimension to 256 and weight the KL divergence term using a factor of $1 e ^ { - 5 }$ . We train the model for 3125000 iterations (1000 epochs) using a batch size of 32, and use the same optimizer and learning rate as the distance learned for MBOLD.
+
+# C.2 TEMPORAL DISTANCE REGRESSION
+
+To train the temporal distance regression model, we sample state-goal pairs from trajectories in the dataset by first selecting the initial state index $t _ { i }$ uniformly from all timesteps, and then selecting the goal state index $t _ { g }$ uniformly from timesteps greater than $t _ { i }$ . We compute the label for this pair as $\operatorname* { m i n } ( t _ { g } - t _ { i } , m a \bar { x } d i s t )$ , where maxdist is a hyperparameter we set to 10. The maxdist parameter helps to improve the optimality of distances on average. We train the neural network to regress this target label using an $\ell _ { 2 }$ error loss. We train the network for 3125000 iterations (1000 epochs) with a batch size of 32, and use the same optimizer and learning rate as the distance learned for MBOLD.
+
+The architecture for the temporal distance regression model begins with the convolutional encoder described in Appendix B. Its flattened outputs are fed into 5 fully-connected layers of 256 units each, with batch-norm and ReLU activations after each intermediate layer.
+
+# C.3 Q-FUNCTION POLICY
+
+We find that the policy directly learned by our method when learning distances performs extremely poorly. However, performing Q-learning using random shooting over 100 uniformly random actions selected from $[ - 1 , \bar { 1 } ] ^ { 4 }$ to optimize over actions to compute target values produces much better results when used directly as a policy, compared to using an actor network to perform this optimization as in our method. Therefore, we report results from acting according to this random shooting method. At test time, we estimate the optimal action $a ^ { \star } = \arg \operatorname* { m a x } _ { a } Q ( s _ { t } , a , g )$ by again sampling 100 uniformly random actions, and selecting the best one.
+
+# D COMPUTATIONAL COMPLEXITY ANALYSIS
+
+In this section, we discuss the computation complexity of training and acting using MBOLD.
+
+Training: Training the dynamics model takes about $3 0 \mathrm { h r }$ while training the distance function takes about $5 \mathrm { h r }$ . These training times are dwarfed by the cost of collecting data in the real world, which could take on the order of 3-4 days in the real world (but can be reused for various tasks). In contrast, a single RL approach only requires learning the distance function. While this means that it takes MBOLD significantly longer to train than the single RL approach, note that the dynamics model can be shared across many tasks. We train the dynamics model for $2 0 0 \mathrm { k }$ and distance function for 94k training steps. A training step for the dynamics model involves one forward and backward pass through the dynamics model. A training step for the distance function requires sampling positive and negative goals, two Q-function forward passes and a policy network forward pass to compute target values and current Q-values, and a backward pass to update model parameters. In contrast, a single RL approach would just learn the distance function, not the dynamics model. From the above estimates, this means that training steps for the dynamics model are around 3 times slower than training steps for the distance model. Because the dynamics model can be used to perform many tasks, this cost is amortized over these tasks, as compared to a single RL approach.
+
+Acting: Selecting a sequence of actions (6 actions in our experiments) using MBOLD requires one forward pass of the dynamics model for each CEM iteration (3 total in our experiments), and one forward pass through the distance function and policy network. Amortized over a trajectory, this amounts to about 2 seconds wall clock time per action, which can be sped up by around $2 \mathbf { x }$ with similar performance by replanning less frequently. For a single RL approach, each action would require just one forward pass through the policy network.
+
+# E ABLATION EXPERIMENTS
+
+# E.1 NEGATIVE MINING & ACTUATED STATE COMPONENTS
+
+The ablation experiments presented in Section 5 demonstrate that the negative mining technique can improve performance on manipulation tasks, as evaluated by the final position of the object being manipulated. However, in experiments performed in the real-world Franka drawer setting which only required the robot arm to “reach” to a particular location to match the goal, we found that MBOLD achieved a mean final Euclidean distance to goal of $0 . 1 4 \mathrm { { m } }$ , while Visual Foresight achieved 0.066m over 10 trials. Here, we conduct additional experiments in simulation to investigate the effect of negative mining on reaching goals based on accuracy of matching the highly actuated components, for example, the robot arm. In the single-object block pushing setting, we evaluate the performance of distance functions trained with and without negative mining on reaching the desired goal arm position. We perform the evaluation using (1) the set of test goals used in our original experiments, which include object movement, and (2) an additional set of test goals which only require robot arm movement. We present the results in Table 6. We find that training without negative mining improves the planner’s ability to reach goal arm positions when goals also require object movement, but note that this results in weaker performance in actually relocating those objects, establishing a trade-off. When goals are selected to require just arm movement, performance is comparable with and without the negative sampling scheme.
+
+# E.2 PLANNING HORIZON ABLATIONS
+
+In this section, we investigate the effect of the planning horizon $h$ on control performance. After training distance functions according to Appendix A.1, we perform planning with three different settings for $h$ on the simulated block pushing tasks. We present the results in Figure 8. We find that a longer planning horizon is beneficial, especially for solving more difficult tasks. We hypothesize that this is because longer planning horizons allow the planner and distance function to better distinguish promising predicted states, while the fidelity of state predictions remains relatively high.
+
+# E.3 RANDOM OBJECT RESET ABLATIONS
+
+In this section, we perform experiments to evaluate the impact of the distribution of initial object position on task performance. In particular, we look at the single-object Sawyer pushing task. We collect an additional dataset with the same policy and other parameters as that used in the main comparative evaluations, but restrict the random object initialization position to be within $[ - 0 . 0 5 , 0 . 0 5 ] ^ { 2 }$ as opposed to $[ - 0 . 2 , 0 . 2 ] ^ { 2 }$ . This represents a 16x reduction in the area of possible initializations. We then train a new dynamics model and distance function from scratch and compare the control performance on the same benchmark tasks from the main comparisons. We present the results in Table 5. We find that the control performance on these tasks remain within one standard deviation despite the restriction in reset position.
+
+![](images/4fbeca00daca303e81c62fbc28356fbefde8de390d6f0377eda2c111356e3d90.jpg)  
+Figure 8: Results for planning horizon ablations.
+
+Table 5: Comparison of success rates for our method when trained using a dataset where object positions at the start of each episode were greatly restricted, compared to uniform over the entire space. Standard deviations are over 5 random seeds.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Uniform reset</td><td rowspan=1 colspan=1>Restricted reset</td></tr><tr><td rowspan=1 colspan=1>1 object push (regular)1 object push (hard)</td><td rowspan=1 colspan=1>55.2 ± 4.3%40.2 ± 7.2%</td><td rowspan=1 colspan=1>54.5 ± 3.9%43.2 ± 7.2%</td></tr></table>
+
+Table 6: Effect of training using negative mining on final arm position matching performance. A final $\ell _ { 2 }$ distance to goal arm position of $0 . 0 5 \mathrm { m }$ or less is considered a success. Standard deviations of success rates are computed over 5 random seeds.
+
+<table><tr><td rowspan=1 colspan=1>Test goals</td><td rowspan=1 colspan=1>MBOLD</td><td rowspan=1 colspan=1>MBOLD (nonegative mining)</td></tr><tr><td rowspan=1 colspan=1>No object movementObject movement</td><td rowspan=1 colspan=1>89.2 ±1.9%64.4± 5.9%</td><td rowspan=1 colspan=1>91.6 ± 2.3%83.4± 4.0%</td></tr></table>