Add files using upload-large-folder tool

parse/train/S1gOpsCctm/S1gOpsCctm.md

@@ -0,0 +1,239 @@
+# LEARNING FINITE STATE REPRESENTATIONS OF RECURRENT POLICY NETWORKS
+
+Anurag Koul & Alan Fern   
+School of EECS   
+Oregon State University   
+Corvallis, Oregon, USA   
+{koula,alan.fern}@oregonstate.edu   
+Sam Greydanus ∗   
+Google Brain   
+Mountain View, California, USA   
+sgrey@google.com
+
+# ABSTRACT
+
+Recurrent neural networks (RNNs) are an effective representation of control policies for a wide range of reinforcement and imitation learning problems. RNN policies, however, are particularly difficult to explain, understand, and analyze due to their use of continuous-valued memory vectors and observation features. In this paper, we introduce a new technique, Quantized Bottleneck Insertion, to learn finite representations of these vectors and features. The result is a quantized representation of the RNN that can be analyzed to improve our understanding of memory use and general behavior. We present results of this approach on synthetic environments and six Atari games. The resulting finite representations are surprisingly small in some cases, using as few as 3 discrete memory states and 10 observations for a perfect Pong policy. We also show that these finite policy representations lead to improved interpretability.
+
+# 1 INTRODUCTION
+
+Deep reinforcement learning (RL) and imitation learning (IL) have demonstrated impressive performance across a wide range of applications. Unfortunately, the learned policies are difficult to understand and explain, which limits the degree that they can be trusted and used in high-stakes applications. Such explanations are particularly problematic for policies represented as recurrent neural networks (RNNs) (Mnih et al., 2016; Mikolov et al., 2010), which are increasingly used to achieve state-of-the-art performance (Mnih et al., 2015; Silver et al., 2017). This is because RNN policies use internal memory to encode features of the observation history, which are critical to their decision making, but extremely difficult to interpret. In this paper, we take a step towards comprehending and explaining RNN policies by learning more compact memory representations.
+
+Explaining RNN memory is challenging due to the typical use of high-dimensional continuous memory vectors that are updated through complex gating networks (e.g. LSTMs, GRUs (Hochreiter & Schmidhuber, 1997; Chung et al., 2014; Cho et al., 2014)). We hypothesize that, in many cases, the continuous memory is capturing and updating one or more discrete concepts. If exposed, such concepts could significantly aid explainability. This motivates attempting to quantize the memory and observation representation used by an RNN to more directly capture those concepts. In this case, understanding the memory use can be approached by manipulating and analyzing the quantized system. Of course, not all RNN policies will have compact quantized representations, but many powerful forms of memory usage can be captured in this way.
+
+Our main contribution is to introduce an approach for transforming an RNN policy with continuous memory and continuous observations to a finite-state representation known as a Moore Machine. To accomplish this we introduce the idea of Quantized Bottleneck Network (QBN) insertion. QBNs are simply auto-encoders, where the latent representation is quantized. Given a trained RNN, we train QBNs to encode the memory states and observation vectors that are encountered during the RNN operation. We then insert the QBNs into the trained RNN policy in place of the “wires” that propagated the memory and observation vectors. The combination of the RNN and QBN results in a policy represented as a Moore Machine Network (MMN) with quantized memory and observations that is nearly equivalent to the original RNN. The MMN can be used directly or fine-tuned to improve on inaccuracies introduced by QBN insertion.
+
+While training quantized networks is often considered to be quite challenging, we show that a simple approach works well in the case of QBNs. In particular, we demonstrate that “straight through” gradient estimators as in (Bengio et al., 2013; Courbariaux et al., 2016) are quite effective.
+
+We present experiments in synthetic domains designed to exercise different types of memory use as well as benchmark grammar learning problems. Our approach is able to accurately extract the ground-truth MMNs, providing insight into the RNN memory use. We also did experiments on 6 Atari games using RNNs that achieve state-of-the-art performance. We show that in most cases it is possible to extract near-equivalent MMNs and that the MMNs can be surprisingly small. Further, the extracted MMNs give insights into the memory usage that are not obvious based on just observing the RNN policy in action. For example, we identify games where the RNNs do not use memory in a meaningful way, indicating the RNN is implementing purely reactive control. In contrast, in other games, the RNN does not use observations in a meaningful way, which indicates that the RNN is implementing an open-loop controller.
+
+# 2 RELATED WORK
+
+There have been efforts made in the past to understand the internals of Recurrent Networks (Karpathy et al., 2015; Arras et al., 2017; Strobelt et al., 2016; Murdoch & Szlam, 2017; Jacobsson, 2005; Omlin & Giles, 1996). However, to the best of our knowledge there is no prior work on learning finite-memory representations of continuous RNN policies. Our work, however, is related to a large body of work on learning finite-state representations of recurrent neural networks. Below we summarize the branches of that work and the relationship to our own.
+
+There has been a significant history of work on extracting Finite State Machines (FSMs) from recurrent networks trained to recognize languages (Zeng et al., 1993; Tino et al., 1998; Cechin et al., ˇ 2003). Typical approaches include discretizing the continuous memory space via gridding or clustering followed by minimization. A more recent approach is to use classic query-based learning algorithms to extract FSMs by asking membership and equivalence queries (Weiss et al., 2017). However, none of these approaches directly apply to learning policies, which require extending to Moore Machines. In addition, all of these approaches produce an FSM approximation that is separated from the RNN and thus serve as only a proxy of the RNN behavior. Rather, our approach directly inserts discrete elements into the RNN that preserves its behavior, but allows for a finite state characterization. This insertion approach has the advantage of allowing fine-tuning and visualization using standard learning frameworks.
+
+The work most similar to ours also focused on learning FSMs (Zeng et al., 1993). However, the approach is based on directly learning recurrent networks with finite memory, which are qualitatively similar to the memory representation of our MMNs. That work, however, focused on learning from scratch rather than aiming to describe the behavior of a continuous RNN. Our work extends that approach to learn MMNs and more importantly introduces the method of QBN insertion as a way of learning via guidance from a continuous RNN.This transforms any pre-trained recurrent policy into a finite representation.
+
+We note that there has been prior work on learning fully binary networks, where the activation functions and/or weights are binary (e.g. (Bengio et al., 2013; Courbariaux et al., 2016; Hinton, 2012)). The goal of that line of work is typically to learn more time and space efficient networks. Rather, we focus on learning only discrete representations of memory and observations, while allowing the rest of the network to use arbitrary activations and weights. This is due to our alternative goal of supporting interpretability rather than efficiency.
+
+# 3 RECURRENT POLICY NETWORKS: CONTINUOUS AND QUANTIZED
+
+Recurrent neural networks (RNNs) are commonly used in reinforcement learning to represent policies that require or can benefit from internal memory. At each time step, an RNN is given an observation $o _ { t }$ (e.g. image) and must output an action $a _ { t }$ to be taken in the environment. During execution an RNN maintains a continuous-valued hidden state $h _ { t }$ , which is updated on each transition and influences the action choice. In particular, given the current observation $o _ { t }$ and current state $h _ { t }$ , an RNN performs the following operations: 1) Extract a set of observation features $f _ { t }$ from $o _ { t }$ , for example, using a CNN when observations are images, 2) Outputting an action $a _ { t } = \pi ( h _ { t } )$ according to policy $\pi$ , which is often a linear softmax function of $h _ { t }$ , 3) transition to a new state $h _ { t + 1 } = \bar { \delta } ( f _ { t } , \mathsf { \bar { h } } _ { t } )$ where $\delta$ is the transition function, which is often implemented via different types of gating networks such as LSTMs or GRUs.
+
+The continuous and high dimensional nature of $h _ { t }$ and $f _ { t }$ can make interpreting the role of memory difficult. This motivates our goal of extracting compact quantized representations of $h _ { t }$ and $f _ { t }$ . Such representations have the potential to allow investigating a finite system that captures the key features of the memory and observations. For this purpose we introduce Moore Machines and their deep network counterparts.
+
+Moore Machines. A classical Moore Machine (MM) is a standard finite state machine where all states are labeled by output values, which in our case will correspond to actions. In particular, a Moore Machine is described by a finite set of (hidden) states $\hat { H }$ , an initial hidden state $\hat { h } _ { 0 }$ , a finite set of observations $\hat { O }$ , a finite set of actions $A$ , a transition function $\hat { \delta }$ , and a policy $\hat { \pi }$ that maps hidden states to actions. The transition function $\hat { \delta } : \hat { H } \times \hat { O }  \hat { H }$ returns the next hidden state $\hat { h } _ { t + 1 } = \hat { \delta } ( \hat { h } _ { t } , \hat { o } _ { t } )$ given the current state $\hat { h } _ { t }$ and observation $\hat { o } _ { t }$ . By convention we will use $h _ { t }$ and $\hat { h } _ { t }$ to denote continuous and discrete states respectively and similarly for other quantities and functions.
+
+Moore Machine Networks. A Moore Machine Network (MMN) is a Moore Machine where the transition function $\hat { \delta }$ and policy $\hat { \pi }$ are represented via deep networks. In addition, since the raw observations given to an MMN are often continuous, or from an effectively unbounded set (e.g. images), an MMN will also provide a mapping $\hat { g }$ from the continuous observations to a finite discrete observation space $\hat { O }$ . Here $\hat { g }$ will also be represented via a deep network. In this work, we consider quantized state and observation representations where each $\hat { h } \in \hat { H }$ is a discrete vector and each discrete observation in $\hat { O }$ is a discrete vector that describes the raw observation. We will denote the quantization level as $k$ and the dimensions of $\hat { h }$ and $\hat { f }$ by $B _ { h }$ and $B _ { f }$ respectively.
+
+Based on the above discussion, an MMN can be viewed as a traditional RNN, where: 1) The memory is restricted to be composed of $k$ -level activation units, and 2) The environmental observations are intermediately transformed to a $k$ -level representation $\hat { f }$ before being fed to the recurrent module. Given an approach for incorporating quantized units into the backpropagation process, it is straightforward, in concept, to learn MMNs from scratch via standard RNN learning algorithms. However, we have found that learning MMNs from scratch can be quite difficult for non-trivial problems, even when an RNN can be learned with relative ease. For example, we have not been able to train highperforming MMNs from scratch for Atari games. Below we introduce a new approach for learning MMNs that is able to leverage the ability to learn RNNs.
+
+# 4 LEARNING MOORE MACHINE NETWORKS FROM RNNS
+
+Given a trained RNN, our key idea is to first learn quantized bottleneck networks (QBNs) for embedding the continuous observation features and hidden state into a $k$ -level quantized representation. We will then insert the QBNs into the original recurrent net in such a way that its behavior is minimally changed with the option of fine-tuning after insertion. The resulting network can be viewed as consuming quantized features and maintaining quantized state, which is effectively an MMN. Below we describe the steps in further detail, which are illustrated in Figure 1.
+
+# 4.1 QUANTIZED BOTTLENECK NETWORKS
+
+A QBN is simply an autoencoder where the latent representation between the encoder and decoder (i.e. the bottleneck) is constrained to be composed of $k$ -level activation units. While, traditional autoencoders are generally used for the purpose of dimensionality reduction in continuous space (Hinton & Salakhutdinov, 2006), QBNs are motivated by the goal of discretizing a continuous space. Conceptually, this can be done by quantizing the activations of units in the encoding layer.
+
+![](images/8e6ffec04cb5d48cb94463e00191c657158e780f30ce437df980135cd9a97c85.jpg)  
+Figure 1: Learning Moore Machine Networks. (1.) Learn an RNN policy. (2.) Learn QBN’s to quantize memory and observations. (3.) Insertion and Fine Tuning. The modules labelled O, R are observation feature-extraction and recurrent modules, respectively
+
+We represent a QBN via a continuous multilayer encoder $E$ , which maps inputs $x$ to a latent encoding $E ( x )$ , and a corresponding multilayer decoder $D$ . To quantize the encoding, the QBN output is given by
+
+$$
+b ( x ) = D ( { \mathrm { q u a n t i z e } } ( E ( x ) ) )
+$$
+
+In our case, we use 3-level quantization in the form of $+ 1 , 0$ and $- 1$ using the quantize function, which assumes the outputs of $E ( x )$ are in the range $[ - 1 , 1 ]$ .1 One choice for the output nodes of $E ( x )$ would be the tanh activation. However, since the gradient of tanh is close to 1 near 0, it can be difficult to produce quantization level 0 during learning. Thus, as suggested in Pitis (2017), to support 3-valued quantization we use the following activation function, which is flatter in the region around zero input.
+
+$$
+\phi ( x ) = 1 . 5 \operatorname { t a n h } ( x ) + 0 . 5 \operatorname { t a n h } ( - 3 x )
+$$
+
+Of course introducing the quantize function in the QBN results in $b ( x )$ being non-differentiable, making it apparently incompatible with backpropagation, since the gradients between the decoder and encoder will almost always be zero. While there are a variety of ways to deal with this issue, we have found that the straight-through estimator, as suggested and used in prior work (Hinton, 2012; Bengio et al., 2013; Courbariaux et al., 2016) is quite effective. In particular, the standard straightthrough estimator of the gradient simply treats the quantize function as the identity function during back-propagation. Overall, the inclusion of the quantize function in the QBN effectively allows us to view the last layer of $E$ as producing a $k$ -level encoding. We train a QBN as an autoencoder using the standard $L _ { 2 }$ reconstruction error $\| x - b ( x ) \| ^ { 2 }$ for a given input $x$ .
+
+# 4.2 BOTTLENECK INSERTION
+
+Given a recurrent policy we can run the policy in the target environment in order to produce an arbitrarily large set of training sequences of triples $\left( o _ { t } , f _ { t } , h _ { t } \right)$ , giving the observation, corresponding observation feature, and hidden state at time $t$ . Let $F$ and $H$ be the sets of all observed features and states respectively. The first step of our approach is to train two QBNs, $b _ { f }$ and $b _ { h }$ , on $F$ and $H$ respectively. If the QBNs are able to achieve low reconstruction error then we can view latent “bottlenecks” of the QBNs as a high-quality $k$ -level encodings of the original hidden states and features.
+
+We now view $b _ { f }$ and $b _ { h }$ as “wires” that propagate the input to the output, with some noise due to imperfect reconstruction. We insert these wires into the original RNN in the natural way (stage-3 in Figure 1). The $b _ { f }$ QBN is inserted between the RNN units that compute the features $f$ and the nodes those units are connected to. The $b _ { h }$ QBN is inserted between the output of the recurrent network block and the input to the recurrent block. If $b _ { f }$ and $b _ { h }$ always produced perfect reconstructions, then the result of inserting them as described would not change the behavior of the RNN. Yet, the RNN can now be viewed as an MMN since the bottlenecks of $b _ { f }$ and $b _ { h }$ provide a quantized representation of the features $f _ { t }$ and states $h _ { t }$ .
+
+Fine Tuning. In practice, the QBNs will not achieve perfect reconstruction and thus, the resulting MMN may not behave identically to the original RNN. Empirically, we have found that the performance of the resulting MMN is often very close to the RNN directly after insertion. However, when there is non-trivial performance degradation, we can fine-tune the MMN by training on the original rollout data of the RNN. Importantly, since our primary goal is to learn a representation of the original RNN, during fine-tuning our objective is to have the MMN match the softmax distribution over actions produced by the RNN. We found that training in this way was significantly more stable than training the MMN to simply output the same action as the RNN.
+
+# 4.3 MOORE MACHINE EXTRACTION AND MINIMIZATION
+
+After obtaining the MMN, one could use visualization and other analysis tools to investigate the memory and it’s feature bits in order to gain a semantic understanding of their roles. Solving the full interpretation problem in a primitive way is beyond the scope of this work.
+
+Extraction. Another way to gain insight is to use the MMN to produce an equivalent Moore Machine over atomic state and observation spaces, where each state and observation is a discrete symbol. This machine can be analyzed to understand the role of different machine states and how they are related. In order to create the Moore Machine we run the learned MMN to produce a dataset of $< \hat { h } _ { t - 1 } , \hat { f } _ { t } , \hat { h } _ { t } , a _ { t } > ,$ , giving the consecutive pairs of quantized states, the quantized features that led to the transition, and the action selected after the transition. The state-space of the Moore Machine will correspond to the $p$ distinct quantized states in the data and the observation-space of the machine will be the $q$ unique quantized feature vectors in the data. The transition function of the machine $\hat { \delta }$ is constructed from the data by producing a $p \times q$ transaction table that captures the transitions seen in the data.
+
+Minimization. In general, the number of states $p$ in the resulting Moore Machine will be larger than necessary in the sense that there is a much smaller, but equivalent, minimal machine. Thus, we apply standard Moore Machine minimization techniques to arrive at the minimal2 equivalent Moore Machine (Paull & Unger, 1959). This often dramatically reduces the number of distinct states and observations.
+
+# 5 SYNTHETIC EXPERIMENTS
+
+Our experiments address the following questions: 1) Is it possible to extract MMNs from RNNs without significant loss in Performance? 2) What is the general magnitude of the number of states and observations in the minimal machines, especially for complex domains such as Atari? 3) Do the learned MMNs help with interpretability of the recurrent policies? In this section, we begin addressing these questions by considering two domains where ground truth Moore Machines are known. The first is a parameterized synthetic environment, Mode Counter, which can capture multiple types of memory use. Second, we consider benchmark grammar learning problems.
+
+# 5.1 MODE COUNTER
+
+The class of Mode Counter Environments (MCEs) allows us to vary the amount of memory required by a policy (including no memory) and the required type of memory usage. In particular, MCEs can require varying amounts of memory for remembering past events and implementing internal counters.
+
+An MCE is a restricted type of Partially Observable Markov Decision Process, which transitions between one of $M$ modes over time according to a transition distribution, which can depend on the current mode and amount of time spent in the current mode. There are $M$ actions, one for each mode, and the agent receives a reward of $+ 1$ at the end of the episode if it takes the correct action associated with the active mode at each time step. The agent does not observe the mode directly, but rather must infer the mode via a combination of observations and memory use. Different parameterizations place different requirements on how (and if) memory needs to be used to infer the mode and achieve optimal performance. Below we give an intuitive description of the $\mathbf { M C E s } ^ { 3 }$ in our experiments.
+
+We conduct experiments in three MCE instances, which use memory and observations in fundamentally different ways. This tests our ability to use our approach for determining the type of memory use. 1) Amnesia. This MCE is designed so that the optimal policy does not need memory to track past information and can select optimal actions based on just the current observation. 2) Blind. Here we consider the opposite extreme, where the MCE observations provide no information about optimal actions. Rather, memory must be used to implement counters that keep track of a deterministic mode sequence for determining the optimal actions. 3) Tracker. This MCE is designed so that the optimal policy must both use observations and memory in order to select optimal actions. Intuitively the memory must implement counters that keep track of key time steps where the observations provide information about the mode. In all above instances, we used $M = 4$ modes.
+
+RNN Training. For each MCE instance we use the following recurrent architecture: the input feeds into 1 feed-forward layer with 4 Relu6 nodes (Krizhevsky & Hinton, 2010) $( f _ { t } )$ , followed by a 1-layer GRU with 8 hidden units $\left( { { h _ { t } } } \right)$ , followed by a fully connected softmax layer giving a distribution over the $M$ actions (one per mode). Since we know the optimal policy in the MCEs we use imitation learning for training. For all of the MCEs in our experiments, the trained RNNs achieve $100 \%$ accuracy on the imitation dataset and appeared to produce optimal policies.
+
+MMN Training. The observation QBN $b _ { f }$ and hidden-state QBN $b _ { h }$ have the same architecture, except that the number of quantized bottleneck units $B _ { f }$ and $B _ { h }$ are varied in our experiments. The encoders consist of 1 feed-forward layer of tanh nodes, where the number of nodes is 4 times the size of the bottleneck. This layer feeds into 1 feedforward layer of quantized bottleneck nodes (see Section 4). The decoder for both $b _ { f }$ and $b _ { h }$ has a symmetric architecture to the encoder. Training of $b _ { f }$ and $b _ { h }$ in the MCE environments was extremely fast compared to the RNN training, since QBNs do not need to learn temporal dependencies. We trained QBNs with bottleneck sizes of $B _ { f } \in \{ 4 , 8 \}$ and $B _ { h } \in \{ 4 , 8 \}$ . For each combination of $B _ { f }$ and $B _ { h }$ we embedded the QBNs into the RNN to give a discrete MMN and then measured performance of the MMN before and after fine tuning. Table 1 gives the average test score over 50 test episodes. Score of 1 indicates the agent performed optimally for all episodes. In most of the cases no fine tuning was required (marked as ’-’) since the agent achieved perfect performance immediately after bottleneck insertion due to low reconstruction error. In all other cases, except for Tracker $B _ { h } = 4$ , $B _ { f } = 4 _ { . }$ ) fine-tuning resulted in perfect MMN performance. The exception yielded $98 \%$ accuracy. Interestingly in that case, we see that if we only insert one of the bottlenecks at a time, we yield perfect performance, which indicates that the combined error accumulation of the two bottlenecks is responsible for the reduced performance.
+
+Moore Machine Extraction. Table 1 also gives the number of states and observations of the MMs extracted from the MMNs both before and after minimization. Recall that the number of states and obsevations before minimization is the number of distinct combinations of values observed for the bottleneck nodes during long executions of the MMN. We see that there are typically significantly more states and observations before minimization than after. This indicates that the MMN learning does not necessarily learn minimal discrete state and observation representations, though the representations accurately describe the RNN. After minimization (Section 4.3), however, in all but one case we get exact minimal machines for each MCE domain. The ground truth minimal machines that are found are shown in the Appendix (Figure 3). This shows that the MMNs learned via QBN insertions were equivalent to the true minimal machines and hence indeed optimal in most cases. The exception matches the case where the MMN did not achieve perfect accuracy.
+
+Examining these machines allows one to understand the memory use. For example, the machine for Blind has just a single observation symbol and hence its transitions cannot depend on the input observations. In contrast, the machine for Amnesia shows that each distinct observation symbol leads to the same state (and hence action choice) regardless of the source state. Thus, the policies action is completely determined by the current observation.
+
+Table 1: Moore Machine extraction for MCE   
+
+<table><tr><td rowspan=2 colspan=1>Game</td><td rowspan=2 colspan=1>Bh,Bf</td><td rowspan=1 colspan=2>Fine-TuningScore</td><td rowspan=1 colspan=3>BeforeMinimization</td><td rowspan=1 colspan=3>AfterMinimization</td></tr><tr><td rowspan=1 colspan=1>Before(%)</td><td rowspan=1 colspan=1>After(%)</td><td rowspan=1 colspan=1>H</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>Acc.(%)</td><td rowspan=1 colspan=1>H</td><td rowspan=1 colspan=1>|0|</td><td rowspan=1 colspan=1>Acc.(%)</td></tr><tr><td rowspan=3 colspan=1>Amnesia</td><td rowspan=2 colspan=1>4,44,8</td><td rowspan=2 colspan=1>0.980.99</td><td rowspan=2 colspan=1>11</td><td rowspan=2 colspan=1>77</td><td rowspan=2 colspan=1>57</td><td rowspan=1 colspan=1>1</td><td rowspan=2 colspan=1>44</td><td rowspan=2 colspan=1>44</td><td rowspan=2 colspan=1>11</td></tr><tr><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>8,48,8</td><td rowspan=1 colspan=1>10.99</td><td rowspan=1 colspan=1>-1</td><td rowspan=1 colspan=1>67</td><td rowspan=1 colspan=1>57</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>44</td><td rowspan=1 colspan=1>44</td><td rowspan=1 colspan=1>11</td></tr><tr><td rowspan=2 colspan=1>Blind</td><td rowspan=1 colspan=1>4,44,8</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>-1</td><td rowspan=1 colspan=1>1212</td><td rowspan=1 colspan=1>68</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>1010</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>11</td></tr><tr><td rowspan=1 colspan=1>8,48,8</td><td rowspan=1 colspan=1>10.78</td><td rowspan=1 colspan=1>-1</td><td rowspan=1 colspan=1>513</td><td rowspan=1 colspan=1>68</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>1010</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>11</td></tr><tr><td rowspan=4 colspan=1>Tracker</td><td rowspan=2 colspan=1>4,44,8</td><td rowspan=2 colspan=1>0.980.99</td><td rowspan=2 colspan=1>0.981</td><td rowspan=2 colspan=1>5823</td><td rowspan=2 colspan=1>55</td><td rowspan=2 colspan=1>0.981</td><td rowspan=2 colspan=1>5010</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0.98</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=2 colspan=1>8,48,8</td><td rowspan=2 colspan=1>0.980.99</td><td rowspan=2 colspan=1>11</td><td rowspan=2 colspan=1>9185</td><td rowspan=2 colspan=1>55</td><td rowspan=2 colspan=1>11</td><td rowspan=2 colspan=1>1010</td><td rowspan=1 colspan=1>4</td><td rowspan=2 colspan=1>11</td></tr><tr><td rowspan=1 colspan=1>4</td></tr></table>
+
+# 5.2 TOMITA GRAMMARS
+
+The Tomita Grammars are popular benchmarks for learning finite state machines (FSMs), including work on extracting FSMs from RNNs (e.g. (Watrous & Kuhn, 1992; Weiss et al., 2017)). Here we evaluate our approach over the 7 Tomita Grammars4, where each grammar defines the set of binary strings that should be accepted or rejected. Since, our focus is on policy learning problems, we treat the grammars as environments with two actions ‘accept’ and ‘reject’. Each episode corresponds to a random string that is either part of the particular grammar or not. The agent receives a reward of 1 if the correct action accept/reject is chosen on the last symbol of a string.
+
+RNN Training. The RNN for each grammar is comprised of a one-layer GRU with 10 hidden units, followed by a fully connected softmax layer with 2 nodes (accept/reject). Since we know the optimal policy, we again use imitation learning to train each RNN using the Adam optimizer and learning rate of 0.001. The training dataset is comprised of an equal number of accept/reject strings with lengths uniformly sampled in the range [1,50]. Table 2 presents the test results for the trained RNNs giving the accuracy over a test set of 100 strings drawn from the same distribution as used for training. Other than grammar $\# 6 ^ { 5 }$ , the RNNs were $100 \%$ accurate.
+
+MMN Training. Since the raw observations for this problem are from a finite alphabet, we don’t need to employ a bottleneck encoder to discretize the observation features. Thus the only bottleneck learned here is $b _ { h }$ for the hidden memory state. We use the same architecture for $b _ { h }$ as used for the MCE experiments and conduct experiments with $B _ { h } \in \{ 8 , 1 6 \}$ . These bottlenecks were then inserted in the RNNs to give MMNs. The performance of the MMNs before and after fine-tuning are shared in Table 2. In almost all cases, the MMN is able to maintain the performance of the RNN without fine-tuning. Fine tuning provides only minor improvements in other cases, which already are achieving high accuracy.
+
+Moore Machine Extraction. Our results for MM extraction and minimization are in Table 2. In each case, we see a considerable reduction in the MM’s state-space after minimization while accurately maintaining the MMN’s performance. Again, this shows that the MMN learning does not directly result in minimal machines, yet are equivalent to the minimal machines and hence are exact solutions. In all cases, except for grammar 6 the minimized machines are identical to the minimal machines that are known for these grammars (Tomita, 1982).
+
+Table 2: Moore Machine extraction for Tomita grammar   
+
+<table><tr><td rowspan=2 colspan=1>#Grammar</td><td rowspan=2 colspan=1>RNNAcc. (%)</td><td rowspan=2 colspan=1>Bh</td><td rowspan=1 colspan=2>Fine-TuningAcc.(%)</td><td rowspan=1 colspan=2>BeforeMinimization</td><td rowspan=1 colspan=2>AfterMinimization</td></tr><tr><td rowspan=1 colspan=1>Before</td><td rowspan=1 colspan=1>After</td><td rowspan=1 colspan=1>H</td><td rowspan=1 colspan=1>Acc.(%)</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>Acc.(%)</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>--</td><td rowspan=1 colspan=1>1328</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>22</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>--</td><td rowspan=1 colspan=1>1314</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>33</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>--</td><td rowspan=1 colspan=1>3439</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>55</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>-1</td><td rowspan=1 colspan=1>1718</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>44</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>95100</td><td rowspan=1 colspan=1>961</td><td rowspan=1 colspan=1>192316</td><td rowspan=1 colspan=1>96100</td><td rowspan=1 colspan=1>1154</td><td rowspan=1 colspan=1>96100</td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>9899</td><td rowspan=1 colspan=1>9899</td><td rowspan=1 colspan=1>100518</td><td rowspan=1 colspan=1>9899</td><td rowspan=1 colspan=1>1211</td><td rowspan=1 colspan=1>9899</td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>-1</td><td rowspan=1 colspan=1>25107</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>55</td><td rowspan=1 colspan=1>100100</td></tr></table>
+
+# 6 ATARI EXPERIMENTS
+
+In this section, we consider applying our technique to RNNs learned for six Atari6 games using the OpenAI gym (Brockman et al., 2016). Unlike the above experiments, where we knew the ground truth MMs, for Atari we did not have any preconception of what the MMs might look and how large they might be. The fact that the input observations for Atari (i.e. images) are much more complex than the previous experiments inputs makes it completely unclear if we can expect similar types of results. There have been other recent efforts towards understanding Atari agents (Zahavy et al., 2016; Greydanus et al., 2017). However, we are not aware of any other work which aims to extract finite state representations for Atari policies.
+
+RNN Training. All the Atari agents have the same recurrent architecture. The input observation is an image frame, preprocessed by gray-scaling, $2 \mathbf { x }$ down-sampling, cropping to an $8 0 \times 8 0$ square and normalizing the values to [0, 1]. The network has 4 convolutional layers (kernel size 3, strides 2, padding 1, and 32,32,16,4 filters respectively). We used Relu as the intermediate activation and Relu6 over the last convolutional layer. This is followed by a GRU layer with 32 hidden units and a fully connected layer with $n { + 1 }$ units, where $n$ is the dimension of the Atari action space. We applied a softmax to first $n$ neurons to obtain the policy and used the last neuron to predict the value function. We used the A3C RL algorithm (Mnih et al., 2016) (learning rate $1 0 ^ { - 4 }$ , discount factor 0.99) and computed loss on the policy using Generalized Advantage Estimation $\lambda = 1 . 0$ ) (Schulman et al., 2015). We report the trained RNN performance on our six games in the second column of Table 3.
+
+MMN Training. We used the same general architecture for the QBN $b _ { f }$ as used for the MCE experiments, but adjusted the encoder input and decoder output sizes to match the dimension of the continuous observation features $f _ { t }$ . For $b _ { h }$ , the encoder has 3 feed-forward layers with $( 8 \times$ $B _ { h . }$ ), $( 4 \times B _ { h } )$ and $B _ { h }$ nodes. The decoder is symmetric to the encoder. For the Atari domains, the training data for $b _ { f }$ and $b _ { h }$ was generated using noisy rollouts. In particular, each training episode was generated by executing the learned RNN for a random number of steps and then executing an $\epsilon$ -greedy (with $\epsilon = 0 . 3$ ) version of the RNN policy. This is intended to increase the diversity of the training data and we found that it helps to more robustly learn the QBNs. We trained bottlenecks for
+
+$B _ { h } \in \{ 6 4 , 1 2 8 \}$ and $B _ { f } \in \{ 1 0 0 , 4 0 0 \}$ noting that these values are significantly larger than for our earlier experiments due to the complexity of Atari. Note that while there are an enormous number of potential discrete states for these values of $B _ { h }$ the actual number of states observed and hence the number of MMN states can be substantially smaller. Each bottleneck was trained to the point of saturation of training loss and then inserted into the RNN to give an MMN for each Atari game.
+
+MMN Performance. Table 3 gives the performance of the trained MMNs before and after finetuning for different combinations of $B _ { h }$ and $B _ { f }$ . We see that for 4 games, Pong, Freeway, Bowling, and Boxing, the MMNs after fine tuning either achieve identical scores to the RNN or very close (in the case of boxing). This demonstrates the ability to learn a discrete representation of the input and memory for these complex games with no impact on performance. We see that for Boxing and Pong fine tuning was required to match the RNN performance. In the case of Freeway and Bowling, fine-tuning was not required.
+
+In the remaining two games, Breakout and Space Invaders, we see that the MMNs learned after fine tuning achieve lower scores than the original RNNs, though the scores are still relatively good. On further investigation, we found that this drop in performance was due to poor reconstruction on some rare parts of the game. For example, in Breakout, after the first board is cleared, the policy needs to press the fire-button to continue, but the learned MMN does not do this and instead times out, which results in less score. This motivates the investigation into more intelligent approaches for training QBNs to capture critical information in such rare, but critically important, states.
+
+MM Minimization. We see from Table 3 that before minimization, the MMs often have relatively large numbers of discrete states and observations. This is unsurprising given that we are using relatively large values of $B _ { h }$ and $B _ { f }$ . However, we see that after minimizing the MMNs the number of states and observations reduces by orders of magnitude, sometimes to just a single state and/or single observation. The number of states and observations in many cases are small enough to write out and analyze by hand, making them amenable to careful analysis. However, this analysis is likely to be non-trivial for moderately complex policies due to the need to understand the “meaning” of the observations and in turn of the states.
+
+Understanding Memory Use. We were surprised to observe in Atari the same three types of memory use considered for the MCE domains above. First, we see that the MM for Pong has just three states (one per action) and 10 discrete observation symbols (see Figure 2a). Most importantly we see that each observation transitions to the same state (and hence action) regardless of the current state. So we can view this MM as defining a set of rule that maps individual observations to actions with no memory necessary. In this sense, the Pong policy is analogous to the Amnesia MCE [5.1].
+
+In contrast, we see that in both Bowling and Freeway there is only one observation symbol in the minimal MM. This means that the MM actually ignores the input image when selecting actions. Rather the policies are open-loop controllers whose action just depends on the time-step rather than the observations. Thus, these policies are analogous to the Blind MCE [5.1]. Freeway has a particularly trivial policy that always takes the Up action at each time step. While this policy behavior could have been determined by looking at the action sequence of the rollouts, it is encouraging that our MM extraction approach also discovered this. As shown in Figure 2b, Bowling has a more interesting open-loop policy structure where it has an initial sequence of actions and then a loop is entered where the action sequence is repeated. It is not immediately obvious that this policy has such an open-loop structure by just watching the policy. Thus, we can see that the MM extraction approach we use here can provide significant additional insight.
+
+Breakout, Space Invaders and Boxing use both memory and observations based on our analysis of the MM transition structures. We have not yet attempted a full semantic analysis of the discrete observations and states for any of the Atari policies. This will require additional visualization and interaction tools and is an important direction of future work that is enabled by our approach.
+
+# 7 SUMMARY AND FUTURE WORK
+
+Motivated by the goal of better understanding memory use in RNN polices, we introduced an approach for extracting finite state Moore Machines from those policies. The key idea, bottleneck insertion, is to train Quantized Bottleneck Networks to produce binary encodings of continuous RNN memory and input features, and then insert those bottlenecks into the RNN. This yields a near equivalent Moore Machine Network (MMN) which has quantized memory and observation features. From the MMN we then extract a discrete Moore machine that can then be transformed into an equivalent minimal machine for analysis and usage. Our results on two environments where the ground truth machines are known show that our approach is able to accurately extract the ground truth. We also show experiments in six Atari games, where we have no prior insight into the ground truth machines. We show that, in most cases, the learned MMNs maintain similar performance to the original RNN policies. Further, the extracted machines provide insight into the memory usage of the policies. First, we see that the number of required memory states and observations is surprisingly small. Second, we can identify cases where the policy did not use memory in a significant way (e.g. Pong) and policies that relied only on memory and ignored the observations (e.g. Bowling and Freeway). To our knowledge, this is the first work where this type of insight was reported for policies in such complex domains. A key direction for future work is to develop tools and visualizations for attaching meaning to the discrete observations and in turn states, which will allow for an additional level of insight into the policies. It is also worth considering the use of tools for analyzing finite-state machine structure to gain further insight and analyze formal properties of the policies.
+
+Table 3: Moore Machine extraction for trained Atari RNN policies. DQN (Mnih et al., 2015), A3C (Mnih et al., 2016) scores have been reported for performance comparison with trained policies.   
+
+<table><tr><td rowspan="3">Game (# of actions)</td><td rowspan="3">DQN (Score)</td><td rowspan="3">A3C LSTM (Score)</td><td rowspan="3">RNN (Score)</td><td rowspan="3">(Bh,Bf)</td><td colspan="2">Fine-Tuning Score</td><td colspan="3">Before Minimization</td><td colspan="3">After Minimization</td></tr><tr><td>Before</td><td>After</td><td>H</td><td>10</td><td>Score</td><td>间</td><td>10</td><td>Score</td></tr><tr><td>20</td><td>21</td><td>380</td><td>374</td><td>21</td><td></td><td></td><td></td></tr><tr><td rowspan="4">Pong (3)</td><td rowspan="4">18.9</td><td rowspan="4">10.7</td><td rowspan="4">21</td><td>64,100 64,400</td><td>20</td><td>21</td><td>373</td><td>372</td><td>21</td><td>4 3</td><td>12 10</td><td>21 21</td></tr><tr><td>128,100</td><td>20</td><td>21</td><td>383</td><td>373</td><td>21</td><td>3</td><td>12</td><td>21</td></tr><tr><td>128,400</td><td>20</td><td>21</td><td>379</td><td>371</td><td>21</td><td>3</td><td>11</td><td>21</td></tr><tr><td>64,100</td><td>21</td><td>：</td><td>11</td><td>11</td><td>21</td><td>11</td><td>1</td><td>21</td></tr><tr><td rowspan="3">Freeway (3)</td><td rowspan="3">30.3</td><td rowspan="3">0.1</td><td rowspan="3">21</td><td>64,400</td><td>21</td><td></td><td></td><td></td><td>21</td><td></td><td></td><td>21</td></tr><tr><td>128,100 128,400</td><td>21 21</td><td>：</td><td>1 1</td><td>1 1</td><td>21 21</td><td>11</td><td>1 1</td><td>21</td></tr><tr><td>64,100</td><td>32</td><td>423</td><td>1898</td><td>1874</td><td>423</td><td>8</td><td>3</td><td>21 423</td></tr><tr><td rowspan="4">Breakout (4)</td><td rowspan="4">401.2</td><td rowspan="4">766.8</td><td rowspan="4">773</td><td>64,400</td><td>25</td><td>415</td><td>1888</td><td>1871</td><td>415</td><td>8</td><td></td><td>415</td></tr><tr><td>128,100</td><td>41</td><td>377</td><td>1583</td><td>1514</td><td>377</td><td>11</td><td>30</td><td>377</td></tr><tr><td>128,400</td><td>85</td><td>379</td><td>1729</td><td>1769</td><td>379</td><td>8</td><td></td><td>379</td></tr><tr><td>64,100</td><td>520</td><td>1335</td><td>1495</td><td>1502</td><td>1335</td><td>8</td><td></td><td>1335</td></tr><tr><td rowspan="3">Space Invaders (4)</td><td rowspan="3">1976</td><td rowspan="3">23846</td><td rowspan="3">1820</td><td>64,400</td><td>365</td><td>1235</td><td>1625</td><td>1620</td><td>1235</td><td>12</td><td>29</td><td>1235</td></tr><tr><td>128,100</td><td>390</td><td>1040</td><td>1563</td><td>1457</td><td>1040</td><td>12</td><td>35</td><td>1040</td></tr><tr><td>128,400</td><td>520</td><td>1430</td><td>1931</td><td>1921</td><td>1430</td><td>6</td><td>27</td><td>1430</td></tr><tr><td rowspan="4">Bowling (6)</td><td rowspan="4">42.4</td><td rowspan="4">41.8</td><td rowspan="4">60</td><td>64,100 64,400</td><td>60</td><td>-</td><td>49</td><td>1</td><td>60</td><td>33</td><td>1</td><td>60</td></tr><tr><td></td><td>60</td><td>-</td><td>49</td><td>1</td><td>60</td><td>33</td><td>1</td><td>60</td></tr><tr><td>128,100</td><td>60</td><td>-</td><td>26</td><td>11</td><td>60</td><td>24</td><td>T</td><td>60</td></tr><tr><td>128,400</td><td>60</td><td>-</td><td>26</td><td></td><td>60</td><td>24</td><td></td><td>60</td></tr><tr><td rowspan="4">Boxing (18)</td><td rowspan="4">71.8</td><td rowspan="4">37.3</td><td rowspan="4">100</td><td>64,100</td><td>94</td><td>100</td><td>1173</td><td>1167</td><td>100</td><td>13</td><td>79</td><td>100</td></tr><tr><td>64,400</td><td>98</td><td>100</td><td>2621</td><td>2605</td><td>100</td><td>14</td><td>119</td><td>100</td></tr><tr><td>128,100</td><td>94</td><td>97</td><td>2499</td><td>2482</td><td>97</td><td>14</td><td>106</td><td>97</td></tr><tr><td>128,400</td><td>97</td><td>100</td><td>1173</td><td>1169</td><td>100</td><td>14</td><td>88</td><td>100</td></tr></table>
+
+![](images/d3fb4e58681fc6a910ba757405979178b3787603f3c9e9e2303e94b5bbb72621.jpg)  
+Figure 2: Moore Machine representation for Atari policies
+
+# REFERENCES
+
+Leila Arras, Gregoire Montavon, Klaus-Robert M ´ uller, and Wojciech Samek. Explaining recurrent ¨ neural network predictions in sentiment analysis. arXiv preprint arXiv:1706.07206, 2017.
+
+Yoshua Bengio, Nicholas Leonard, and Aaron Courville. Estimating or propagating gradients ´ through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.
+
+Adelmo Luis Cechin, D Regina, P Simon, and K Stertz. State automata extraction from recurrent neural nets using k-means and fuzzy clustering. In Chilean Computer Science Society, 2003. SCCC 2003. Proceedings. 23rd International Conference of the, pp. 73–78. IEEE, 2003.
+
+Kyunghyun Cho, Bart Van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014.
+
+Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.
+
+Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained to $+ 1$ or-1. arXiv preprint arXiv:1602.02830, 2016.
+
+Sam Greydanus, Anurag Koul, Jonathan Dodge, and Alan Fern. Visualizing and understanding atari agents. arXiv preprint arXiv:1711.00138, 2017.
+
+Geoffrey Hinton. Neural networks for machine learning. video lectures, 2012.
+
+Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural networks. science, 313(5786):504–507, 2006.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Henrik Jacobsson. Rule extraction from recurrent neural networks: Ataxonomy and review. Neural Computation, 17(6):1223–1263, 2005.
+
+Andrej Karpathy, Justin Johnson, and Li Fei-Fei. Visualizing and understanding recurrent networks. arXiv preprint arXiv:1506.02078, 2015.
+
+Alex Krizhevsky and Geoff Hinton. Convolutional deep belief networks on cifar-10. Unpublished manuscript, 40(7), 2010.
+
+Tom Mikolov, Martin Karafiat, Luk Burget, and Sanjeev Khudanpur.´ Recurrent neural network based language model. INTERSPEECH 2010, 11th Annual Conference of the International Speech Communication Association, pp. 1045–1048, 2010. URL http://www.fit.vutbr.cz/research/groups/speech/publi/2010/ mikolov_interspeech2010_IS100722.pdf.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518, 2015. doi: 10.1038/nature14236. URL https://storage.googleapis. com/deepmind-media/dqn/DQNNaturePaper.pdf.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International conference on machine learning, pp. 1928–1937, 2016.
+
+W James Murdoch and Arthur Szlam. Automatic rule extraction from long short term memory networks. arXiv preprint arXiv:1702.02540, 2017.
+
+Christian W Omlin and C Lee Giles. Extraction of rules from discrete-time recurrent neural networks. Neural networks, 9(1):41–52, 1996.
+
+Marvin C Paull and Stephen H Unger. Minimizing the number of states in incompletely specified sequential switching functions. IRE Transactions on Electronic Computers, (3):356–367, 1959.
+
+Silviu Pitis. Beyond binary: Ternary and one-hot neurons. https://r2rt.com/ beyond-binary-ternary-and-one-hot-neurons.html, 2017.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. arXiv preprint arXiv:1506.02438, 2015.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy Lillicrap, Fan Hui, Laurent Sifre, George van den Driessche, Thore Graepel, and Demis Hassabis. Mastering the game of Go without human knowledge. Nature Publishing Group, 550, 2017. doi: 10.1038/nature24270. URL https://www.nature.com/nature/journal/ v550/n7676/pdf/nature24270.pdf.
+
+Hendrik Strobelt, Sebastian Gehrmann, Bernd Huber, Hanspeter Pfister, and Alexander M Rush. Visual analysis of hidden state dynamics in recurrent neural networks. arXiv preprint arXiv:1606.07461, 2016.
+
+Peter Tino, Bill G Horne, C Lee Giles, and Pete C Collingwood. Finite state machines and recurrent ˇ neural networksautomata and dynamical systems approaches. In Neural networks and pattern recognition, pp. 171–219. Elsevier, 1998.
+
+Masaru Tomita. Dynamic construction of finite-state automata from examples using hill-climbing. In Proceedings of the Fourth Annual Conference of the Cognitive Science Society, pp. 105–108, 1982.
+
+Raymond L Watrous and Gary M Kuhn. Induction of finite-state automata using second-order recurrent networks. In Advances in neural information processing systems, pp. 309–317, 1992.
+
+Gail Weiss, Yoav Goldberg, and Eran Yahav. Extracting automata from recurrent neural networks using queries and counterexamples. arXiv preprint arXiv:1711.09576, 2017.
+
+Tom Zahavy, Nir Ben-Zrihem, and Shie Mannor. Graying the black box: Understanding dqns. In International Conference on Machine Learning, pp. 1899–1908, 2016.
+
+Zheng Zeng, Rodney M Goodman, and Padhraic Smyth. Learning finite state machines with selfclustering recurrent networks. Neural Computation, 5(6):976–990, 1993.
+
+# APPENDIX
+
+# 7.1 FORMAL DEFINITION OF MODE COUNTER ENVIRONMENT
+
+An MCE is parameterized by the mode number $M$ , a mode transition function $P$ , a mode life span mapping $\Delta ( m )$ that assigns a positive integer to each mode, and a count set $C$ containing zero or more natural numbers. At time $t$ the MCE hidden state is a tuple $( m _ { t } , c _ { t } )$ , where $\overline { { m _ { t } } } ~ \in ~ \{ 1 , 2 , \dots , M \}$ is the current mode and $c _ { t }$ is the count of time-steps that the system has been consecutively in mode $m _ { t }$ . The mode only changes when the lifespan is reached, i.e. $c _ { t } = \Delta ( m _ { t } ) - 1$ , upon which the next mode $m _ { t + 1 }$ is generated according to the transition distribution $P ( m _ { t + 1 } \mid m _ { t } )$ . The transition distribution also specifies the distribution over initial modes. The agent does not directly observe the state, but rather, the agent only receives a continuous-valued observations $o _ { t } \in [ 0 , 1 ]$ at each step, based on the current state $( m _ { t } , c _ { t } )$ . If $c _ { t } \in C$ then $o _ { t }$ is drawn uniformly at random from $[ m _ { t } / M , ( m _ { t } + 1 ) / M ) ]$ and otherwise $o _ { t }$ is drawn uniformly at random from [0, 1]. Thus, observations determine the mode when the mode count is in $C$ and otherwise the observations are uninformative. Note that the agent does not observe the counter. This means that to keep track of the mode for optimal performance the agent must remember the current mode and use memory to keep track of how long the mode has been active, in order to determine when it needs to “pay attention” to the current observation.
+
+We conduct experiments with the following three MCE instances 7: 1) Amnesia. This MCE uses $\Delta ( m ) = 1$ for all modes, $C = \{ 0 \}$ , and uniformly samples random initial mode and transition distributions. Thus, an optimal policy will not use memory to track information from the past, since the current observation alone determines the current mode. This tests our ability to use MMN extraction to determine that a policy is purely reactive, i.e. not using memory. 2) Blind. Here we use deterministic initial mode and transition distributions, mode life spans that can be larger than 1, and $C = \{ \}$ . Thus, the observations provide no information about the mode and optimal performance can only be achieved by using memory to keep track of the deterministic mode sequence. This allows us to test whether the extraction of an MMN could infer that the recurrent policy is ignoring observations and only using memory. 3) Tracker. This MCE is identical to Amnesia, except that the $\Delta ( m )$ values can be larger than 1. This requires an optimal policy to pay attention to observations when $c _ { t } = 0$ and use memory to keep track of the current mode and mode count. This is the most general instance of the environment and can result in difficult problems when the number of modes and their life-spans grow. In all above instances, we used $M = 4$ .
+
+# 7.2 GROUND TRUTH MCE MOORE MACHINES
+
+![](images/e7cd336a61b1fc10f2f80cbc3c40f5d29f9a8092c3204b02c29226434987d837.jpg)  
+Figure 3: Moore machine representation of Mode Counter Environments (MCE). We use $\cdot _ { m }$ ’ to indicate the activate mode/action required in that state. Given $M = 4$ , we have 4 observations classes, $o _ { 1 } = ( 0 , 0 . 2 5 ]$ , $o _ { 2 } = ( 0 . 2 5 , 0 . 5 ]$ , $o _ { 3 } = ( 0 . 5 , 0 . 7 5 ]$ and $o _ { 4 } = ( 0 . 7 5 , 1 ]$ . Also, $^ { O _ { * } }$ implies that the transaction is valid for all observations. The minimal moore machines extracted by our approach from trained RNN policies exactly matches these ground truth machines.
+
+![](images/a4e9003bcecc0374482ab76fa7dba9d19edd23d300fd319d7e789d2735b16e1e.jpg)  
+Figure 4: Extracted Moore machine representation for Tomita Grammar policies where $B _ { h } = 1 6$ . We use ‘A’ and $\cdot _ { \mathrm { R } } \cdot$ to denote accept and reject states, respectively. Other than Grammar 6, all machines are $100 \%$ accurate.

parse/train/S1gOpsCctm/S1gOpsCctm_content_list.json

@@ -0,0 +1,1342 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING FINITE STATE REPRESENTATIONS OF RECURRENT POLICY NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            750,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anurag Koul & Alan Fern   \nSchool of EECS   \nOregon State University   \nCorvallis, Oregon, USA   \n{koula,alan.fern}@oregonstate.edu   \nSam Greydanus ∗   \nGoogle Brain   \nMountain View, California, USA   \nsgrey@google.com ",
+        "bbox": [
+            184,
+            170,
+            504,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            560,
+            171,
+            776,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recurrent neural networks (RNNs) are an effective representation of control policies for a wide range of reinforcement and imitation learning problems. RNN policies, however, are particularly difficult to explain, understand, and analyze due to their use of continuous-valued memory vectors and observation features. In this paper, we introduce a new technique, Quantized Bottleneck Insertion, to learn finite representations of these vectors and features. The result is a quantized representation of the RNN that can be analyzed to improve our understanding of memory use and general behavior. We present results of this approach on synthetic environments and six Atari games. The resulting finite representations are surprisingly small in some cases, using as few as 3 discrete memory states and 10 observations for a perfect Pong policy. We also show that these finite policy representations lead to improved interpretability. ",
+        "bbox": [
+            233,
+            309,
+            764,
+            476
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            505,
+            336,
+            520
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep reinforcement learning (RL) and imitation learning (IL) have demonstrated impressive performance across a wide range of applications. Unfortunately, the learned policies are difficult to understand and explain, which limits the degree that they can be trusted and used in high-stakes applications. Such explanations are particularly problematic for policies represented as recurrent neural networks (RNNs) (Mnih et al., 2016; Mikolov et al., 2010), which are increasingly used to achieve state-of-the-art performance (Mnih et al., 2015; Silver et al., 2017). This is because RNN policies use internal memory to encode features of the observation history, which are critical to their decision making, but extremely difficult to interpret. In this paper, we take a step towards comprehending and explaining RNN policies by learning more compact memory representations. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Explaining RNN memory is challenging due to the typical use of high-dimensional continuous memory vectors that are updated through complex gating networks (e.g. LSTMs, GRUs (Hochreiter & Schmidhuber, 1997; Chung et al., 2014; Cho et al., 2014)). We hypothesize that, in many cases, the continuous memory is capturing and updating one or more discrete concepts. If exposed, such concepts could significantly aid explainability. This motivates attempting to quantize the memory and observation representation used by an RNN to more directly capture those concepts. In this case, understanding the memory use can be approached by manipulating and analyzing the quantized system. Of course, not all RNN policies will have compact quantized representations, but many powerful forms of memory usage can be captured in this way. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            795
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our main contribution is to introduce an approach for transforming an RNN policy with continuous memory and continuous observations to a finite-state representation known as a Moore Machine. To accomplish this we introduce the idea of Quantized Bottleneck Network (QBN) insertion. QBNs are simply auto-encoders, where the latent representation is quantized. Given a trained RNN, we train QBNs to encode the memory states and observation vectors that are encountered during the RNN operation. We then insert the QBNs into the trained RNN policy in place of the “wires” that propagated the memory and observation vectors. The combination of the RNN and QBN results in a policy represented as a Moore Machine Network (MMN) with quantized memory and observations that is nearly equivalent to the original RNN. The MMN can be used directly or fine-tuned to improve on inaccuracies introduced by QBN insertion. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While training quantized networks is often considered to be quite challenging, we show that a simple approach works well in the case of QBNs. In particular, we demonstrate that “straight through” gradient estimators as in (Bengio et al., 2013; Courbariaux et al., 2016) are quite effective. ",
+        "bbox": [
+            176,
+            152,
+            821,
+            195
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We present experiments in synthetic domains designed to exercise different types of memory use as well as benchmark grammar learning problems. Our approach is able to accurately extract the ground-truth MMNs, providing insight into the RNN memory use. We also did experiments on 6 Atari games using RNNs that achieve state-of-the-art performance. We show that in most cases it is possible to extract near-equivalent MMNs and that the MMNs can be surprisingly small. Further, the extracted MMNs give insights into the memory usage that are not obvious based on just observing the RNN policy in action. For example, we identify games where the RNNs do not use memory in a meaningful way, indicating the RNN is implementing purely reactive control. In contrast, in other games, the RNN does not use observations in a meaningful way, which indicates that the RNN is implementing an open-loop controller. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            344,
+            376
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There have been efforts made in the past to understand the internals of Recurrent Networks (Karpathy et al., 2015; Arras et al., 2017; Strobelt et al., 2016; Murdoch & Szlam, 2017; Jacobsson, 2005; Omlin & Giles, 1996). However, to the best of our knowledge there is no prior work on learning finite-memory representations of continuous RNN policies. Our work, however, is related to a large body of work on learning finite-state representations of recurrent neural networks. Below we summarize the branches of that work and the relationship to our own. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            476
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There has been a significant history of work on extracting Finite State Machines (FSMs) from recurrent networks trained to recognize languages (Zeng et al., 1993; Tino et al., 1998; Cechin et al., ˇ 2003). Typical approaches include discretizing the continuous memory space via gridding or clustering followed by minimization. A more recent approach is to use classic query-based learning algorithms to extract FSMs by asking membership and equivalence queries (Weiss et al., 2017). However, none of these approaches directly apply to learning policies, which require extending to Moore Machines. In addition, all of these approaches produce an FSM approximation that is separated from the RNN and thus serve as only a proxy of the RNN behavior. Rather, our approach directly inserts discrete elements into the RNN that preserves its behavior, but allows for a finite state characterization. This insertion approach has the advantage of allowing fine-tuning and visualization using standard learning frameworks. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            635
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The work most similar to ours also focused on learning FSMs (Zeng et al., 1993). However, the approach is based on directly learning recurrent networks with finite memory, which are qualitatively similar to the memory representation of our MMNs. That work, however, focused on learning from scratch rather than aiming to describe the behavior of a continuous RNN. Our work extends that approach to learn MMNs and more importantly introduces the method of QBN insertion as a way of learning via guidance from a continuous RNN.This transforms any pre-trained recurrent policy into a finite representation. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We note that there has been prior work on learning fully binary networks, where the activation functions and/or weights are binary (e.g. (Bengio et al., 2013; Courbariaux et al., 2016; Hinton, 2012)). The goal of that line of work is typically to learn more time and space efficient networks. Rather, we focus on learning only discrete representations of memory and observations, while allowing the rest of the network to use arbitrary activations and weights. This is due to our alternative goal of supporting interpretability rather than efficiency. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            830
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 RECURRENT POLICY NETWORKS: CONTINUOUS AND QUANTIZED",
+        "text_level": 1,
+        "bbox": [
+            173,
+            851,
+            754,
+            867
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recurrent neural networks (RNNs) are commonly used in reinforcement learning to represent policies that require or can benefit from internal memory. At each time step, an RNN is given an observation $o _ { t }$ (e.g. image) and must output an action $a _ { t }$ to be taken in the environment. During execution an RNN maintains a continuous-valued hidden state $h _ { t }$ , which is updated on each transition and influences the action choice. In particular, given the current observation $o _ { t }$ and current state $h _ { t }$ , an RNN performs the following operations: 1) Extract a set of observation features $f _ { t }$ from $o _ { t }$ , for example, using a CNN when observations are images, 2) Outputting an action $a _ { t } = \\pi ( h _ { t } )$ according to policy $\\pi$ , which is often a linear softmax function of $h _ { t }$ , 3) transition to a new state $h _ { t + 1 } = \\bar { \\delta } ( f _ { t } , \\mathsf { \\bar { h } } _ { t } )$ where $\\delta$ is the transition function, which is often implemented via different types of gating networks such as LSTMs or GRUs. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            200
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The continuous and high dimensional nature of $h _ { t }$ and $f _ { t }$ can make interpreting the role of memory difficult. This motivates our goal of extracting compact quantized representations of $h _ { t }$ and $f _ { t }$ . Such representations have the potential to allow investigating a finite system that captures the key features of the memory and observations. For this purpose we introduce Moore Machines and their deep network counterparts. ",
+        "bbox": [
+            174,
+            208,
+            823,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Moore Machines. A classical Moore Machine (MM) is a standard finite state machine where all states are labeled by output values, which in our case will correspond to actions. In particular, a Moore Machine is described by a finite set of (hidden) states $\\hat { H }$ , an initial hidden state $\\hat { h } _ { 0 }$ , a finite set of observations $\\hat { O }$ , a finite set of actions $A$ , a transition function $\\hat { \\delta }$ , and a policy $\\hat { \\pi }$ that maps hidden states to actions. The transition function $\\hat { \\delta } : \\hat { H } \\times \\hat { O }  \\hat { H }$ returns the next hidden state $\\hat { h } _ { t + 1 } = \\hat { \\delta } ( \\hat { h } _ { t } , \\hat { o } _ { t } )$ given the current state $\\hat { h } _ { t }$ and observation $\\hat { o } _ { t }$ . By convention we will use $h _ { t }$ and $\\hat { h } _ { t }$ to denote continuous and discrete states respectively and similarly for other quantities and functions. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Moore Machine Networks. A Moore Machine Network (MMN) is a Moore Machine where the transition function $\\hat { \\delta }$ and policy $\\hat { \\pi }$ are represented via deep networks. In addition, since the raw observations given to an MMN are often continuous, or from an effectively unbounded set (e.g. images), an MMN will also provide a mapping $\\hat { g }$ from the continuous observations to a finite discrete observation space $\\hat { O }$ . Here $\\hat { g }$ will also be represented via a deep network. In this work, we consider quantized state and observation representations where each $\\hat { h } \\in \\hat { H }$ is a discrete vector and each discrete observation in $\\hat { O }$ is a discrete vector that describes the raw observation. We will denote the quantization level as $k$ and the dimensions of $\\hat { h }$ and $\\hat { f }$ by $B _ { h }$ and $B _ { f }$ respectively. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Based on the above discussion, an MMN can be viewed as a traditional RNN, where: 1) The memory is restricted to be composed of $k$ -level activation units, and 2) The environmental observations are intermediately transformed to a $k$ -level representation $\\hat { f }$ before being fed to the recurrent module. Given an approach for incorporating quantized units into the backpropagation process, it is straightforward, in concept, to learn MMNs from scratch via standard RNN learning algorithms. However, we have found that learning MMNs from scratch can be quite difficult for non-trivial problems, even when an RNN can be learned with relative ease. For example, we have not been able to train highperforming MMNs from scratch for Atari games. Below we introduce a new approach for learning MMNs that is able to leverage the ability to learn RNNs. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            648
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 LEARNING MOORE MACHINE NETWORKS FROM RNNS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            678,
+            665,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a trained RNN, our key idea is to first learn quantized bottleneck networks (QBNs) for embedding the continuous observation features and hidden state into a $k$ -level quantized representation. We will then insert the QBNs into the original recurrent net in such a way that its behavior is minimally changed with the option of fine-tuning after insertion. The resulting network can be viewed as consuming quantized features and maintaining quantized state, which is effectively an MMN. Below we describe the steps in further detail, which are illustrated in Figure 1. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 QUANTIZED BOTTLENECK NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            824,
+            483,
+            838
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A QBN is simply an autoencoder where the latent representation between the encoder and decoder (i.e. the bottleneck) is constrained to be composed of $k$ -level activation units. While, traditional autoencoders are generally used for the purpose of dimensionality reduction in continuous space (Hinton & Salakhutdinov, 2006), QBNs are motivated by the goal of discretizing a continuous space. Conceptually, this can be done by quantizing the activations of units in the encoding layer. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/8e6ffec04cb5d48cb94463e00191c657158e780f30ce437df980135cd9a97c85.jpg",
+        "image_caption": [
+            "Figure 1: Learning Moore Machine Networks. (1.) Learn an RNN policy. (2.) Learn QBN’s to quantize memory and observations. (3.) Insertion and Fine Tuning. The modules labelled O, R are observation feature-extraction and recurrent modules, respectively "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            101,
+            723,
+            294
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We represent a QBN via a continuous multilayer encoder $E$ , which maps inputs $x$ to a latent encoding $E ( x )$ , and a corresponding multilayer decoder $D$ . To quantize the encoding, the QBN output is given by ",
+        "bbox": [
+            173,
+            376,
+            825,
+            417
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/104211c8f20500801b1bdf91981a7d5767477194aa54767bb54a3f008c2e42dd.jpg",
+        "text": "$$\nb ( x ) = D ( { \\mathrm { q u a n t i z e } } ( E ( x ) ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            416,
+            591,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our case, we use 3-level quantization in the form of $+ 1 , 0$ and $- 1$ using the quantize function, which assumes the outputs of $E ( x )$ are in the range $[ - 1 , 1 ]$ .1 One choice for the output nodes of $E ( x )$ would be the tanh activation. However, since the gradient of tanh is close to 1 near 0, it can be difficult to produce quantization level 0 during learning. Thus, as suggested in Pitis (2017), to support 3-valued quantization we use the following activation function, which is flatter in the region around zero input. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            521
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d81f75caed697986167f0dc3489888dd41167be67c71aeac959eed7e2574eb6f.jpg",
+        "text": "$$\n\\phi ( x ) = 1 . 5 \\operatorname { t a n h } ( x ) + 0 . 5 \\operatorname { t a n h } ( - 3 x )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            520,
+            625,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Of course introducing the quantize function in the QBN results in $b ( x )$ being non-differentiable, making it apparently incompatible with backpropagation, since the gradients between the decoder and encoder will almost always be zero. While there are a variety of ways to deal with this issue, we have found that the straight-through estimator, as suggested and used in prior work (Hinton, 2012; Bengio et al., 2013; Courbariaux et al., 2016) is quite effective. In particular, the standard straightthrough estimator of the gradient simply treats the quantize function as the identity function during back-propagation. Overall, the inclusion of the quantize function in the QBN effectively allows us to view the last layer of $E$ as producing a $k$ -level encoding. We train a QBN as an autoencoder using the standard $L _ { 2 }$ reconstruction error $\\| x - b ( x ) \\| ^ { 2 }$ for a given input $x$ . ",
+        "bbox": [
+            173,
+            540,
+            825,
+            669
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 BOTTLENECK INSERTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            685,
+            390,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given a recurrent policy we can run the policy in the target environment in order to produce an arbitrarily large set of training sequences of triples $\\left( o _ { t } , f _ { t } , h _ { t } \\right)$ , giving the observation, corresponding observation feature, and hidden state at time $t$ . Let $F$ and $H$ be the sets of all observed features and states respectively. The first step of our approach is to train two QBNs, $b _ { f }$ and $b _ { h }$ , on $F$ and $H$ respectively. If the QBNs are able to achieve low reconstruction error then we can view latent “bottlenecks” of the QBNs as a high-quality $k$ -level encodings of the original hidden states and features. ",
+        "bbox": [
+            173,
+            712,
+            825,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now view $b _ { f }$ and $b _ { h }$ as “wires” that propagate the input to the output, with some noise due to imperfect reconstruction. We insert these wires into the original RNN in the natural way (stage-3 in Figure 1). The $b _ { f }$ QBN is inserted between the RNN units that compute the features $f$ and the nodes those units are connected to. The $b _ { h }$ QBN is inserted between the output of the recurrent network block and the input to the recurrent block. If $b _ { f }$ and $b _ { h }$ always produced perfect reconstructions, then the result of inserting them as described would not change the behavior of the RNN. Yet, the RNN can now be viewed as an MMN since the bottlenecks of $b _ { f }$ and $b _ { h }$ provide a quantized representation of the features $f _ { t }$ and states $h _ { t }$ . ",
+        "bbox": [
+            174,
+            815,
+            825,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fine Tuning. In practice, the QBNs will not achieve perfect reconstruction and thus, the resulting MMN may not behave identically to the original RNN. Empirically, we have found that the performance of the resulting MMN is often very close to the RNN directly after insertion. However, when there is non-trivial performance degradation, we can fine-tune the MMN by training on the original rollout data of the RNN. Importantly, since our primary goal is to learn a representation of the original RNN, during fine-tuning our objective is to have the MMN match the softmax distribution over actions produced by the RNN. We found that training in this way was significantly more stable than training the MMN to simply output the same action as the RNN. ",
+        "bbox": [
+            173,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 MOORE MACHINE EXTRACTION AND MINIMIZATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            281,
+            581,
+            295
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After obtaining the MMN, one could use visualization and other analysis tools to investigate the memory and it’s feature bits in order to gain a semantic understanding of their roles. Solving the full interpretation problem in a primitive way is beyond the scope of this work. ",
+        "bbox": [
+            176,
+            308,
+            825,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Extraction. Another way to gain insight is to use the MMN to produce an equivalent Moore Machine over atomic state and observation spaces, where each state and observation is a discrete symbol. This machine can be analyzed to understand the role of different machine states and how they are related. In order to create the Moore Machine we run the learned MMN to produce a dataset of $< \\hat { h } _ { t - 1 } , \\hat { f } _ { t } , \\hat { h } _ { t } , a _ { t } > ,$ , giving the consecutive pairs of quantized states, the quantized features that led to the transition, and the action selected after the transition. The state-space of the Moore Machine will correspond to the $p$ distinct quantized states in the data and the observation-space of the machine will be the $q$ unique quantized feature vectors in the data. The transition function of the machine $\\hat { \\delta }$ is constructed from the data by producing a $p \\times q$ transaction table that captures the transitions seen in the data. ",
+        "bbox": [
+            174,
+            357,
+            825,
+            500
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Minimization. In general, the number of states $p$ in the resulting Moore Machine will be larger than necessary in the sense that there is a much smaller, but equivalent, minimal machine. Thus, we apply standard Moore Machine minimization techniques to arrive at the minimal2 equivalent Moore Machine (Paull & Unger, 1959). This often dramatically reduces the number of distinct states and observations. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 SYNTHETIC EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            597,
+            428,
+            613
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our experiments address the following questions: 1) Is it possible to extract MMNs from RNNs without significant loss in Performance? 2) What is the general magnitude of the number of states and observations in the minimal machines, especially for complex domains such as Atari? 3) Do the learned MMNs help with interpretability of the recurrent policies? In this section, we begin addressing these questions by considering two domains where ground truth Moore Machines are known. The first is a parameterized synthetic environment, Mode Counter, which can capture multiple types of memory use. Second, we consider benchmark grammar learning problems. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 MODE COUNTER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            744,
+            331,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The class of Mode Counter Environments (MCEs) allows us to vary the amount of memory required by a policy (including no memory) and the required type of memory usage. In particular, MCEs can require varying amounts of memory for remembering past events and implementing internal counters. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An MCE is a restricted type of Partially Observable Markov Decision Process, which transitions between one of $M$ modes over time according to a transition distribution, which can depend on the current mode and amount of time spent in the current mode. There are $M$ actions, one for each mode, and the agent receives a reward of $+ 1$ at the end of the episode if it takes the correct action associated with the active mode at each time step. The agent does not observe the mode directly, but rather must infer the mode via a combination of observations and memory use. Different parameterizations place different requirements on how (and if) memory needs to be used to infer the mode and achieve optimal performance. Below we give an intuitive description of the $\\mathbf { M C E s } ^ { 3 }$ in our experiments. ",
+        "bbox": [
+            176,
+            833,
+            820,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments in three MCE instances, which use memory and observations in fundamentally different ways. This tests our ability to use our approach for determining the type of memory use. 1) Amnesia. This MCE is designed so that the optimal policy does not need memory to track past information and can select optimal actions based on just the current observation. 2) Blind. Here we consider the opposite extreme, where the MCE observations provide no information about optimal actions. Rather, memory must be used to implement counters that keep track of a deterministic mode sequence for determining the optimal actions. 3) Tracker. This MCE is designed so that the optimal policy must both use observations and memory in order to select optimal actions. Intuitively the memory must implement counters that keep track of key time steps where the observations provide information about the mode. In all above instances, we used $M = 4$ modes. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            347
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "RNN Training. For each MCE instance we use the following recurrent architecture: the input feeds into 1 feed-forward layer with 4 Relu6 nodes (Krizhevsky & Hinton, 2010) $( f _ { t } )$ , followed by a 1-layer GRU with 8 hidden units $\\left( { { h _ { t } } } \\right)$ , followed by a fully connected softmax layer giving a distribution over the $M$ actions (one per mode). Since we know the optimal policy in the MCEs we use imitation learning for training. For all of the MCEs in our experiments, the trained RNNs achieve $100 \\%$ accuracy on the imitation dataset and appeared to produce optimal policies. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            438
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MMN Training. The observation QBN $b _ { f }$ and hidden-state QBN $b _ { h }$ have the same architecture, except that the number of quantized bottleneck units $B _ { f }$ and $B _ { h }$ are varied in our experiments. The encoders consist of 1 feed-forward layer of tanh nodes, where the number of nodes is 4 times the size of the bottleneck. This layer feeds into 1 feedforward layer of quantized bottleneck nodes (see Section 4). The decoder for both $b _ { f }$ and $b _ { h }$ has a symmetric architecture to the encoder. Training of $b _ { f }$ and $b _ { h }$ in the MCE environments was extremely fast compared to the RNN training, since QBNs do not need to learn temporal dependencies. We trained QBNs with bottleneck sizes of $B _ { f } \\in \\{ 4 , 8 \\}$ and $B _ { h } \\in \\{ 4 , 8 \\}$ . For each combination of $B _ { f }$ and $B _ { h }$ we embedded the QBNs into the RNN to give a discrete MMN and then measured performance of the MMN before and after fine tuning. Table 1 gives the average test score over 50 test episodes. Score of 1 indicates the agent performed optimally for all episodes. In most of the cases no fine tuning was required (marked as ’-’) since the agent achieved perfect performance immediately after bottleneck insertion due to low reconstruction error. In all other cases, except for Tracker $B _ { h } = 4$ , $B _ { f } = 4 _ { . }$ ) fine-tuning resulted in perfect MMN performance. The exception yielded $98 \\%$ accuracy. Interestingly in that case, we see that if we only insert one of the bottlenecks at a time, we yield perfect performance, which indicates that the combined error accumulation of the two bottlenecks is responsible for the reduced performance. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Moore Machine Extraction. Table 1 also gives the number of states and observations of the MMs extracted from the MMNs both before and after minimization. Recall that the number of states and obsevations before minimization is the number of distinct combinations of values observed for the bottleneck nodes during long executions of the MMN. We see that there are typically significantly more states and observations before minimization than after. This indicates that the MMN learning does not necessarily learn minimal discrete state and observation representations, though the representations accurately describe the RNN. After minimization (Section 4.3), however, in all but one case we get exact minimal machines for each MCE domain. The ground truth minimal machines that are found are shown in the Appendix (Figure 3). This shows that the MMNs learned via QBN insertions were equivalent to the true minimal machines and hence indeed optimal in most cases. The exception matches the case where the MMN did not achieve perfect accuracy. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            825
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Examining these machines allows one to understand the memory use. For example, the machine for Blind has just a single observation symbol and hence its transitions cannot depend on the input observations. In contrast, the machine for Amnesia shows that each distinct observation symbol leads to the same state (and hence action choice) regardless of the source state. Thus, the policies action is completely determined by the current observation. ",
+        "bbox": [
+            174,
+            833,
+            823,
+            876
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/7b2b5f5f58062cbcc4358ec32db84938637b24bfb58429e5f1ffd40ea955f9b8.jpg",
+        "table_caption": [
+            "Table 1: Moore Machine extraction for MCE "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Game</td><td rowspan=2 colspan=1>Bh,Bf</td><td rowspan=1 colspan=2>Fine-TuningScore</td><td rowspan=1 colspan=3>BeforeMinimization</td><td rowspan=1 colspan=3>AfterMinimization</td></tr><tr><td rowspan=1 colspan=1>Before(%)</td><td rowspan=1 colspan=1>After(%)</td><td rowspan=1 colspan=1>H</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>Acc.(%)</td><td rowspan=1 colspan=1>H</td><td rowspan=1 colspan=1>|0|</td><td rowspan=1 colspan=1>Acc.(%)</td></tr><tr><td rowspan=3 colspan=1>Amnesia</td><td rowspan=2 colspan=1>4,44,8</td><td rowspan=2 colspan=1>0.980.99</td><td rowspan=2 colspan=1>11</td><td rowspan=2 colspan=1>77</td><td rowspan=2 colspan=1>57</td><td rowspan=1 colspan=1>1</td><td rowspan=2 colspan=1>44</td><td rowspan=2 colspan=1>44</td><td rowspan=2 colspan=1>11</td></tr><tr><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>8,48,8</td><td rowspan=1 colspan=1>10.99</td><td rowspan=1 colspan=1>-1</td><td rowspan=1 colspan=1>67</td><td rowspan=1 colspan=1>57</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>44</td><td rowspan=1 colspan=1>44</td><td rowspan=1 colspan=1>11</td></tr><tr><td rowspan=2 colspan=1>Blind</td><td rowspan=1 colspan=1>4,44,8</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>-1</td><td rowspan=1 colspan=1>1212</td><td rowspan=1 colspan=1>68</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>1010</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>11</td></tr><tr><td rowspan=1 colspan=1>8,48,8</td><td rowspan=1 colspan=1>10.78</td><td rowspan=1 colspan=1>-1</td><td rowspan=1 colspan=1>513</td><td rowspan=1 colspan=1>68</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>1010</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>11</td></tr><tr><td rowspan=4 colspan=1>Tracker</td><td rowspan=2 colspan=1>4,44,8</td><td rowspan=2 colspan=1>0.980.99</td><td rowspan=2 colspan=1>0.981</td><td rowspan=2 colspan=1>5823</td><td rowspan=2 colspan=1>55</td><td rowspan=2 colspan=1>0.981</td><td rowspan=2 colspan=1>5010</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0.98</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=2 colspan=1>8,48,8</td><td rowspan=2 colspan=1>0.980.99</td><td rowspan=2 colspan=1>11</td><td rowspan=2 colspan=1>9185</td><td rowspan=2 colspan=1>55</td><td rowspan=2 colspan=1>11</td><td rowspan=2 colspan=1>1010</td><td rowspan=1 colspan=1>4</td><td rowspan=2 colspan=1>11</td></tr><tr><td rowspan=1 colspan=1>4</td></tr></table>",
+        "bbox": [
+            230,
+            172,
+            767,
+            412
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 TOMITA GRAMMARS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            359,
+            453
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The Tomita Grammars are popular benchmarks for learning finite state machines (FSMs), including work on extracting FSMs from RNNs (e.g. (Watrous & Kuhn, 1992; Weiss et al., 2017)). Here we evaluate our approach over the 7 Tomita Grammars4, where each grammar defines the set of binary strings that should be accepted or rejected. Since, our focus is on policy learning problems, we treat the grammars as environments with two actions ‘accept’ and ‘reject’. Each episode corresponds to a random string that is either part of the particular grammar or not. The agent receives a reward of 1 if the correct action accept/reject is chosen on the last symbol of a string. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "RNN Training. The RNN for each grammar is comprised of a one-layer GRU with 10 hidden units, followed by a fully connected softmax layer with 2 nodes (accept/reject). Since we know the optimal policy, we again use imitation learning to train each RNN using the Adam optimizer and learning rate of 0.001. The training dataset is comprised of an equal number of accept/reject strings with lengths uniformly sampled in the range [1,50]. Table 2 presents the test results for the trained RNNs giving the accuracy over a test set of 100 strings drawn from the same distribution as used for training. Other than grammar $\\# 6 ^ { 5 }$ , the RNNs were $100 \\%$ accurate. ",
+        "bbox": [
+            173,
+            569,
+            825,
+            666
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "MMN Training. Since the raw observations for this problem are from a finite alphabet, we don’t need to employ a bottleneck encoder to discretize the observation features. Thus the only bottleneck learned here is $b _ { h }$ for the hidden memory state. We use the same architecture for $b _ { h }$ as used for the MCE experiments and conduct experiments with $B _ { h } \\in \\{ 8 , 1 6 \\}$ . These bottlenecks were then inserted in the RNNs to give MMNs. The performance of the MMNs before and after fine-tuning are shared in Table 2. In almost all cases, the MMN is able to maintain the performance of the RNN without fine-tuning. Fine tuning provides only minor improvements in other cases, which already are achieving high accuracy. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            785
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moore Machine Extraction. Our results for MM extraction and minimization are in Table 2. In each case, we see a considerable reduction in the MM’s state-space after minimization while accurately maintaining the MMN’s performance. Again, this shows that the MMN learning does not directly result in minimal machines, yet are equivalent to the minimal machines and hence are exact solutions. In all cases, except for grammar 6 the minimized machines are identical to the minimal machines that are known for these grammars (Tomita, 1982). ",
+        "bbox": [
+            173,
+            791,
+            825,
+            848
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/74c749936cba5d10a3fa3adba28f6efb2a53201b7242b0fd6f2102b5239dff36.jpg",
+        "table_caption": [
+            "Table 2: Moore Machine extraction for Tomita grammar "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>#Grammar</td><td rowspan=2 colspan=1>RNNAcc. (%)</td><td rowspan=2 colspan=1>Bh</td><td rowspan=1 colspan=2>Fine-TuningAcc.(%)</td><td rowspan=1 colspan=2>BeforeMinimization</td><td rowspan=1 colspan=2>AfterMinimization</td></tr><tr><td rowspan=1 colspan=1>Before</td><td rowspan=1 colspan=1>After</td><td rowspan=1 colspan=1>H</td><td rowspan=1 colspan=1>Acc.(%)</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>Acc.(%)</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>--</td><td rowspan=1 colspan=1>1328</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>22</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>--</td><td rowspan=1 colspan=1>1314</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>33</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>--</td><td rowspan=1 colspan=1>3439</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>55</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>-1</td><td rowspan=1 colspan=1>1718</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>44</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>95100</td><td rowspan=1 colspan=1>961</td><td rowspan=1 colspan=1>192316</td><td rowspan=1 colspan=1>96100</td><td rowspan=1 colspan=1>1154</td><td rowspan=1 colspan=1>96100</td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>9899</td><td rowspan=1 colspan=1>9899</td><td rowspan=1 colspan=1>100518</td><td rowspan=1 colspan=1>9899</td><td rowspan=1 colspan=1>1211</td><td rowspan=1 colspan=1>9899</td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>816</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>-1</td><td rowspan=1 colspan=1>25107</td><td rowspan=1 colspan=1>100100</td><td rowspan=1 colspan=1>55</td><td rowspan=1 colspan=1>100100</td></tr></table>",
+        "bbox": [
+            236,
+            128,
+            761,
+            398
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            426,
+            823,
+            454
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 ATARI EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            477,
+            383,
+            492
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we consider applying our technique to RNNs learned for six Atari6 games using the OpenAI gym (Brockman et al., 2016). Unlike the above experiments, where we knew the ground truth MMs, for Atari we did not have any preconception of what the MMs might look and how large they might be. The fact that the input observations for Atari (i.e. images) are much more complex than the previous experiments inputs makes it completely unclear if we can expect similar types of results. There have been other recent efforts towards understanding Atari agents (Zahavy et al., 2016; Greydanus et al., 2017). However, we are not aware of any other work which aims to extract finite state representations for Atari policies. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            621
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "RNN Training. All the Atari agents have the same recurrent architecture. The input observation is an image frame, preprocessed by gray-scaling, $2 \\mathbf { x }$ down-sampling, cropping to an $8 0 \\times 8 0$ square and normalizing the values to [0, 1]. The network has 4 convolutional layers (kernel size 3, strides 2, padding 1, and 32,32,16,4 filters respectively). We used Relu as the intermediate activation and Relu6 over the last convolutional layer. This is followed by a GRU layer with 32 hidden units and a fully connected layer with $n { + 1 }$ units, where $n$ is the dimension of the Atari action space. We applied a softmax to first $n$ neurons to obtain the policy and used the last neuron to predict the value function. We used the A3C RL algorithm (Mnih et al., 2016) (learning rate $1 0 ^ { - 4 }$ , discount factor 0.99) and computed loss on the policy using Generalized Advantage Estimation $\\lambda = 1 . 0$ ) (Schulman et al., 2015). We report the trained RNN performance on our six games in the second column of Table 3. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            766
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "MMN Training. We used the same general architecture for the QBN $b _ { f }$ as used for the MCE experiments, but adjusted the encoder input and decoder output sizes to match the dimension of the continuous observation features $f _ { t }$ . For $b _ { h }$ , the encoder has 3 feed-forward layers with $( 8 \\times$ $B _ { h . }$ ), $( 4 \\times B _ { h } )$ and $B _ { h }$ nodes. The decoder is symmetric to the encoder. For the Atari domains, the training data for $b _ { f }$ and $b _ { h }$ was generated using noisy rollouts. In particular, each training episode was generated by executing the learned RNN for a random number of steps and then executing an $\\epsilon$ -greedy (with $\\epsilon = 0 . 3$ ) version of the RNN policy. This is intended to increase the diversity of the training data and we found that it helps to more robustly learn the QBNs. We trained bottlenecks for ",
+        "bbox": [
+            173,
+            772,
+            825,
+            885
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "$B _ { h } \\in \\{ 6 4 , 1 2 8 \\}$ and $B _ { f } \\in \\{ 1 0 0 , 4 0 0 \\}$ noting that these values are significantly larger than for our earlier experiments due to the complexity of Atari. Note that while there are an enormous number of potential discrete states for these values of $B _ { h }$ the actual number of states observed and hence the number of MMN states can be substantially smaller. Each bottleneck was trained to the point of saturation of training loss and then inserted into the RNN to give an MMN for each Atari game. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "MMN Performance. Table 3 gives the performance of the trained MMNs before and after finetuning for different combinations of $B _ { h }$ and $B _ { f }$ . We see that for 4 games, Pong, Freeway, Bowling, and Boxing, the MMNs after fine tuning either achieve identical scores to the RNN or very close (in the case of boxing). This demonstrates the ability to learn a discrete representation of the input and memory for these complex games with no impact on performance. We see that for Boxing and Pong fine tuning was required to match the RNN performance. In the case of Freeway and Bowling, fine-tuning was not required. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            279
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the remaining two games, Breakout and Space Invaders, we see that the MMNs learned after fine tuning achieve lower scores than the original RNNs, though the scores are still relatively good. On further investigation, we found that this drop in performance was due to poor reconstruction on some rare parts of the game. For example, in Breakout, after the first board is cleared, the policy needs to press the fire-button to continue, but the learned MMN does not do this and instead times out, which results in less score. This motivates the investigation into more intelligent approaches for training QBNs to capture critical information in such rare, but critically important, states. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            382
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "MM Minimization. We see from Table 3 that before minimization, the MMs often have relatively large numbers of discrete states and observations. This is unsurprising given that we are using relatively large values of $B _ { h }$ and $B _ { f }$ . However, we see that after minimizing the MMNs the number of states and observations reduces by orders of magnitude, sometimes to just a single state and/or single observation. The number of states and observations in many cases are small enough to write out and analyze by hand, making them amenable to careful analysis. However, this analysis is likely to be non-trivial for moderately complex policies due to the need to understand the “meaning” of the observations and in turn of the states. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            500
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Understanding Memory Use. We were surprised to observe in Atari the same three types of memory use considered for the MCE domains above. First, we see that the MM for Pong has just three states (one per action) and 10 discrete observation symbols (see Figure 2a). Most importantly we see that each observation transitions to the same state (and hence action) regardless of the current state. So we can view this MM as defining a set of rule that maps individual observations to actions with no memory necessary. In this sense, the Pong policy is analogous to the Amnesia MCE [5.1]. ",
+        "bbox": [
+            174,
+            507,
+            823,
+            592
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In contrast, we see that in both Bowling and Freeway there is only one observation symbol in the minimal MM. This means that the MM actually ignores the input image when selecting actions. Rather the policies are open-loop controllers whose action just depends on the time-step rather than the observations. Thus, these policies are analogous to the Blind MCE [5.1]. Freeway has a particularly trivial policy that always takes the Up action at each time step. While this policy behavior could have been determined by looking at the action sequence of the rollouts, it is encouraging that our MM extraction approach also discovered this. As shown in Figure 2b, Bowling has a more interesting open-loop policy structure where it has an initial sequence of actions and then a loop is entered where the action sequence is repeated. It is not immediately obvious that this policy has such an open-loop structure by just watching the policy. Thus, we can see that the MM extraction approach we use here can provide significant additional insight. ",
+        "bbox": [
+            174,
+            598,
+            825,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Breakout, Space Invaders and Boxing use both memory and observations based on our analysis of the MM transition structures. We have not yet attempted a full semantic analysis of the discrete observations and states for any of the Atari policies. This will require additional visualization and interaction tools and is an important direction of future work that is enabled by our approach. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 SUMMARY AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            468,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Motivated by the goal of better understanding memory use in RNN polices, we introduced an approach for extracting finite state Moore Machines from those policies. The key idea, bottleneck insertion, is to train Quantized Bottleneck Networks to produce binary encodings of continuous RNN memory and input features, and then insert those bottlenecks into the RNN. This yields a near equivalent Moore Machine Network (MMN) which has quantized memory and observation features. From the MMN we then extract a discrete Moore machine that can then be transformed into an equivalent minimal machine for analysis and usage. Our results on two environments where the ground truth machines are known show that our approach is able to accurately extract the ground truth. We also show experiments in six Atari games, where we have no prior insight into the ground truth machines. We show that, in most cases, the learned MMNs maintain similar performance to the original RNN policies. Further, the extracted machines provide insight into the memory usage of the policies. First, we see that the number of required memory states and observations is surprisingly small. Second, we can identify cases where the policy did not use memory in a significant way (e.g. Pong) and policies that relied only on memory and ignored the observations (e.g. Bowling and Freeway). To our knowledge, this is the first work where this type of insight was reported for policies in such complex domains. A key direction for future work is to develop tools and visualizations for attaching meaning to the discrete observations and in turn states, which will allow for an additional level of insight into the policies. It is also worth considering the use of tools for analyzing finite-state machine structure to gain further insight and analyze formal properties of the policies. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c7744cb88de1ce65fe21c0249b937cc3218b922de3bb9b1125197afa4309833c.jpg",
+        "table_caption": [
+            "Table 3: Moore Machine extraction for trained Atari RNN policies. DQN (Mnih et al., 2015), A3C (Mnih et al., 2016) scores have been reported for performance comparison with trained policies. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Game (# of actions)</td><td rowspan=\"3\">DQN (Score)</td><td rowspan=\"3\">A3C LSTM (Score)</td><td rowspan=\"3\">RNN (Score)</td><td rowspan=\"3\">(Bh,Bf)</td><td colspan=\"2\">Fine-Tuning Score</td><td colspan=\"3\">Before Minimization</td><td colspan=\"3\">After Minimization</td></tr><tr><td>Before</td><td>After</td><td>H</td><td>10</td><td>Score</td><td>间</td><td>10</td><td>Score</td></tr><tr><td>20</td><td>21</td><td>380</td><td>374</td><td>21</td><td></td><td></td><td></td></tr><tr><td rowspan=\"4\">Pong (3)</td><td rowspan=\"4\">18.9</td><td rowspan=\"4\">10.7</td><td rowspan=\"4\">21</td><td>64,100 64,400</td><td>20</td><td>21</td><td>373</td><td>372</td><td>21</td><td>4 3</td><td>12 10</td><td>21 21</td></tr><tr><td>128,100</td><td>20</td><td>21</td><td>383</td><td>373</td><td>21</td><td>3</td><td>12</td><td>21</td></tr><tr><td>128,400</td><td>20</td><td>21</td><td>379</td><td>371</td><td>21</td><td>3</td><td>11</td><td>21</td></tr><tr><td>64,100</td><td>21</td><td>：</td><td>11</td><td>11</td><td>21</td><td>11</td><td>1</td><td>21</td></tr><tr><td rowspan=\"3\">Freeway (3)</td><td rowspan=\"3\">30.3</td><td rowspan=\"3\">0.1</td><td rowspan=\"3\">21</td><td>64,400</td><td>21</td><td></td><td></td><td></td><td>21</td><td></td><td></td><td>21</td></tr><tr><td>128,100 128,400</td><td>21 21</td><td>：</td><td>1 1</td><td>1 1</td><td>21 21</td><td>11</td><td>1 1</td><td>21</td></tr><tr><td>64,100</td><td>32</td><td>423</td><td>1898</td><td>1874</td><td>423</td><td>8</td><td>3</td><td>21 423</td></tr><tr><td rowspan=\"4\">Breakout (4)</td><td rowspan=\"4\">401.2</td><td rowspan=\"4\">766.8</td><td rowspan=\"4\">773</td><td>64,400</td><td>25</td><td>415</td><td>1888</td><td>1871</td><td>415</td><td>8</td><td></td><td>415</td></tr><tr><td>128,100</td><td>41</td><td>377</td><td>1583</td><td>1514</td><td>377</td><td>11</td><td>30</td><td>377</td></tr><tr><td>128,400</td><td>85</td><td>379</td><td>1729</td><td>1769</td><td>379</td><td>8</td><td></td><td>379</td></tr><tr><td>64,100</td><td>520</td><td>1335</td><td>1495</td><td>1502</td><td>1335</td><td>8</td><td></td><td>1335</td></tr><tr><td rowspan=\"3\">Space Invaders (4)</td><td rowspan=\"3\">1976</td><td rowspan=\"3\">23846</td><td rowspan=\"3\">1820</td><td>64,400</td><td>365</td><td>1235</td><td>1625</td><td>1620</td><td>1235</td><td>12</td><td>29</td><td>1235</td></tr><tr><td>128,100</td><td>390</td><td>1040</td><td>1563</td><td>1457</td><td>1040</td><td>12</td><td>35</td><td>1040</td></tr><tr><td>128,400</td><td>520</td><td>1430</td><td>1931</td><td>1921</td><td>1430</td><td>6</td><td>27</td><td>1430</td></tr><tr><td rowspan=\"4\">Bowling (6)</td><td rowspan=\"4\">42.4</td><td rowspan=\"4\">41.8</td><td rowspan=\"4\">60</td><td>64,100 64,400</td><td>60</td><td>-</td><td>49</td><td>1</td><td>60</td><td>33</td><td>1</td><td>60</td></tr><tr><td></td><td>60</td><td>-</td><td>49</td><td>1</td><td>60</td><td>33</td><td>1</td><td>60</td></tr><tr><td>128,100</td><td>60</td><td>-</td><td>26</td><td>11</td><td>60</td><td>24</td><td>T</td><td>60</td></tr><tr><td>128,400</td><td>60</td><td>-</td><td>26</td><td></td><td>60</td><td>24</td><td></td><td>60</td></tr><tr><td rowspan=\"4\">Boxing (18)</td><td rowspan=\"4\">71.8</td><td rowspan=\"4\">37.3</td><td rowspan=\"4\">100</td><td>64,100</td><td>94</td><td>100</td><td>1173</td><td>1167</td><td>100</td><td>13</td><td>79</td><td>100</td></tr><tr><td>64,400</td><td>98</td><td>100</td><td>2621</td><td>2605</td><td>100</td><td>14</td><td>119</td><td>100</td></tr><tr><td>128,100</td><td>94</td><td>97</td><td>2499</td><td>2482</td><td>97</td><td>14</td><td>106</td><td>97</td></tr><tr><td>128,400</td><td>97</td><td>100</td><td>1173</td><td>1169</td><td>100</td><td>14</td><td>88</td><td>100</td></tr></table>",
+        "bbox": [
+            169,
+            142,
+            834,
+            486
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/d3fb4e58681fc6a910ba757405979178b3787603f3c9e9e2303e94b5bbb72621.jpg",
+        "image_caption": [
+            "Figure 2: Moore Machine representation for Atari policies "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            508,
+            800,
+            671
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            715,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Leila Arras, Gregoire Montavon, Klaus-Robert M ´ uller, and Wojciech Samek. Explaining recurrent ¨ neural network predictions in sentiment analysis. arXiv preprint arXiv:1706.07206, 2017. ",
+        "bbox": [
+            174,
+            126,
+            821,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Nicholas Leonard, and Aaron Courville. Estimating or propagating gradients ´ through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013. ",
+        "bbox": [
+            176,
+            161,
+            821,
+            191
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016. ",
+        "bbox": [
+            173,
+            199,
+            823,
+            228
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adelmo Luis Cechin, D Regina, P Simon, and K Stertz. State automata extraction from recurrent neural nets using k-means and fuzzy clustering. In Chilean Computer Science Society, 2003. SCCC 2003. Proceedings. 23rd International Conference of the, pp. 73–78. IEEE, 2003. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014. ",
+        "bbox": [
+            174,
+            287,
+            825,
+            330
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014. ",
+        "bbox": [
+            171,
+            338,
+            825,
+            368
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained to $+ 1$ or-1. arXiv preprint arXiv:1602.02830, 2016. ",
+        "bbox": [
+            174,
+            376,
+            823,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sam Greydanus, Anurag Koul, Jonathan Dodge, and Alan Fern. Visualizing and understanding atari agents. arXiv preprint arXiv:1711.00138, 2017. ",
+        "bbox": [
+            171,
+            426,
+            825,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton. Neural networks for machine learning. video lectures, 2012. ",
+        "bbox": [
+            173,
+            463,
+            687,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural networks. science, 313(5786):504–507, 2006. ",
+        "bbox": [
+            174,
+            487,
+            826,
+            516
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            525,
+            823,
+            553
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Henrik Jacobsson. Rule extraction from recurrent neural networks: Ataxonomy and review. Neural Computation, 17(6):1223–1263, 2005. ",
+        "bbox": [
+            174,
+            561,
+            823,
+            590
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrej Karpathy, Justin Johnson, and Li Fei-Fei. Visualizing and understanding recurrent networks. arXiv preprint arXiv:1506.02078, 2015. ",
+        "bbox": [
+            173,
+            598,
+            823,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoff Hinton. Convolutional deep belief networks on cifar-10. Unpublished manuscript, 40(7), 2010. ",
+        "bbox": [
+            173,
+            636,
+            823,
+            665
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Mikolov, Martin Karafiat, Luk Burget, and Sanjeev Khudanpur.´ Recurrent neural network based language model. INTERSPEECH 2010, 11th Annual Conference of the International Speech Communication Association, pp. 1045–1048, 2010. URL http://www.fit.vutbr.cz/research/groups/speech/publi/2010/ mikolov_interspeech2010_IS100722.pdf. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            743
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518, 2015. doi: 10.1038/nature14236. URL https://storage.googleapis. com/deepmind-media/dqn/DQNNaturePaper.pdf. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            837
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International conference on machine learning, pp. 1928–1937, 2016. ",
+        "bbox": [
+            176,
+            844,
+            821,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "W James Murdoch and Arthur Szlam. Automatic rule extraction from long short term memory networks. arXiv preprint arXiv:1702.02540, 2017. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian W Omlin and C Lee Giles. Extraction of rules from discrete-time recurrent neural networks. Neural networks, 9(1):41–52, 1996. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marvin C Paull and Stephen H Unger. Minimizing the number of states in incompletely specified sequential switching functions. IRE Transactions on Electronic Computers, (3):356–367, 1959. ",
+        "bbox": [
+            171,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Silviu Pitis. Beyond binary: Ternary and one-hot neurons. https://r2rt.com/ beyond-binary-ternary-and-one-hot-neurons.html, 2017. ",
+        "bbox": [
+            171,
+            179,
+            821,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. arXiv preprint arXiv:1506.02438, 2015. ",
+        "bbox": [
+            173,
+            217,
+            823,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy Lillicrap, Fan Hui, Laurent Sifre, George van den Driessche, Thore Graepel, and Demis Hassabis. Mastering the game of Go without human knowledge. Nature Publishing Group, 550, 2017. doi: 10.1038/nature24270. URL https://www.nature.com/nature/journal/ v550/n7676/pdf/nature24270.pdf. ",
+        "bbox": [
+            173,
+            268,
+            825,
+            353
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hendrik Strobelt, Sebastian Gehrmann, Bernd Huber, Hanspeter Pfister, and Alexander M Rush. Visual analysis of hidden state dynamics in recurrent neural networks. arXiv preprint arXiv:1606.07461, 2016. ",
+        "bbox": [
+            173,
+            361,
+            826,
+            404
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peter Tino, Bill G Horne, C Lee Giles, and Pete C Collingwood. Finite state machines and recurrent ˇ neural networksautomata and dynamical systems approaches. In Neural networks and pattern recognition, pp. 171–219. Elsevier, 1998. ",
+        "bbox": [
+            173,
+            412,
+            825,
+            455
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Masaru Tomita. Dynamic construction of finite-state automata from examples using hill-climbing. In Proceedings of the Fourth Annual Conference of the Cognitive Science Society, pp. 105–108, 1982. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            507
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Raymond L Watrous and Gary M Kuhn. Induction of finite-state automata using second-order recurrent networks. In Advances in neural information processing systems, pp. 309–317, 1992. ",
+        "bbox": [
+            171,
+            516,
+            823,
+            545
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gail Weiss, Yoav Goldberg, and Eran Yahav. Extracting automata from recurrent neural networks using queries and counterexamples. arXiv preprint arXiv:1711.09576, 2017. ",
+        "bbox": [
+            171,
+            554,
+            823,
+            583
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tom Zahavy, Nir Ben-Zrihem, and Shie Mannor. Graying the black box: Understanding dqns. In International Conference on Machine Learning, pp. 1899–1908, 2016. ",
+        "bbox": [
+            171,
+            592,
+            823,
+            621
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zheng Zeng, Rodney M Goodman, and Padhraic Smyth. Learning finite state machines with selfclustering recurrent networks. Neural Computation, 5(6):976–990, 1993. ",
+        "bbox": [
+            171,
+            628,
+            823,
+            659
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            263,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "7.1 FORMAL DEFINITION OF MODE COUNTER ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            616,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "An MCE is parameterized by the mode number $M$ , a mode transition function $P$ , a mode life span mapping $\\Delta ( m )$ that assigns a positive integer to each mode, and a count set $C$ containing zero or more natural numbers. At time $t$ the MCE hidden state is a tuple $( m _ { t } , c _ { t } )$ , where $\\overline { { m _ { t } } } ~ \\in ~ \\{ 1 , 2 , \\dots , M \\}$ is the current mode and $c _ { t }$ is the count of time-steps that the system has been consecutively in mode $m _ { t }$ . The mode only changes when the lifespan is reached, i.e. $c _ { t } = \\Delta ( m _ { t } ) - 1$ , upon which the next mode $m _ { t + 1 }$ is generated according to the transition distribution $P ( m _ { t + 1 } \\mid m _ { t } )$ . The transition distribution also specifies the distribution over initial modes. The agent does not directly observe the state, but rather, the agent only receives a continuous-valued observations $o _ { t } \\in [ 0 , 1 ]$ at each step, based on the current state $( m _ { t } , c _ { t } )$ . If $c _ { t } \\in C$ then $o _ { t }$ is drawn uniformly at random from $[ m _ { t } / M , ( m _ { t } + 1 ) / M ) ]$ and otherwise $o _ { t }$ is drawn uniformly at random from [0, 1]. Thus, observations determine the mode when the mode count is in $C$ and otherwise the observations are uninformative. Note that the agent does not observe the counter. This means that to keep track of the mode for optimal performance the agent must remember the current mode and use memory to keep track of how long the mode has been active, in order to determine when it needs to “pay attention” to the current observation. ",
+        "bbox": [
+            173,
+            160,
+            825,
+            367
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments with the following three MCE instances 7: 1) Amnesia. This MCE uses $\\Delta ( m ) = 1$ for all modes, $C = \\{ 0 \\}$ , and uniformly samples random initial mode and transition distributions. Thus, an optimal policy will not use memory to track information from the past, since the current observation alone determines the current mode. This tests our ability to use MMN extraction to determine that a policy is purely reactive, i.e. not using memory. 2) Blind. Here we use deterministic initial mode and transition distributions, mode life spans that can be larger than 1, and $C = \\{ \\}$ . Thus, the observations provide no information about the mode and optimal performance can only be achieved by using memory to keep track of the deterministic mode sequence. This allows us to test whether the extraction of an MMN could infer that the recurrent policy is ignoring observations and only using memory. 3) Tracker. This MCE is identical to Amnesia, except that the $\\Delta ( m )$ values can be larger than 1. This requires an optimal policy to pay attention to observations when $c _ { t } = 0$ and use memory to keep track of the current mode and mode count. This is the most general instance of the environment and can result in difficult problems when the number of modes and their life-spans grow. In all above instances, we used $M = 4$ . ",
+        "bbox": [
+            173,
+            375,
+            825,
+            569
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "7.2 GROUND TRUTH MCE MOORE MACHINES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            511,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/e7cd336a61b1fc10f2f80cbc3c40f5d29f9a8092c3204b02c29226434987d837.jpg",
+        "image_caption": [
+            "Figure 3: Moore machine representation of Mode Counter Environments (MCE). We use $\\cdot _ { m }$ ’ to indicate the activate mode/action required in that state. Given $M = 4$ , we have 4 observations classes, $o _ { 1 } = ( 0 , 0 . 2 5 ]$ , $o _ { 2 } = ( 0 . 2 5 , 0 . 5 ]$ , $o _ { 3 } = ( 0 . 5 , 0 . 7 5 ]$ and $o _ { 4 } = ( 0 . 7 5 , 1 ]$ . Also, $^ { O _ { * } }$ implies that the transaction is valid for all observations. The minimal moore machines extracted by our approach from trained RNN policies exactly matches these ground truth machines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            125,
+            745,
+            801
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4e9003bcecc0374482ab76fa7dba9d19edd23d300fd319d7e789d2735b16e1e.jpg",
+        "image_caption": [
+            "Figure 4: Extracted Moore machine representation for Tomita Grammar policies where $B _ { h } = 1 6$ . We use ‘A’ and $\\cdot _ { \\mathrm { R } } \\cdot$ to denote accept and reject states, respectively. Other than Grammar 6, all machines are $100 \\%$ accurate. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            107,
+            879,
+            827
+        ],
+        "page_idx": 14
+    }
+]

parse/train/S1q_Cz-Cb/S1q_Cz-Cb.md

@@ -0,0 +1,508 @@
+# TRAINING NEURAL MACHINES WITH PARTIAL TRACES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We present a novel approach for training neural machines which incorporates additional supervision on the machine’s interpretable components (e.g., neural memory). To cleanly capture the kind of neural machines to which our method applies, we introduce the concept of a differential neural computational machine $\left( \partial \mathbf { N } \mathbf { C M } \right)$ and show that several existing architectures (e.g., NTMs, NRAMs) can be instantiated as a $\partial { \bf N C M }$ and can thus benefit from any amount of additional supervision over their interpretable components. Based on our method, we performed a detailed experimental evaluation with NTM and NRAM machines, showing the approach leads to significantly better convergence and generalization capabilities of the learning phase than standard training using only input-output examples.
+
+# 1 INTRODUCTION
+
+Recently, there has been substantial interest in neural abstract machines that can induce programs from examples Feser et al. (2015; 2016); Frankle et al. (2016); Gaunt et al. (2017); Graves et al. (2014; 2016); Kaiser & Sutskever (2016); Kurach et al. (2016); Reed & de Freitas (2016); Vinyals et al. (2015); Zaremba & Sutskever (2015); Zhang et al. (2015). While significant progress has been made towards learning interesting algorithms Graves et al. (2016), ensuring the training of these machines converges to the desired solution can be very challenging. Interestingly however, even though these machines differ architecturally, they tend to rely on components (e.g., neural memory) that are more interpretable than a typical neural network (e.g., an LSTM). A key question then is:
+
+Can we somehow provide additional amounts of supervision for these interpretable components during training so to bias the learning towards the desired solution?
+
+In this work we investigate this question in depth. We refer to the type of supervision mentioned above as partial trace supervision, capturing the intuition that more detailed information, beyond inputoutput examples, is provided during learning. To study the question systematically, we introduce the notion of a differential neural computational machine (∂NCM), a formalism which allows for clean characterization of the neural abstract machines that fall inside our class and that can benefit from any amount of partial trace information. We show that common architectures such as Neural Turing Machines (NTMs) and Neural Random Access Machines (NRAMs) can be phrased as ∂NCMs, useful also because these architectures form the basis for many recent extensions, e.g., Graves et al. (2016); Grefenstette et al. (2015); Kaiser & Sutskever (2016). We also explain why other machines such as the Neural Program Interpreter (NPI) Reed & de Freitas (2016) or its recent extensions (e.g., the Neural Program Lattice Li et al. (2017)) cannot be instantiated as an $\partial { \bf N C M }$ and are thus restricted to require large (and potentially prohibitive) amounts of supervision. We believe the $\partial { \bf N } { \bf C M }$ abstraction is a useful step in better understanding how different neural abstract machines compare when it comes to additional supervision. We then present $\partial { \bf N } { \bf C M }$ loss functions which abstractly capture the concept of partial trace information and show how to instantiate these for both the NTM and the NRAM. We also performed an extensive evaluation for how partial trace information affects training in both architectures. Overall, our experimental results indicate that the additional supervision can substantially improve convergence while leading to better generalization and interpretability.
+
+To provide an intuition for the problem we study in this work, consider the simple task of training an NTM to flip the third bit in a bit stream (called Flip3rd) – such bitstream tasks have been extensively studied in the area of program synthesis (e.g., Jha et al. (2010); Raychev et al. (2016)). An example input-output pair for this task could be $[ 0 , 1 , 0 , 0 ]  [ 0 , 1 , 1 , 0 ]$ . Given a set of such examples, our goal is to train an NTM that solves this task. An example NTM that generalizes well and is understandable is shown in Figure 1c. Here, the y-axis is time (descending), the $\mathbf { X }$ -axis is the accessed memory location, the white squares represent the write head of the NTM, and the orange squares represent the read head. As we can see, the model writes the input sequence to the tape and then reads from the tape in the same order. However, in the absence of richer supervision, the NTM (and other neural architectures) can easily overfit to the training set – an example of an overfitting NTM is shown in Figure 1a. Here, the traces are chaotic and difficult to interpret. Further, even if the NTM generalizes, it can do so with erratic reads and writes, an example of which is shown in Figure 1b. Here, the NTM learns to read from the third bit (circled) with a smaller weight than from other locations, and also reads and writes erratically near the end of the sequence. This model is less interpretable than the one in Figure 1c because it is unclear how the model knows which the third bit actually is, or why a different read weight would help flip that bit.
+
+![](images/21357540fd982f11f221addbac9a18cb1610fd7c05630816f46640f73199b1c5.jpg)  
+Figure 1: Traces of locations accessed by read/write heads for the Flip3rd task in three different training setups. The y-axis represents time (descending); $\mathbf { X }$ -axis represents head locations. First two NTMs are trained without partial trace information. White represents the distribution of the write head; orange the distribution of the read head; (b) and (c) generalize and are more interpretable than (a); (c) was trained using partial trace information and is more interpretable than (b).
+
+In this work we will develop principled ways for guiding the training of a neural abstract machine towards the behavior shown in Figure 1c. For instance, for Flip3rd, providing partial trace information on the NTM’s read heads for $10 \%$ of the input-output examples is sufficient to bias the learning towards the NTM shown in Figure 1c $100 \%$ of the time.
+
+# 2 NEURAL COMPUTATIONAL MACHINES
+
+To capture the essence of our method and illustrate its applicability, we now define the abstract notion of a neural computational machine (NCM). NCMs mimic classic computational machines with a controller and a memory, and generalize multiple existing architectures. Our approach for supervision with partial trace information applies to all neural architectures expressible as NCMs. A useful feature of the NCM abstraction is that it clearly delineates end-to-end differentiable architectures (Graves et al. (2014)’s NTM, Kurach et al. (2016)’s NRAM), which can train with little to no trace supervision, from architectures that are not end-to-end differentiable (Reed & de Freitas (2016)’s NPI) and hence require a certain minimum amount of trace information. In the follow-up section, we show how to phrase two existing neural architectures (NTMs and NRAMs) as an NCM.
+
+An NCM is a triple of functions: a processor, a controller, and a loss:
+
+Processor The processor $\pi : W \times C \times M \to B \times M$ performs a pre-defined set of commands $C$ , which might involve manipulating memories in $M$ . The commands may produce additional feedback in $B$ . Also, the processor’s operation may depend on parameters in $W$ .
+
+Controller The controller $\kappa : W \times B \times Q \times I  C \times Q \times O$ decides which operations the machine performs at each step. It receives external inputs from $I$ and returns external outputs in $O$ . It can also receive feedback from the processor and command it to do certain operations (e.g., memory read). The decisions the controller takes may depend on its internal state (from $Q$ ). The controller can also depend on parameters in $W$ . For instance, if the controller is a neural network, then the network’s weights will range over $W$ .
+
+![](images/9e47039c72e52b7718df66462af17fdc5a58d08d316234162426244db0186003.jpg)  
+Figure 2: (a) is depiction of the generic NCM structure (b) is a high-level overview of an NTM and (c) is a high level overview of the NRAM architecture. The controller outputs a circuit, which in this case contains the modules READ, ADD, SUB, LT, and WRITE. The controller encodes the two inputs to the modules as probability vectors, $a , b$ and $c$ , over the possible choices. The most likely choice is shown in green. The only input to the controller are the registers $r _ { 1 }$ and $r _ { 2 }$ .
+
+Loss Function The loss function $L _ { e } : T r a c e \times E  \mathbb { R }$ indicates how close a trace $\tau \in T r a c e$ of an execution of the machine (defined below) is to a behavior from a set $E$ . The loss function provides a criterion for training a machine to follow a prescribed set of behaviors, and hence we impose certain differentiability conditions. We require that the loss surface is continuous and piecewise differentiable with respect to the weights $w \in W$ for all examples $e$ and inputs $x$ with traces $\tau ( w , x )$ :
+
+$$
+l ( w ; x , e ) = L _ { e } ( \tau ( w , x ) , e )
+$$
+
+Execution The execution of the machine begins with an input sequence $x = \{ x _ { t } \} _ { 1 } ^ { n }$ and initial values of the controller state $q _ { 0 }$ , memory $m _ { 0 }$ , and processor feedback $b _ { 0 }$ . At each time step $t = 1 \ldots n$ controller and processor take turns executing according to the following equations:
+
+$$
+\begin{array} { c } { { ( c _ { t } , q _ { t } , y _ { t } ) = \kappa ( w , b _ { t - 1 } , q _ { t - 1 } , x _ { t } ) } } \\ { { ( b _ { t } , m _ { t } ) = \pi ( w , c _ { t } , m _ { t - 1 } ) } } \end{array}
+$$
+
+A trace $\tau ( w , x , b _ { 0 } , m _ { 0 } , q _ { 0 } ) = \{ ( c _ { t } , b _ { t } , q _ { t } , y _ { t } , m _ { t } ) \} _ { 1 } ^ { n }$ records these quantities’ values at each time step.   
+We will occasionally write $\tau _ { C } , \tau _ { B } , \ldots$ for the trace projected onto one of its components $c , b , \ldots$ .
+
+∂NCMs Note that the differentiability conditions that we impose on the loss do not imply that any of the NCM functions $\pi$ , $\kappa$ and $L _ { e }$ are continuous or differentiable. They indeed can be highly discontinuous as in NCMs like Weston et al. (2014)’s memory networks with a hard attention mechanism, or as in Reed $\&$ de Freitas (2016)’s neural programmer-interpreters. In order to fix these discontinuities and recover a differentiable loss surface, these architectures train with strong supervision only: the training examples $e \in E$ must provide a value for every traced quantity that comes from a discontinuous parameter.
+
+In contrast, what we call differentiable neural computational machines (∂NCM), have $\kappa , \pi$ and $L _ { e }$ continuous and piecewise differentiable. In this case, the loss surface is differentiable with respect to every parameter. Thus, there is no need to specify corresponding values in the examples, and so we can train with as much trace information as available.
+
+# 3 NTMS AND NRAMS AS NCMS
+
+We now show how NTMs and NRAMs can be instantiated as ∂NCMs.
+
+NTM as ∂NCM An Neural Turing Machine (NTM) Graves et al. (2014) (Figure 2b) has access to a memory $\mathcal { M } \in \mathbb { R } ^ { c \times n }$ of $c$ cells of $n$ real numbers each. We suppose the machine has one read head and one write head, whose addresses are, respectively, the probability vectors $r , w \in [ 0 , 1 ] ^ { \{ 1 \ldots c \} }$ At every time step, the read head computes the expected value $m \in \mathbb { R } ^ { n }$ of a random cell at index $i \sim r$ . This value together with the current input are fed into a controller neural network, which then decides on several commands. It decides what fraction $e \in \mathbb { R } ^ { n }$ to erase and how much $a \in \mathbb { R } ^ { n }$ to add to the cells underneath the write head. The write head stores the tape expected after a random modification at index $i \sim w$ . Then the controller indicates the head movement with two probability vectors $\Delta r , \Delta w \in [ 0 , 1 ] ^ { \{ - 1 , 0 , + 1 \} }$ which are convolved with the respective head addresses (the actual addressing mechanism is more involved, but we omit it for brevity) Finally, the controller produces the current output value. In terms of NCMs, the NTM’s variables fall into the following classes:
+
+$$
+\frac { \mathrm { I } / \mathrm { O } } { x \in I } \qquad \begin{array} { r l r } { \mathrm { S t a t e } } & { } & { \mathrm { C o m m u n i c a t i o n } } \\ { q \in Q } & { ( e , a , \Delta r , \Delta w ) \in C } \\ { y \in O } & { ( r , w , \mathcal { M } ) \in M } & { m \in B } \end{array}
+$$
+
+Each of these variables change over time according to certain equations (see Appendix A for details). The processor $\pi$ and the controller $\kappa$ functions for each time step satisfy:
+
+$$
+\begin{array} { r l } & { ( ( e _ { t } , a _ { t } , \Delta r _ { t } , \Delta w _ { t } ) , \ q _ { t } , \ y _ { t } ) = \kappa ( w , m _ { t } , q _ { t - 1 } , x _ { t } ) } \\ & { \qquad ( m _ { t + 1 } , \ ( r _ { t } , w _ { t } , M _ { t } ) ) = \pi ( ( e _ { t } , a _ { t } , \Delta r _ { t } , \Delta w _ { t } ) , \ ( r _ { t - 1 } , w _ { t - 1 } , \mathcal { M } _ { t - 1 } ) ) . } \end{array}
+$$
+
+The standard loss function $L _ { e }$ for the NTM simply includes a term, such as cross-entropy or $L _ { 2 }$ distance, for the machine output at every time step. Each of these compare the machine output to the respective values contained in the examples $e \in E$ .
+
+NRAM as ∂NCM A Neural Random Access Machine (NRAM) Kurach et al. (2016) is a neural machine designed for ease of pointer (de-)referencing. An NRAM has a variable sized memory $\mathcal { M } \in \mathbb { R } ^ { c \times c }$ whose size varies between runs. It also has access to a register file $r \in \mathbb { R } ^ { n \times c }$ with a constant number $n$ of registers. Both the memory and the registers store probability vectors over $\{ 1 \ldots c \}$ . The controller receives no external inputs, but at each time step reads the probability that a register assigns to 0. It also produces no external output, except a probability $f \in [ 0 , 1 ]$ for termination at the current time step. The output of the run is considered to be the final memory state.
+
+Unlike the NTM, computation in the NRAM is performed by a fixed sequence of modules. Each module implements a simple integer operation/memory manipulation lifted to probability vectors. For example, addition lifts to convolution, while memory access is like that of the NTM. At every time step the controller organizes the sequence of modules into a circuit, which is then executed. The circuit is encoded by a pair of probability distributions per module, as shown in Figure $_ { 2 \mathrm { c } }$ . These distributions specify respectively which previous modules or registers will provide a given module first/second arguments. The distributions are stacked in the matrices $a$ and $b$ . A similar matrix $c$ is responsible for specifying what values should be written to the registers at the end of the time step. The NCM instantiation of an NRAM is the following:
+
+<table><tr><td>I/0</td><td>State Communication</td></tr><tr><td>{1}=I qt∈Q</td><td>(at,bt,ct) ∈C</td></tr><tr><td>ft∈O (rt,Mt) ∈ M</td><td>Tt,-,0 ∈B</td></tr></table>
+
+The equations that determine these quantities can be found in Appendix B. The processor function $\pi$ and the controller function $\kappa$ expressed in terms of these quantities are:
+
+$$
+\begin{array} { r l } & { ( ( a _ { t } , b _ { t } , c _ { t } ) , h _ { t } , f _ { t } ) = \kappa ( w , r _ { ( t - 1 ) , - , 0 } , h _ { t - 1 } , 1 ) } \\ & { ( r _ { t , - , 0 } , ( r _ { t } , \mathcal { M } _ { t } ) ) = \pi ( ( a _ { t } , b _ { t } , c _ { t } ) , \ ( r _ { t - 1 } , \mathcal { M } _ { t - 1 } ) ) . } \end{array}
+$$
+
+The loss of the NRAM is more complex than the NTM loss: it is an expectation with respect to the probability distribution $p$ of termination time, as determined by the termination probabilities $f _ { t }$ (see Appendix B). For every $t = 1 \ldots k$ , the loss considers the negative log likelihood that the $i$ -th memory cell at that time step equals the value $e _ { i }$ provided in the example, independently for each $i$ :
+
+$$
+L _ { e } ( \tau , e ) = - \sum _ { t < k } p _ { t } \sum _ { i < c } \log ( \mathcal { M } _ { t , i , e _ { i } } ) .
+$$
+
+# 4 SUBTRACE SUPERVISION OF NCMS
+
+Incorporating supervision during NCM training can be helpful with: (i) convergence: additional bias may steer the minimization of the NCM’s loss function $L _ { e }$ , as much as possible, away from local minima that do not correspond to good solutions, (ii) interpretability: the bias can also be useful in guiding the NCM towards learning a model that is more intuitive/explainable to a user (especially if the user already has an intuition on what it is that parts of the model should do), and (iii) generalization: the bias can steer the NCM towards solutions which minimize not just the loss on example of difficulties it has seen, but on significantly more difficult examples.
+
+The way we provide additional supervision to NCMs is, by encoding, for example, specific commands issued to the processor, into extra loss terms. Let us illustrate how we can bias the learning with an NTM. Consider the task of copying the first half of an input sequence $\{ x _ { t } \} _ { 1 } ^ { 2 l }$ into the second half of the machine’s output $\{ y _ { t } \} _ { 1 } ^ { 2 l }$ , where the last input $x _ { l }$ from the first half is a special value indicating that the first half ended. Starting with both heads at position 1, the most direct solution is to consecutively store the input to the tape during the first half of the execution, and then recall the stored values during the second half. In such a solution, we expect the head positions to be:
+
+$$
+w _ { t } = p ( t ) = { \left\{ \begin{array} { l l } { { \mathrm { o n e - h o t } } ( t ) } & { { \mathrm { i f ~ } } t = 1 \dots l } \\ { { \mathrm { o n e - h o t } } ( l ) } & { { \mathrm { i f ~ } } t \geq l + 1 } \end{array} \right. } \quad r _ { t } = q ( t ) = { \left\{ \begin{array} { l l } { { \mathrm { o n e - h o t } } ( 1 ) } & { { \mathrm { i f ~ } } t = 1 \dots l } \\ { { \mathrm { o n e - h o t } } ( t - l ) } & { { \mathrm { i f ~ } } t \geq l + 1 } \end{array} \right. }
+$$
+
+To incorporate this information into the training, we add loss terms that measure the cross-entropy $( H )$ between $p ( t )$ and $w _ { t }$ as well as between $q ( t )$ and $r _ { t }$ . Importantly, we need not add terms for every time-step, but instead we can consider only the corner cases where heads change direction:
+
+$$
+\sum _ { t = 1 , l + 1 , 2 l } H ( p ( t ) , w _ { t } ) + H ( q ( t ) , r _ { t } ) .
+$$
+
+# 4.1 GENERIC SUBTRACE LOSS FOR NCMS
+
+We now describe the general shape of the extra loss terms for arbitrary NCMs. Since, typically, we can interpret only the memory and the processor in terms of well-understood operations, we will consider loss terms only for the memory state and the communication flow between the controller and the processor. We leave the controller’s hidden state unconstrained – this also permits us to use the same training procedure with different controllers.
+
+The generic loss is expressed with four loss functions for the different components of an NCM trace:
+
+$$
+\begin{array} { r l r l } & { L _ { C } : C \times E _ { C } \to \mathbb { R } \quad } & & { L _ { B } : B \times E _ { B } \to \mathbb { R } } \\ & { L _ { O } : O \times E _ { O } \to \mathbb { R } \quad } & & { L _ { M } : M \times E _ { M } \to \mathbb { R } } \end{array}
+$$
+
+For each part $\alpha \in \{ C , B , O , M \}$ , we provide hints $( t , v , \mu ) \in \sigma _ { \alpha }$ that indicate a time step $t$ at which the hint applies, an example $v \in E _ { \alpha }$ for the relevant component, and a weight $w \in \mathbb { R }$ of the hint. The weight is included to account for hints having a different importance at different time-steps, but also to express our confidence in the hint, e.g., hints coming from noisy sources would get less weight.
+
+A subtrace $\sigma$ is a collection of hints used for a particular input-output example $e$ . We call it a subtrace because, typically, it contains hints for a proper subset of the states traced by the NCM during execution. The net loss for a given input-output example and subtrace equals the original loss $L _ { e }$ added to the weighted losses for all the hints, scaled by a constant factor $\lambda$ :
+
+$$
+L ( \tau , ( \sigma , e ) ) = L _ { e } ( \tau , e ) + \lambda \frac { \sum _ { \alpha \in \{ C , B , O , M \} } \sum _ { ( t , v , \mu ) \in \sigma _ { \alpha } } \mu L _ { \alpha } ( \tau _ { \alpha , t } , v ) } { \sum _ { \alpha \in \{ C , B , O , M \} } \sum _ { ( t , v , \mu ) \in \sigma _ { \alpha } } \mu }
+$$
+
+![](images/7c3b4c4acf52085a0a92fa966175121916ff1c4724981578babd2db042bdf4e5.jpg)  
+Figure 3: An example circuit for the task of adding one to all memory cells. The arrows for register updates are shown in red. Technically, modules take two arguments, but some ignore an argument, such as INC or READ. For them, we show only the relevant arrows.
+
+# 4.2 SUBTRACES FOR NTM
+
+For NTMs, we allow hints on the output $y$ , the addresses $r$ and $w$ , and the tape $\mathcal { M }$ . We include extra loss terms for the memory state only (all other loss terms are zero):
+
+$$
+\begin{array} { r } { \begin{array} { r l } & { L _ { M } ( ( r _ { t } , w _ { t } , \mathcal { M } _ { t } ) , ( \mathrm { w r } , v ) ) = H ( v , w _ { t } ) } \\ & { L _ { M } ( ( r _ { t } , w _ { t } , \mathcal { M } _ { t } ) , ( \mathrm { r d } , v ) ) = H ( v , r _ { t } ) } \end{array} } \end{array}
+$$
+
+Unlike the output and addresses, values on the tape are interpreted according to an encoding internal to the controller (which emerges only during training). Forcing the controller to use a specific encoding for the tape, as we do with NTM output, can have a negative effect on training (in our experiments, training diverged consistently). To remedy this, we do not apply loss to the tape directly but to a decoded version of a cell on the tape. While a decoder might find multiple representations and overfit, we found that it forced just enough consistency to improve the convergence rate. The decoder itself is an auxiliary network $\phi$ trained together with the NTM, which takes a single cell from memory as input. The output of the decoder is compared against the expected value which should be in that cell:
+
+$$
+L _ { M } ( ( - , - , \mathcal { M } _ { t } ) , ( \mathsf { t a p e } , i , v ) ) = H ( \phi ( \mathcal { M } _ { t , i } ) , v ) .
+$$
+
+For all subtraces we provide in our experiments with NTMs, the hints have the same unit weight.
+
+# 4.3 SUBTRACES FOR NRAM
+
+For NRAMs, we hint which connections should be present in the circuit the controller constructs at each step, including the ones for register updates. An example circuit is shown in Figure 3. In terms of an NCM, this amounts to providing loss for commands and no loss for anything else. We set the loss to the negative log likelihood of the controller choosing specific connections revealed in the hint:
+
+$$
+\begin{array} { r l } & { L _ { C } ( ( a _ { t } , b _ { t } , c _ { t } ) , ( \mathrm { m o d u l e } , m , i , j ) ) = - \log ( a _ { t , m , i } ) - \log ( b _ { t , m , j } ) } \\ & { L _ { C } ( ( a _ { t } , b _ { t } , c _ { t } ) , ( \mathrm { r e g i s t e r } , r , i ) ) = - \log ( c _ { t , r , i } ) } \end{array}
+$$
+
+In our experiments, we observed that assigning higher weight to hints at earlier timesteps is crucial for convergence of the training process. For a hint at time-step $t$ , we use the weight $\mu \bar { = } ( t + 1 ) ^ { - 2 }$ . A possible reason for why this helps is that the machine’s behavior at later time-steps is highly dependent on its behavior at the early time-steps. Thus, the machine cannot reach a later behavior that is right before it fixes its early behavior. Unless the behavior is correct early on, the loss feedback from later time-steps will be mostly noise, masking the feedback from early time-steps.
+
+Other Architectures The NCM can be instantiated to architectures as diverse as a common LSTM network or End-To-End Differentiable Memory Networks. Any programming inducing neural network with at least partially interpretable intermediate states for which the dataset contains additional hints could be considered a good candidate for application of this abstraction.
+
+# 5 EXPERIMENTAL EVALUATION
+
+We evaluated our NCM supervision method on the NTM and NRAM architectures. For each of the two architectures we implemented a variety of tasks and experimented with different setups of trace supervision. The main questions that we address are: (i) does trace supervision help convergence, interpretability, and generalization? (ii) how much supervision is needed to train such models? Below, we summarize our findings – further details are provided in the appendix.
+
+![](images/9012ce406364e17741a044aab68eec4015cc8c28294cb9b771fc464ff29df069.jpg)  
+Figure 4: Relative percentage of training instances which generalized out of ten runs per task for the NTM. We provide a subtrace $100 \%$ of the time and use $\lambda = 1$ . $\mathbf { X }$ -axis shows the type of supervision.
+
+![](images/91a6581f64e028dcffae6466e2b3aaeee4494e3c26a9e32a19536b121f5f1b70.jpg)  
+Figure 5: The number of initial runs which generalized for Flip3rd. The first dimension listed in the rows controls the execution details revealed in a subtrace, while the second dimension (the density column) controls the proportion of examples that receive extra subtrace supervision.
+
+Subtraces For NTMs We measured how often we successfully trained an NTM that achieves strong generalization. We consider a model to generalize if relative to the training size limit $n$ , it achieves perfect accuracy on all of tests of $\mathrm { s i z e } \le 1 . 5 n$ , and perfect accuracy on $90 \%$ of the tests of size $\leq 2 n$ . Figure 4 reports the average improvement compared to a baseline using only $\mathrm { I / O }$ examples. We ran experiments with four different tasks and various types of hints (cf. Appendices C, E). Some of the hint types are: read and write specify respective head addresses for all time steps; address combines the previous two; corner reveals the head addresses, but only when the heads change direction; value gives value for a single cell. Except for three cases, trace supervision helped improve generalization. Here, RepeatFlip3d is most challenging, with baseline generalizing only $5 \%$ of the time (cf. Appendix I). Here we have the largest improvement with extra supervision: corner type of hints achieve eight-fold increase in success rate, reaching $40 \%$ . Another task with an even larger ratio is RepeatCopyTwice (cf. Appendix), where success increases from $1 5 . 5 \%$ to $100 \%$ .
+
+In addition to this experiment, we performed an extensive evaluation of different setups, varying the global $\lambda$ parameter of the loss Eq. 8, and providing hints for just a fraction of the examples. The full results are in Appendix I; here we provide those for RepeatFlip3d in Table 5. The table reveals that the efficacy of our method heavily depends on these two parameters. The best results in this case are for the read/corner type of hints $\mathbf { \dot { \frac { 1 } { 2 } } } / \mathbf { \frac { 1 } { 1 0 } } ^ { - }$ of the time, with $\bar { \lambda } \in \{ 0 . 1 , 1 \}$ . The best results for other tasks are achieved with different setups. Generally, our conclusion is that training with traces $50 \%$ of the time usually improves performance (or does not lower it much) when compared to the best method. This observation raises the interesting question of what the best type and amount of hints are for a given task.
+
+Finally, we observed that in all cases where training with trace supervision converged, it successfully learned the head movements/tape values we had intended. This show that trace supervision can bias the architecture towards more interpretable behaviors. In those cases, the NTM learned consistently sharper head positions/tape values than the baseline, as Figure 6 shows for Flip3rd.
+
+Effect of Subtraces For NRAMs Ease of generalization for the NRAM is a known issue, with Neelakantan et al. (2015) reporting that ListK for example generalizes poorly, even when trained with noise in the gradient, curriculum learning, and an entropy bonus. We observed that when run on an indefinite number of examples with the correct number of timesteps and a correct module sequence, Swap and Increment would in fact occasionally generalize perfectly, but did not have the resources to run such indefinite tests with Permute, ListK, and Merge.
+
+![](images/05f97e68b99ccea1d695c9f045dce91f40b39e130b996228c5f01b70c999edc5.jpg)  
+Figure 6: Execution traces of two NTMs trained on $\mathtt { F 1 1 p 3 r d }$ until generalization. First is baseline (no trace supervision); second is trained with corner hints. Time flows top to bottom. The first pane from every pair shows the value written to tape; second shows head locations. Figures show that a little extra supervision helps the NTM write sharper 0–1 values and have more focused heads.
+
+![](images/b8e81fe61863d4fcc0588fb02a05a41785d40e03c95c52c62c0cd6e8a3d80458.jpg)  
+Figure 7: (a) average number of errors after training had completed for NRAM. Observe that full training results in a significantly higher percent of generalization after training stopped. (b) shows the distribution of errors to problem length for Permute (one character of noise in $10 \%$ of samples).
+
+Figure 7a demonstrates that when training had finished, either because it had ended early or had reached 5000 training examples (our upper bound), generalization would in fact be on average significantly better than the baseline the more hints that were used for all tasks. Here, number of hints used seemed to be a sufficient predictor for the quality of the trained model.
+
+Robustness to Noise The effect of increasing supervision on the quality of the trained model was so strong that not even noise in the input was able to significantly hinder generalization. In Figure 7b, we corrupted a single character in the output examples for the Permute problem in $10 \%$ of the examples. We found that without any extra hints, no convergence was seen after training was complete, whereas with just corner subtraces, the generalization was nearly optimal.
+
+Furthermore, we found that noise in the trace does not seriously harm performance. We corrupted a single hint for $20 \%$ of the traces of the Increment task using otherwise full supervision, as can be seen in the NoisyFull line of Figure 14.
+
+# 6 CONCLUSION
+
+We presented a method for incorporating (any amount of) additional supervision into the training of neural abstract machines. The basic idea was to provide this supervision (called partial trace information) over the interpretable components of the machine and to thus more effectively guide the learning towards the desired solution. We introduced the $\partial { \bf N } { \bf C M }$ architecture in order to precisely capture the neural abstract machines to which our method applies. We showed how to formulate partial trace information as abstract loss functions, how to instantiate common neural architectures such as NTMs and NRAMs as ∂NCMs and concretize the $\partial { \bf N C M }$ loss functions. Our experimental results indicate that partial trace information is effective in biasing the learning of both NTM’s and NRAM’s towards better converge, generalization and interpretability of the resulting models.
+
+# REFERENCES
+
+Matko Bošnjak, Tim Rocktäschel, Jason Naradowsky, and Sebastian Riedel. Programming with a differentiable forth interpreter. In under review for ICLR (2017). URL http://arxiv.org/ abs/1605.06640.
+
+Corinna Cortes, Neil D. Lawrence, Daniel D. Lee, Masashi Sugiyama, and Roman Garnett (eds.). Advances in Neural Information Processing Systems 28, 2015. URL http://papers.nips.cc/ book/advances-in-neural-information-processing-systems-28-2015.
+
+John K Feser, Swarat Chaudhuri, and Isil Dillig. Synthesizing data structure transformations from input-output examples. In ACM SIGPLAN Notices, volume 50, pp. 229–239. ACM, 2015.
+
+John K Feser, Marc Brockschmidt, Alexander L Gaunt, and Daniel Tarlow. Differentiable functional program interpreters. arXiv preprint arXiv:1611.01988, 2016.
+
+Jonathan Frankle, Peter-Michael Osera, David Walker, and Steve Zdancewic. Example-directed synthesis: a type-theoretic interpretation. ACM SIGPLAN Notices, 51(1):802–815, 2016.
+
+Karlis Freivalds and Renars Liepins. Improving the neural gpu architecture for algorithm learning. arXiv preprint arXiv:1702.08727, 2017.
+
+Alexander L. Gaunt, Marc Brockschmidt, Nate Kushman, and Daniel Tarlow. Lifelong perceptual programming by example. In under review for ICLR (2017). URL https://arxiv.org/ abs/1611.02109.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, abs/1410.5401, 2014. URL http://arxiv.org/abs/1410.5401.
+
+Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio Gómez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, ´ Adrià Puigdomènech Badia, Karl Moritz Hermann, Yori Zwols, Georg Ostrovski, Adam Cain, Helen King, Christopher Summerfield, Phil Blunsom, Koray Kavukcuoglu, and Demis Hassabis. Hybrid computing using a neural network with dynamic external memory. Nature, 538(7626):471– 476, Oct 2016. ISSN 0028-0836. URL http://dx.doi.org/10.1038/nature20101.
+
+Edward Grefenstette, Karl Moritz Hermann, Mustafa Suleyman, and Phil Blunsom. Learning to transduce with unbounded memory. In Cortes et al. (2015), pp. 1828–1836. URL http://papers. nips.cc/paper/5648-learning-to-transduce-with-unbounded-memory.
+
+Susmit Jha, Sumit Gulwani, Sanjit A Seshia, and Ashish Tiwari. Oracle-guided component-based program synthesis. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering-Volume 1, pp. 215–224. ACM, 2010.
+
+Lukasz Kaiser and Ilya Sutskever. Neural GPUs learn algorithms. In Kingsbury & Bengio (2016). URL http://arxiv.org/abs/1511.08228.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Brian Kingsbury and Samy Bengio (eds.). 4th International Conference on Learning Representations, May 2-4, 2016, San Juan, Puerto Rico, 2016. URL http://www.iclr.cc/doku.php?id= iclr2016:main.
+
+Karol Kurach, Marcin Andrychowicz, and Ilya Sutskever. Neural random-access machines. ERCIM News, 2016(107), 2016. URL http://ercim-news.ercim.eu/en107/special/ neural-random-access-machines.
+
+Chengtao Li, Daniel Tarlow, Alexander L. Gaunt, Marc Brockschmidt, and Nate Kushman. Neural program lattices. In under review for ICLR (2017). URL https://openreview.net/pdf? id=HJjiFK5gx.
+
+Arvind Neelakantan, Luke Vilnis, Quoc V Le, Ilya Sutskever, Lukasz Kaiser, Karol Kurach, and James Martens. Adding gradient noise improves learning for very deep networks. arXiv preprint arXiv:1511.06807, 2015.
+
+Veselin Raychev, Pavol Bielik, Martin T. Vechev, and Andreas Krause. Learning programs from noisy data. In Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2016, St. Petersburg, FL, USA, January 20 - 22, 2016, pp. 761–774, 2016. doi: 10.1145/2837614.2837671. URL http://doi.acm.org/10.1145/ 2837614.2837671.
+
+Scott Reed and Nando de Freitas. Neural programmer-interpreters. In Kingsbury & Bengio (2016). URL https://arxiv.org/abs/1511.06279.
+
+under review for ICLR (ed.). 5th International Conference on Learning Representations, April 24- 26, 2017, Toloun, France, 2017. URL http://www.iclr.cc/doku.php?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ ICLR2017: main.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Cortes et al. (2015), pp. 2692–2700. URL http://papers.nips.cc/paper/5866-pointer-networks.
+
+Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. arXiv preprint arXiv:1410.3916, 2014.
+
+Wojciech Zaremba and Ilya Sutskever. Learning to execute. CoRR, abs/1410.4615, 2014. URL http://arxiv.org/abs/1410.4615.
+
+Wojciech Zaremba and Ilya Sutskever. Reinforcement learning neural turing machines. CoRR, abs/1505.00521, 2015. URL http://arxiv.org/abs/1505.00521.
+
+Wei Zhang, Yang Yu, and Bowen Zhou. Structured memory for neural turing machines. CoRR, abs/1510.03931, 2015. URL http://arxiv.org/abs/1510.03931.
+
+# A NTM EQUATIONS
+
+The controller for the NTM consists of the networks $\varphi$ $\varphi , \psi _ { y } , \psi _ { e } , \psi _ { a } , \chi _ { r } , \chi _ { w }$ , which operate on the variables:
+
+$$
+\begin{array} { r l r l r l } { x - \operatorname* { i n } \quad } & { q \mathrm { - c o n t r o l l e r ~ s t a t e } } & { r \mathrm { - r e a d ~ a d d r e s s } } & { \Delta r \mathrm { - c h a n g e ~ i n } r } & { e \mathrm { - e r a s e } } & { \mathcal { M } \mathrm { - t a p e } } \\ { y \mathrm { - o u t } \quad m \mathrm { - r e a d ~ v a l u e } } & { w \mathrm { - w r i t e ~ a d d r e s s } } & { \Delta w \mathrm { - c h a n g e ~ i n } w } & { a \mathrm { - a d d } } & { ( 1 \mathrm { - } r \mathrm { - } \mathrm { ~ a d d } ) } \end{array}
+$$
+
+The equations that describe NTM executions are:
+
+$$
+\begin{array} { r } { \Delta r _ { t } = \chi _ { r } ( q _ { t } ) } \\ { \Delta w _ { t } = \chi _ { w } ( q _ { t } ) } \\ { y _ { t } = \psi _ { y } ( q _ { t } ) } \\ { e _ { t } = \psi _ { e } ( q _ { t } ) } \\ { a _ { t } = \psi _ { a } ( q _ { t } ) } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { { \boldsymbol { r } } _ { t } = a d d r e s s ( \Delta { \boldsymbol { r } } _ { t } , { \boldsymbol { r } } _ { t - 1 } , \mathcal { M } _ { t - 1 } ) } \\ & { { \boldsymbol { w } } _ { t } = a d d r e s s ( \Delta { \boldsymbol { w } } _ { t } , { \boldsymbol { w } } _ { t - 1 } , \mathcal { M } _ { t - 1 } ) } \\ & { { \boldsymbol { m } } _ { t } = { \boldsymbol { r } } _ { t } { \boldsymbol { M } } _ { t - 1 } } \\ & { { \boldsymbol { \mathcal { M } } } _ { t } = \mathcal { M } _ { t - 1 } - ( { \boldsymbol { w } } _ { t } \otimes { \boldsymbol { e } } _ { t } ) \odot \mathcal { M } _ { t - 1 } + { \boldsymbol { w } } _ { t } \otimes { \boldsymbol { a } } _ { t } } \\ & { { \boldsymbol { q } } _ { t } = \varphi ( { \boldsymbol { x } } _ { t } , { \boldsymbol { q } } _ { t - 1 } , { \boldsymbol { m } } _ { t } ) . } \end{array}
+$$
+
+# B NRAM EQUATIONS
+
+The controller of the NRAM consists of the networks $\varphi , \psi _ { a } , \psi _ { b } , \psi _ { c } , \psi _ { f }$ , which operate on the variables:
+
+$$
+\begin{array} { r l r l r l } & { a - \mathrm { l h s ~ c i r c u i t } } & & { b - \mathrm { r h s ~ c i r c u i t } } & & { c - \mathrm { r e g i s t e r ~ i n p u t s } } & & { o - \mathrm { m o d u l e ~ o u t p u t s } } \\ & { r - \mathrm { r e g i s t e r ~ s t a t e } } & & { \mathcal { M } - \mathrm { m e m o r y ~ t a p e } } & & { h - \mathrm { c o n t r o l l e r ~ s t a t e } } & & { f - \mathrm { s t o p ~ p r o b a b i l i t y } . } \end{array}
+$$
+
+The equations that describe the NRAM execution are:
+
+$$
+\begin{array} { r l r } { a _ { t } = \mathrm { s o f m a x } ( \psi _ { a } ( q _ { t } ) ) } & { A _ { t , i } = ( r _ { 1 } , \dots , r _ { R } , o _ { 0 } , \dots , o _ { i - 1 } ) ^ { T } a _ { t , i } } & { \forall i < M } \\ { b _ { t } = \mathrm { s o f m a x } ( \psi _ { b } ( q _ { t } ) ) } & { B _ { t , i } = ( r _ { 1 } , \dots , r _ { R } , o _ { 0 } , \dots , o _ { i - 1 } ) ^ { T } b _ { t , i } } & { \forall i < M } \\ { c _ { t } = \mathrm { s o f m a x } ( \psi _ { c } ( q _ { t } ) ) } & { r _ { t , i } = ( r _ { 1 } , \dots , r _ { R } , o _ { 1 } , \dots , o _ { Q } ) ^ { T } c _ { t , i } } & { \forall i < R } \\ { f _ { t } = \psi _ { f } ( q _ { t } ) } & { o _ { t , i , k } = \displaystyle \sum _ { 0 \leq a , b < M } A _ { t , i , a } B _ { t , i , b } [ m _ { i } ( a , b ) = k ] } & { \forall i \notin \{ \rho , \omega \} , k < M } \\ { q _ { t } = \varphi ( q _ { t - 1 } , r _ { t , - , 0 } ) } & { o _ { t , \rho } = \mathcal { M } _ { t } A _ { t , \rho } } & { \mathrm { ( ) } } \\ & { \mathcal { M } _ { t } = ( J - A _ { t , \omega } ) J ^ { T } \cdot \mathcal { M } _ { t - 1 } + A _ { t , \omega } B _ { t , \omega } ^ { T } } & { \mathrm { ( ) } } \\ { p _ { t } = f _ { t } \prod ( 1 - f _ { i } ) } & { p _ { T } = 1 - \displaystyle \sum _ { i \ < T } p _ { i } } & { \mathrm { ( ) } } \end{array}
+$$
+
+# C SETUP FOR NTM
+
+For all of our NTM experiments we use a densely connected feed-forward controller. There are two architectural differences from the original NTM Graves et al. (2014) that helped our baseline performance: (1) the feed-forward controller, the erase and the add gates use tanh activation; (2) the output layer uses softmax. In the original architecture these are all logistic sigmoids. For the newly introduced tape decoder (active only during training) we used two alternative implementations: a tanh-softmax network, and a single affine transformation. We tested the NTM’s learning ability on five different tasks for sequence manipulation, two of which have not been previously investigated in this domain. These tasks can be found in Appendix E.
+
+We performed experiments using several combination of losses as summarized in Appendix F. The observed training performance per task is shown in Appendix I, with rows corresponding to the different loss setups. The corner setup differs from the address setup in that the example subtraces were defined only for a few important corner cases. For example in RepeatCopyTwice, the write head was provided once at the beginning of the input sequence, and once at the end. Similarly, the read head was revealed at the beginning and at the end of every output repetition. In all other setups we provide full subtraces (defined for all time steps).
+
+The supervision amount can be tuned by adjusting the $\lambda$ weight from Equation 8. Further, we can also control the fraction of examples which get extra subtrace supervision (the density row in Figure I). The performance metric we use is the percentage of runs that do generalize after $1 0 0 \mathrm { k }$ iterations for the given task and supervision type. By generalize we mean that the NTM has perfect accuracy on all testing examples up to $1 . 5 \times$ the size of the max training length, and also perfect accuracy on $90 \%$ of the testing examples up to $2 \times$ the maximum training length.
+
+We used a feed-forwad controller with $2 \times 5 0$ units, except for RepeatCopyTwice, which uses $2 \times 1 0 0$ units. For training we used the Adam optimizer Kingma & Ba (2014), a learning rate of $1 0 ^ { - 3 }$ for all tasks except RepeatFlip3d and $\mathtt { F 1 1 p 3 r d }$ which use $5 \cdot 1 0 ^ { - 4 } $ . The lengths of the training sequences for the first four tasks are from 1 to 5, whereas the generalization of the model was tested with sequences of lengths up to 20. For Flip3rd and RepeatFlip3d, the training sequence length was up to 16, whereas the testing sequences have maximum length of 32.
+
+# D SETUP FOR NRAM
+
+Like in the NTM, we use a densely connected two layer feed forward controller for our experiments, and use ReLU as the activation function. We make no modifications to the original architecture, and use noise with the parameter $\eta = 0 . 3$ as suggested by Neelakantan et al. (2015), and curriculum learning as described by Zaremba & Sutskever (2014). We stop training once we get to a difficulty specified by the task, and increase the difficulty once 0 errors were found on a new testing batch of 10 samples. Each training iteration trains with 50 examples of the currently randomly sampled difficulty. Regardless of whether the model had converged, training is stopped after 5000 samples were used. Such a low number is used to replicate the potential conditions under which such a model might be used. As with the NTM, the Adam optimizer was used. The specific tasks we use are described in Appendix G, and the specific kinds of supervision we give are described in Appendix H. The $\lambda$ we used here was 40. The system was implemented using PyTorch.
+
+# E NTM TASKS
+
+Every input sequence ends with a special delimiter $x _ { E }$ not occurring elsewhere in the sequence
+
+Copy – The input consists of generic elements, $x _ { 1 } \ldots x _ { n } x _ { E }$ . The desired output is $x _ { 1 } \ldots x _ { n } x _ { E }$
+
+RepeatCopyTwice – The input is again a sequence of generic elements, $x _ { 1 } \ldots x _ { n } x _ { E }$ . The desired output is the input copied twice $x _ { 1 } \ldots x _ { n } x _ { 1 } \ldots x _ { n } x _ { E }$ . Placing the delimiter only at the end of the output ensures that the machine learns to keep track of the number of copies. Otherwise, it could simply learn to cycle through the tape reproducing the given input indefinitely. We kept the number of repetitions fixed in order to increase baseline task performance for the benefit of comparison.
+
+DyckWords – The input is a sequence of open and closed parentheses, $x _ { 1 } \ldots x _ { n } x _ { E }$ . The desired output is a sequence of bits $y _ { 1 } \ldots y _ { n } x _ { E }$ such that $y _ { i } = 1$ iff the prefix $x _ { 1 } \ldots x _ { i }$ is a balanced string of parentheses (a Dyck word). Both positive and negative examples were given.
+
+Flip3rd – The input is a sequence of bits, $x _ { 1 } x _ { 2 } x _ { 3 } \ldots x _ { n } x _ { E }$ . The desired output is the same sequence of bits but with the 3rd bit flipped: $x _ { 1 } x _ { 2 } \bar { x } _ { 3 } \ldots x _ { n } x _ { E }$ . Such a task with a specific index to be updated (e.g., 3rd) still requires handling data dependence on the contents of the index (unlike say the Copy task).
+
+RepeatFlip3d – The input is a sequence of bits, $x _ { 1 } x _ { 2 } x _ { 3 } x _ { 4 } x _ { 5 } x _ { 5 } \ldots x _ { E }$ . The desired output is the same sequence of bits but with every 3rd bit flipped: $x _ { 1 } x _ { 2 } \bar { x } _ { 3 } x _ { 4 } x _ { 5 } \bar { x } _ { 6 } \ldots x _ { E }$ .
+
+# F NTM SUBTRACES
+
+![](images/03de411aa623b31ff4230905962c1c5fc6b628d79de2e170396a0663fe891fac.jpg)  
+Figure 8: A heirarchy of supervision types (but not quantities) for NTMs.
+
+value traces provide hints for the memory at every timestep as explained in Equation 10.
+
+read – provides a hint for the address of the read head at every timestep.
+
+write – provides a hint for the address of the write head at every timestep.
+
+address – provides hints for the address of both the read and the write head at every timestep.
+
+addr+val – provides value, read and write hints for every timestep.
+
+corner – provides hints for the address of both the read and the write head at every “important” timestep - we decided what important means here depends on which task we are referring to. In general, we consider the first and last timesteps important, and also any timestep where a head should change direction. For example, in RepeatCopyTwice for an example of size $n$ with $e$ repeats, we’d provide the heads at timesteps $0 , n , 2 n , 3 n \ldots , e n$ .
+
+# G NRAM TASKS
+
+Below we describe all the tasks we experimented with. We predominantly picked tasks that the NRAM is known to have trouble generalizing on. We did not introduce any new tasks, and more detailed descriptions of these tasks can be found in Kurach et al. (2016).
+
+Swap – Provided two numbers, $a$ and $b$ and an array $p$ , swap $p [ a ]$ and $p [ b ]$ . All elements but that in the last memory cell are not zero.
+
+Increment – Given an array $p$ , return the array with one added to each element. All elements but that in the last cell for the input are not zero. Elements can be zero in the output.
+
+Permute – Given two arrays $p$ and $q$ return a new array $s$ such that $s [ i ] ~ = ~ q [ p [ i ] ]$ . The arrays $p$ and $q$ are preceded by a pointer, $a$ , to array $q$ . The output is expected to be $a , s [ 0 ] \ldots , s [ n ] , q [ 0 ] , q [ n ]$ .
+
+ListK – Given a linked list in array form, and an index $k$ return the value at node $k$ .
+
+Merge – given arrays $p$ and $q$ , and three pointers $a , b , c$ to array $p , q$ , and the output sequence (given as zeros initially), place the sorted combination of $p$ and $q$ into the output location.
+
+The following table describes the specific NRAM instantiation used for each task. The default sequence (def) is the one described by Kurach et al. (2016). The number of timesteps is usually dependent on the length of the problem instance, $M$ (equivalently the word size or difficulty), and in the case of ListKwas given with respect to the argument $k$ . The difficulty (D) was simply the length of the sequence used.
+
+<table><tr><td>Task</td><td>No. Regs</td><td>Module Sequence</td><td>Timesteps</td><td>Learn Rate</td><td>Start D</td><td>End D</td></tr><tr><td>Swap</td><td>5</td><td>def</td><td>7</td><td>0.01</td><td>6</td><td>10</td></tr><tr><td>Increment</td><td>2</td><td>def+R</td><td>M+2</td><td>0.01</td><td>4</td><td>10</td></tr><tr><td>Permute</td><td>4</td><td>R+def+R+W</td><td>M+3</td><td>0.05</td><td>7</td><td>12</td></tr><tr><td>ListK</td><td>6</td><td>def</td><td>k+5</td><td>0.05</td><td>9</td><td>16</td></tr><tr><td>Merge</td><td>8</td><td>def + def + def</td><td>M+3</td><td>0.05</td><td>13</td><td>16</td></tr></table>
+
+# H NRAM SUBTRACES
+
+For each of the tasks listed Appendix G, we hand coded a complete circuit for every module and every timestep we would provide. The following subtraces types describe how we provide hints based on this circuit.
+
+None – provides no hints.
+
+Full – provides the entire circuit.
+
+SingleHint – provides a random hint at a random timestep.
+
+SingleTimestep – provides the entire circuit at a random timestep.
+
+Corners – provides the entire circuit at the first and last timesteps.
+
+Registers – provides hints for the registers at every timestep.
+
+Modules – provides hints for the modules at every timestep.
+
+# I NTM RESULTS
+
+(a) Copy   
+
+<table><tr><td rowspan=1 colspan=1>density</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.01</td></tr><tr><td rowspan=1 colspan=1>baseline</td><td rowspan=1 colspan=1>52.5</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>addr+val</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>address</td><td></td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>50</td></tr><tr><td rowspan=1 colspan=1>value</td><td></td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>read</td><td></td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>write</td><td></td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>40</td></tr><tr><td rowspan=1 colspan=1>corner</td><td></td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>30</td></tr></table>
+
+(b) RepeatCopyTwice   
+
+<table><tr><td rowspan=1 colspan=1>density</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.03</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.03</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.03</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.03</td></tr><tr><td rowspan=1 colspan=1>baseline</td><td rowspan=1 colspan=1>15.5</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>addr+val</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>。</td></tr><tr><td rowspan=1 colspan=1>address</td><td></td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>30</td></tr><tr><td rowspan=1 colspan=1>value</td><td></td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>read</td><td></td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>。</td></tr><tr><td rowspan=1 colspan=1>write</td><td></td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>comer</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>0</td></tr></table>
+
+(c) DyckWords   
+
+<table><tr><td rowspan=1 colspan=1>density</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.01</td></tr><tr><td rowspan=1 colspan=1>baseline</td><td rowspan=1 colspan=2>45</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>address</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>70</td></tr><tr><td rowspan=1 colspan=1>read</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td></tr><tr><td rowspan=1 colspan=1>corner</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>50</td></tr></table>
+
+(d) Flip3rd   
+
+<table><tr><td rowspan=1 colspan=1>density</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.03</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.03</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.03</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.03</td></tr><tr><td rowspan=1 colspan=1>baseline</td><td rowspan=1 colspan=1>45</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>addr+val</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>address</td><td></td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>60</td></tr><tr><td rowspan=1 colspan=1>value</td><td></td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>60</td></tr><tr><td rowspan=1 colspan=1>read</td><td></td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>30</td></tr><tr><td rowspan=1 colspan=1>write</td><td></td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>50</td></tr><tr><td rowspan=1 colspan=1>corner</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>40</td></tr></table>
+
+(e) RepeatFlip3d   
+
+<table><tr><td rowspan=1 colspan=1>density</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.03</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.03</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.03</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.03</td></tr><tr><td rowspan=1 colspan=1>baseline</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>addr+val</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>address</td><td></td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>。</td></tr><tr><td rowspan=1 colspan=1>value</td><td></td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>read</td><td></td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>write</td><td></td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>。</td></tr><tr><td rowspan=1 colspan=1>corner</td><td></td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>。</td><td rowspan=1 colspan=1>10</td></tr></table>
+
+Figure 9: Baselines have generalization on over 40 different initial weights. Other tests use 10.
+
+Which Details to Reveal for NTM? The first dimension listed in the rows of the tables of Figure I controls the execution details revealed in a Subtrace. We use subtraces showing either the addresses without the tape values, only the read heads or the write heads, or even weaker supervision in a few corner cases. In tasks Copy Figure 9a), RepeatCopyTwice (Figure 9b) and DyckWords (Figure 9c), it is frequently the case that when the NTM generalizes without supervision, it converges to an algorithm which we are able to interpret. For them, we designed the addr+val traces to match this algorithm, and saw increases in generalization frequency of at least $45 \%$ . It can be concluded that when additionally provided supervision reflects the interpretable “natural” behavior of the NTM, the learning becomes significantly more robust to changes in initial weights. Additionally, for tasks Flip3rd (Figure 9d) and RepeatFlip3d (Figure 9e), both the baseline and other supervision types are outperformed by training with read supervision. It is also notable that corner supervision in RepeatFlip3d achieves highest improvement over the baseline, $60 \%$ over $5 \%$ . In essence, this means that providing only a small part of the trace can diminish the occurrence of local minima in the loss function.
+
+How Often to Reveal for NTM? The second dimension controls the proportion of examples that receive extra subtrace supervision (the density columns in Figure I). For Flip3rd, RepeatCopyTwice and DyckWords we observed that having only a small number of examples with extra supervision leads to models which are more robust to initial weight changes than the baseline, although not necessarily always as robust as providing supervision all the time.
+
+A couple of interesting cases stand out. For Flip3rd with $10 \%$ corner subtraces and $\lambda = 1$ , we find a surprisingly high rate of generalization. Providing address traces $10 \%$ of the time when training RepeatCopyTwice leads to better performance all the time. For RepeatFlip3d, write traces at $1 \%$ frequency and $\lambda = 0 . 1$ generalize $30 \%$ of the time vs. $5 \%$ for baseline.
+
+While the type of trace which works best varies per task, for each task there exists a trace which can be provided only $1 \%$ of the time and still greatly improve the performance over the baseline. This suggests that a small amount of extra supervision can improve performance significantly, but the kind of supervision may differ. It is an interesting research question to find out how the task at hand relates to the optimal kind of supervision.
+
+# J NRAM RESULTS
+
+<table><tr><td rowspan=1 colspan=1>Subtrace Type \Task</td><td rowspan=1 colspan=1>Permute</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>Increment</td><td rowspan=1 colspan=1>ListK</td><td rowspan=1 colspan=1>Merge</td><td rowspan=1 colspan=1>PermuteNoise</td></tr><tr><td rowspan=8 colspan=1>NoneSingleHintCornersSingleTimestepRegistersModulesFullNoisyFull</td><td rowspan=1 colspan=1>36</td><td rowspan=1 colspan=1>44</td><td rowspan=1 colspan=1>58</td><td rowspan=1 colspan=1>41</td><td rowspan=1 colspan=1>13</td><td rowspan=3 colspan=1>121417</td></tr><tr><td rowspan=1 colspan=1>24</td><td rowspan=1 colspan=1>38</td><td rowspan=1 colspan=1>28</td><td rowspan=1 colspan=1>22</td><td rowspan=1 colspan=1>12</td></tr><tr><td rowspan=1 colspan=1>29</td><td rowspan=1 colspan=1>23</td><td rowspan=1 colspan=1>36</td><td rowspan=1 colspan=1>22</td><td rowspan=1 colspan=1>9</td></tr><tr><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>52</td><td rowspan=1 colspan=1>29</td><td rowspan=1 colspan=1>28</td><td rowspan=1 colspan=1>12</td><td rowspan=5 colspan=1>13-1141</td></tr><tr><td rowspan=1 colspan=1>48</td><td rowspan=1 colspan=1>58</td><td rowspan=1 colspan=1>73</td><td rowspan=1 colspan=1>54</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>48</td><td rowspan=1 colspan=1>58</td><td rowspan=1 colspan=1>107</td><td rowspan=1 colspan=1>54</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>26</td><td rowspan=1 colspan=1>33</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>44</td><td rowspan=1 colspan=1>21</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>36</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+Figure 11: The average time (in seconds) to finish training for each task and subtrace type. For most tasks it is clear that Full traces while introducing extra computations to individual timesteps, reduce the amount of time to finish training over not using supervision.   
+
+<table><tr><td rowspan=1 colspan=1>Subtrace Type \Task</td><td rowspan=1 colspan=1>Permute</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>Increment</td><td rowspan=1 colspan=1>ListK</td></tr><tr><td rowspan=1 colspan=1>None</td><td rowspan=1 colspan=1>6290.29</td><td rowspan=1 colspan=1>5505.22</td><td rowspan=1 colspan=1>3500.13</td><td rowspan=1 colspan=1>5880.11</td></tr><tr><td rowspan=6 colspan=1>SingleHintCornersSingleTimestepRegistersModulesFull</td><td rowspan=1 colspan=1>5565.22</td><td rowspan=1 colspan=1>3700.64</td><td rowspan=1 colspan=1>4318.20</td><td rowspan=1 colspan=1>6574.59</td></tr><tr><td rowspan=2 colspan=1>4468.856259.05</td><td rowspan=1 colspan=1>6195.75</td><td rowspan=1 colspan=1>3199.86</td><td rowspan=1 colspan=1>6601.16</td></tr><tr><td rowspan=1 colspan=1>2662.35</td><td rowspan=1 colspan=1>4042.18</td><td rowspan=1 colspan=1>5076.17</td></tr><tr><td rowspan=1 colspan=1>6618.12</td><td rowspan=1 colspan=1>5774.61</td><td rowspan=1 colspan=1>3839.18</td><td rowspan=1 colspan=1>6185.54</td></tr><tr><td rowspan=1 colspan=1>6523.16</td><td rowspan=1 colspan=1>5781.99</td><td rowspan=1 colspan=1>2335.99</td><td rowspan=1 colspan=1>6183.74</td></tr><tr><td rowspan=1 colspan=1>4919.33</td><td rowspan=1 colspan=1>4110.14</td><td rowspan=1 colspan=1>3758.99</td><td rowspan=1 colspan=1>3216.01</td></tr></table>
+
+![](images/232ab43e8c51ec0e89536082b2db6f5617e6956fdd854ed7f08bdb8e4c76c1fb.jpg)  
+Figure 10: The number of runs which completed for each task and subtrace type. The Data in the graphs below is taken by averaging the results of these runs.
+
+Figure 12: The average number of errors on the test set for each task and subtrace type once trained.   
+
+<table><tr><td rowspan=1 colspan=1>Subtrace Type \Task</td><td rowspan=1 colspan=1>ListK</td><td rowspan=1 colspan=1>Swap</td><td rowspan=1 colspan=1>Permute</td><td rowspan=1 colspan=1>Increment</td><td rowspan=1 colspan=1>Merge</td><td rowspan=1 colspan=1>PermuteNoise</td></tr><tr><td rowspan=7 colspan=1>NoneSingleHintCornersSingleTimestepFullRegistersModules</td><td rowspan=1 colspan=1>95.08</td><td rowspan=1 colspan=1>91.52</td><td rowspan=1 colspan=1>99.97</td><td rowspan=1 colspan=1>99.91</td><td rowspan=1 colspan=1>99.96</td><td rowspan=7 colspan=1>99.9956.9020.7933.6023.57-=</td></tr><tr><td rowspan=1 colspan=1>93.61</td><td rowspan=1 colspan=1>2.41</td><td rowspan=1 colspan=1>57.55</td><td rowspan=1 colspan=1>14.86</td><td rowspan=1 colspan=1>100.0</td></tr><tr><td rowspan=1 colspan=1>94.47</td><td rowspan=1 colspan=1>99.09</td><td rowspan=1 colspan=1>16.40</td><td rowspan=1 colspan=1>2.14</td><td rowspan=1 colspan=1>100.0</td></tr><tr><td rowspan=1 colspan=1>36.91</td><td rowspan=1 colspan=1>1.75</td><td rowspan=1 colspan=1>47.79</td><td rowspan=1 colspan=1>13.77</td><td rowspan=1 colspan=1>100.0</td></tr><tr><td rowspan=1 colspan=1>12.77</td><td rowspan=1 colspan=1>11.01</td><td rowspan=1 colspan=1>7.83</td><td rowspan=1 colspan=1>9.89</td><td rowspan=1 colspan=1>78.44</td></tr><tr><td rowspan=1 colspan=1>93.22</td><td rowspan=1 colspan=1>93.44</td><td rowspan=1 colspan=1>99.97</td><td rowspan=1 colspan=1>90.36</td><td rowspan=1 colspan=1>=</td></tr><tr><td rowspan=1 colspan=1>93.70</td><td rowspan=1 colspan=1>95.57</td><td rowspan=1 colspan=1>86.48</td><td rowspan=1 colspan=1>40.87</td><td rowspan=1 colspan=1>=</td></tr></table>
+
+![](images/086bbebd2eb0491343e7fd0b76fbb439ad4aae9be0cf52a11f440ab4d367ee11.jpg)  
+Figure 13: Comparing average generalization to sequence length for Swap   
+Figure 14: Comparing average generalization to sequence length for Increment
+
+![](images/e3dba20d2c5bd53262dcbdf4bef1c68583366cb53f8278d3f89b24b7fb5a86b3.jpg)  
+Figure 15: Comparing average generalization to sequence length for Permute
+
+![](images/9301a49fa001ce291735e64357eb48c181aea5f96a72910c68e1a9e74be76c3c.jpg)  
+Figure 16: Comparing average generalization to sequence length for ListK
+
+![](images/ff9209c3c84190b14a4c24b53927e673b29bd4daee46b1b21a8abf5ddd25881a.jpg)  
+Figure 17: Comparing average generalization to sequence length for Merge
+
+![](images/97f411bd44fb1177f7f229770f71c37840227a7b1da355d2d3189a706b1ff263.jpg)  
+Figure 18: Comparing average generalization of the DNGPU Freivalds & Liepins (2017) with that of the NRAM using the full tracer for Merge. For this experiment, a maximum of 10000 samples were used for the DNGPU and 5000 for the NRAM. The DNGPU was run out of the box from the code supplied by the authors. 20 runs were averaged for the DNGPU and 38 runs for the NRAM. One can deduce that while neither is able to generalize this task perfectly, the simpler and easier to understand architecture, NRAM, does generalize better with fewer examples when those examples come with richer supervision.
+
+# K PROGRAMMING NRAMS
+
+The NRAM is parametrized by one or more straight-line partial programs, i.e., programs with no branching and no loops, chosen by register states. The machine runs in a loop, repeatedly selecting the program for that register state then executing it. The programs are expressend in a simple single-assignment imperative language. Each program statement $i$ invokes one of the modules of the architecture and assigns the result of the invocation to a local variable $x _ { i }$ . That variable cannot be changed later. The final program statement is a parallel-asignment that modifies the machine registers $r _ { 1 } \ldots r _ { k }$ . The values that appear in assignments/invocations can be: variables in scope, machine registers, or holes ?. These values are not used directly during execution: the actual values needs to be supplied by the NRAM controller. The values are only used as hints for the controller during training, with the whole ? denoting no hint. We can describe the language in an EBNF-style grammar:
+
+$$
+{ \begin{array} { r l r l } & { F _ { n } : : = { \mathrm { m o d u l e s ~ o f ~ a r i t y ~ } } n } & & { S _ { i } : : = x _ { i }  F _ { n } ( \underbrace { V _ { i } , \dotsc , V _ { i } } _ { n } ) } \\ & { V _ { i } : = r _ { 1 } \mid \dots \mid r _ { k } \mid ? \mid x _ { 1 } \mid \dots \mid x _ { i - 1 } } & & { R _ { i } : = r _ { j 1 } , \dotsc , r _ { j _ { n } }  \underbrace { V _ { i } , \dotsc , V _ { i } } _ { n } } \\ & { P _ { 1 } : = S _ { 1 } } & { P _ { i } : = P _ { i - 1 } ; S _ { i } } & & { P : : = P _ { 1 } ; R _ { 1 } \mid P _ { 2 } ; R _ { 2 } \mid \dots } \end{array} }
+$$
+
+An example program for the Increment task would be the following:
+
+$x _ { 1 } \gets 1$ ;   
+$x _ { 2 } \gets \mathsf { R E A D } ( r _ { 1 } )$ ;   
+$x _ { 3 } \gets \mathsf { A D D } ( x _ { 2 } , x _ { 1 } )$ ; $x _ { 4 } \gets \mathsf { W R I T E } ( r _ { 1 } , x _ { 3 } ) ;$ $x _ { 5 } \gets \mathsf { A D D } ( r _ { 1 } , x _ { 1 } ) ;$ r1 ← x5
+
+Here, the controller is encouraged to read the memory at the location stored in the first register $r _ { 1 }$ add one to it, then store it back, and then increment the the first register.
+
+An alternative to the trace-based approach is to make the controller produce values only for the holes, and use directly the specified variable/register arguments. This way, only the unspecified parts of the program are learned. This is, for example, the approach taken by ∂Forth Bošnjak et al. (2017). There, programs are expressed in a suitably adapted variant of the Forth programming language, which is as expressive as the language discussed above, but less syntactically constrained.
+
+The drawback of this alternative is that whenever an argument other than a whole is specified, one must also specify the time steps to which it applies in all possible executions and not just the training ones. That is why, typically, these values are specified either for all or for none of the time steps.
+
+In the following examples, we will describe the register states using $\mathbf { \vec { \nabla } } _ { 0 } , \mathbf { \vec { \mathbf { \phi } } } _ { 0 } ,$ , “ $! 0 ^ { \dag }$ and “-” meaning respectively that a register has 0, that it contains anything but zero, or that it can contain anything.
+
+# L NRAM PERMUTATION PROGRAM
+
+For any register pattern.
+
+# M NRAM LISTK PROGRAM
+
+When the registers are $[ 0 , ! 0 , ! 0 , - , - ]$ :
+
+$x _ { 1 } \gets R E A D ( r _ { 0 } )$ ; $x _ { 2 }  A D D ( x _ { 1 } , 2 )$ ; $\begin{array} { r l } & { x _ { 3 } \gets W R I T E ( 0 , x _ { 1 } ) ; } \\ & { r _ { 0 } \gets 1 ; } \\ & { r _ { 1 } \gets 1 ; } \\ & { r _ { 2 } \gets 1 ; } \\ & { r _ { 3 } \gets x _ { 2 } ; } \end{array}$
+
+When the registers are [!0, !0, !0, -, -]:
+
+$$
+\begin{array} { l } { { x _ { 1 } \gets R E A D ( r _ { 1 } ) ; } } \\ { { x _ { 2 } \gets A D D ( x _ { 1 } , 2 ) ; } } \\ { { x _ { 3 } \gets W R I T E ( r _ { 1 } , x _ { 1 } ) ; } } \\ { { r _ { 0 } \gets 1 ; } } \\ { { r _ { 1 } \gets 0 ; } } \\ { { r _ { 2 } \gets 1 ; } } \\ { { r _ { 3 } \gets r _ { 3 } ; } } \\ { { x _ { 4 } \gets x _ { 2 } ; } } \end{array}
+$$
+
+When the registers are $[ ! 0 , 0 , ! 0 , - , - ]$ :
+
+When the registers are $[ ! 0 , 0 , 0 , \cdot , - ]$ :
+
+$$
+\begin{array} { l } { x _ { 1 } \gets R E A D ( r _ { 4 } ) ; } \\ { x _ { 2 } \gets W R I T E ( r _ { 4 } , r _ { 3 } ) ; } \\ { r _ { 0 } \gets 1 ; } \\ { r _ { 1 } \gets 1 ; } \\ { r _ { 2 } \gets 0 ; } \\ { r _ { 3 } \gets x _ { 1 } ; } \end{array}
+$$
+
+When the registers are $[ 0 , ! 0 , 0 , \cdot , - ]$ :
+
+$$
+\begin{array} { r l } & { x _ { 1 } \gets R E A D ( r _ { 2 } ) ; } \\ & { x _ { 2 } \gets A D D ( x _ { 1 } , 2 ) ; } \\ & { x _ { 3 } \gets W R I T E ( x _ { 2 } ) ; } \\ & { r _ { 0 } \gets 0 ; } \\ & { r _ { 1 } \gets 1 ; } \\ & { r _ { 2 } \gets 0 ; } \end{array}
+$$
+
+# N NRAM LISTK PROGRAM
+
+# Timestep 0:
+
+$$
+\begin{array} { l } { { x _ { 1 }  R E A D ( r _ { 0 } ) ; } } \\ { { x _ { 2 }  I N C ( x _ { 1 } ) ; } } \\ { { x _ { 3 }  0 ; } } \\ { { x _ { 4 }  W R I T E ( x _ { 3 } , x _ { 1 } ) ; } } \\ { { r _ { 0 }  r _ { 1 } ; } } \\ { { r _ { 1 }  r _ { 1 } ; } } \\ { { r _ { 2 }  r _ { 2 } ; } } \\ { { r _ { 3 }  x _ { 2 } ; } } \\ { { x _ { 4 }  r _ { 4 } ; } } \end{array}
+$$
+
+$$
+r _ { 5 } \gets r _ { 5 } ;
+$$
+
+$$
+\begin{array} { l } { { x _ { 1 }  R E A D ( r _ { 1 } ) ; } } \\ { { x _ { 2 }  W R I T E ( r _ { 1 } , x _ { 1 } ) ; } } \\ { { x _ { 3 }  0 ; } } \\ { { r _ { 0 }  r _ { 0 } ; } } \\ { { r _ { 1 }  x _ { 1 } ; } } \\ { { r _ { 2 }  r _ { 2 } ; } } \\ { { r _ { 3 }  r _ { 3 } ; } } \\ { { r _ { 4 }  x _ { 3 } ; } } \\ { { r _ { 5 }  r _ { 5 } ; } } \end{array}
+$$
+
+# Timestep 2:
+
+$x _ { 1 } \gets R E A D ( r _ { 2 } )$ ;   
+$x _ { 2 } \gets W R I T E ( r _ { 2 } , x _ { 1 } ) ;$ ;   
+x3 ← 0;   
+r0 ← r0;   
+$r _ { 1 }  r _ { 1 }$ ;   
+$r _ { 2 } \gets x _ { 1 }$ ;   
+$r _ { 3 } \gets r _ { 3 }$ ;   
+$r _ { 4 } \gets x _ { 3 } { \mathrm { : } }$ r5 ← x3;
+
+$$
+\begin{array} { l } { { x _ { 1 }  R E A D ( r _ { 0 } ) ; } } \\ { { x _ { 2 }  I  N C ( x _ { 1 } ) ; } } \\ { { x _ { 3 }  0 ; } } \\ { { x _ { 4 }  D E C ( x _ { 1 } ) ; } } \\ { { x _ { 5 }  W H T E ( r _ { 0 } , x _ { 1 } ) ; } } \\ { { r _ { 0 }  x _ { 1 } ; } } \\ { { r _ { 1 }  x _ { 4 } ; } } \\ { { r _ { 2 }  r _ { 2 } ; } } \\ { { r _ { 3 }  x _ { 2 } ; } } \\ { { r _ { 4 }  x _ { 3 } ; } } \\ { { r _ { 5 }  x _ { 3 } ; } } \end{array}
+$$
+
+Timestep $3 + \mathrm { k }$ : $x _ { 1 } \gets R E A D ( r _ { 3 } )$ ; $x _ { 2 } \gets W R I T E ( r _ { 2 } , x _ { 1 } ) ;$ ; x3 ← 0; x4 ← 1; $r _ { 0 } \gets r _ { 0 }$ ; $r _ { 1 }  r _ { 1 }$ ; $r _ { 2 } \gets r _ { 2 } ;$ $r _ { 3 } \gets x _ { 1 }$ ; $r _ { 4 } \gets x _ { 4 }$ ; $r _ { 5 }  s _ { 3 }$ ;
+
+# Rest:
+
+$$
+\begin{array} { l } { { x _ { 1 }  W R I T E ( r _ { 2 } , r _ { 3 } ) ; } } \\ { { x _ { 2 }  1 ; } } \\ { { x _ { 3 }  0 ; } } \\ { { r _ { 0 }  r _ { 0 } ; } } \\ { { r _ { 1 }  r _ { 1 } ; } } \\ { { r _ { 2 }  r _ { 2 } ; } } \\ { { r _ { 3 }  r _ { 3 } ; } } \\ { { r _ { 4 }  x _ { 2 } ; } } \\ { { r _ { 5 }  x _ { 3 } ; } } \end{array}
+$$

parse/train/Sks9_ajex/Sks9_ajex.md

@@ -0,0 +1,271 @@
+# PAYING MORE ATTENTION TO ATTENTION: IMPROVING THE PERFORMANCE OF CONVOLUTIONAL NEURAL NETWORKS VIA ATTENTION TRANSFER
+
+Sergey Zagoruyko, Nikos Komodakis   
+Universite Paris-Est, ´ Ecole des Ponts ParisTech ´   
+Paris, France   
+{sergey.zagoruyko,nikos.komodakis}@enpc.fr
+
+# ABSTRACT
+
+Attention plays a critical role in human visual experience. Furthermore, it has recently been demonstrated that attention can also play an important role in the context of applying artificial neural networks to a variety of tasks from fields such as computer vision and NLP. In this work we show that, by properly defining attention for convolutional neural networks, we can actually use this type of information in order to significantly improve the performance of a student CNN network by forcing it to mimic the attention maps of a powerful teacher network. To that end, we propose several novel methods of transferring attention, showing consistent improvement across a variety of datasets and convolutional neural network architectures. Code and models for our experiments are available at https://github.com/szagoruyko/attention-transfer.
+
+# 1 INTRODUCTION
+
+As humans, we need to pay attention in order to be able to adequately perceive our surroundings. Attention is therefore a key aspect of our visual experience, and closely relates to perception - we need to keep attention to build a visual representation, possessing detail and coherence.
+
+As artificial neural networks became more popular in fields such as computer vision and natural language processing in the recent years, artificial attention mechanisms started to be developed as well. Artificial attention lets a system “attend” to an object to examine it with greater detail. It has also become a research tool for understanding mechanisms behind neural networks, similar to attention used in psychology.
+
+One of the popular hypothesis there is that there are non-attentional and attentional perception processes. Non-attentional processes help to observe a scene in general and gather high-level information, which, when associated with other thinking processes, helps us to control the attention processes and navigate to a certain part of the scene. This implies that different observers with different knowledge, different goals, and therefore different attentional strategies can literally see the same scene differently. This brings us to the main topic of this paper: how attention differs within artificial vision systems, and can we use attention information in order to improve the performance of convolutional neural networks ? More specifically, can a teacher network improve the performance of another student network by providing to it information about where it looks, i.e., about where it concentrates its attention into ?
+
+To study these questions, one first needs to properly specify how attention is defined w.r.t. a given convolutional neural network. To that end, here we consider attention as a set of spatial maps that essentially try to encode on which spatial areas of the input the network focuses most for taking its output decision (e.g., for classifying an image), where, furthermore, these maps can be defined w.r.t. various layers of the network so that they are able to capture both low-, mid-, and high-level representation information. More specifically, in this work we define two types of spatial attention maps: activation-based and gradient-based. We explore how both of these attention maps change over various datasets and architectures, and show that these actually contain valuable information that can be used for significantly improving the performance of convolutional neural network architectures (of various types and trained for various different tasks). To that end, we propose several novel ways of transferring attention from a powerful teacher network to a smaller student network with the goal of improving the performance of the latter (Fig. 1).
+
+![](images/eab8212626fdafd2cd7dfa6c01a9064ec3518bbe8b21086a6a8d038e6c3e0aee.jpg)  
+Figure 1: (a) An input image and a corresponding spatial attention map of a convolutional network that shows where the network focuses in order to classify the given image. Surely, this type of map must contain valuable information about the network. The question that we pose in this paper is the following: can we use knowledge of this type to improve the training of CNN models ? (b) Schematic representation of attention transfer: a student CNN is trained so as, not only to make good predictions, but to also have similar spatial attention maps to those of an already trained teacher CNN.
+
+To summarize, the contributions of this work are as follows:
+
+• We propose attention as a mechanism of transferring knowledge from one network to another   
+• We propose the use of both activation-based and gradient-based spatial attention maps   
+• We show experimentally that our approach provides significant improvements across a variety of datasets and deep network architectures, including both residual and non-residual networks   
+• We show that activation-based attention transfer gives better improvements than fullactivation transfer, and can be combined with knowledge distillation
+
+The rest of the paper is structured as follows: we first describe related work in section 2, we explain our approach for activation-based and gradient-based attention transfer in section 3, and then present experimental results for both methods in section 4. We conclude the paper in section 5.
+
+# 2 RELATED WORK
+
+Early work on attention based tracking Larochelle & Hinton (2010), Denil et al. (2012) was motivated by human attention mechanism theories Rensink (2000) and was done via Restricted Bolzmann Machines. It was recently adapted for neural machine translation with recurrent neural networks, e.g. Bahdanau et al. (2014) as well as in several other NLP-related tasks. It was also exploited in computer-vision-related tasks such as image captioning Xu et al. (2015), visual question answering Yang et al. (2015), as well as in weakly-supervised object localization Oquab et al. (2015) and classification Mnih et al. (2014), to mention a few characteristic examples. In all these tasks attention proved to be useful.
+
+Visualizing attention maps in deep convolutional neural networks is an open problem. The simplest gradient-based way of doing that is by computing a Jacobian of network output w.r.t. input (this leads to attention visualization that are not necessarily class-discriminative), as for example in Simonyan et al. (2014). Another approach was proposed by Zeiler & Fergus (2014) that consists of attaching a network called “deconvnet” that shares weights with the original network and is used to project certain features onto the image plane. A number of methods was proposed to improve gradientbased attention as well, for example guided backpropagation Springenberg et al. (2015), adding a change in ReLU layers during calculation of gradient w.r.t. previous layer output. Attention maps obtained with guided backpropagation are non-class-discriminative too. Among existing methods for visualizing attention, we should also mention class activation maps Zhou et al. (2016), which are based on removing top average-pooling layer and converting the linear classification layer into a convolutional layer, producing attention maps per each class. A method combining both guided backpropagation and CAM is Grad-CAM by Selvaraju et al. (2016), adding image-level details to class-discriminative attention maps.
+
+Knowledge distillation with neural networks was pioneered by Hinton et al. (2015); Bucila et al. (2006), which is a transfer learning method that aims to improve the training of a student network by relying on knowledge borrowed from a powerful teacher network. Although in certain special cases shallow networks had been shown to be able to approximate deeper ones without loss in accuracy Lei & Caruana (2014), later work related to knowledge distillation was mostly based on the assumption that deeper networks always learn better representations. For example, FitNets Romero et al. (2014) tried to learn a thin deep network using a shallow one with more parameters. The introduction of highway Srivastava et al. (2015) and later residual networks He et al. (2015) allowed training very deep architectures with higher accuracy, and generality of these networks was experimentally showed over a large variety of datasets. Although the main motivation for residual networks was increasing depth, it was later shown by Zagoruyko & Komodakis (2016) that, after a certain depth, the improvements came mostly from increased capacity of the networks, i.e. number of parameters (for instance, a wider deep residual network with only 16 layers was shown that it could learn as good or better representations as very thin 1000 layer one, provided that they were using comparable number of parameters).
+
+Due to the above fact and due to that thin deep networks are less parallelizable than wider ones, we think that knowledge transfer needs to be revisited, and take an opposite to FitNets approach - we try to learn less deep student networks. Our attention maps used for transfer are similar to both gradient-based and activation-based maps mentioned above, which play a role similar to “hints” in FitNets, although we don’t introduce new weights.
+
+# 3 ATTENTION TRANSFER
+
+In this section we explain the two methods that we use for defining the spatial attention maps of a convolutional neural network as well as how we transfer attention information from a teacher to a student network in each case.
+
+# 3.1 ACTIVATION-BASED ATTENTION TRANSFER
+
+Let us consider a CNN layer and its corresponding activation tensor $A \in R ^ { C \times H \times W }$ , which consists of $C$ feature planes with spatial dimensions $H \times W$ . An activation-based mapping function $\mathcal { F }$ (w.r.t. that layer) takes as input the above 3D tensor $A$ and outputs a spatial attention map, i.e., a flattened 2D tensor defined over the spatial dimensions, or
+
+$$
+\mathcal { F } : R ^ { C \times H \times W }  R ^ { H \times W } .
+$$
+
+To define such a spatial attention mapping function, the implicit assumption that we make in this section is that the absolute value of a hidden neuron activation (that results when the network is evaluated on given input) can be used as an indication about the importance of that neuron w.r.t. the specific input. By considering, therefore, the absolute values of the elements of tensor $A$ , we can construct a spatial attention map by computing statistics of these values across the channel dimension (see Fig. 3). More specifically, in this work we will consider the following activation-based spatial attention maps:
+
+• sum of absolute values: $\begin{array} { r } { F _ { \mathrm { s u m } } ( A ) = \sum _ { i = 1 } ^ { C } | A _ { i } | } \end{array}$ • sum of absolute values raised to the power of $p$ (where $p > 1 _ { \cdot }$ ): $\begin{array} { r } { F _ { \mathrm { s u m } } ^ { p } ( A ) = \sum _ { i = 1 } ^ { C } | A _ { i } | ^ { p } } \end{array}$ • max of absolute values raised to the power of $p$ (where $p > 1$ ): $F _ { \operatorname* { m a x } } ^ { p } ( A ) = \operatorname* { m a x } _ { i = 1 , C } | A _ { i } | ^ { p }$ where $A _ { i } = A ( i , : , : )$ (using Matlab notation), and max, power and absolute value operations are elementwise (e.g. $| A _ { i } | ^ { p }$ is equivalent to abs $( \mathbb { A } _ { i } ) \cdot { } ^ { \wedge } \mathtt { p }$ in Matlab notation).
+
+![](images/a810f404f345874269d478e85bafdf6df6ed6eb8ded9d40e011795d05be4c787.jpg)  
+Figure 2: Sum of absolute values attention maps $F _ { \mathrm { s u m } }$ over different levels of a network trained for face recognition. Mid-level attention maps have higher activation level around eyes, nose and lips, high-level activations correspond to the whole face.
+
+We visualized activations of various networks on several datasets, including ImageNet classification and localization, COCO object detection, face recognition, and fine-grained recognition. We were mostly focused on modern architectures without top dense linear layers, such as Network-InNetwork, ResNet and Inception, which have streamlined convolutional structure. We also examined networks of the same architecture, width and depth, but trained with different frameworks with significant difference in performance. We found that the above statistics of hidden activations not only have spatial correlation with predicted objects on image level, but these correlations also tend to be higher in networks with higher accuracy, and stronger networks have peaks in attention where weak networks don’t (e.g., see Fig. 4). Furthermore, attention maps focus on different parts for different layers in the network. In the first layers neurons activation level is high for low-level gradient points, in the middle it is higher for the most discriminative regions such as eyes or wheels, and in the top layers it reflects full objects. For example, mid-level attention maps of a network trained for face recognition Parkhi et al. (2015) will have higher activations around eyes, nose and lips, and top level activation will correspond to full face (Fig. 2).
+
+Concerning the different attention mapping functions defined above, these can have slightly different properties. E.g.:
+
+• Compared to $F _ { \mathrm { s u m } } ( A )$ , the spatial map $F _ { \mathrm { s u m } } ^ { p } ( A )$ (where $p > 1$ ) puts more weight to spatial locations that correspond to the neurons with the highest activations, i.e., puts more weight to the most discriminative parts (the larger the $p$ the more focus is placed on those parts with highest activations).   
+Furthermore, among all neuron activations corresponding to the same spatial location, $F _ { \mathrm { m a x } } ^ { p } ( A )$ will consider only one of them to assign a weight to that spatial location (as opposed to $F _ { \mathrm { s u m } } ^ { p } ( A )$ that will favor spatial locations that carry multiple neurons with high activations).
+
+To further illustrate the differences of these functions we visualized attention maps of 3 networks with sufficient difference in classification performance: Network-In-Network $62 \%$ top-1 val accuracy), ResNet34 ( $73 \%$ top-1 val accuracy) and ResNet-101 ( $7 7 . 3 \%$ top-1 val accuracy). In each network we took last pre-downsampling activation maps, on the left for mid-level and on the right for top pre-average pooling activations in fig. 4. Top-level maps are blurry because their original spatial resolution is $7 \times 7$ . It is clear that most discriminative regions have higher activation levels, e.g. face of the wolf, and that shape details disappear as the parameter $p$ (used as exponent) increases.
+
+In attention transfer, given the spatial attention maps of a teacher network (computed using any of the above attention mapping functions), the goal is to train a student network that will not only make correct predictions but will also have attentions maps that are similar to those of the teacher. In general, one can place transfer losses w.r.t. attention maps computed across several layers. For instance, in the case of ResNet architectures, one can consider the following two cases, depending on the depth of teacher and student:
+
+![](images/ecea16573bf41e3859b1bb7a08e2e1f06b2b2c4af1a8193e2bb2d962a4b0e095.jpg)  
+Figure 3: Attention mapping over feature dimension.
+
+• Same depth: possible to have attention transfer layer after every residual block • Different depth: have attention transfer on output activations of each group of residual blocks
+
+![](images/781eb750349972c73251c3706985fc4fdd949468996c34b70fb12c9dc71cba30.jpg)  
+Figure 4: Activation attention maps for various ImageNet networks: Network-In-Network $6 2 \%$ top-1 val accuracy), ResNet-34 $73 \%$ top-1 val accuracy), ResNet-101 $7 7 . 3 \%$ top-1 val accuracy). Left part: mid-level activations, right part: top-level pre-softmax acivations
+
+![](images/77bb0edefec14bad0b13034ac4f6bc3cc6cf506fed258747cfc540c385faf28d.jpg)  
+Figure 5: Schematics of teacher-student attention transfer for the case when both networks are residual, and the teacher is deeper.
+
+Similar cases apply also to other architectures (such as NIN, in which case a group refers to a block of a $3 \times 3 , 1 \times 1 , 1 \times 1$ convolutions). In fig. 5 we provide a schematic illustration of the different depth case for residual network architectures.
+
+Without loss of generality, we assume that transfer losses are placed between student and teacher attention maps of same spatial resolution, but, if needed, attention maps can be interpolated to match their shapes. Let $S$ , $T$ and $\mathbf { W } _ { S }$ , $\mathbf { W } _ { T }$ denote student, teacher and their weights correspondingly, and let $\mathcal { L } ( \mathbf { W } , x )$ denote a standard cross entropy loss. Let also $\mathcal { T }$ denote the indices of all teacher-student activation layer pairs for which we want to transfer attention maps. Then we can define the following total loss:
+
+$$
+\mathcal { L } _ { A T } = \mathcal { L } ( \mathbf { W } _ { S } , x ) + \frac { \beta } { 2 } \sum _ { j \in \mathcal { T } } \Vert \frac { Q _ { S } ^ { j } } { \Vert Q _ { S } ^ { j } \Vert _ { 2 } } - \frac { Q _ { T } ^ { j } } { \Vert Q _ { T } ^ { j } \Vert _ { 2 } } \Vert _ { p } \enspace ,
+$$
+
+where $Q _ { S } ^ { j } = v e c ( F ( A _ { S } ^ { j } ) )$ and $Q _ { T } ^ { j } = v e c ( F ( A _ { T } ^ { j } ) )$ are respectively the $j$ -th pair of student and teacher attention maps in vectorized form, and $p$ refers to norm type (in the experiments we use $p = 2$ ). As can be seen, during attention transfer we make use of $l _ { 2 }$ -normalized attention maps, i.e., we replace each vectorized attention map $Q$ with QkQk2 (l1 normalization could be used as well). It is worth emphasizing that normalization of attention maps is important for the success of the student training.
+
+Attention transfer can also be combined with knowledge distillation Hinton et al. (2015), in which case an additional term (corresponding to the cross entropy between softened distributions over labels of teacher and student) simply needs to be included to the above loss. When combined, attention transfer adds very little computational cost, as attention maps for teacher can be easily computed during forward propagation, needed for distillation.
+
+# 3.2 GRADIENT-BASED ATTENTION TRANSFER
+
+In this case we define attention as gradient w.r.t. input, which can be viewed as an input sensitivity map Simonyan et al. (2014), i.e., attention at an input spatial location encodes how sensitive the output prediction is w.r.t. changes at that input location (e.g., if small changes at a pixel can have a large effect on the network output then it is logical to assume that the network is “paying attention” to that pixel). Let’s define the gradient of the loss w.r.t input for teacher and student as:
+
+$$
+J _ { S } = \frac { \partial } { \partial x } \mathcal { L } ( \mathbf { W _ { S } } , x ) , J _ { T } = \frac { \partial } { \partial x } \mathcal { L } ( \mathbf { W _ { T } } , x )
+$$
+
+Then if we want student gradient attention to be similar to teacher attention, we can minimize a distance between them (here we use $l _ { 2 }$ distance but other distances can be employed as well):
+
+$$
+\mathcal { L } _ { A T } ( \mathbf { W _ { S } } , \mathbf { W _ { T } } , x ) = \mathcal { L } ( \mathbf { W _ { S } } , x ) + \frac { \beta } { 2 } | | J _ { S } - J _ { T } | | _ { 2 }
+$$
+
+As $\mathbf { W } _ { T }$ and $x$ are given, to get the needed derivative w.r.t. $\mathbf { W } _ { S }$ :
+
+$$
+\frac { \partial } { \partial \mathbf { W _ { S } } } \mathcal { L } _ { A T } = \frac { \partial } { \partial \mathbf { W _ { S } } } \mathcal { L } ( \mathbf { W _ { S } } , x ) + \beta ( J _ { S } - J _ { T } ) \frac { \partial ^ { 2 } } { \partial \mathbf { W _ { S } } \partial x } \mathcal { L } ( \mathbf { W _ { S } } , x )
+$$
+
+So to do an update we first need to do forward and back propagation to get $J _ { S }$ and $J _ { T }$ , compute the second error $ { \mathbf { \bar { \rho } } } _ { 2 } ^ { \beta } | | J _ { S } - J _ { T } | | _ { 2 }$ and propagate it second time. The second propagation is similar to forward propagation in this case, and involves second order mixed partial derivative calculation ∂2∂WS∂x . The above computation is similar to the double backpropagation technique developed by Drucker & LeCun (1992) (where the $l _ { 2 }$ norm of the gradient w.r.t. input is used as regularizer). Furthermore, it can be implemented efficiently in a framework with automatic differentiation support, even for modern architectures with sophisticated graphs. The second backpropagation has approximately the same cost with first backpropagation, excluding forward propagation.
+
+We also propose to enforce horizontal flip invariance on gradient attention maps. To do that we propagate horizontally flipped images as well as originals, backpropagate and flip gradient attention maps back. We then add $l _ { 2 }$ losses on the obtained attentions and outputs, and do second backpropagation:
+
+$$
+\mathcal { L } _ { s y m } ( \mathbf { W } , x ) = \mathcal { L } ( \mathbf { W } , x ) + \frac { \beta } { 2 } | | \frac { \partial } { \partial x } \mathcal { L } ( \mathbf { W } , x ) - \mathrm { H i p } ( \frac { \partial } { \partial x } \mathcal { L } ( \mathbf { W } , \mathrm { H i p } ( x ) ) ) | | _ { 2 } \ ,
+$$
+
+where $\operatorname { f i i p } ( x )$ denotes the flip operator. This is similar to Group Equivariant CNN approach by Cohen & Welling (2016), however it is not a hard constraint. We experimentally find that this has a regularization effect on training.
+
+We should note that in this work we consider only gradients w.r.t. the input layer, but in general one might have the proposed attention transfer and symmetry constraints w.r.t. higher layers of the network.
+
+# 4 EXPERIMENTAL SECTION
+
+In the following section we explore attention transfer on various image classification datasets. We split the section in two parts, in the first we include activation-based attention transfer and gradientbased attention transfer experiments on CIFAR, and in the second activation-based attention transfer experiments on larger datasets. For activation-based attention transfer we used Network-InNetwork Lin et al. (2013) and ResNet-based architectures (including the recently introduced Wide Residual Networks (WRN) Zagoruyko & Komodakis (2016)), as they are most performant and set strong baselines in terms of number of parameters compared to AlexNet or VGG, and have been explored in various papers across small and large datasets. On Scenes, CUB and ImageNet we experimented with ResNet-18 and ResNet-34. As for gradient-based attention, we constrained ourselves to Network-In-Network without batch normalization and CIFAR dataset, due to the need of complex automatic differentiation.
+
+# 4.1 CIFAR EXPERIMENTS
+
+We start with CIFAR dataset which has small $3 2 \times 3 2$ images, and after downsampling top activations have even smaller resolution, so there is not much space for attention transfer. Interestingly, even under this adversarial setting, we find that attention transfer seems to give reasonable benefits, offering in all cases consistent improvements. We use horizontal flips and random crops data augmentations, and all networks have batch normalization. We find that ZCA whitening has negative effect on validation accuracy, and omit it in favor of simpler meanstd normalization. We raise Knowledge Distillation (KD) temperature for ResNet transfers to 4, and use $\alpha = 0 . 9$ (see Hinton et al. (2015) for an explanation of these parameters).
+
+# 4.1.1 ACTIVATION-BASED ATTENTION TRANSFER
+
+Results of attention transfer (using $F _ { \mathrm { s u m } } ^ { 2 }$ attention maps) for various networks on CIFAR-10 can be found in table 1. We experimented with teacher/student having the same depth (WRN-16-2/WRN16-1), as well as different depth (WRN-40-1/WRN-16-1, WRN-40-2/WRN-16-2). In all combinations, attention transfer (AT) shows significant improvements, which are also higher when it is combined with knowledge distillation $( \mathrm { A T + K D } )$ ).
+
+<table><tr><td>student</td><td>teacher</td><td>student</td><td>AT</td><td>F-ActT</td><td>KD</td><td>AT+KD</td><td>teacher</td></tr><tr><td>NIN-thin,0.2M</td><td>NIN-wide,1M</td><td>9.38</td><td>8.93</td><td>9.05</td><td>8.55</td><td>8.33</td><td>7.28</td></tr><tr><td>WRN-16-1, 0.2M</td><td>WRN-16-2, 0.7M</td><td>8.77</td><td>7.93</td><td>8.51</td><td>7.41</td><td>7.51</td><td>6.31</td></tr><tr><td>WRN-16-1, 0.2M</td><td>WRN-40-1, 0.6M</td><td>8.77</td><td>8.25</td><td>8.62</td><td>8.39</td><td>8.01</td><td>6.58</td></tr><tr><td>WRN-16-2,0.7M</td><td>WRN-40-2,2.2M</td><td>6.31</td><td>5.85</td><td>6.24</td><td>6.08</td><td>5.71</td><td>5.23</td></tr></table>
+
+Table 1: Activation-based attention transfer (AT) with various architectures on CIFAR-10. Error is computed as median of 5 runs with different seed. F-ActT means full-activation transfer (see $\ S 4 . 1 . 2 )$ .
+
+To verify if having at least one activation-based attention transfer loss per group in WRN transfer is important, we trained three networks with only one transfer loss per network in group1, group2 and group3 separately, and compared to a network trained with all three losses. The corresponding results were 8.11, 7.96, 7.97 (for the separate losses) and 7.93 for the combined loss (using WRN16-2/WRN-16-1 as teacher/student pair). Each loss provides some additional degree of attention transfer.
+
+We also explore which attention mapping functions tend to work best using WRN-16-1 and WRN16-2 as student and teacher networks respectively (table 2). Interestingly, sum-based functions work very similar, and better than max-based ones. From now on, we will use sum of squared attention mapping function $F _ { \mathrm { s u m } } ^ { 2 }$ for simplicity. As for parameter $\beta$ in eq. 2, it usually varies about 0.1, as we set it to $\mathrm { \bar { 1 0 ^ { 3 } } }$ divided by number of elements in attention map and batch size for each layer. In case of combinining AT with KD we decay it during traning in order to simplify learning harder examples.
+
+# 4.1.2 ACTIVATION-BASED AT VS. TRANSFERRING FULL ACTIVATION
+
+To check if transferring information from full activation tensors is more beneficial than from attention maps, we experimented with FitNets-style hints using $l _ { 2 }$ losses on full activations directly, with $1 \times 1$ convolutional layers to match tensor shapes, and found that improvements over baseline student were minimal (see column F-ActT in table 1). For networks of the same width different depth we tried to regress directly to activations, without $1 \times 1$ convolutions. We also use $l _ { 2 }$ normalization before transfer losses, and decay $\beta$ in eq. 2 during training as these give better performance. We find that AT, as well as full-activation transfer, greatly speeds up convergence, but AT gives much better final accuracy improvement than full-activation transfer (see fig. 7(b), Appendix). It seems quite interesting that attention maps carry information that is more important for transfer than full activations.
+
+<table><tr><td>norm type</td><td>error</td></tr><tr><td>baseline (no attention transfer) min-l2 Drucker &amp; LeCun (1992) grad-based AT KD symmetry norm activation-based AT</td><td>13.5 12.5 12.1 12.1 11.8 11.2</td></tr></table>
+
+Table 2: Test error of WRN16-2/WRN-16-1 teacher/student pair for various attention mapping functions. Median of 5 runs test errors are reported.   
+Table 3: Performance of various gradient-based attention methods on CIFAR-10. Baseline is a thin NIN network with ${ \bf 0 . 2 M }$ parameters (trained only on horizontally flipped augmented data and without batch normalization), min- $\mathbf { \cdot } l _ { 2 }$ refers to using $l _ { 2 }$ norm of gradient w.r.t. input as regularizer, symmetry norm - to using flip invariance on gradient attention maps (see eq. 6), AT - to attention transfer, and KD - to Knowledge Distillation (both AT and KD use a wide NIN of 1M parameters as teacher).   
+
+<table><tr><td>attention mapping function</td><td>error</td></tr><tr><td>no attention transfer Fsum</td><td>8.77 7.99 7.93</td></tr></table>
+
+# 4.1.3 GRADIENT-BASED ATTENTION TRANSFER
+
+For simplicity we use thin Network-In-Network model in these experiments, and don’t apply random crop data augmentation with batch normalization, just horizontal flips augmentation. We also only use deterministic algorithms and sampling with fixed seed, so reported numbers are for single run experiments. We find that in this setting network struggles to fit into training data already, and turn off weight decay even for baseline experiments. In future we plan to explore gradient-based attention for teacher-student pairs that make use of batch normalization, because it is so far unclear how batch normalization should behave in the second backpropagation step required during gradientbased attention transfer (e.g., should it contribute to batch normalization parameters, or is a separate forward propagation with fixed parameters needed).
+
+We explored the following methods:
+
+• Minimizing $l _ { 2 }$ norm of gradient w.r.t. input, i.e. the double backpropagation method Drucker & LeCun (1992);   
+• Symmetry norm on gradient attention maps (see eq. 6);   
+• Student-teacher gradient-based attention transfer;   
+• Student-teacher activation-based attention transfer.
+
+Results for various methods are shown in table 3. Interestingly, just minimizing $l _ { 2 }$ norm of gradient already works pretty well. Also, symmetry norm is one the best performing attention norms, which we plan to investigate in future on other datasets as well. We also observe that, similar to activationbased attention transfer, using gradient-based attention transfer leads to improved performance. We also trained a network with activation-based AT in the same training conditions, which resulted in the best performance among all methods. We should note that the architecture of student NIN without batch normalization is slightly different from teacher network, it doesn’t have ReLU activations before pooling layers, which leads to better performance without batch normalization, and worse with. So to achieve the best performance with activation-based AT we had to train a new teacher, with batch normalization and without ReLU activations before pooling layers, and have AT losses on outputs of convolutional layers.
+
+# 4.2 LARGE INPUT IMAGE NETWORKS
+
+In this section we experiment with hidden activation attention transfer on ImageNet networks which have $2 2 4 \times 2 2 4$ input image size. Presumably, attention matters more in this kind of networks as spatial resolution of attention maps is higher.
+
+Table 4: Finetuning with attention transfer error on Scenes and CUB datasets   
+
+<table><tr><td>type</td><td>model</td><td>ImageNet-→CUB</td><td>ImageNet-→Scenes</td></tr><tr><td>student</td><td>ResNet-18</td><td>28.5</td><td>28.2</td></tr><tr><td>KD</td><td>ResNet-18</td><td>27 (-1.5)</td><td>28.1 (-0.1)</td></tr><tr><td>AT</td><td>ResNet-18</td><td>27 (-1.5)</td><td>27.1 (-1.1)</td></tr><tr><td>teacher</td><td>ResNet-34</td><td>26.5</td><td>26</td></tr></table>
+
+# 4.2.1 TRANSFER LEARNING
+
+To see how attention transfer works in finetuning we choose two datasets: Caltech-UCSD Birds-200- 2011 fine-grained classification (CUB) by Wah et al. (2011), and MIT indoor scene classification (Scenes) by Quattoni & Torralba (2009), both containing around 5K images training images. We took ResNet-18 and ResNet-34 pretrained on ImageNet and finetuned on both datasets. On CUB we crop bounding boxes, rescale to 256 in one dimension and then take a random crop. Batch normalization layers are fixed for finetuning, and first group of residual blocks is frozen. We then took finetuned ResNet-34 networks and used them as teachers for ResNet-18 pretrained on ImageNet, with $F _ { \mathrm { s u m } } ^ { 2 }$ attention losses on 2 last groups. In both cases attention transfer provides significant improvements, closing the gap between ResNet-18 and ResNet-34 in accuracy. On Scenes AT works as well as KD, and on CUB AT works much better, which we speculate is due to importance of intermediate attention for fine-grained recognition. Moreover, after finetuning, student’s attention maps indeed look more similar to teacher’s (Fig. 6, Appendix).
+
+# 4.2.2 IMAGENET
+
+To showcase activation-based attention transfer on ImageNet we took ResNet-18 as a student, and ResNet-34 as a teacher, and tried to improve ResNet-18 accuracy. We added only two losses in the 2 last groups of residual blocks and used squared sum attention $F _ { \mathrm { s u m } } ^ { 2 }$ . We also did not have time to tune any hyperparameters and kept them from finetuning experiments. Nevertheless, ResNet-18 with attention transfer achieved $1 . 1 \%$ top-1 and $0 . 8 \%$ top-5 better validation accuracy (Table. 5 and Fig. 7(a), Appendix), we plan to update the paper with losses on all 4 groups of residual blocks.
+
+We were not able to achieve positive results with KD on ImageNet. With ResNet-18-ResNet-34 student-teacher pair it actually hurts convergence with the same hyperparameters as on CIFAR. As it was reported that KD struggles to work if teacher and student have different architecture/depth (we observe the same on CIFAR), so we tried using the same architecture and depth for attention transfer. On CIFAR both AT and KD work well in this case and improve convergence and final accuracy, on ImageNet though KD converges significantly slower (we did not train until the end due to lack of computational resources). We also could not find applications of FitNets, KD or similar methods on ImageNet in the literature. Given that, we can assume that proposed activation-based AT is the first knowledge transfer method to be successfully applied on ImageNet.
+
+# 5 CONCLUSIONS
+
+We presented several ways of transferring attention from one network to another, with experimental results over several image recognition datasets. It would be interesting to see how attention transfer works in cases where spatial information is more important, e.g. object detection or weaklysupervised localization, which is something that we plan to explore in the future.
+
+Overall, we think that our interesting findings will help further advance knowledge distillation, and understanding convolutional neural networks in general.
+
+# REFERENCES
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. CoRR, abs/1409.0473, 2014. URL http://arxiv.org/ abs/1409.0473.
+
+Cristian Bucila, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In KDD, pp. 535–541, 2006.
+
+Taco S. Cohen and Max Welling. Group equivariant convolutional networks. CoRR, abs/1602.07576, 2016. URL http://arxiv.org/abs/1602.07576.
+
+Misha Denil, Loris Bazzani, Hugo Larochelle, and Nando de Freitas. Learning where to attend with deep architectures for image tracking. Neural Computation, 2012.
+
+H. Drucker and Y LeCun. Improving generalization performance using double backpropagation. IEEE Transaction on Neural Networks, 3(6):991–997, 1992.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015.
+
+Geoffrey E. Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural networks. 2015.
+
+Hugo Larochelle and Geoffrey E. Hinton. Learning to combine foveal glimpses with a third-order boltzmann machine. In J. D. Lafferty, C. K. I. Williams, J. Shawe-Taylor, R. S. Zemel, and A. Culotta (eds.), Advances in Neural Information Processing Systems 23, pp. 1243–1251. Curran Associates, Inc., 2010.
+
+Jimmy Ba Lei and Rich Caruana. Do deep nets really need to be deep? In NIPS, 2014.
+
+Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. CoRR, abs/1312.4400, 2013.
+
+Volodymyr Mnih, Nicolas Heess, Alex Graves, and koray kavukcuoglu. Recurrent models of visual attention. In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 2204–2212. Curran Associates, Inc., 2014. URL http://papers.nips.cc/paper/ 5542-recurrent-models-of-visual-attention.pdf.
+
+M. Oquab, L. Bottou, I. Laptev, and J. Sivic. Is object localization for free? weakly-supervised learning with convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2015.
+
+O. M. Parkhi, A. Vedaldi, and A. Zisserman. Deep face recognition. In British Machine Vision Conference, 2015.
+
+A. Quattoni and A. Torralba. Recognizing indoor scenes. In CVPR, 2009.
+
+Ronald A. Rensink. The dynamic representation of scenes. In Visual Cognition, pp. 17–42, 2000.
+
+Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. FitNets: Hints for thin deep nets. Technical Report Arxiv report 1412.6550, arXiv, 2014.
+
+Ramprasaath R. Selvaraju, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Why did you say that? visual explanations from deep networks via gradient-based localization. 2016.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. In ICLR Workshop, 2014.
+
+J. T. Springenberg, A. Dosovitskiy, T. Brox, and M. Riedmiller. Striving for simplicity: The all convolutional net. In arXiv:1412.6806, also appeared at ICLR 2015 Workshop Track, 2015. URL http://arxiv.org/abs/1412.6806.
+
+Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ CoRR, abs/1505.00387, 2015.
+
+C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds-200-2011 Dataset. Technical Report CNS-TR-2011-001, California Institute of Technology, 2011.
+
+Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron C. Courville, Ruslan Salakhutdinov, Richard S. Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. CoRR, abs/1502.03044, 2015. URL http://arxiv.org/abs/1502. 03044.
+
+Zichao Yang, Xiaodong He, Jianfeng Gao, Li Deng, and Alexander J. Smola. Stacked attention networks for image question answering. CoRR, abs/1511.02274, 2015. URL http://arxiv. org/abs/1511.02274.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.
+
+Matthew Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In ECCV, 2014.
+
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Computer Vision and Pattern Recognition, 2016.
+
+# A APPENDIX
+
+# A.1 FIGURES AND TABLES
+
+![](images/a6852adc648143a8da669a4269ab0c67e38607b3d22191a3838c564f0afd6901.jpg)  
+Figure 6: Top activation attention maps for different Scenes networks: original pretrained ResNet-18 (ResNet-18-ImageNet), ResNet-18 trained on Scenes (ResNet-18-scenes), ResNet-18 trained with attention transfer (ResNet-18-scenes-AT) with ResNet-34 as a teacher, ResNet-34 trained on Scenes (ResNet-34-scenes). Predicted classes for each task are shown on top. Attention maps look more similar after transfer (images taken from test set).
+
+![](images/c20211c1047b61992778f2016adb04f866db4ac50dc4d94cb2703c8c36f78489.jpg)  
+(a) Attention transfer on ImageNet between ResNet18 and ResNet-34. Solid lines represent top-5 validation error, dashed - top-5 training error. Two attention transfer losses were used on the outputs of two last groups of residual blocks respectively, no KD losses used.
+
+![](images/559c91e539374d17e840fd28649202f9f0b10146b4b0ea025da1995c2f8e48b2.jpg)
+
+(b) Activation attention transfer on CIFAR-10 from WRN-16-2 to WRN-16-1. Test error is in bold, train error is in dashed lines. Attention transfer greatly speeds up convergence and improves final accuracy.
+
+Table 5: Attention transfer validation error (single crop) on ImageNet. Transfer losses are added on epoch 60/100.   
+
+<table><tr><td>Model</td><td>top1, top5</td></tr><tr><td>ResNet-18</td><td>30.4,10.8</td></tr><tr><td>AT</td><td>29.3,10.0</td></tr><tr><td>ResNet-34</td><td>26.1,8.3</td></tr></table>
+
+# A.2 IMPLEMENTATION DETAILS
+
+The experiments were conducted in Torch machine learning framework. Double propagation can be implemented in a modern framework with automatic differentiation support, e.g. Torch, Theano, Tensorflow. For ImageNet experiments we used fb.resnet.torch code, and used 2 Titan X cards with data parallelizm in both teacher and student to speed up training. Code and models for our experiments are available at https://github.com/szagoruyko/attention-transfer.

parse/train/Sks9_ajex/Sks9_ajex_content_list.json

@@ -0,0 +1,1461 @@
+[
+    {
+        "type": "text",
+        "text": "PAYING MORE ATTENTION TO ATTENTION: IMPROVING THE PERFORMANCE OF CONVOLUTIONAL NEURAL NETWORKS VIA ATTENTION TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            821,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko, Nikos Komodakis   \nUniversite Paris-Est, ´ Ecole des Ponts ParisTech ´   \nParis, France   \n{sergey.zagoruyko,nikos.komodakis}@enpc.fr ",
+        "bbox": [
+            184,
+            195,
+            593,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            290,
+            544,
+            304
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Attention plays a critical role in human visual experience. Furthermore, it has recently been demonstrated that attention can also play an important role in the context of applying artificial neural networks to a variety of tasks from fields such as computer vision and NLP. In this work we show that, by properly defining attention for convolutional neural networks, we can actually use this type of information in order to significantly improve the performance of a student CNN network by forcing it to mimic the attention maps of a powerful teacher network. To that end, we propose several novel methods of transferring attention, showing consistent improvement across a variety of datasets and convolutional neural network architectures. Code and models for our experiments are available at https://github.com/szagoruyko/attention-transfer. ",
+        "bbox": [
+            233,
+            323,
+            764,
+            476
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            507,
+            336,
+            523
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As humans, we need to pay attention in order to be able to adequately perceive our surroundings. Attention is therefore a key aspect of our visual experience, and closely relates to perception - we need to keep attention to build a visual representation, possessing detail and coherence. ",
+        "bbox": [
+            176,
+            540,
+            823,
+            583
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As artificial neural networks became more popular in fields such as computer vision and natural language processing in the recent years, artificial attention mechanisms started to be developed as well. Artificial attention lets a system “attend” to an object to examine it with greater detail. It has also become a research tool for understanding mechanisms behind neural networks, similar to attention used in psychology. ",
+        "bbox": [
+            174,
+            589,
+            823,
+            660
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the popular hypothesis there is that there are non-attentional and attentional perception processes. Non-attentional processes help to observe a scene in general and gather high-level information, which, when associated with other thinking processes, helps us to control the attention processes and navigate to a certain part of the scene. This implies that different observers with different knowledge, different goals, and therefore different attentional strategies can literally see the same scene differently. This brings us to the main topic of this paper: how attention differs within artificial vision systems, and can we use attention information in order to improve the performance of convolutional neural networks ? More specifically, can a teacher network improve the performance of another student network by providing to it information about where it looks, i.e., about where it concentrates its attention into ? ",
+        "bbox": [
+            174,
+            666,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To study these questions, one first needs to properly specify how attention is defined w.r.t. a given convolutional neural network. To that end, here we consider attention as a set of spatial maps that essentially try to encode on which spatial areas of the input the network focuses most for taking its output decision (e.g., for classifying an image), where, furthermore, these maps can be defined w.r.t. various layers of the network so that they are able to capture both low-, mid-, and high-level representation information. More specifically, in this work we define two types of spatial attention maps: activation-based and gradient-based. We explore how both of these attention maps change over various datasets and architectures, and show that these actually contain valuable information that can be used for significantly improving the performance of convolutional neural network architectures (of various types and trained for various different tasks). To that end, we propose several novel ways of transferring attention from a powerful teacher network to a smaller student network with the goal of improving the performance of the latter (Fig. 1). ",
+        "bbox": [
+            174,
+            813,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/eab8212626fdafd2cd7dfa6c01a9064ec3518bbe8b21086a6a8d038e6c3e0aee.jpg",
+        "image_caption": [
+            "Figure 1: (a) An input image and a corresponding spatial attention map of a convolutional network that shows where the network focuses in order to classify the given image. Surely, this type of map must contain valuable information about the network. The question that we pose in this paper is the following: can we use knowledge of this type to improve the training of CNN models ? (b) Schematic representation of attention transfer: a student CNN is trained so as, not only to make good predictions, but to also have similar spatial attention maps to those of an already trained teacher CNN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            63,
+            767,
+            220
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            353,
+            825,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize, the contributions of this work are as follows: ",
+        "bbox": [
+            174,
+            415,
+            566,
+            430
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose attention as a mechanism of transferring knowledge from one network to another   \n• We propose the use of both activation-based and gradient-based spatial attention maps   \n• We show experimentally that our approach provides significant improvements across a variety of datasets and deep network architectures, including both residual and non-residual networks   \n• We show that activation-based attention transfer gives better improvements than fullactivation transfer, and can be combined with knowledge distillation ",
+        "bbox": [
+            215,
+            443,
+            825,
+            573
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is structured as follows: we first describe related work in section 2, we explain our approach for activation-based and gradient-based attention transfer in section 3, and then present experimental results for both methods in section 4. We conclude the paper in section 5. ",
+        "bbox": [
+            176,
+            584,
+            825,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            648,
+            341,
+            664
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Early work on attention based tracking Larochelle & Hinton (2010), Denil et al. (2012) was motivated by human attention mechanism theories Rensink (2000) and was done via Restricted Bolzmann Machines. It was recently adapted for neural machine translation with recurrent neural networks, e.g. Bahdanau et al. (2014) as well as in several other NLP-related tasks. It was also exploited in computer-vision-related tasks such as image captioning Xu et al. (2015), visual question answering Yang et al. (2015), as well as in weakly-supervised object localization Oquab et al. (2015) and classification Mnih et al. (2014), to mention a few characteristic examples. In all these tasks attention proved to be useful. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Visualizing attention maps in deep convolutional neural networks is an open problem. The simplest gradient-based way of doing that is by computing a Jacobian of network output w.r.t. input (this leads to attention visualization that are not necessarily class-discriminative), as for example in Simonyan et al. (2014). Another approach was proposed by Zeiler & Fergus (2014) that consists of attaching a network called “deconvnet” that shares weights with the original network and is used to project certain features onto the image plane. A number of methods was proposed to improve gradientbased attention as well, for example guided backpropagation Springenberg et al. (2015), adding a change in ReLU layers during calculation of gradient w.r.t. previous layer output. Attention maps obtained with guided backpropagation are non-class-discriminative too. Among existing methods for visualizing attention, we should also mention class activation maps Zhou et al. (2016), which are based on removing top average-pooling layer and converting the linear classification layer into a convolutional layer, producing attention maps per each class. A method combining both guided backpropagation and CAM is Grad-CAM by Selvaraju et al. (2016), adding image-level details to class-discriminative attention maps. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Knowledge distillation with neural networks was pioneered by Hinton et al. (2015); Bucila et al. (2006), which is a transfer learning method that aims to improve the training of a student network by relying on knowledge borrowed from a powerful teacher network. Although in certain special cases shallow networks had been shown to be able to approximate deeper ones without loss in accuracy Lei & Caruana (2014), later work related to knowledge distillation was mostly based on the assumption that deeper networks always learn better representations. For example, FitNets Romero et al. (2014) tried to learn a thin deep network using a shallow one with more parameters. The introduction of highway Srivastava et al. (2015) and later residual networks He et al. (2015) allowed training very deep architectures with higher accuracy, and generality of these networks was experimentally showed over a large variety of datasets. Although the main motivation for residual networks was increasing depth, it was later shown by Zagoruyko & Komodakis (2016) that, after a certain depth, the improvements came mostly from increased capacity of the networks, i.e. number of parameters (for instance, a wider deep residual network with only 16 layers was shown that it could learn as good or better representations as very thin 1000 layer one, provided that they were using comparable number of parameters). ",
+        "bbox": [
+            174,
+            181,
+            825,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Due to the above fact and due to that thin deep networks are less parallelizable than wider ones, we think that knowledge transfer needs to be revisited, and take an opposite to FitNets approach - we try to learn less deep student networks. Our attention maps used for transfer are similar to both gradient-based and activation-based maps mentioned above, which play a role similar to “hints” in FitNets, although we don’t introduce new weights. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ATTENTION TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            486,
+            397,
+            502
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section we explain the two methods that we use for defining the spatial attention maps of a convolutional neural network as well as how we transfer attention information from a teacher to a student network in each case. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 ACTIVATION-BASED ATTENTION TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            579,
+            513,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let us consider a CNN layer and its corresponding activation tensor $A \\in R ^ { C \\times H \\times W }$ , which consists of $C$ feature planes with spatial dimensions $H \\times W$ . An activation-based mapping function $\\mathcal { F }$ (w.r.t. that layer) takes as input the above 3D tensor $A$ and outputs a spatial attention map, i.e., a flattened 2D tensor defined over the spatial dimensions, or ",
+        "bbox": [
+            174,
+            604,
+            825,
+            661
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e1a2f4609c7793c8f981468f34ea72277781915aa2c7e5bdde465f032fc42345.jpg",
+        "text": "$$\n\\mathcal { F } : R ^ { C \\times H \\times W }  R ^ { H \\times W } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            679,
+            593,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To define such a spatial attention mapping function, the implicit assumption that we make in this section is that the absolute value of a hidden neuron activation (that results when the network is evaluated on given input) can be used as an indication about the importance of that neuron w.r.t. the specific input. By considering, therefore, the absolute values of the elements of tensor $A$ , we can construct a spatial attention map by computing statistics of these values across the channel dimension (see Fig. 3). More specifically, in this work we will consider the following activation-based spatial attention maps: ",
+        "bbox": [
+            173,
+            709,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• sum of absolute values: $\\begin{array} { r } { F _ { \\mathrm { s u m } } ( A ) = \\sum _ { i = 1 } ^ { C } | A _ { i } | } \\end{array}$ • sum of absolute values raised to the power of $p$ (where $p > 1 _ { \\cdot }$ ): $\\begin{array} { r } { F _ { \\mathrm { s u m } } ^ { p } ( A ) = \\sum _ { i = 1 } ^ { C } | A _ { i } | ^ { p } } \\end{array}$ • max of absolute values raised to the power of $p$ (where $p > 1$ ): $F _ { \\operatorname* { m a x } } ^ { p } ( A ) = \\operatorname* { m a x } _ { i = 1 , C } | A _ { i } | ^ { p }$ where $A _ { i } = A ( i , : , : )$ (using Matlab notation), and max, power and absolute value operations are elementwise (e.g. $| A _ { i } | ^ { p }$ is equivalent to abs $( \\mathbb { A } _ { i } ) \\cdot { } ^ { \\wedge } \\mathtt { p }$ in Matlab notation). ",
+        "bbox": [
+            215,
+            820,
+            825,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/a810f404f345874269d478e85bafdf6df6ed6eb8ded9d40e011795d05be4c787.jpg",
+        "image_caption": [
+            "Figure 2: Sum of absolute values attention maps $F _ { \\mathrm { s u m } }$ over different levels of a network trained for face recognition. Mid-level attention maps have higher activation level around eyes, nose and lips, high-level activations correspond to the whole face. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            80,
+            745,
+            184
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We visualized activations of various networks on several datasets, including ImageNet classification and localization, COCO object detection, face recognition, and fine-grained recognition. We were mostly focused on modern architectures without top dense linear layers, such as Network-InNetwork, ResNet and Inception, which have streamlined convolutional structure. We also examined networks of the same architecture, width and depth, but trained with different frameworks with significant difference in performance. We found that the above statistics of hidden activations not only have spatial correlation with predicted objects on image level, but these correlations also tend to be higher in networks with higher accuracy, and stronger networks have peaks in attention where weak networks don’t (e.g., see Fig. 4). Furthermore, attention maps focus on different parts for different layers in the network. In the first layers neurons activation level is high for low-level gradient points, in the middle it is higher for the most discriminative regions such as eyes or wheels, and in the top layers it reflects full objects. For example, mid-level attention maps of a network trained for face recognition Parkhi et al. (2015) will have higher activations around eyes, nose and lips, and top level activation will correspond to full face (Fig. 2). ",
+        "bbox": [
+            174,
+            265,
+            825,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Concerning the different attention mapping functions defined above, these can have slightly different properties. E.g.: ",
+        "bbox": [
+            174,
+            467,
+            823,
+            494
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Compared to $F _ { \\mathrm { s u m } } ( A )$ , the spatial map $F _ { \\mathrm { s u m } } ^ { p } ( A )$ (where $p > 1$ ) puts more weight to spatial locations that correspond to the neurons with the highest activations, i.e., puts more weight to the most discriminative parts (the larger the $p$ the more focus is placed on those parts with highest activations).   \nFurthermore, among all neuron activations corresponding to the same spatial location, $F _ { \\mathrm { m a x } } ^ { p } ( A )$ will consider only one of them to assign a weight to that spatial location (as opposed to $F _ { \\mathrm { s u m } } ^ { p } ( A )$ that will favor spatial locations that carry multiple neurons with high activations). ",
+        "bbox": [
+            215,
+            507,
+            825,
+            625
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To further illustrate the differences of these functions we visualized attention maps of 3 networks with sufficient difference in classification performance: Network-In-Network $62 \\%$ top-1 val accuracy), ResNet34 ( $73 \\%$ top-1 val accuracy) and ResNet-101 ( $7 7 . 3 \\%$ top-1 val accuracy). In each network we took last pre-downsampling activation maps, on the left for mid-level and on the right for top pre-average pooling activations in fig. 4. Top-level maps are blurry because their original spatial resolution is $7 \\times 7$ . It is clear that most discriminative regions have higher activation levels, e.g. face of the wolf, and that shape details disappear as the parameter $p$ (used as exponent) increases. ",
+        "bbox": [
+            174,
+            637,
+            645,
+            776
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In attention transfer, given the spatial attention maps of a teacher network (computed using any of the above attention mapping functions), the goal is to train a student network that will not only make correct predictions but will also have attentions maps that are similar to those of the teacher. In general, one can place transfer losses w.r.t. attention maps computed across several layers. For instance, in the case of ResNet architectures, one can consider the following two cases, depending on the depth of teacher and student: ",
+        "bbox": [
+            174,
+            784,
+            647,
+            895
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ecea16573bf41e3859b1bb7a08e2e1f06b2b2c4af1a8193e2bb2d962a4b0e095.jpg",
+        "image_caption": [
+            "Figure 3: Attention mapping over feature dimension. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            658,
+            654,
+            828,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Same depth: possible to have attention transfer layer after every residual block • Different depth: have attention transfer on output activations of each group of residual blocks ",
+        "bbox": [
+            215,
+            909,
+            745,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/781eb750349972c73251c3706985fc4fdd949468996c34b70fb12c9dc71cba30.jpg",
+        "image_caption": [
+            "Figure 4: Activation attention maps for various ImageNet networks: Network-In-Network $6 2 \\%$ top-1 val accuracy), ResNet-34 $73 \\%$ top-1 val accuracy), ResNet-101 $7 7 . 3 \\%$ top-1 val accuracy). Left part: mid-level activations, right part: top-level pre-softmax acivations "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            98,
+            818,
+            362
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/77bb0edefec14bad0b13034ac4f6bc3cc6cf506fed258747cfc540c385faf28d.jpg",
+        "image_caption": [
+            "Figure 5: Schematics of teacher-student attention transfer for the case when both networks are residual, and the teacher is deeper. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            428,
+            816,
+            553
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            215,
+            619,
+            823,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similar cases apply also to other architectures (such as NIN, in which case a group refers to a block of a $3 \\times 3 , 1 \\times 1 , 1 \\times 1$ convolutions). In fig. 5 we provide a schematic illustration of the different depth case for residual network architectures. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            705
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Without loss of generality, we assume that transfer losses are placed between student and teacher attention maps of same spatial resolution, but, if needed, attention maps can be interpolated to match their shapes. Let $S$ , $T$ and $\\mathbf { W } _ { S }$ , $\\mathbf { W } _ { T }$ denote student, teacher and their weights correspondingly, and let $\\mathcal { L } ( \\mathbf { W } , x )$ denote a standard cross entropy loss. Let also $\\mathcal { T }$ denote the indices of all teacher-student activation layer pairs for which we want to transfer attention maps. Then we can define the following total loss: ",
+        "bbox": [
+            173,
+            713,
+            826,
+            796
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d92a2a6814bded05a23688e8f03280327d1eedb66ca494b0565a4fb579087c76.jpg",
+        "text": "$$\n\\mathcal { L } _ { A T } = \\mathcal { L } ( \\mathbf { W } _ { S } , x ) + \\frac { \\beta } { 2 } \\sum _ { j \\in \\mathcal { T } } \\Vert \\frac { Q _ { S } ^ { j } } { \\Vert Q _ { S } ^ { j } \\Vert _ { 2 } } - \\frac { Q _ { T } ^ { j } } { \\Vert Q _ { T } ^ { j } \\Vert _ { 2 } } \\Vert _ { p } \\enspace ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            804,
+            671,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $Q _ { S } ^ { j } = v e c ( F ( A _ { S } ^ { j } ) )$ and $Q _ { T } ^ { j } = v e c ( F ( A _ { T } ^ { j } ) )$ are respectively the $j$ -th pair of student and teacher attention maps in vectorized form, and $p$ refers to norm type (in the experiments we use $p = 2$ ). As can be seen, during attention transfer we make use of $l _ { 2 }$ -normalized attention maps, i.e., we replace each vectorized attention map $Q$ with QkQk2 (l1 normalization could be used as well). It is worth emphasizing that normalization of attention maps is important for the success of the student training. ",
+        "bbox": [
+            173,
+            863,
+            825,
+            928
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Attention transfer can also be combined with knowledge distillation Hinton et al. (2015), in which case an additional term (corresponding to the cross entropy between softened distributions over labels of teacher and student) simply needs to be included to the above loss. When combined, attention transfer adds very little computational cost, as attention maps for teacher can be easily computed during forward propagation, needed for distillation. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            209
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 GRADIENT-BASED ATTENTION TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            226,
+            503,
+            239
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this case we define attention as gradient w.r.t. input, which can be viewed as an input sensitivity map Simonyan et al. (2014), i.e., attention at an input spatial location encodes how sensitive the output prediction is w.r.t. changes at that input location (e.g., if small changes at a pixel can have a large effect on the network output then it is logical to assume that the network is “paying attention” to that pixel). Let’s define the gradient of the loss w.r.t input for teacher and student as: ",
+        "bbox": [
+            173,
+            251,
+            825,
+            321
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ad17650acada2c3e36d1907d9ab0ccbcf175315f0fb02cbca36cf2bf053a2fa.jpg",
+        "text": "$$\nJ _ { S } = \\frac { \\partial } { \\partial x } \\mathcal { L } ( \\mathbf { W _ { S } } , x ) , J _ { T } = \\frac { \\partial } { \\partial x } \\mathcal { L } ( \\mathbf { W _ { T } } , x )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            330,
+            638,
+            361
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Then if we want student gradient attention to be similar to teacher attention, we can minimize a distance between them (here we use $l _ { 2 }$ distance but other distances can be employed as well): ",
+        "bbox": [
+            174,
+            369,
+            826,
+            398
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15213dd42eecf05fccd4996b0afc684cee08a291da893f6650bb403a700ffc2a.jpg",
+        "text": "$$\n\\mathcal { L } _ { A T } ( \\mathbf { W _ { S } } , \\mathbf { W _ { T } } , x ) = \\mathcal { L } ( \\mathbf { W _ { S } } , x ) + \\frac { \\beta } { 2 } | | J _ { S } - J _ { T } | | _ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            407,
+            668,
+            439
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As $\\mathbf { W } _ { T }$ and $x$ are given, to get the needed derivative w.r.t. $\\mathbf { W } _ { S }$ : ",
+        "bbox": [
+            173,
+            446,
+            593,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0f828380e1cf94b387c133639904db6b1a6666bf03d7c23c9b9e1d571bd9858.jpg",
+        "text": "$$\n\\frac { \\partial } { \\partial \\mathbf { W _ { S } } } \\mathcal { L } _ { A T } = \\frac { \\partial } { \\partial \\mathbf { W _ { S } } } \\mathcal { L } ( \\mathbf { W _ { S } } , x ) + \\beta ( J _ { S } - J _ { T } ) \\frac { \\partial ^ { 2 } } { \\partial \\mathbf { W _ { S } } \\partial x } \\mathcal { L } ( \\mathbf { W _ { S } } , x )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            472,
+            718,
+            506
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "So to do an update we first need to do forward and back propagation to get $J _ { S }$ and $J _ { T }$ , compute the second error $ { \\mathbf { \\bar { \\rho } } } _ { 2 } ^ { \\beta } | | J _ { S } - J _ { T } | | _ { 2 }$ and propagate it second time. The second propagation is similar to forward propagation in this case, and involves second order mixed partial derivative calculation ∂2∂WS∂x . The above computation is similar to the double backpropagation technique developed by Drucker & LeCun (1992) (where the $l _ { 2 }$ norm of the gradient w.r.t. input is used as regularizer). Furthermore, it can be implemented efficiently in a framework with automatic differentiation support, even for modern architectures with sophisticated graphs. The second backpropagation has approximately the same cost with first backpropagation, excluding forward propagation. ",
+        "bbox": [
+            173,
+            513,
+            825,
+            635
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also propose to enforce horizontal flip invariance on gradient attention maps. To do that we propagate horizontally flipped images as well as originals, backpropagate and flip gradient attention maps back. We then add $l _ { 2 }$ losses on the obtained attentions and outputs, and do second backpropagation: ",
+        "bbox": [
+            173,
+            640,
+            825,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/17423230f75804ce7bab0c6dff0abf0df6b5ff552911035cce3ecf9221bbaeb5.jpg",
+        "text": "$$\n\\mathcal { L } _ { s y m } ( \\mathbf { W } , x ) = \\mathcal { L } ( \\mathbf { W } , x ) + \\frac { \\beta } { 2 } | | \\frac { \\partial } { \\partial x } \\mathcal { L } ( \\mathbf { W } , x ) - \\mathrm { H i p } ( \\frac { \\partial } { \\partial x } \\mathcal { L } ( \\mathbf { W } , \\mathrm { H i p } ( x ) ) ) | | _ { 2 } \\ ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            698,
+            746,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\operatorname { f i i p } ( x )$ denotes the flip operator. This is similar to Group Equivariant CNN approach by Cohen & Welling (2016), however it is not a hard constraint. We experimentally find that this has a regularization effect on training. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            781
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We should note that in this work we consider only gradients w.r.t. the input layer, but in general one might have the proposed attention transfer and symmetry constraints w.r.t. higher layers of the network. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            830
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            851,
+            415,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the following section we explore attention transfer on various image classification datasets. We split the section in two parts, in the first we include activation-based attention transfer and gradientbased attention transfer experiments on CIFAR, and in the second activation-based attention transfer experiments on larger datasets. For activation-based attention transfer we used Network-InNetwork Lin et al. (2013) and ResNet-based architectures (including the recently introduced Wide Residual Networks (WRN) Zagoruyko & Komodakis (2016)), as they are most performant and set strong baselines in terms of number of parameters compared to AlexNet or VGG, and have been explored in various papers across small and large datasets. On Scenes, CUB and ImageNet we experimented with ResNet-18 and ResNet-34. As for gradient-based attention, we constrained ourselves to Network-In-Network without batch normalization and CIFAR dataset, due to the need of complex automatic differentiation. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 CIFAR EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            232,
+            367,
+            246
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We start with CIFAR dataset which has small $3 2 \\times 3 2$ images, and after downsampling top activations have even smaller resolution, so there is not much space for attention transfer. Interestingly, even under this adversarial setting, we find that attention transfer seems to give reasonable benefits, offering in all cases consistent improvements. We use horizontal flips and random crops data augmentations, and all networks have batch normalization. We find that ZCA whitening has negative effect on validation accuracy, and omit it in favor of simpler meanstd normalization. We raise Knowledge Distillation (KD) temperature for ResNet transfers to 4, and use $\\alpha = 0 . 9$ (see Hinton et al. (2015) for an explanation of these parameters). ",
+        "bbox": [
+            174,
+            257,
+            823,
+            369
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 ACTIVATION-BASED ATTENTION TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            386,
+            529,
+            398
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results of attention transfer (using $F _ { \\mathrm { s u m } } ^ { 2 }$ attention maps) for various networks on CIFAR-10 can be found in table 1. We experimented with teacher/student having the same depth (WRN-16-2/WRN16-1), as well as different depth (WRN-40-1/WRN-16-1, WRN-40-2/WRN-16-2). In all combinations, attention transfer (AT) shows significant improvements, which are also higher when it is combined with knowledge distillation $( \\mathrm { A T + K D } )$ ). ",
+        "bbox": [
+            176,
+            407,
+            823,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/457e87329667a3637946d4edcafbba6930d454b5a51d77eef2470e323d963977.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>student</td><td>teacher</td><td>student</td><td>AT</td><td>F-ActT</td><td>KD</td><td>AT+KD</td><td>teacher</td></tr><tr><td>NIN-thin,0.2M</td><td>NIN-wide,1M</td><td>9.38</td><td>8.93</td><td>9.05</td><td>8.55</td><td>8.33</td><td>7.28</td></tr><tr><td>WRN-16-1, 0.2M</td><td>WRN-16-2, 0.7M</td><td>8.77</td><td>7.93</td><td>8.51</td><td>7.41</td><td>7.51</td><td>6.31</td></tr><tr><td>WRN-16-1, 0.2M</td><td>WRN-40-1, 0.6M</td><td>8.77</td><td>8.25</td><td>8.62</td><td>8.39</td><td>8.01</td><td>6.58</td></tr><tr><td>WRN-16-2,0.7M</td><td>WRN-40-2,2.2M</td><td>6.31</td><td>5.85</td><td>6.24</td><td>6.08</td><td>5.71</td><td>5.23</td></tr></table>",
+        "bbox": [
+            200,
+            491,
+            797,
+            558
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Activation-based attention transfer (AT) with various architectures on CIFAR-10. Error is computed as median of 5 runs with different seed. F-ActT means full-activation transfer (see $\\ S 4 . 1 . 2 )$ . ",
+        "bbox": [
+            176,
+            569,
+            823,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To verify if having at least one activation-based attention transfer loss per group in WRN transfer is important, we trained three networks with only one transfer loss per network in group1, group2 and group3 separately, and compared to a network trained with all three losses. The corresponding results were 8.11, 7.96, 7.97 (for the separate losses) and 7.93 for the combined loss (using WRN16-2/WRN-16-1 as teacher/student pair). Each loss provides some additional degree of attention transfer. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            695
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also explore which attention mapping functions tend to work best using WRN-16-1 and WRN16-2 as student and teacher networks respectively (table 2). Interestingly, sum-based functions work very similar, and better than max-based ones. From now on, we will use sum of squared attention mapping function $F _ { \\mathrm { s u m } } ^ { 2 }$ for simplicity. As for parameter $\\beta$ in eq. 2, it usually varies about 0.1, as we set it to $\\mathrm { \\bar { 1 0 ^ { 3 } } }$ divided by number of elements in attention map and batch size for each layer. In case of combinining AT with KD we decay it during traning in order to simplify learning harder examples. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            786
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 ACTIVATION-BASED AT VS. TRANSFERRING FULL ACTIVATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            801,
+            663,
+            815
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To check if transferring information from full activation tensors is more beneficial than from attention maps, we experimented with FitNets-style hints using $l _ { 2 }$ losses on full activations directly, with $1 \\times 1$ convolutional layers to match tensor shapes, and found that improvements over baseline student were minimal (see column F-ActT in table 1). For networks of the same width different depth we tried to regress directly to activations, without $1 \\times 1$ convolutions. We also use $l _ { 2 }$ normalization before transfer losses, and decay $\\beta$ in eq. 2 during training as these give better performance. We find that AT, as well as full-activation transfer, greatly speeds up convergence, but AT gives much better final accuracy improvement than full-activation transfer (see fig. 7(b), Appendix). It seems quite interesting that attention maps carry information that is more important for transfer than full activations. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/fa42ab76995dcaf083f9b8b726cd4c931eadab7bd69140b85762df9ed202d66d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>norm type</td><td>error</td></tr><tr><td>baseline (no attention transfer) min-l2 Drucker &amp; LeCun (1992) grad-based AT KD symmetry norm activation-based AT</td><td>13.5 12.5 12.1 12.1 11.8 11.2</td></tr></table>",
+        "bbox": [
+            500,
+            150,
+            763,
+            242
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e993fc2fc74b0f9ba78d5d39b5f03f1cc654e5872b107df249412fe3d3f03195.jpg",
+        "table_caption": [
+            "Table 2: Test error of WRN16-2/WRN-16-1 teacher/student pair for various attention mapping functions. Median of 5 runs test errors are reported. ",
+            "Table 3: Performance of various gradient-based attention methods on CIFAR-10. Baseline is a thin NIN network with ${ \\bf 0 . 2 M }$ parameters (trained only on horizontally flipped augmented data and without batch normalization), min- $\\mathbf { \\cdot } l _ { 2 }$ refers to using $l _ { 2 }$ norm of gradient w.r.t. input as regularizer, symmetry norm - to using flip invariance on gradient attention maps (see eq. 6), AT - to attention transfer, and KD - to Knowledge Distillation (both AT and KD use a wide NIN of 1M parameters as teacher). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>attention mapping function</td><td>error</td></tr><tr><td>no attention transfer Fsum</td><td>8.77 7.99 7.93</td></tr></table>",
+        "bbox": [
+            173,
+            176,
+            403,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1.3 GRADIENT-BASED ATTENTION TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            383,
+            516,
+            397
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For simplicity we use thin Network-In-Network model in these experiments, and don’t apply random crop data augmentation with batch normalization, just horizontal flips augmentation. We also only use deterministic algorithms and sampling with fixed seed, so reported numbers are for single run experiments. We find that in this setting network struggles to fit into training data already, and turn off weight decay even for baseline experiments. In future we plan to explore gradient-based attention for teacher-student pairs that make use of batch normalization, because it is so far unclear how batch normalization should behave in the second backpropagation step required during gradientbased attention transfer (e.g., should it contribute to batch normalization parameters, or is a separate forward propagation with fixed parameters needed). ",
+        "bbox": [
+            174,
+            407,
+            825,
+            534
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We explored the following methods: ",
+        "bbox": [
+            176,
+            540,
+            413,
+            555
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• Minimizing $l _ { 2 }$ norm of gradient w.r.t. input, i.e. the double backpropagation method Drucker & LeCun (1992);   \n• Symmetry norm on gradient attention maps (see eq. 6);   \n• Student-teacher gradient-based attention transfer;   \n• Student-teacher activation-based attention transfer. ",
+        "bbox": [
+            215,
+            570,
+            823,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results for various methods are shown in table 3. Interestingly, just minimizing $l _ { 2 }$ norm of gradient already works pretty well. Also, symmetry norm is one the best performing attention norms, which we plan to investigate in future on other datasets as well. We also observe that, similar to activationbased attention transfer, using gradient-based attention transfer leads to improved performance. We also trained a network with activation-based AT in the same training conditions, which resulted in the best performance among all methods. We should note that the architecture of student NIN without batch normalization is slightly different from teacher network, it doesn’t have ReLU activations before pooling layers, which leads to better performance without batch normalization, and worse with. So to achieve the best performance with activation-based AT we had to train a new teacher, with batch normalization and without ReLU activations before pooling layers, and have AT losses on outputs of convolutional layers. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 LARGE INPUT IMAGE NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            442,
+            867
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section we experiment with hidden activation attention transfer on ImageNet networks which have $2 2 4 \\times 2 2 4$ input image size. Presumably, attention matters more in this kind of networks as spatial resolution of attention maps is higher. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/aa326066a7003553cbde413286cb73a50f53244db58c482a4b29f28497c4f47a.jpg",
+        "table_caption": [
+            "Table 4: Finetuning with attention transfer error on Scenes and CUB datasets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>type</td><td>model</td><td>ImageNet-→CUB</td><td>ImageNet-→Scenes</td></tr><tr><td>student</td><td>ResNet-18</td><td>28.5</td><td>28.2</td></tr><tr><td>KD</td><td>ResNet-18</td><td>27 (-1.5)</td><td>28.1 (-0.1)</td></tr><tr><td>AT</td><td>ResNet-18</td><td>27 (-1.5)</td><td>27.1 (-1.1)</td></tr><tr><td>teacher</td><td>ResNet-34</td><td>26.5</td><td>26</td></tr></table>",
+        "bbox": [
+            297,
+            97,
+            700,
+            164
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 TRANSFER LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            213,
+            382,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To see how attention transfer works in finetuning we choose two datasets: Caltech-UCSD Birds-200- 2011 fine-grained classification (CUB) by Wah et al. (2011), and MIT indoor scene classification (Scenes) by Quattoni & Torralba (2009), both containing around 5K images training images. We took ResNet-18 and ResNet-34 pretrained on ImageNet and finetuned on both datasets. On CUB we crop bounding boxes, rescale to 256 in one dimension and then take a random crop. Batch normalization layers are fixed for finetuning, and first group of residual blocks is frozen. We then took finetuned ResNet-34 networks and used them as teachers for ResNet-18 pretrained on ImageNet, with $F _ { \\mathrm { s u m } } ^ { 2 }$ attention losses on 2 last groups. In both cases attention transfer provides significant improvements, closing the gap between ResNet-18 and ResNet-34 in accuracy. On Scenes AT works as well as KD, and on CUB AT works much better, which we speculate is due to importance of intermediate attention for fine-grained recognition. Moreover, after finetuning, student’s attention maps indeed look more similar to teacher’s (Fig. 6, Appendix). ",
+        "bbox": [
+            174,
+            238,
+            825,
+            405
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2.2 IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            419,
+            305,
+            434
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To showcase activation-based attention transfer on ImageNet we took ResNet-18 as a student, and ResNet-34 as a teacher, and tried to improve ResNet-18 accuracy. We added only two losses in the 2 last groups of residual blocks and used squared sum attention $F _ { \\mathrm { s u m } } ^ { 2 }$ . We also did not have time to tune any hyperparameters and kept them from finetuning experiments. Nevertheless, ResNet-18 with attention transfer achieved $1 . 1 \\%$ top-1 and $0 . 8 \\%$ top-5 better validation accuracy (Table. 5 and Fig. 7(a), Appendix), we plan to update the paper with losses on all 4 groups of residual blocks. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            527
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We were not able to achieve positive results with KD on ImageNet. With ResNet-18-ResNet-34 student-teacher pair it actually hurts convergence with the same hyperparameters as on CIFAR. As it was reported that KD struggles to work if teacher and student have different architecture/depth (we observe the same on CIFAR), so we tried using the same architecture and depth for attention transfer. On CIFAR both AT and KD work well in this case and improve convergence and final accuracy, on ImageNet though KD converges significantly slower (we did not train until the end due to lack of computational resources). We also could not find applications of FitNets, KD or similar methods on ImageNet in the literature. Given that, we can assume that proposed activation-based AT is the first knowledge transfer method to be successfully applied on ImageNet. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            679,
+            328,
+            695
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We presented several ways of transferring attention from one network to another, with experimental results over several image recognition datasets. It would be interesting to see how attention transfer works in cases where spatial information is more important, e.g. object detection or weaklysupervised localization, which is something that we plan to explore in the future. ",
+        "bbox": [
+            176,
+            710,
+            823,
+            766
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Overall, we think that our interesting findings will help further advance knowledge distillation, and understanding convolutional neural networks in general. ",
+        "bbox": [
+            174,
+            772,
+            823,
+            801
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            821,
+            287,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. CoRR, abs/1409.0473, 2014. URL http://arxiv.org/ abs/1409.0473. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Cristian Bucila, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In KDD, pp. 535–541, 2006. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Taco S. Cohen and Max Welling. Group equivariant convolutional networks. CoRR, abs/1602.07576, 2016. URL http://arxiv.org/abs/1602.07576. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Misha Denil, Loris Bazzani, Hugo Larochelle, and Nando de Freitas. Learning where to attend with deep architectures for image tracking. Neural Computation, 2012. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "H. Drucker and Y LeCun. Improving generalization performance using double backpropagation. IEEE Transaction on Neural Networks, 3(6):991–997, 1992. ",
+        "bbox": [
+            173,
+            176,
+            821,
+            205
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015. ",
+        "bbox": [
+            176,
+            213,
+            821,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E. Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural networks. 2015. ",
+        "bbox": [
+            173,
+            250,
+            823,
+            279
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hugo Larochelle and Geoffrey E. Hinton. Learning to combine foveal glimpses with a third-order boltzmann machine. In J. D. Lafferty, C. K. I. Williams, J. Shawe-Taylor, R. S. Zemel, and A. Culotta (eds.), Advances in Neural Information Processing Systems 23, pp. 1243–1251. Curran Associates, Inc., 2010. ",
+        "bbox": [
+            173,
+            285,
+            826,
+            343
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Ba Lei and Rich Caruana. Do deep nets really need to be deep? In NIPS, 2014. ",
+        "bbox": [
+            173,
+            349,
+            741,
+            366
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. CoRR, abs/1312.4400, 2013. ",
+        "bbox": [
+            171,
+            373,
+            787,
+            388
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Nicolas Heess, Alex Graves, and koray kavukcuoglu. Recurrent models of visual attention. In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 2204–2212. Curran Associates, Inc., 2014. URL http://papers.nips.cc/paper/ 5542-recurrent-models-of-visual-attention.pdf. ",
+        "bbox": [
+            173,
+            396,
+            825,
+            467
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. Oquab, L. Bottou, I. Laptev, and J. Sivic. Is object localization for free? weakly-supervised learning with convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2015. ",
+        "bbox": [
+            173,
+            474,
+            823,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "O. M. Parkhi, A. Vedaldi, and A. Zisserman. Deep face recognition. In British Machine Vision Conference, 2015. ",
+        "bbox": [
+            173,
+            523,
+            821,
+            554
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. Quattoni and A. Torralba. Recognizing indoor scenes. In CVPR, 2009. ",
+        "bbox": [
+            174,
+            560,
+            661,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ronald A. Rensink. The dynamic representation of scenes. In Visual Cognition, pp. 17–42, 2000. ",
+        "bbox": [
+            173,
+            583,
+            808,
+            599
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. FitNets: Hints for thin deep nets. Technical Report Arxiv report 1412.6550, arXiv, 2014. ",
+        "bbox": [
+            174,
+            606,
+            823,
+            648
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ramprasaath R. Selvaraju, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Why did you say that? visual explanations from deep networks via gradient-based localization. 2016. ",
+        "bbox": [
+            173,
+            656,
+            821,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. In ICLR Workshop, 2014. ",
+        "bbox": [
+            173,
+            707,
+            821,
+            737
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. T. Springenberg, A. Dosovitskiy, T. Brox, and M. Riedmiller. Striving for simplicity: The all convolutional net. In arXiv:1412.6806, also appeared at ICLR 2015 Workshop Track, 2015. URL http://arxiv.org/abs/1412.6806. ",
+        "bbox": [
+            174,
+            743,
+            821,
+            786
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ CoRR, abs/1505.00387, 2015. ",
+        "bbox": [
+            171,
+            794,
+            821,
+            824
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds-200-2011 Dataset. Technical Report CNS-TR-2011-001, California Institute of Technology, 2011. ",
+        "bbox": [
+            171,
+            830,
+            823,
+            859
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron C. Courville, Ruslan Salakhutdinov, Richard S. Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. CoRR, abs/1502.03044, 2015. URL http://arxiv.org/abs/1502. 03044. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zichao Yang, Xiaodong He, Jianfeng Gao, Li Deng, and Alexander J. Smola. Stacked attention networks for image question answering. CoRR, abs/1511.02274, 2015. URL http://arxiv. org/abs/1511.02274. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016. ",
+        "bbox": [
+            174,
+            155,
+            727,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In ECCV, 2014. ",
+        "bbox": [
+            171,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            173,
+            217,
+            825,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            299,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 FIGURES AND TABLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            372,
+            147
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/a6852adc648143a8da669a4269ab0c67e38607b3d22191a3838c564f0afd6901.jpg",
+        "image_caption": [
+            "Figure 6: Top activation attention maps for different Scenes networks: original pretrained ResNet-18 (ResNet-18-ImageNet), ResNet-18 trained on Scenes (ResNet-18-scenes), ResNet-18 trained with attention transfer (ResNet-18-scenes-AT) with ResNet-34 as a teacher, ResNet-34 trained on Scenes (ResNet-34-scenes). Predicted classes for each task are shown on top. Attention maps look more similar after transfer (images taken from test set). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            160,
+            772,
+            433
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/c20211c1047b61992778f2016adb04f866db4ac50dc4d94cb2703c8c36f78489.jpg",
+        "image_caption": [
+            "(a) Attention transfer on ImageNet between ResNet18 and ResNet-34. Solid lines represent top-5 validation error, dashed - top-5 training error. Two attention transfer losses were used on the outputs of two last groups of residual blocks respectively, no KD losses used. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            546,
+            482,
+            698
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/559c91e539374d17e840fd28649202f9f0b10146b4b0ea025da1995c2f8e48b2.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            546,
+            810,
+            698
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(b) Activation attention transfer on CIFAR-10 from WRN-16-2 to WRN-16-1. Test error is in bold, train error is in dashed lines. Attention transfer greatly speeds up convergence and improves final accuracy. ",
+        "bbox": [
+            503,
+            704,
+            818,
+            756
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/7fc36abdab659263129fe9d4dbb7a091ac40fee72761bb64536b2c892ddb22ad.jpg",
+        "table_caption": [
+            "Table 5: Attention transfer validation error (single crop) on ImageNet. Transfer losses are added on epoch 60/100. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>top1, top5</td></tr><tr><td>ResNet-18</td><td>30.4,10.8</td></tr><tr><td>AT</td><td>29.3,10.0</td></tr><tr><td>ResNet-34</td><td>26.1,8.3</td></tr></table>",
+        "bbox": [
+            415,
+            101,
+            581,
+            155
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            220,
+            406,
+            236
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The experiments were conducted in Torch machine learning framework. Double propagation can be implemented in a modern framework with automatic differentiation support, e.g. Torch, Theano, Tensorflow. For ImageNet experiments we used fb.resnet.torch code, and used 2 Titan X cards with data parallelizm in both teacher and student to speed up training. Code and models for our experiments are available at https://github.com/szagoruyko/attention-transfer. ",
+        "bbox": [
+            174,
+            246,
+            825,
+            318
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rJevYoA9Fm/rJevYoA9Fm.md

@@ -0,0 +1,356 @@
+# The Singular Values of Convolutional Layers
+
+Hanie Sedghi, Vineet Gupta and Philip M. Long
+
+Google Brain   
+Mountain View, CA 94043   
+{hsedghi,vineet,plong}@google.com
+
+# Abstract
+
+We characterize the singular values of the linear transformation associated with a standard 2D multi-channel convolutional layer, enabling their efficient computation. This characterization also leads to an algorithm for projecting a convolutional layer onto an operator-norm ball. We show that this is an effective regularizer; for example, it improves the test error of a deep residual network using batch normalization on CIFAR-10 from $6 . 2 \%$ to $5 . 3 \%$ .
+
+# 1 Introduction
+
+Exploding and vanishing gradients (Hochreiter, 1991; Hochreiter et al., 2001; Goodfellow et al., 2016) are fundamental obstacles to effective training of deep neural networks. Many deep networks used in practice are layered. We can think of such networks as the composition of a number of feature transformations, followed by a linear classifier on the final layer of features. The singular values of the Jacobian of a layer bound the factor by which it increases or decreases the norm of the backpropagated signal. If these singular values are all close to 1, then gradients neither explode nor vanish. These singular values also bound these factors in the forward direction, which affects the stability of computations, including whether the network produces the dreaded “Nan”. Moreover, it has been proven (Bartlett et al., 2017) that the generalization error for a network is bounded by the Lipschitz constant of the network, which in turn can be bounded by the product of the operator norms of the Jacobians of the layers. Cisse et al. (2017) discussed robustness to adversarial examples as a result of bounding the operator norm.
+
+These considerations have led authors to regularize networks by driving down the operator norms of network layers (Drucker and Le Cun, 1992; Hein and Andriushchenko, 2017; Yoshida and Miyato, 2017; Miyato et al., 2018). Orthogonal initialization (Saxe et al., 2013; Pennington et al., 2017) and Parseval networks (Cisse et al., 2017) are motivated by similar considerations.
+
+Convolutional layers (LeCun et al., 1998) are key components of modern deep networks. They compute linear transformations of their inputs. The Jacobian of a linear transformation is always equal to the linear transformation itself. Because of the central importance of convolutional layers to the practice of deep learning, and the fact that the singular values of the linear transformation computed by a convolutional layer are the key to its contribution to exploding and vanishing gradients, we study these singular values. Up until now, authors seeking to control the operator norm of convolutional layers have resorted to approximations (Yoshida and Miyato, 2017; Miyato et al., 2018; Gouk et al., 2018a). In this paper, we provide an efficient way to compute the singular values exactly — this opens the door to various regularizers.
+
+We consider the convolutional layers commonly applied to image analysis tasks. The input to a typical layer is a feature map, with multiple channels for each position in an $n \times n$ field. If there are $m$ channels, then the input as a whole is a $m \times n \times n$ tensor. The output is also an $n \times n$ field with multiple channels per position1. Each channel of the output is obtained by taking a linear combination of the values of the features in all channels in a local neighborhood centered at the corresponding position in the input feature map. Crucially, the same linear combination is used for all positions in the feature map. The coefficients are compiled in the kernel of the convolution. If the neighborhood is a $k \times k$ region, a kernel $K$ is a $k \times k \times m \times m$ tensor. The projection $K _ { : , : , c , }$ : gives the coefficients that determine the cth channel of the output, in terms of the values found in all of the channels of all positions in it neighborhood; $K _ { : , : , c , d }$ gives the coefficients to apply to the dth input channel, and $K _ { p , q , c , d }$ is the coefficient to apply to this input at in the position in the field offset horizontally by $p$ and vertically by $q$ . For ease of exposition, we assume that feature maps and local neighborhoods are square and that the number of channels in the output is equal to the number of channels in the input - the extension to the general case is completely straightforward.
+
+To handle edge cases in which the offsets call for inputs that are off the feature maps, practical convolutional layers either do not compute outputs (reducing the size of the feature map), or pad the input with zeros. The behavior of these layers can be approximated by a layer that treats the input as if it were a torus; when the offset calls for a pixel that is off the right end of the image, the layer “wraps around” to take it from the left edge, and similarly for the other edges. The quality of this approximation has been heavily analyzed in the case of one-dimensional signals (Gray, 2006). Consequently, theoretical analysis of convolutions that wrap around has been become standard. This is the case analyzed in this paper.
+
+Summary of Results: Our main result is a characterization of the singular values of a convolutional layer in terms of the kernel tensor $K$ . Our characterization enables these singular values to be computed exactly in a simple and practically fast way, using $O ( n ^ { 2 } m ^ { 2 } ( m + \log n ) )$ time. For comparison, the brute force solution that performs SVD on the matrix that encodes the convolutional layer’s linear transformation would take $O ( ( n ^ { 2 } m ) ^ { 3 } ) = O ( n ^ { 6 } m ^ { 3 } )$ time, and is impractical for commonly used network sizes. As another point of comparison, simply to compute the convolution takes $O ( n ^ { 2 } m ^ { 2 } k ^ { 2 } )$ time. We prove that the following two lines of NumPy correctly compute the singular values.
+
+def SingularValues(kernel, input_shape): transforms $=$ np.fft.fft2(kernel, input_shape, axes $=$ [0, 1]) return np.linalg.svd(transforms, compute_uv=False)
+
+Here kernel is any $k \times k \times m \times m$ tensor2 and input_shape is the shape of the feature map to be convolved. A TensorFlow implementation is similarly simple.
+
+Timing tests, reported in Section 4.1, confirm that this characterization speeds up the computation of singular values by multiple orders of magnitude – making it usable in practice. The algorithm first performs $m ^ { 2 }$ FFTs, and then it performs ${ { \bar { n } } ^ { 2 } }$ SVDs. The FFTs, and then the SVDs, may be executed in parallel. Our TensorFlow implementation runs a lot faster than the NumPy implementation (see Figure 1); we think that this parallelism is the cause. We used our code to compute the singular values of the convolutional layers of the official ResNet-v2 model released with TensorFlow (He et al., 2016). The results are described in Appendix C.
+
+Exposing the singular values of a convolutional layer opens the door to a variety of regularizers for these layers, including operator-norm regularizers. In Section 4.2, we evaluate an algorithm that periodically projects each convolutional layer onto a operator-norm ball. Using the projections improves the test error from $6 . 2 \%$ to $5 . 3 \%$ on CIFAR-10. We evaluate bounding the operator norm with and without batchnorm and we see that regularizing the operator norm helps, even in the presence of batch normalization. Moreover, operator-norm regularization and batch normalization are not redundant, and neither dominates the other. They complement each other.
+
+Related work: Prior to our work, authors have responded to the difficulty of computing the singular values of convolutional layers in various ways. Cisse et al. (2017) constrained the matrix to have orthogonal rows and scale the output of each layer by a factor of $( 2 k + 1 ) ^ { - \frac { 1 } { 2 } }$ , for $k \times k$ kernels. Gouk et al. (2018a;b) proposed regularizing using a per-mini-batch approximation to the operator norm. They find the largest ratio between the input and output of a layer in the minibatch, and then scale down the transformation (thereby scaling down all of the singular values, not just the largest ones) so that the new value of this ratio obeys a constraint.
+
+Yoshida and Miyato (2017) used an approximation of the operator norm of a reshaping of $K$ in place of the operator norm for the linear transformation associated with $K$ in their experiments. They reshape the given $k \times k \times m \times m$ into a $m k ^ { 2 } \times m$ matrix, and compute its largest singular value using a power iteration method, and use this as a substitute for the operator norm. While this provides a useful heuristic for regularization, the largest singular value of the reshaped matrix is often quite different from the operator norm of the linear transform associated with $K$ . Furthermore if we want to regularize using projection onto an operator-norm ball, we need the whole spectrum of the linear transformation (see Section 3). The reshaped $K$ has only $m$ singular values, whereas the linear transformation has $m n ^ { 2 }$ singular values of which $m n ^ { 2 } / 2$ are distinct except in rare degenerate cases. It is possible to project the reshaped $K$ onto an operator-norm ball by taking its SVD and clipping its singular values — we conducted experiments with this projection and report the results in Section 4.4.
+
+A close relative of our main result was independently discovered by Bibi et al. (2019, Lemma 2).
+
+Overview of the Analysis: If the signal is 1D and there is a single input and output channel, then the linear transformation associated with a convolution is encoded by a circulant matrix, i.e., a matrix whose rows are circular shifts of a single row (Gray, 2006). For example, for a row $a = ( a _ { 1 } , a _ { 2 } , a _ { 3 } )$ , the circulant matrix $\mathrm { c i r c } ( a )$ generated by $a$ is $\left( \begin{array} { l l l } { a _ { 0 } } & { a _ { 1 } } & { a _ { 2 } } \\ { a _ { 2 } } & { a _ { 0 } } & { a _ { 1 } } \\ { a _ { 1 } } & { a _ { 2 } } & { a _ { 0 } } \end{array} \right)$ . In the special case of a 2D signal with a single input channel and single output channel, the linear transformation is doubly block circulant (see (Goodfellow et al., 2016)). Such a matrix is made up of a circulant matrix of blocks, each of which in turn is itself circulant. Finally, when there are $m$ input channels and $m$ output channels, there are three levels to the hierarchy: there is a $m \times m$ matrix of blocks, each of which is doubly block circulant. Our analysis extends tools from the literature built for circulant (Horn and Johnson, 2012) and doubly circulant (Chao, 1974) matrices to analyze the matrices with a third level in the hierarchy arising from the convolutional layers used in deep learning. One key point is that the eigenvectors of a circulant matrix are Fourier basis vectors: in the 2D, one-channel case, the matrix whose columns are the eigenvectors is $F \otimes F$ , for the matrix $F$ whose columns form the Fourier basis. Multiplying by this matrix is a 2D Fourier transform. In the multi-channel case, we show that the singular values can be computed by (a) finding the eigenvalues of each of the $m ^ { 2 }$ doubly circulant matrices (of dimensions $n ^ { 2 } \times n ^ { 2 }$ ) using a 2D Fourier transform, (b) by forming multiple $m \times m$ matrices, one for each eigenvalue, by picking out the $i$ -th eigenvalue of each of the $n ^ { 2 } \times n ^ { 2 }$ blocks, for $i \in [ 1 . . n ^ { 2 } ]$ . The union of all of the singular values of all of those $m \times m$ matrices is the multiset of singular values of the layer.
+
+Notation: We use upper case letters for matrices, lower case for vectors. For matrix $M , M _ { i }$ ,: represents the $i$ -th row and $M _ { : , j }$ represents the $j$ -th column; we will also use the analogous notation for higher-order tensors. The operator norm of $M$ is denoted by $| | { \cal M } | | _ { 2 }$ . For $n \in \mathbb { N }$ , we use $[ n ]$ to denote the set $\{ 0 , 1 , \ldots , n - 1 \}$ (instead of usual $\{ 1 , \ldots , n \} )$ . We will index the rows and columns of matrices using elements of $[ n ]$ , i.e. numbering from 0. Addition of row and column indices will be done mod $n$ unless otherwise indicated. (Tensors will be treated analogously.) Let $\sigma ( \cdot )$ be the mapping from a matrix to (the multiset of) its singular values. 3
+
+Let $\omega = \exp ( 2 \pi i / n )$ , where $i = \sqrt { - 1 }$ . (Because we need a lot of indices in this paper, our use of √ $i$ to define $\omega$ is the only place in the paper where we will use $i$ to denote $\sqrt { - 1 }$ .)
+
+Let $F$ be the $n \times n$ matrix that represents the discrete Fourier transform: $F _ { i j } = \omega ^ { i j }$ . We use $I _ { n }$ to denote the identity matrix of size $n \times n$ . For $i \in [ n ]$ , we use $e _ { i }$ to represent the ith basis vector in $\mathbb { R } ^ { n }$ We use $\otimes$ to represent the Kronecker product between two matrices (which also refers to the outer product of two vectors).
+
+# 2 Analysis
+
+# 2.1 One filter
+
+As a warmup, we focus on the case that the number $m$ of input channels and output channels is 1. In this case, the filter coefficients are simply a $k \times k$ matrix. It will simplify notation, however, if we embed this $k \times k$ matrix in an $n \times n$ matrix, by padding with zeroes (which corresponds to the fact that the offsets with those indices are not used). Let us refer to this $n \times n$ matrix also as $K$ .
+
+An $n ^ { 2 } \times n ^ { 2 }$ matrix $A$ is doubly block circulant if $A$ is a circulant matrix of $n \times n$ blocks that are in turn circulant.
+
+For a matrix $X$ , let $\operatorname { v e c } ( X )$ be the vector obtained by stacking the columns of $X$ .
+
+Lemma 1 (see Jain (1989) Section 5.5, Goodfellow et al. (2016) page 329) For any filter coefficients $K$ , the linear transform for the convolution by $K$ is represented by the following doubly block circulant matrix:
+
+$$
+\begin{array} { r } { A = \left[ \begin{array} { c c c c } { \mathrm { c i r c } ( K _ { 0 , : } ) } & { \mathrm { c i r c } ( K _ { 1 , : } ) } & { \ldots } & { \mathrm { c i r c } ( K _ { n - 1 , : } ) } \\ { \mathrm { c i r c } ( K _ { n - 1 , : } ) } & { \mathrm { c i r c } ( K _ { 0 , : } ) } & { \ldots } & { \mathrm { c i r c } ( K _ { n - 2 , : } ) } \\ { \vdots } & { \vdots } & { \vdots } & { \vdots } \\ { \mathrm { c i r c } ( K _ { 1 , : } ) } & { \mathrm { c i r c } ( K _ { 2 , : } ) } & { \ldots } & { \mathrm { c i r c } ( K _ { 0 , : } ) } \end{array} \right] . } \end{array}
+$$
+
+That is, $i f X$ is an $n \times n$ matrix, and $Y$ is the result of a 2-d convolution of $X$ with $K$ , i.e.
+
+$$
+\forall i j , Y _ { i j } = \sum _ { p \in [ n ] } \sum _ { q \in [ n ] } X _ { i + p , j + q } K _ { p , q }
+$$
+
+then $\operatorname { v e c } ( Y ) = A \operatorname { v e c } ( X ) .$
+
+So now we want to determine the singular values of a doubly block circulant matrix.
+
+We will make use of the characterization of the eigenvalues and eigenvectors of doubly block circulant matrices, which uses the following definition: $Q \stackrel { \mathrm { d e f } } { = } \frac { 1 } { n } \left( F \otimes F \right)$ .
+
+Theorem 2 (Jain (1989) Section 5.5) For any $n ^ { 2 } \times n ^ { 2 }$ doubly block circulant matrix $A$ , the eigenvectors of $A$ are the columns of $Q$ .
+
+To get singular values in addition to eigenvalues, we need the following two lemmas.
+
+Lemma 3 (Jain (1989) Section 5.5) $Q$ is unitary.
+
+Using Theorem 2 and Lemma 3, we can get the eigenvalues as the diagonal elements of $Q ^ { * } A Q$ .
+
+Lemma 4 The matrix $A$ defined in equation $^ { l }$ is normal, i.e., $A ^ { T } A = A A ^ { T }$ .
+
+# Proof:
+
+$$
+A A ^ { T } = A A ^ { * } = Q ^ { * } D Q Q ^ { * } D ^ { * } Q = Q ^ { * } D D ^ { * } Q = Q ^ { * } D ^ { * } D Q = Q ^ { * } D ^ { * } Q Q ^ { * } D Q = A ^ { * } A = A ^ { T } A .
+$$
+
+The following theorem characterizes the singular values of $A$ as a simple function of $K$ . As we will see, a characterization of the eigenvalues plays a major role. Chao (1974) provided a more technical characterization of the eigenvalues which may be regarded as making partial progress toward Theorem 5. However, we provide a proof from first principles, since it is the cleanest way we know to prove the theorem.
+
+Theorem 5 For the matrix $A$ defined in equation $I$ , the eigenvalues of $A$ are the entries of $F ^ { T } K F$ and its singular values are their magnitudes. That is, the singular values of $A$ are
+
+$$
+\left\{ \left| ( F ^ { T } K F ) _ { u , v } \right| \ : \ u , v \in [ n ] \right\} .
+$$
+
+Proof: By Theorems 2 and Lemma 3, the eigenvalues of $A$ are the diagonal elements of $Q ^ { * } A Q =$ $\mathring { \neg } ( F ^ { * } \otimes \bar { F } ^ { * } ) A ( F \otimes F )$ . If we view $( F ^ { * } \otimes F ^ { * } ) A ( F \otimes F )$ as a compound $n \times n$ matrix of $n \times n$ blocks, for $u , v \in [ n ]$ , the $( u n + v )$ th diagonal element is the $v$ th element of the $u$ th diagonal block. Let us first evaluate the uth diagonal block. Using $i , j$ to index blocks, we have
+
+$$
+\begin{array} { l } { { ( Q ^ { * } A Q ) _ { u u } = \displaystyle \frac { 1 } { n ^ { 2 } } \sum _ { i , j \in [ n ] } ( F ^ { * } \otimes F ^ { * } ) _ { u i } A _ { i j } ( F \otimes F ) _ { j u } = \displaystyle \frac { 1 } { n ^ { 2 } } \sum _ { i , j \in [ n ] } \omega ^ { - u i } F ^ { * } \mathrm { c i r c } ( K _ { j - i , \cdot } ) \omega ^ { j u } F } } \\ { { = \displaystyle \frac { 1 } { n ^ { 2 } } \sum _ { i , j \in [ n ] } \omega ^ { u ( j - i ) } F ^ { * } \mathrm { c i r c } ( K _ { j - i , \cdot } ) F . } } \end{array}
+$$
+
+To get the $v$ th element of the diagonal of (4), we may sum the vth elements of the diagonals of each of its terms. Toward this end, we have
+
+$$
+( F ^ { * } \mathrm { c i r c } ( K _ { j - i , : } ) F ) _ { v v } = \sum _ { r , s \in [ n ] } \omega ^ { - v r } \mathrm { c i r c } ( K _ { j - i , : } ) _ { r s } \omega ^ { s v } = \sum _ { r , s \in [ n ] } \omega ^ { v ( s - r ) } K _ { j - i , s - r } .
+$$
+
+Substituting into (4), we get $\begin{array} { r } { \frac { 1 } { n ^ { 2 } } \sum _ { i , j , r , s \in [ n ] } \omega ^ { u ( j - i ) } \omega ^ { v ( s - r ) } K _ { j - i , s - r } . } \end{array}$ . Collecting terms where $j - i =$ $p$ and $s - r = q$ , this is $\begin{array} { r } { \sum _ { p , q \in [ n ] } \omega ^ { u p } \omega ^ { v q } K _ { p , q } = ( F ^ { T } K F ) _ { u v } } \end{array}$ .
+
+Since the singular values of any normal matrix are the magnitudes of its eigenvalues (Horn and Johnson (2012) page 158), applying Lemma 4 completes the proof. □
+
+Note that $F ^ { T } K F$ is the 2D Fourier transform of $K$ , and recall that $| | A | | _ { 2 }$ is the largest singular value of $A$ .
+
+# 2.2 Multi-channel convolution
+
+Now, we consider case where the number $m$ of channels may be more than one. Assume we have a 4D kernel tensor $K$ with element $K _ { p , q , c , d }$ giving the connection strength between a unit in channel $d$ of the input and a unit in channel $c$ of the output, with an offset of $p$ rows and $q$ columns between the input unit and the output unit. The input $X \in \mathbb { R } ^ { m \times n \times n }$ ; element $X _ { d , i , j }$ is the value of the input unit within channel $d$ at row $i$ and column $j$ . The output $Y \in \mathbb { R } ^ { m \times n \times n }$ has the same format as $X$ , and is produced by
+
+$$
+Y _ { c r s } = \sum _ { d \in [ m ] } \sum _ { p \in [ n ] } \sum _ { q \in [ n ] } X _ { d , r + p , s + q } K _ { p , q , c , d } .
+$$
+
+By inspection, $\operatorname { v e c } ( Y ) = M \operatorname { v e c } ( X )$ , where $M$ is as follows
+
+$$
+{ \cal M } = \left[ \begin{array} { c c c c } { { B _ { 0 0 } } } & { { B _ { 0 1 } } } & { { \dots } } & { { B _ { 0 ( m - 1 ) } } } \\ { { B _ { 1 0 } } } & { { B _ { 1 1 } } } & { { \dots } } & { { B _ { 1 ( m - 1 ) } } } \\ { { \vdots } } & { { \vdots } } & { { \ddots } } & { { \vdots } } \\ { { B _ { ( m - 1 ) 0 } } } & { { B _ { ( m - 1 ) 1 } } } & { { \dots } } & { { B _ { ( m - 1 ) ( m - 1 ) } } } \end{array} \right]
+$$
+
+and each $B _ { c d }$ is a doubly block circulant matrix from Lemma 1 corresponding to the portion $K _ { : , : , c , d }$ of $K$ that concerns the effect of the $d$ -th input channel on the $c$ -th output channel. (We can think of each output in the multichannel case as being a sum of single channel filters parameterized by one of the $K _ { : , : , c , d }$ ’s.)
+
+The following is our main result.
+
+Theorem 6 For any $K \in \mathbb { R } ^ { n \times n \times m \times m }$ , let $M$ is the matrix encoding the linear transformation computed by a convolutional layer parameterized by $K$ , defined as in (6). For each $u , v \in [ n ] \times [ n ]$ , let $P ^ { ( u , v ) }$ be the $m \times m$ matrix given by $P _ { c d } ^ { ( u , v ) } = ( F ^ { T } K _ { : , : , c , d } F ) _ { u v }$ . Then
+
+$$
+\sigma ( M ) = \bigcup _ { u \in [ n ] , v \in [ n ] } \sigma \left( P ^ { ( u , v ) } \right) .
+$$
+
+The rest of this section is devoted to proving Theorem 6 through a series of lemmas.
+
+The analysis of Section 2.1 implies that for all $c , d \in [ m ]$ , $D _ { c d } \stackrel { \mathrm { d e f } } { = } Q ^ { * } B _ { c d } Q$ is diagonal. Define
+
+$$
+\begin{array} { r } { L \stackrel { \mathrm { d e f } } { = } \left[ \begin{array} { c c c c } { D _ { 0 0 } } & { D _ { 0 1 } } & { . . . } & { D _ { 0 ( m - 1 ) } } \\ { D _ { 1 0 } } & { D _ { 1 1 } } & { . . . } & { D _ { 1 ( m - 1 ) } } \\ { \vdots } & { \vdots } & { . . . } & { \vdots } \\ { D _ { ( m - 1 ) 0 } } & { D _ { ( m - 1 ) 1 } } & { . . . } & { D _ { ( m - 1 ) ( m - 1 ) } } \end{array} \right] . } \end{array}
+$$
+
+Lemma 7 $M$ and $L$ have the same singular values.
+
+Proof: We have
+
+$$
+\begin{array} { r l } & { M = \left[ \begin{array} { c c c } { B _ { 0 0 } } & { \ldots } & { B _ { 0 ( m - 1 ) } } \\ { \vdots } & { \vdots } & { \vdots } \\ { B _ { ( m - 1 ) 0 } } & { \ldots } & { B _ { ( m - 1 ) ( m - 1 ) } } \end{array} \right] = \left[ \begin{array} { c c c } { Q D _ { 0 0 } Q ^ { * } } & { \ldots } & { Q D _ { 0 ( m - 1 ) } Q ^ { * } } \\ { \vdots } & { \vdots } & { \vdots } \\ { Q D _ { ( m - 1 ) 0 } Q ^ { * } } & { \ldots } & { Q D _ { ( m - 1 ) ( m - 1 ) } Q ^ { * } } \end{array} \right] } \\ & { \quad \quad = R \left[ \begin{array} { c c c } { D _ { 0 0 } } & { \ldots } & { D _ { 0 ( m - 1 ) } } \\ { \vdots } & { \vdots } & { \vdots } \\ { D _ { ( m - 1 ) 0 } } & { \ldots } & { D _ { ( m - 1 ) ( m - 1 ) } } \end{array} \right] R ^ { * } = R L R ^ { * } , } \end{array}
+$$
+
+where $R \stackrel { \mathrm { d e f } } { = } I _ { m } \otimes Q$ . Note that $R$ is unitary because
+
+$$
+R R ^ { * } = ( I _ { m } \otimes Q ) ( I _ { m } \otimes Q ^ { * } ) = ( I _ { m } I _ { m } ) \otimes ( Q Q ^ { * } ) = I _ { m n ^ { 2 } } ;
+$$
+
+this implies that $M$ and $L$ have the same singular values.
+
+So now we have as a subproblem characterizing the singular values of a block matrix whose blocks are diagonal. To express the the characterization, it helps to reshape the nonzero elements of $L$ into a $m \times \overline { { m \times n ^ { 2 } } }$ tensor $G$ as follows: $G _ { c d w } = ( D _ { c d } ) _ { w w }$ .
+
+Theorem 8 $\sigma ( L ) = \bigcup _ { w \in [ n ^ { 2 } ] } \sigma \left( G _ { : , : , w } \right) .$ .
+
+Proof: Choose an arbitrary $w \in [ n ^ { 2 } ]$ , and a (scalar) singular value $\sigma$ of $G _ { : , : , w }$ whose left singular vector is $x$ and whose right singular vector is $y$ , so that $G _ { : , : , w } y = \sigma x$ . Recall that $e _ { w } \in \mathbb { R } ^ { n ^ { 2 } }$ is a standard basis vector.
+
+We claim that $L ( y \otimes e _ { w } ) = \sigma ( x \otimes e _ { w } )$ . Since $D _ { c d }$ is diagonal, $D _ { c d } e _ { w } = ( D _ { c d } ) _ { w w } e _ { w } = G _ { c d w } e _ { w }$ Thus we have $\begin{array} { r } { ( L ( y \otimes e _ { w } ) ) _ { c } = \sum _ { d \in [ m ] } D _ { c d } y _ { d } e _ { w } = ( \sum _ { d \in [ m ] } G _ { c d w } y _ { d } ) e _ { w } = ( G _ { : , : , w } y ) _ { c } e _ { w } = \sigma x _ { c } e _ { w } , } \end{array}$ which shows that
+
+$$
+{ \boldsymbol { \zeta } } ( y \otimes e _ { w } ) = \left[ { \begin{array} { c c c c } { D _ { 0 0 } } & { \ldots } & { D _ { 0 ( m - 1 ) } } \\ { D _ { 1 0 } } & { \ldots } & { D _ { 1 ( m - 1 ) } } \\ { \vdots } & { \ldots } & { \vdots } \\ { D _ { ( m - 1 ) 0 } } & { \ldots } & { D _ { ( m - 1 ) ( m - 1 ) } } \end{array} } \right] \left[ { \begin{array} { c } { y _ { 0 } e _ { w } } \\ { \vdots } \\ { y _ { m - 1 } e _ { w } } \end{array} } \right] = \left[ { \begin{array} { c } { \sigma x _ { 0 } e _ { w } } \\ { \vdots } \\ { \sigma x _ { m - 1 } e _ { w } } \end{array} } \right] = \sigma ( x \otimes e _ { w } ) .
+$$
+
+If $\tilde { \sigma }$ is another singular value of $G _ { : , : , w }$ with a left singular vector $\tilde { x }$ and a right singular vector $\tilde { y }$ , then $\langle ( x \otimes e _ { w } ) , ( \tilde { x } \otimes e _ { w } ) \rangle = \langle x , \tilde { x } \rangle = 0$ and, similarly $\langle ( y \otimes e _ { w } ) , ( \tilde { y } \otimes e _ { w } ) \rangle = 0$ . Also, $\langle ( x \otimes e _ { w } ) , ( x \otimes e _ { w } ) \rangle = 1$ and $\langle ( y \otimes e _ { w } ) , ( y \otimes e _ { w } ) \rangle = 1$ .
+
+For any $x$ and $\tilde { x }$ , whether they are equal or not, if $w \ne \tilde { w }$ , then $\langle ( x \otimes e _ { w } ) , ( \tilde { x } \otimes e _ { \tilde { w } } ) \rangle = 0$ , simply because their non-zero components do not overlap.
+
+Thus, by taking the Kronecker product of each singular vector of $G _ { : , : , w }$ with $e _ { w }$ and assembling the results for various $w$ , we may form a singular value decomposition of $L$ whose singular values are $\cup _ { w \in [ n ^ { 2 } ] } \sigma ( G _ { : , : , w } ) .$ . This completes the proof. □
+
+Using Lemmas 7 and Theorem 8, we are now ready to prove Theorem 6.
+
+Proof (of Theorem 6). Recall that, for each input channel $c$ and output channel $d$ , the diagonal elements of $D _ { c , d }$ are the eigenvalues of $B _ { c , d }$ . By Theorem 5, this means that the diagonal elements of $D _ { c , d }$ are
+
+$$
+\{ ( F ^ { T } K _ { : , : , c , d } F ) _ { u , v } : u , v \in [ n ] \} .
+$$
+
+The elements of (9) map to the diagonal elements of $D _ { c , d }$ as follows:
+
+$$
+G _ { c d w } = ( D _ { c , d } ) _ { w w } = ( F ^ { T } K _ { : , : , c , d } F ) _ { \lfloor w / m \rfloor , w \mod m }
+$$
+
+and thus
+
+$$
+G _ { : , : , w } = \left( ( F ^ { T } K _ { : , : , c , d } F ) _ { \lfloor w / m \rfloor , w \mod m } \right) _ { c d }
+$$
+
+which in turn implies
+
+$$
+\bigcup _ { w \in [ n ^ { 2 } ] } \sigma ( G _ { : , : , w } ) = \cup _ { u \in [ n ] , v \in [ n ] } \sigma \left( \left( ( F ^ { T } K _ { : , : , c , d } F ) _ { u , v } \right) _ { c d } \right) .
+$$
+
+Applying Lemmas 7 and 8 completes the proof.
+
+# 3 Regularization
+
+We now show how to use the spectrum computed above to project a convolution onto the set of convolutions with bounded operator norm. We exploit the following key fact.
+
+Proposition 9 (Lefkimmiatis et al. (2013), Proposition 1) Let $A \in \mathbb { R } ^ { n \times n }$ , and let $A = U D V ^ { \top }$ be its singular value decomposition. Let $\tilde { A } = U \tilde { D } \bar { V } ^ { \top }$ , where, for all $i \in [ n ] , \tilde { D } _ { i i } = \operatorname* { m i n } ( D _ { i i } , c )$ and $B = \{ X \mid | X | | _ { 2 } \leq c \}$ . Then $\tilde { A }$ is the projection of $A$ onto $\boldsymbol { B }$ ; i.e. ${ \tilde { A } } = \underset { X \in \mathcal { B } } { \arg \operatorname* { m i n } } \ | | A - X | | _ { F } .$ .
+
+This implies that the desired projection can be obtained by clipping the singular values of linear transformation associated with a convolutional layer to the interval $[ 0 , c ]$ . Note that the eigenvectors remained the same in the proposition, hence the projected matrix is still generated by a convolution. However, after the projection, the resulting convolution neighborhood may become as large as $n \times n$ . On the other hand, we can project this convolution onto the set of convolutions with $k \times k$ neighborhoods, by zeroing out all other coefficients. NumPy code for this is in Appendix A.
+
+Repeatedly alternating the two projections would give a point in the intersection of the two sets, i.e., a $k \times k$ convolution with bounded operator norm (Cheney and Goldstein (1959) Theorem 4, Boyd and Dattorro (2003) Section 2), and the projection onto that intersection could be found using the more complicated Dykstra’s projection algorithm (Boyle and Dykstra, 1986).
+
+When we wish to control the operator norm during an iterative optimization process, however, repeating the alternating projections does not seem to be worth it – we found that the first two projections already often produced a convolutional layer with an operator norm close to the desired value. Furthermore, because SGD does not change the parameters very fast, we can think of a given pair of projections as providing a warm start for the next pair.
+
+In practice, we run the two projections once every few steps, thus letting the projection alternate with the training.
+
+# 4 Experiments
+
+First, we validated Theorem 6 with unit tests in which the output of the code given in the introduction is compared with evaluating the singular values by constructing the full matrix encoding the linear transformation corresponding to the convolutional layer and computing its SVD.
+
+# 4.1 Timing
+
+We generated 4D tensors of various shapes with random standard normal values, and computed their singular values using the full matrix method, the NumPy code given above and the equivalent TensorFlow code. For small tensors, the NumPy code was faster than TensorFlow, but for larger tensors, the TensorFlow code was able to exploit the parallelism in the algorithm and run much faster on a GPU. The timing results are shown in Figure 1.
+
+# 4.2 Regularization
+
+We next explored the effect of regularizing the convolutional layers by clipping their operator norms as described in Section 3. We ran the CIFAR-10 benchmark with a standard 32 layer residual network with 2.4M training parameters; (He et al., 2016). This network reached a test error rate of $6 . 2 \%$ after 250 epochs, using a learning rate schedule determined by a grid search (shown by the gray plot in Figure 2). We then evaluated an algorithm that, every 100 steps, clipped the norms of the convolutional layers to various different values between 0.1 and 3.0. As expected, clipping to 2.5 and 3.0 had little impact on the performance, since the norms of the convolutional layers were between 2.5 and 2.8. Clipping to 0.1 yielded a surprising $6 . 7 \%$ test error, whereas clipping to 0.5 and 1.0 yielded test errors of $5 . 3 \%$ and $5 . 5 \%$ respectively (shown in Figure 2). A plot of test error against training time is provided in Figure 4 in Appendix B, showing that the projections did not slow down the training very much.
+
+![](images/5ca872dd9b2f7dda8d75174026703ad85648d97a4e1cc3686f4dfd1cc25ddd1f.jpg)  
+Figure 1: Time used to compute singular values. The left graph is for a $3 \times 3$ convolution on a $1 6 \times 1 6$ image with the number of input/output channels on the $x$ -axis. The right graph is for a $1 1 \times 1 1$ convolution on a $6 4 \times 6 4$ image (no curve for full matrix method is shown as this method could not complete in a reasonable time for these inputs).
+
+![](images/aef8fcd02dda25632a62ea916f9c61667a60909bec96589f9dd4a13662ccd92a.jpg)  
+Figure 2: Training loss and test error for ResNet model (He et al., 2016) for CIFAR-10.
+
+# 4.3 Robustness to changes in hyperparameters
+
+The baseline algorithm studied in the previous subsection used batch normalization. Batch normalization tends to make the network less sensitive to linear transformations with large operator norms. However, batch normalization includes trainable scaling parameters (called $\gamma$ in the original paper) that are applied after the normalization step. The existence of these parameters lead to a complicated interaction between batch normalization and methods like ours that act to control the norm of the linear transformation applied before batch normalization.
+
+Because the effect of regularizing the operator norm is more easily understood in the absence of batch normalization, we also performed experiments with a baseline that did not use batch normalization.
+
+Another possibility that we wanted to study was that using a regularizer may make the process overall more stable, enabling a larger learning rate. We were generally interested in whether operator-norm regularization made the training process more robust to the choice of hyperparameters.
+
+In one experiment, we started with the same baseline as the previous subsection, but disabled batch normalization. This baseline started with a learning rate of 0.1, which was multiplied by a factor 0.95 after every epoch. We tried all combinations of the following hyperparameters: (a) the norm of the ball projected onto (no projection, 0.5, 1.0, 1.5, 2.0); (b) the initial learning rate (0.001, 0.003, 0.01, 0.03, 0.1); (c) the minibatch size (32, 64); (d) the number of epochs per decay of the learning rate (1,2,3). We tried each of the 150 combinations of the hyperparameters, trained for 100 epochs, and measured the test error. The results are plotted in Figure 3a. The operator norm regularization improved the best result, and also made the process more robust to the choice of hyperparameters.
+
+![](images/0a6350eb054416feb2a9f086e2abc8aab36e4eed2bd1744a93c2d6e1d99dc11c.jpg)  
+Figure 3: A scatterplot of the test errors obtained with different hyperparameter combinations, and different operator-norm regularizers.
+
+We conducted a similar experiment in the presence of batch normalization, except using learning rates 0.01, 0.03, 0.1, 0.2, and 0.3. Those results are shown in Figure 3b. Regularizing the operator norm helps, even in the presence of batch normalization.
+
+It appears that operator-norm regularization and batch normalization are not redundant, and neither dominates the other. We were surprised by this.
+
+# 4.4 Comparison with reshaping $K$
+
+In Section 1 we mentioned that Yoshida and Miyato (2017) approximated the linear transformation induced by $K$ by reshaping $K$ . This leads to an alternate regularization method — we compute the spectrum of the reshaped $K$ , and project it onto a ball using clipping, as above. We implemented this an experimented with it using the same network and hyperparameters as in Section 4.2 and found the following.
+
+• We clipped the singular values of the reshaped $K$ every 100 steps. We tried various constants for the clipped value (0.05, 0.1, 0.2, 0.5, 1.0), and found that the best accuracy we achieved, using 0.2, was the same as the accuracy we achieved in Section 4.2. • We clipped the singular values of the reshaped $K$ to these same values every step, and found that the best accuracy achieved was slightly worse than the accuracy achieved in the previous step. We observed similar behavior when we clipped norms using our method. • Most surprisingly, we found that clipping norms by our method on a GPU was about $2 5 \%$ faster than clipping the singular values of the reshaped $K$ — when we clipped after every step, on the same machine, 10000 batches of CIFAR10 took 14490 seconds when we clipped the reshaped $K$ , whereas they took 11004 seconds with our exact method! One possible explanation is parallelization — clipping reshaped $K$ takes $O ( m ^ { 3 } k ^ { 2 } )$ flops, whereas our method does $m ^ { 2 }$ FFTs, followed by $\bar { n ^ { 2 } } m \times m$ SVDs, which takes $O ( m ^ { 3 } n ^ { 2 } )$ flops, but these can be parallelized and completed in as little as $O ( n ^ { 2 } \log n + m ^ { 3 } )$ time.
+
+Clearly this is only one dataset, and the results may not generalize to other sets. However it does suggest that finding the full spectrum of the convolutional layer may be no worse than computing heuristic approximations, both in classification accuracy and speed.
+
+# 5 Acknowledgements
+
+We thank Tomer Koren, Nishal Shah, Yoram Singer and Chiyuan Zhang for valuable conversations.
+
+# References
+
+P. L. Bartlett, D. J. Foster, and M. J. Telgarsky. Spectrally-normalized margin bounds for neural networks. In NIPS, pages 6240–6249, 2017.
+
+Adel Bibi, Bernard Ghanem, Vladlen Koltun, and Rene Ranftl. Deep layers as stochastic solvers. ICLR, 2019.
+
+S. Boyd and J. Dattorro. Alternating projections, 2003. https://web.stanford.edu/class/ee392o/alt_proj.pdf.
+
+J. P. Boyle and R. L. Dykstra. A method for finding projections onto the intersection of convex sets in hilbert spaces. In Advances in order restricted statistical inference, pages 28–47. Springer, 1986.
+
+C. Chao. A note on block circulant matrices. Kyungpook Mathematical Journal, 14:97–100, 1974.
+
+W. Cheney and A. A. Goldstein. Proximity maps for convex sets. Proceedings of the American Mathematical Society, 10(3):448–450, 1959. ISSN 00029939, 10886826. URL http://www.jstor.org/stable/ 2032864.
+
+M. Cisse, P. Bojanowski, E. Grave, Y. Dauphin, and N. Usunier. Parseval networks: Improving robustness to adversarial examples. ICML, 2017.
+
+H. Drucker and Y. Le Cun. Improving generalization performance using double backpropagation. IEEE Transactions on Neural Networks, 3(6):991–997, 1992.
+
+I. Goodfellow, Y. Bengio, and A. Courville. Deep Learning. MIT Press, 2016. http://www. deeplearningbook.org.
+
+H. Gouk, E. Frank, B. Pfahringer, and M. Cree. Regularisation of neural networks by enforcing lipschitz continuity. arXiv preprint arXiv:1804.04368, 2018a.
+
+H. Gouk, B. Pfahringer, E. Frank, and M. Cree. MaxGain: Regularisation of neural networks by constraining activation magnitudes. arXiv preprint arXiv:1804.05965, 2018b.
+
+R. M. Gray. Toeplitz and circulant matrices: A review. Foundations and Trends® in Communications and Information Theory, 2(3):155–239, 2006.
+
+K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pages 630–645. Springer, 2016. http://download.tensorflow.org/models/official/resnet_v2_imagenet_checkpoint.tar.gz; downloaded on on 5/1/18.
+
+M. Hein and M. Andriushchenko. Formal guarantees on the robustness of a classifier against adversarial manipulation. In NIPS, pages 2266–2276, 2017.
+
+S. Hochreiter. Untersuchungen zu dynamischen neuronalen netzen. Diploma, Technische Universität München, 91:1, 1991.
+
+S. Hochreiter, Y. Bengio, P. Frasconi, J. Schmidhuber, et al. Gradient flow in recurrent nets: the difficulty of learning long-term dependencies, 2001.
+
+R. A. Horn and C. R. Johnson. Matrix Analysis. Cambridge University Press, New York, NY, USA, 2nd edition, 2012. ISBN 0521548233, 9780521548236.
+
+A. K. Jain. Fundamentals of digital image processing. Englewood Cliffs, NJ: Prentice Hall„ 1989.
+
+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.
+
+S. Lefkimmiatis, J. P. Ward, and M. Unser. Hessian Schatten-norm regularization for linear inverse problems. IEEE transactions on image processing, 22(5):1873–1888, 2013.
+
+T. Miyato, T. Kataoka, M. Koyama, and Y. Yoshida. Spectral normalization for generative adversarial networks. ICLR, 2018.
+
+J. Pennington, S. Schoenholz, and S. Ganguli. Resurrecting the sigmoid in deep learning through dynamical isometry: theory and practice. In Advances in neural information processing systems, pages 4788–4798, 2017.
+
+A. M. Saxe, J. L. McClelland, and S. Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv preprint arXiv:1312.6120, 2013.
+
+Y. Yoshida and T. Miyato. Spectral norm regularization for improving the generalizability of deep learning. arXiv preprint arXiv:1705.10941, 2017.
+
+# A NumPy code for operator norm projection
+
+def Clip_OperatorNorm(kernel, input_shape, clip_to): transform_coefficients $=$ np.fft.fft2(kernel, input_shape, axes $\displaystyle { \varepsilon }$ [0, 1]) U, D, $\texttt { V } =$ np.linalg.svd(transform_coefficients, compute_uv $\mathbf { \bar { \Pi } } = \mathbf { \bar { \Pi } }$ True, full_matrices $\underline { { \underline { { \mathbf { \Pi } } } } }$ False) D_clipped $=$ np.minimum(D, clip_to)
+
+if kernel.shape[2] $>$ kernel.shape[3]:
+
+clipped_transform_coefficients $=$ np.matmul(U, D_clipped[..., None] \* V) else:
+
+clipped_transform_coefficients $=$ np.matmul(U \* D_clipped[..., None, :], V) clipped_kernel $=$ np.fft.ifft2(clipped_transform_coefficients, axes $=$ [0, 1]).real return clipped_kernel[np.ix_(\*[range(d) for d in kernel.shape])]
+
+# B Test error vs. training time
+
+Figure 4 shows the plots of test error vs. training time in our CIFAR-10 experiment.
+
+![](images/16182abaa61eb2491c74d1791275021b6cb0a5a33588bd499de658f57826f6d3.jpg)  
+Figure 4: Test error vs. training time for ResNet model (He et al., 2016) for CIFAR-10.
+
+C The official pre-trained ResNet model
+
+![](images/670ced69ed852252c2545e4ebf004a4911c911a0667c1ac6d6e75836cc91b167.jpg)  
+Figure 5: Plot of the singular values of the linear operators associated with the convolutional layers of the pretrained "ResNet V2" from the TensorFlow website.
+
+The singular values of the convolutional layers from the official “Resnet $\mathbf { V } 2 ^ { \mathbf { \mathfrak { s } } }$ pre-trained model (He et al., 2016) are plotted in Figure 5. The singular values are ordered by value. Only layers with kernels larger than $1 \times 1$ are plotted. The curves are plotted with a mixture of red and green; layers closer to the input are plotted with colors with a greater share of red. The transformations with the largest operator norms are closest to the inputs. As the data has undergone more rounds of processing, as we proceed through the layers, the number of non-negligible singular values increases for a while, but at the end, it tapers off.
+
+![](images/921efa0f13c6eee7ac71d664f437e5ccc2cc5a08dd2f7fe04e1bdf51684c6cc4.jpg)  
+Figure 6: Plot of the ratio of singular values to maximum singular value of the linear operators associated with the convolutional layers of the pretrained "ResNet V2" from the TensorFlow website.
+
+![](images/0f31db2c8ee9490026570859907e73364cf336b1887958a36edfcea9e824d188.jpg)  
+Figure 7: Plot of the ratio of singular values to maximum singular value of the linear operators associated with the convolutional layers of the pretrained "ResNet V2" normalized by size of the convolution.
+
+In Figure 5, we plotted the singular values ordered by value. It can be observed that while singular values in the first layer are much larger than the rest, many layers have a lot of singular values that are pretty big. For example, most of the layers have at least 10000 singular values that are at least 1. To give a complementary view, Figure 6 presents a plot of the ratios of the singular values in each layer with the largest singular value in that layer. We see that the effective rank of the convolutional layers is larger closer to the inputs.
+
+Figure 6 shows that different convolutional layers have significantly different numbers of non-negligible singular values. A question that may arise is to what extent this was due to the fact that different layers simply are of different sizes, so that the total number of their singular values, tiny or not, was different. To look into this, instead of plotting the singular value ratios as a function of the rank of the singular values, as in the Figure 6, we normalized the values on the horizontal axis by dividing by the total number of singular values. The result is shown in Figure 7.

parse/train/rJevYoA9Fm/rJevYoA9Fm_content_list.json

@@ -0,0 +1,1863 @@
+[
+    {
+        "type": "text",
+        "text": "The Singular Values of Convolutional Layers ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            710,
+            122
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hanie Sedghi, Vineet Gupta and Philip M. Long ",
+        "bbox": [
+            187,
+            148,
+            519,
+            164
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Google Brain   \nMountain View, CA 94043   \n{hsedghi,vineet,plong}@google.com ",
+        "bbox": [
+            184,
+            165,
+            468,
+            205
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            459,
+            242,
+            539,
+            257
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We characterize the singular values of the linear transformation associated with a standard 2D multi-channel convolutional layer, enabling their efficient computation. This characterization also leads to an algorithm for projecting a convolutional layer onto an operator-norm ball. We show that this is an effective regularizer; for example, it improves the test error of a deep residual network using batch normalization on CIFAR-10 from $6 . 2 \\%$ to $5 . 3 \\%$ . ",
+        "bbox": [
+            233,
+            273,
+            766,
+            358
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            386,
+            318,
+            402
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Exploding and vanishing gradients (Hochreiter, 1991; Hochreiter et al., 2001; Goodfellow et al., 2016) are fundamental obstacles to effective training of deep neural networks. Many deep networks used in practice are layered. We can think of such networks as the composition of a number of feature transformations, followed by a linear classifier on the final layer of features. The singular values of the Jacobian of a layer bound the factor by which it increases or decreases the norm of the backpropagated signal. If these singular values are all close to 1, then gradients neither explode nor vanish. These singular values also bound these factors in the forward direction, which affects the stability of computations, including whether the network produces the dreaded “Nan”. Moreover, it has been proven (Bartlett et al., 2017) that the generalization error for a network is bounded by the Lipschitz constant of the network, which in turn can be bounded by the product of the operator norms of the Jacobians of the layers. Cisse et al. (2017) discussed robustness to adversarial examples as a result of bounding the operator norm. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            585
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "These considerations have led authors to regularize networks by driving down the operator norms of network layers (Drucker and Le Cun, 1992; Hein and Andriushchenko, 2017; Yoshida and Miyato, 2017; Miyato et al., 2018). Orthogonal initialization (Saxe et al., 2013; Pennington et al., 2017) and Parseval networks (Cisse et al., 2017) are motivated by similar considerations. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            647
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional layers (LeCun et al., 1998) are key components of modern deep networks. They compute linear transformations of their inputs. The Jacobian of a linear transformation is always equal to the linear transformation itself. Because of the central importance of convolutional layers to the practice of deep learning, and the fact that the singular values of the linear transformation computed by a convolutional layer are the key to its contribution to exploding and vanishing gradients, we study these singular values. Up until now, authors seeking to control the operator norm of convolutional layers have resorted to approximations (Yoshida and Miyato, 2017; Miyato et al., 2018; Gouk et al., 2018a). In this paper, we provide an efficient way to compute the singular values exactly — this opens the door to various regularizers. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We consider the convolutional layers commonly applied to image analysis tasks. The input to a typical layer is a feature map, with multiple channels for each position in an $n \\times n$ field. If there are $m$ channels, then the input as a whole is a $m \\times n \\times n$ tensor. The output is also an $n \\times n$ field with multiple channels per position1. Each channel of the output is obtained by taking a linear combination of the values of the features in all channels in a local neighborhood centered at the corresponding position in the input feature map. Crucially, the same linear combination is used for all positions in the feature map. The coefficients are compiled in the kernel of the convolution. If the neighborhood is a $k \\times k$ region, a kernel $K$ is a $k \\times k \\times m \\times m$ tensor. The projection $K _ { : , : , c , }$ : gives the coefficients that determine the cth channel of the output, in terms of the values found in all of the channels of all positions in it neighborhood; $K _ { : , : , c , d }$ gives the coefficients to apply to the dth input channel, and $K _ { p , q , c , d }$ is the coefficient to apply to this input at in the position in the field offset horizontally by $p$ and vertically by $q$ . For ease of exposition, we assume that feature maps and local neighborhoods are square and that the number of channels in the output is equal to the number of channels in the input - the extension to the general case is completely straightforward. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To handle edge cases in which the offsets call for inputs that are off the feature maps, practical convolutional layers either do not compute outputs (reducing the size of the feature map), or pad the input with zeros. The behavior of these layers can be approximated by a layer that treats the input as if it were a torus; when the offset calls for a pixel that is off the right end of the image, the layer “wraps around” to take it from the left edge, and similarly for the other edges. The quality of this approximation has been heavily analyzed in the case of one-dimensional signals (Gray, 2006). Consequently, theoretical analysis of convolutions that wrap around has been become standard. This is the case analyzed in this paper. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Summary of Results: Our main result is a characterization of the singular values of a convolutional layer in terms of the kernel tensor $K$ . Our characterization enables these singular values to be computed exactly in a simple and practically fast way, using $O ( n ^ { 2 } m ^ { 2 } ( m + \\log n ) )$ time. For comparison, the brute force solution that performs SVD on the matrix that encodes the convolutional layer’s linear transformation would take $O ( ( n ^ { 2 } m ) ^ { 3 } ) = O ( n ^ { 6 } m ^ { 3 } )$ time, and is impractical for commonly used network sizes. As another point of comparison, simply to compute the convolution takes $O ( n ^ { 2 } m ^ { 2 } k ^ { 2 } )$ time. We prove that the following two lines of NumPy correctly compute the singular values. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            415
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "def SingularValues(kernel, input_shape): transforms $=$ np.fft.fft2(kernel, input_shape, axes $=$ [0, 1]) return np.linalg.svd(transforms, compute_uv=False) ",
+        "bbox": [
+            189,
+            425,
+            651,
+            463
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here kernel is any $k \\times k \\times m \\times m$ tensor2 and input_shape is the shape of the feature map to be convolved. A TensorFlow implementation is similarly simple. ",
+        "bbox": [
+            174,
+            474,
+            823,
+            502
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Timing tests, reported in Section 4.1, confirm that this characterization speeds up the computation of singular values by multiple orders of magnitude – making it usable in practice. The algorithm first performs $m ^ { 2 }$ FFTs, and then it performs ${ { \\bar { n } } ^ { 2 } }$ SVDs. The FFTs, and then the SVDs, may be executed in parallel. Our TensorFlow implementation runs a lot faster than the NumPy implementation (see Figure 1); we think that this parallelism is the cause. We used our code to compute the singular values of the convolutional layers of the official ResNet-v2 model released with TensorFlow (He et al., 2016). The results are described in Appendix C. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            608
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Exposing the singular values of a convolutional layer opens the door to a variety of regularizers for these layers, including operator-norm regularizers. In Section 4.2, we evaluate an algorithm that periodically projects each convolutional layer onto a operator-norm ball. Using the projections improves the test error from $6 . 2 \\%$ to $5 . 3 \\%$ on CIFAR-10. We evaluate bounding the operator norm with and without batchnorm and we see that regularizing the operator norm helps, even in the presence of batch normalization. Moreover, operator-norm regularization and batch normalization are not redundant, and neither dominates the other. They complement each other. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Related work: Prior to our work, authors have responded to the difficulty of computing the singular values of convolutional layers in various ways. Cisse et al. (2017) constrained the matrix to have orthogonal rows and scale the output of each layer by a factor of $( 2 k + 1 ) ^ { - \\frac { 1 } { 2 } }$ , for $k \\times k$ kernels. Gouk et al. (2018a;b) proposed regularizing using a per-mini-batch approximation to the operator norm. They find the largest ratio between the input and output of a layer in the minibatch, and then scale down the transformation (thereby scaling down all of the singular values, not just the largest ones) so that the new value of this ratio obeys a constraint. ",
+        "bbox": [
+            173,
+            727,
+            825,
+            827
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Yoshida and Miyato (2017) used an approximation of the operator norm of a reshaping of $K$ in place of the operator norm for the linear transformation associated with $K$ in their experiments. They reshape the given $k \\times k \\times m \\times m$ into a $m k ^ { 2 } \\times m$ matrix, and compute its largest singular value using a power iteration method, and use this as a substitute for the operator norm. While this provides a useful heuristic for regularization, the largest singular value of the reshaped matrix is often quite different from the operator norm of the linear transform associated with $K$ . Furthermore if we want to regularize using projection onto an operator-norm ball, we need the whole spectrum of the linear transformation (see Section 3). The reshaped $K$ has only $m$ singular values, whereas the linear transformation has $m n ^ { 2 }$ singular values of which $m n ^ { 2 } / 2$ are distinct except in rare degenerate cases. It is possible to project the reshaped $K$ onto an operator-norm ball by taking its SVD and clipping its singular values — we conducted experiments with this projection and report the results in Section 4.4. ",
+        "bbox": [
+            174,
+            833,
+            825,
+            890
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A close relative of our main result was independently discovered by Bibi et al. (2019, Lemma 2). ",
+        "bbox": [
+            173,
+            208,
+            805,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Overview of the Analysis: If the signal is 1D and there is a single input and output channel, then the linear transformation associated with a convolution is encoded by a circulant matrix, i.e., a matrix whose rows are circular shifts of a single row (Gray, 2006). For example, for a row $a = ( a _ { 1 } , a _ { 2 } , a _ { 3 } )$ , the circulant matrix $\\mathrm { c i r c } ( a )$ generated by $a$ is $\\left( \\begin{array} { l l l } { a _ { 0 } } & { a _ { 1 } } & { a _ { 2 } } \\\\ { a _ { 2 } } & { a _ { 0 } } & { a _ { 1 } } \\\\ { a _ { 1 } } & { a _ { 2 } } & { a _ { 0 } } \\end{array} \\right)$ . In the special case of a 2D signal with a single input channel and single output channel, the linear transformation is doubly block circulant (see (Goodfellow et al., 2016)). Such a matrix is made up of a circulant matrix of blocks, each of which in turn is itself circulant. Finally, when there are $m$ input channels and $m$ output channels, there are three levels to the hierarchy: there is a $m \\times m$ matrix of blocks, each of which is doubly block circulant. Our analysis extends tools from the literature built for circulant (Horn and Johnson, 2012) and doubly circulant (Chao, 1974) matrices to analyze the matrices with a third level in the hierarchy arising from the convolutional layers used in deep learning. One key point is that the eigenvectors of a circulant matrix are Fourier basis vectors: in the 2D, one-channel case, the matrix whose columns are the eigenvectors is $F \\otimes F$ , for the matrix $F$ whose columns form the Fourier basis. Multiplying by this matrix is a 2D Fourier transform. In the multi-channel case, we show that the singular values can be computed by (a) finding the eigenvalues of each of the $m ^ { 2 }$ doubly circulant matrices (of dimensions $n ^ { 2 } \\times n ^ { 2 }$ ) using a 2D Fourier transform, (b) by forming multiple $m \\times m$ matrices, one for each eigenvalue, by picking out the $i$ -th eigenvalue of each of the $n ^ { 2 } \\times n ^ { 2 }$ blocks, for $i \\in [ 1 . . n ^ { 2 } ]$ . The union of all of the singular values of all of those $m \\times m$ matrices is the multiset of singular values of the layer. ",
+        "bbox": [
+            173,
+            241,
+            826,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notation: We use upper case letters for matrices, lower case for vectors. For matrix $M , M _ { i }$ ,: represents the $i$ -th row and $M _ { : , j }$ represents the $j$ -th column; we will also use the analogous notation for higher-order tensors. The operator norm of $M$ is denoted by $| | { \\cal M } | | _ { 2 }$ . For $n \\in \\mathbb { N }$ , we use $[ n ]$ to denote the set $\\{ 0 , 1 , \\ldots , n - 1 \\}$ (instead of usual $\\{ 1 , \\ldots , n \\} )$ . We will index the rows and columns of matrices using elements of $[ n ]$ , i.e. numbering from 0. Addition of row and column indices will be done mod $n$ unless otherwise indicated. (Tensors will be treated analogously.) Let $\\sigma ( \\cdot )$ be the mapping from a matrix to (the multiset of) its singular values. 3 ",
+        "bbox": [
+            173,
+            541,
+            825,
+            638
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\omega = \\exp ( 2 \\pi i / n )$ , where $i = \\sqrt { - 1 }$ . (Because we need a lot of indices in this paper, our use of √ $i$ to define $\\omega$ is the only place in the paper where we will use $i$ to denote $\\sqrt { - 1 }$ .) ",
+        "bbox": [
+            174,
+            643,
+            821,
+            675
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $F$ be the $n \\times n$ matrix that represents the discrete Fourier transform: $F _ { i j } = \\omega ^ { i j }$ . We use $I _ { n }$ to denote the identity matrix of size $n \\times n$ . For $i \\in [ n ]$ , we use $e _ { i }$ to represent the ith basis vector in $\\mathbb { R } ^ { n }$ We use $\\otimes$ to represent the Kronecker product between two matrices (which also refers to the outer product of two vectors). ",
+        "bbox": [
+            174,
+            681,
+            825,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            762,
+            282,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 One filter ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            287,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As a warmup, we focus on the case that the number $m$ of input channels and output channels is 1. In this case, the filter coefficients are simply a $k \\times k$ matrix. It will simplify notation, however, if we embed this $k \\times k$ matrix in an $n \\times n$ matrix, by padding with zeroes (which corresponds to the fact that the offsets with those indices are not used). Let us refer to this $n \\times n$ matrix also as $K$ . ",
+        "bbox": [
+            174,
+            825,
+            825,
+            881
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An $n ^ { 2 } \\times n ^ { 2 }$ matrix $A$ is doubly block circulant if $A$ is a circulant matrix of $n \\times n$ blocks that are in turn circulant. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For a matrix $X$ , let $\\operatorname { v e c } ( X )$ be the vector obtained by stacking the columns of $X$ . ",
+        "bbox": [
+            173,
+            138,
+            705,
+            155
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1 (see Jain (1989) Section 5.5, Goodfellow et al. (2016) page 329) For any filter coefficients $K$ , the linear transform for the convolution by $K$ is represented by the following doubly block circulant matrix: ",
+        "bbox": [
+            173,
+            164,
+            825,
+            207
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf18dcaeb7ed4f6ee830b35407e9e346fbec023aebd221af99f64b4a5bf36ac1.jpg",
+        "text": "$$\n\\begin{array} { r } { A = \\left[ \\begin{array} { c c c c } { \\mathrm { c i r c } ( K _ { 0 , : } ) } & { \\mathrm { c i r c } ( K _ { 1 , : } ) } & { \\ldots } & { \\mathrm { c i r c } ( K _ { n - 1 , : } ) } \\\\ { \\mathrm { c i r c } ( K _ { n - 1 , : } ) } & { \\mathrm { c i r c } ( K _ { 0 , : } ) } & { \\ldots } & { \\mathrm { c i r c } ( K _ { n - 2 , : } ) } \\\\ { \\vdots } & { \\vdots } & { \\vdots } & { \\vdots } \\\\ { \\mathrm { c i r c } ( K _ { 1 , : } ) } & { \\mathrm { c i r c } ( K _ { 2 , : } ) } & { \\ldots } & { \\mathrm { c i r c } ( K _ { 0 , : } ) } \\end{array} \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            208,
+            694,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "That is, $i f X$ is an $n \\times n$ matrix, and $Y$ is the result of a 2-d convolution of $X$ with $K$ , i.e. ",
+        "bbox": [
+            173,
+            281,
+            758,
+            296
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2967315b55fc342e5bc9c604818ab2ceaab7d5c2c69c1e282cbeb4326e6319be.jpg",
+        "text": "$$\n\\forall i j , Y _ { i j } = \\sum _ { p \\in [ n ] } \\sum _ { q \\in [ n ] } X _ { i + p , j + q } K _ { p , q }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            299,
+            619,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "then $\\operatorname { v e c } ( Y ) = A \\operatorname { v e c } ( X ) .$ ",
+        "bbox": [
+            174,
+            340,
+            348,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "So now we want to determine the singular values of a doubly block circulant matrix. ",
+        "bbox": [
+            176,
+            367,
+            723,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We will make use of the characterization of the eigenvalues and eigenvectors of doubly block circulant matrices, which uses the following definition: $Q \\stackrel { \\mathrm { d e f } } { = } \\frac { 1 } { n } \\left( F \\otimes F \\right)$ . ",
+        "bbox": [
+            176,
+            388,
+            821,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2 (Jain (1989) Section 5.5) For any $n ^ { 2 } \\times n ^ { 2 }$ doubly block circulant matrix $A$ , the eigenvectors of $A$ are the columns of $Q$ . ",
+        "bbox": [
+            176,
+            433,
+            823,
+            464
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To get singular values in addition to eigenvalues, we need the following two lemmas. ",
+        "bbox": [
+            173,
+            473,
+            727,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3 (Jain (1989) Section 5.5) $Q$ is unitary. ",
+        "bbox": [
+            173,
+            497,
+            504,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Using Theorem 2 and Lemma 3, we can get the eigenvalues as the diagonal elements of $Q ^ { * } A Q$ . ",
+        "bbox": [
+            171,
+            523,
+            799,
+            540
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4 The matrix $A$ defined in equation $^ { l }$ is normal, i.e., $A ^ { T } A = A A ^ { T }$ . ",
+        "bbox": [
+            173,
+            549,
+            678,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proof: ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            577,
+            220,
+            590
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e0a170445ca8fc22ab0fc9c16bfc5bfdd84f9e1c9915cecdcec18d384badcef1.jpg",
+        "text": "$$\nA A ^ { T } = A A ^ { * } = Q ^ { * } D Q Q ^ { * } D ^ { * } Q = Q ^ { * } D D ^ { * } Q = Q ^ { * } D ^ { * } D Q = Q ^ { * } D ^ { * } Q Q ^ { * } D Q = A ^ { * } A = A ^ { T } A .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            594,
+            816,
+            613
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The following theorem characterizes the singular values of $A$ as a simple function of $K$ . As we will see, a characterization of the eigenvalues plays a major role. Chao (1974) provided a more technical characterization of the eigenvalues which may be regarded as making partial progress toward Theorem 5. However, we provide a proof from first principles, since it is the cleanest way we know to prove the theorem. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            708
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5 For the matrix $A$ defined in equation $I$ , the eigenvalues of $A$ are the entries of $F ^ { T } K F$ and its singular values are their magnitudes. That is, the singular values of $A$ are ",
+        "bbox": [
+            171,
+            718,
+            825,
+            748
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b4489f66523ab07dc89a4fad1abc9688d1b38e90bf9b0cf0902794ae693203c.jpg",
+        "text": "$$\n\\left\\{ \\left| ( F ^ { T } K F ) _ { u , v } \\right| \\ : \\ u , v \\in [ n ] \\right\\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            751,
+            606,
+            771
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proof: By Theorems 2 and Lemma 3, the eigenvalues of $A$ are the diagonal elements of $Q ^ { * } A Q =$ $\\mathring { \\neg } ( F ^ { * } \\otimes \\bar { F } ^ { * } ) A ( F \\otimes F )$ . If we view $( F ^ { * } \\otimes F ^ { * } ) A ( F \\otimes F )$ as a compound $n \\times n$ matrix of $n \\times n$ blocks, for $u , v \\in [ n ]$ , the $( u n + v )$ th diagonal element is the $v$ th element of the $u$ th diagonal block. Let us first evaluate the uth diagonal block. Using $i , j$ to index blocks, we have ",
+        "bbox": [
+            174,
+            780,
+            825,
+            838
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2e9ab1c263360c17e4bb4073a14e684eb58fc40eace4c38eb96c6d3137d9219.jpg",
+        "text": "$$\n\\begin{array} { l } { { ( Q ^ { * } A Q ) _ { u u } = \\displaystyle \\frac { 1 } { n ^ { 2 } } \\sum _ { i , j \\in [ n ] } ( F ^ { * } \\otimes F ^ { * } ) _ { u i } A _ { i j } ( F \\otimes F ) _ { j u } = \\displaystyle \\frac { 1 } { n ^ { 2 } } \\sum _ { i , j \\in [ n ] } \\omega ^ { - u i } F ^ { * } \\mathrm { c i r c } ( K _ { j - i , \\cdot } ) \\omega ^ { j u } F } } \\\\ { { = \\displaystyle \\frac { 1 } { n ^ { 2 } } \\sum _ { i , j \\in [ n ] } \\omega ^ { u ( j - i ) } F ^ { * } \\mathrm { c i r c } ( K _ { j - i , \\cdot } ) F . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            840,
+            803,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To get the $v$ th element of the diagonal of (4), we may sum the vth elements of the diagonals of each of its terms. Toward this end, we have ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/80a0689efbdd7472da0a56701fe521988ac42d92e59bd41cf6849e9a2d524dc8.jpg",
+        "text": "$$\n( F ^ { * } \\mathrm { c i r c } ( K _ { j - i , : } ) F ) _ { v v } = \\sum _ { r , s \\in [ n ] } \\omega ^ { - v r } \\mathrm { c i r c } ( K _ { j - i , : } ) _ { r s } \\omega ^ { s v } = \\sum _ { r , s \\in [ n ] } \\omega ^ { v ( s - r ) } K _ { j - i , s - r } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            136,
+            772,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Substituting into (4), we get $\\begin{array} { r } { \\frac { 1 } { n ^ { 2 } } \\sum _ { i , j , r , s \\in [ n ] } \\omega ^ { u ( j - i ) } \\omega ^ { v ( s - r ) } K _ { j - i , s - r } . } \\end{array}$ . Collecting terms where $j - i =$ $p$ and $s - r = q$ , this is $\\begin{array} { r } { \\sum _ { p , q \\in [ n ] } \\omega ^ { u p } \\omega ^ { v q } K _ { p , q } = ( F ^ { T } K F ) _ { u v } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            199,
+            825,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since the singular values of any normal matrix are the magnitudes of its eigenvalues (Horn and Johnson (2012) page 158), applying Lemma 4 completes the proof. □ ",
+        "bbox": [
+            174,
+            242,
+            825,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that $F ^ { T } K F$ is the 2D Fourier transform of $K$ , and recall that $| | A | | _ { 2 }$ is the largest singular value of $A$ . ",
+        "bbox": [
+            173,
+            276,
+            825,
+            306
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2 Multi-channel convolution ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            323,
+            415,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now, we consider case where the number $m$ of channels may be more than one. Assume we have a 4D kernel tensor $K$ with element $K _ { p , q , c , d }$ giving the connection strength between a unit in channel $d$ of the input and a unit in channel $c$ of the output, with an offset of $p$ rows and $q$ columns between the input unit and the output unit. The input $X \\in \\mathbb { R } ^ { m \\times n \\times n }$ ; element $X _ { d , i , j }$ is the value of the input unit within channel $d$ at row $i$ and column $j$ . The output $Y \\in \\mathbb { R } ^ { m \\times n \\times n }$ has the same format as $X$ , and is produced by ",
+        "bbox": [
+            173,
+            348,
+            826,
+            433
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15ce5e4b0763da1fc3e28dee2e70e520f6f63e30ad16c3c59868c993d599aa35.jpg",
+        "text": "$$\nY _ { c r s } = \\sum _ { d \\in [ m ] } \\sum _ { p \\in [ n ] } \\sum _ { q \\in [ n ] } X _ { d , r + p , s + q } K _ { p , q , c , d } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            439,
+            643,
+            476
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By inspection, $\\operatorname { v e c } ( Y ) = M \\operatorname { v e c } ( X )$ , where $M$ is as follows ",
+        "bbox": [
+            173,
+            489,
+            566,
+            506
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/57a2ed388c1b005e298cd2a7fc808a56a6ede79262b9f2614102fa1228c4f9a7.jpg",
+        "text": "$$\n{ \\cal M } = \\left[ \\begin{array} { c c c c } { { B _ { 0 0 } } } & { { B _ { 0 1 } } } & { { \\dots } } & { { B _ { 0 ( m - 1 ) } } } \\\\ { { B _ { 1 0 } } } & { { B _ { 1 1 } } } & { { \\dots } } & { { B _ { 1 ( m - 1 ) } } } \\\\ { { \\vdots } } & { { \\vdots } } & { { \\ddots } } & { { \\vdots } } \\\\ { { B _ { ( m - 1 ) 0 } } } & { { B _ { ( m - 1 ) 1 } } } & { { \\dots } } & { { B _ { ( m - 1 ) ( m - 1 ) } } } \\end{array} \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            511,
+            676,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and each $B _ { c d }$ is a doubly block circulant matrix from Lemma 1 corresponding to the portion $K _ { : , : , c , d }$ of $K$ that concerns the effect of the $d$ -th input channel on the $c$ -th output channel. (We can think of each output in the multichannel case as being a sum of single channel filters parameterized by one of the $K _ { : , : , c , d }$ ’s.) ",
+        "bbox": [
+            176,
+            587,
+            821,
+            643
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The following is our main result. ",
+        "bbox": [
+            174,
+            650,
+            388,
+            665
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 6 For any $K \\in \\mathbb { R } ^ { n \\times n \\times m \\times m }$ , let $M$ is the matrix encoding the linear transformation computed by a convolutional layer parameterized by $K$ , defined as in (6). For each $u , v \\in [ n ] \\times [ n ]$ , let $P ^ { ( u , v ) }$ be the $m \\times m$ matrix given by $P _ { c d } ^ { ( u , v ) } = ( F ^ { T } K _ { : , : , c , d } F ) _ { u v }$ . Then ",
+        "bbox": [
+            173,
+            675,
+            826,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92bb344dd01a8020b9b0e72299336f4d1c04d9ad06e856b2b9b8a8bd2270211f.jpg",
+        "text": "$$\n\\sigma ( M ) = \\bigcup _ { u \\in [ n ] , v \\in [ n ] } \\sigma \\left( P ^ { ( u , v ) } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            729,
+            607,
+            767
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The rest of this section is devoted to proving Theorem 6 through a series of lemmas. ",
+        "bbox": [
+            173,
+            780,
+            723,
+            796
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The analysis of Section 2.1 implies that for all $c , d \\in [ m ]$ , $D _ { c d } \\stackrel { \\mathrm { d e f } } { = } Q ^ { * } B _ { c d } Q$ is diagonal. Define ",
+        "bbox": [
+            171,
+            804,
+            792,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65790b5844631b07b810021de78a672668fde36ad1720ec8da8dae3eb663907b.jpg",
+        "text": "$$\n\\begin{array} { r } { L \\stackrel { \\mathrm { d e f } } { = } \\left[ \\begin{array} { c c c c } { D _ { 0 0 } } & { D _ { 0 1 } } & { . . . } & { D _ { 0 ( m - 1 ) } } \\\\ { D _ { 1 0 } } & { D _ { 1 1 } } & { . . . } & { D _ { 1 ( m - 1 ) } } \\\\ { \\vdots } & { \\vdots } & { . . . } & { \\vdots } \\\\ { D _ { ( m - 1 ) 0 } } & { D _ { ( m - 1 ) 1 } } & { . . . } & { D _ { ( m - 1 ) ( m - 1 ) } } \\end{array} \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            828,
+            681,
+            900
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 7 $M$ and $L$ have the same singular values. ",
+        "bbox": [
+            173,
+            909,
+            514,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proof: We have ",
+        "bbox": [
+            173,
+            103,
+            282,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5f52efe46a6ad162972562edc581b86502cd29065dc00dbf98751a1804dcf681.jpg",
+        "text": "$$\n\\begin{array} { r l } & { M = \\left[ \\begin{array} { c c c } { B _ { 0 0 } } & { \\ldots } & { B _ { 0 ( m - 1 ) } } \\\\ { \\vdots } & { \\vdots } & { \\vdots } \\\\ { B _ { ( m - 1 ) 0 } } & { \\ldots } & { B _ { ( m - 1 ) ( m - 1 ) } } \\end{array} \\right] = \\left[ \\begin{array} { c c c } { Q D _ { 0 0 } Q ^ { * } } & { \\ldots } & { Q D _ { 0 ( m - 1 ) } Q ^ { * } } \\\\ { \\vdots } & { \\vdots } & { \\vdots } \\\\ { Q D _ { ( m - 1 ) 0 } Q ^ { * } } & { \\ldots } & { Q D _ { ( m - 1 ) ( m - 1 ) } Q ^ { * } } \\end{array} \\right] } \\\\ & { \\quad \\quad = R \\left[ \\begin{array} { c c c } { D _ { 0 0 } } & { \\ldots } & { D _ { 0 ( m - 1 ) } } \\\\ { \\vdots } & { \\vdots } & { \\vdots } \\\\ { D _ { ( m - 1 ) 0 } } & { \\ldots } & { D _ { ( m - 1 ) ( m - 1 ) } } \\end{array} \\right] R ^ { * } = R L R ^ { * } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            117,
+            808,
+            236
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $R \\stackrel { \\mathrm { d e f } } { = } I _ { m } \\otimes Q$ . Note that $R$ is unitary because ",
+        "bbox": [
+            173,
+            239,
+            516,
+            257
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61c941174a79ab0bf6640d73ba1b7a8606b2f94303eba99c688ed4e6ca6823d4.jpg",
+        "text": "$$\nR R ^ { * } = ( I _ { m } \\otimes Q ) ( I _ { m } \\otimes Q ^ { * } ) = ( I _ { m } I _ { m } ) \\otimes ( Q Q ^ { * } ) = I _ { m n ^ { 2 } } ;\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            261,
+            694,
+            279
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "this implies that $M$ and $L$ have the same singular values. ",
+        "bbox": [
+            173,
+            281,
+            547,
+            296
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "So now we have as a subproblem characterizing the singular values of a block matrix whose blocks are diagonal. To express the the characterization, it helps to reshape the nonzero elements of $L$ into a $m \\times \\overline { { m \\times n ^ { 2 } } }$ tensor $G$ as follows: $G _ { c d w } = ( D _ { c d } ) _ { w w }$ . ",
+        "bbox": [
+            173,
+            303,
+            826,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 8 $\\sigma ( L ) = \\bigcup _ { w \\in [ n ^ { 2 } ] } \\sigma \\left( G _ { : , : , w } \\right) .$ . ",
+        "bbox": [
+            173,
+            354,
+            429,
+            383
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof: Choose an arbitrary $w \\in [ n ^ { 2 } ]$ , and a (scalar) singular value $\\sigma$ of $G _ { : , : , w }$ whose left singular vector is $x$ and whose right singular vector is $y$ , so that $G _ { : , : , w } y = \\sigma x$ . Recall that $e _ { w } \\in \\mathbb { R } ^ { n ^ { 2 } }$ is a standard basis vector. ",
+        "bbox": [
+            173,
+            395,
+            826,
+            440
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We claim that $L ( y \\otimes e _ { w } ) = \\sigma ( x \\otimes e _ { w } )$ . Since $D _ { c d }$ is diagonal, $D _ { c d } e _ { w } = ( D _ { c d } ) _ { w w } e _ { w } = G _ { c d w } e _ { w }$ Thus we have $\\begin{array} { r } { ( L ( y \\otimes e _ { w } ) ) _ { c } = \\sum _ { d \\in [ m ] } D _ { c d } y _ { d } e _ { w } = ( \\sum _ { d \\in [ m ] } G _ { c d w } y _ { d } ) e _ { w } = ( G _ { : , : , w } y ) _ { c } e _ { w } = \\sigma x _ { c } e _ { w } , } \\end{array}$ which shows that ",
+        "bbox": [
+            173,
+            446,
+            826,
+            492
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5c684470f1adc3a7d28b32c0a35b20298ae91e534f499c93328da3c8cf90d593.jpg",
+        "text": "$$\n{ \\boldsymbol { \\zeta } } ( y \\otimes e _ { w } ) = \\left[ { \\begin{array} { c c c c } { D _ { 0 0 } } & { \\ldots } & { D _ { 0 ( m - 1 ) } } \\\\ { D _ { 1 0 } } & { \\ldots } & { D _ { 1 ( m - 1 ) } } \\\\ { \\vdots } & { \\ldots } & { \\vdots } \\\\ { D _ { ( m - 1 ) 0 } } & { \\ldots } & { D _ { ( m - 1 ) ( m - 1 ) } } \\end{array} } \\right] \\left[ { \\begin{array} { c } { y _ { 0 } e _ { w } } \\\\ { \\vdots } \\\\ { y _ { m - 1 } e _ { w } } \\end{array} } \\right] = \\left[ { \\begin{array} { c } { \\sigma x _ { 0 } e _ { w } } \\\\ { \\vdots } \\\\ { \\sigma x _ { m - 1 } e _ { w } } \\end{array} } \\right] = \\sigma ( x \\otimes e _ { w } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            492,
+            830,
+            563
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "If $\\tilde { \\sigma }$ is another singular value of $G _ { : , : , w }$ with a left singular vector $\\tilde { x }$ and a right singular vector $\\tilde { y }$ , then $\\langle ( x \\otimes e _ { w } ) , ( \\tilde { x } \\otimes e _ { w } ) \\rangle = \\langle x , \\tilde { x } \\rangle = 0$ and, similarly $\\langle ( y \\otimes e _ { w } ) , ( \\tilde { y } \\otimes e _ { w } ) \\rangle = 0$ . Also, $\\langle ( x \\otimes e _ { w } ) , ( x \\otimes e _ { w } ) \\rangle = 1$ and $\\langle ( y \\otimes e _ { w } ) , ( y \\otimes e _ { w } ) \\rangle = 1$ . ",
+        "bbox": [
+            174,
+            565,
+            825,
+            609
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For any $x$ and $\\tilde { x }$ , whether they are equal or not, if $w \\ne \\tilde { w }$ , then $\\langle ( x \\otimes e _ { w } ) , ( \\tilde { x } \\otimes e _ { \\tilde { w } } ) \\rangle = 0$ , simply because their non-zero components do not overlap. ",
+        "bbox": [
+            171,
+            613,
+            823,
+            643
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Thus, by taking the Kronecker product of each singular vector of $G _ { : , : , w }$ with $e _ { w }$ and assembling the results for various $w$ , we may form a singular value decomposition of $L$ whose singular values are $\\cup _ { w \\in [ n ^ { 2 } ] } \\sigma ( G _ { : , : , w } ) .$ . This completes the proof. □ ",
+        "bbox": [
+            173,
+            648,
+            826,
+            693
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Using Lemmas 7 and Theorem 8, we are now ready to prove Theorem 6. ",
+        "bbox": [
+            174,
+            698,
+            650,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof (of Theorem 6). Recall that, for each input channel $c$ and output channel $d$ , the diagonal elements of $D _ { c , d }$ are the eigenvalues of $B _ { c , d }$ . By Theorem 5, this means that the diagonal elements of $D _ { c , d }$ are ",
+        "bbox": [
+            173,
+            719,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/927892efd2938938398dd616b62d4f51343f81de6401ba11bddab1f3c4ae0bd7.jpg",
+        "text": "$$\n\\{ ( F ^ { T } K _ { : , : , c , d } F ) _ { u , v } : u , v \\in [ n ] \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            761,
+            606,
+            780
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The elements of (9) map to the diagonal elements of $D _ { c , d }$ as follows: ",
+        "bbox": [
+            174,
+            780,
+            622,
+            796
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d734bd88d925709d70e2529f5b104b85cdce91e333790b04126aecc05d79c81.jpg",
+        "text": "$$\nG _ { c d w } = ( D _ { c , d } ) _ { w w } = ( F ^ { T } K _ { : , : , c , d } F ) _ { \\lfloor w / m \\rfloor , w \\mod m }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            799,
+            673,
+            819
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "and thus ",
+        "bbox": [
+            173,
+            821,
+            232,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad493def1cb3947e724c83755400ef3cf2636413c69f50f9080b19deaa6feac6.jpg",
+        "text": "$$\nG _ { : , : , w } = \\left( ( F ^ { T } K _ { : , : , c , d } F ) _ { \\lfloor w / m \\rfloor , w \\mod m } \\right) _ { c d }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            832,
+            647,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which in turn implies ",
+        "bbox": [
+            173,
+            853,
+            316,
+            867
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6a6e06ab68764df63f7221d18344133bd37a91f93d563b9a3cd832d77e51e91.jpg",
+        "text": "$$\n\\bigcup _ { w \\in [ n ^ { 2 } ] } \\sigma ( G _ { : , : , w } ) = \\cup _ { u \\in [ n ] , v \\in [ n ] } \\sigma \\left( \\left( ( F ^ { T } K _ { : , : , c , d } F ) _ { u , v } \\right) _ { c d } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            871,
+            691,
+            906
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Applying Lemmas 7 and 8 completes the proof. ",
+        "bbox": [
+            173,
+            909,
+            486,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 Regularization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            339,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now show how to use the spectrum computed above to project a convolution onto the set of convolutions with bounded operator norm. We exploit the following key fact. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            164
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Proposition 9 (Lefkimmiatis et al. (2013), Proposition 1) Let $A \\in \\mathbb { R } ^ { n \\times n }$ , and let $A = U D V ^ { \\top }$ be its singular value decomposition. Let $\\tilde { A } = U \\tilde { D } \\bar { V } ^ { \\top }$ , where, for all $i \\in [ n ] , \\tilde { D } _ { i i } = \\operatorname* { m i n } ( D _ { i i } , c )$ and $B = \\{ X \\mid | X | | _ { 2 } \\leq c \\}$ . Then $\\tilde { A }$ is the projection of $A$ onto $\\boldsymbol { B }$ ; i.e. ${ \\tilde { A } } = \\underset { X \\in \\mathcal { B } } { \\arg \\operatorname* { m i n } } \\ | | A - X | | _ { F } .$ . ",
+        "bbox": [
+            174,
+            176,
+            825,
+            233
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This implies that the desired projection can be obtained by clipping the singular values of linear transformation associated with a convolutional layer to the interval $[ 0 , c ]$ . Note that the eigenvectors remained the same in the proposition, hence the projected matrix is still generated by a convolution. However, after the projection, the resulting convolution neighborhood may become as large as $n \\times n$ . On the other hand, we can project this convolution onto the set of convolutions with $k \\times k$ neighborhoods, by zeroing out all other coefficients. NumPy code for this is in Appendix A. ",
+        "bbox": [
+            174,
+            246,
+            825,
+            329
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Repeatedly alternating the two projections would give a point in the intersection of the two sets, i.e., a $k \\times k$ convolution with bounded operator norm (Cheney and Goldstein (1959) Theorem 4, Boyd and Dattorro (2003) Section 2), and the projection onto that intersection could be found using the more complicated Dykstra’s projection algorithm (Boyle and Dykstra, 1986). ",
+        "bbox": [
+            174,
+            337,
+            825,
+            392
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When we wish to control the operator norm during an iterative optimization process, however, repeating the alternating projections does not seem to be worth it – we found that the first two projections already often produced a convolutional layer with an operator norm close to the desired value. Furthermore, because SGD does not change the parameters very fast, we can think of a given pair of projections as providing a warm start for the next pair. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In practice, we run the two projections once every few steps, thus letting the projection alternate with the training. ",
+        "bbox": [
+            171,
+            476,
+            825,
+            505
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            527,
+            312,
+            545
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First, we validated Theorem 6 with unit tests in which the output of the code given in the introduction is compared with evaluating the singular values by constructing the full matrix encoding the linear transformation corresponding to the convolutional layer and computing its SVD. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Timing ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            626,
+            261,
+            638
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We generated 4D tensors of various shapes with random standard normal values, and computed their singular values using the full matrix method, the NumPy code given above and the equivalent TensorFlow code. For small tensors, the NumPy code was faster than TensorFlow, but for larger tensors, the TensorFlow code was able to exploit the parallelism in the algorithm and run much faster on a GPU. The timing results are shown in Figure 1. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Regularization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            743,
+            325,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We next explored the effect of regularizing the convolutional layers by clipping their operator norms as described in Section 3. We ran the CIFAR-10 benchmark with a standard 32 layer residual network with 2.4M training parameters; (He et al., 2016). This network reached a test error rate of $6 . 2 \\%$ after 250 epochs, using a learning rate schedule determined by a grid search (shown by the gray plot in Figure 2). We then evaluated an algorithm that, every 100 steps, clipped the norms of the convolutional layers to various different values between 0.1 and 3.0. As expected, clipping to 2.5 and 3.0 had little impact on the performance, since the norms of the convolutional layers were between 2.5 and 2.8. Clipping to 0.1 yielded a surprising $6 . 7 \\%$ test error, whereas clipping to 0.5 and 1.0 yielded test errors of $5 . 3 \\%$ and $5 . 5 \\%$ respectively (shown in Figure 2). A plot of test error against training time is provided in Figure 4 in Appendix B, showing that the projections did not slow down the training very much. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5ca872dd9b2f7dda8d75174026703ad85648d97a4e1cc3686f4dfd1cc25ddd1f.jpg",
+        "image_caption": [
+            "Figure 1: Time used to compute singular values. The left graph is for a $3 \\times 3$ convolution on a $1 6 \\times 1 6$ image with the number of input/output channels on the $x$ -axis. The right graph is for a $1 1 \\times 1 1$ convolution on a $6 4 \\times 6 4$ image (no curve for full matrix method is shown as this method could not complete in a reasonable time for these inputs). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            101,
+            816,
+            297
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/aef8fcd02dda25632a62ea916f9c61667a60909bec96589f9dd4a13662ccd92a.jpg",
+        "image_caption": [
+            "Figure 2: Training loss and test error for ResNet model (He et al., 2016) for CIFAR-10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            395,
+            821,
+            594
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Robustness to changes in hyperparameters ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            652,
+            524,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The baseline algorithm studied in the previous subsection used batch normalization. Batch normalization tends to make the network less sensitive to linear transformations with large operator norms. However, batch normalization includes trainable scaling parameters (called $\\gamma$ in the original paper) that are applied after the normalization step. The existence of these parameters lead to a complicated interaction between batch normalization and methods like ours that act to control the norm of the linear transformation applied before batch normalization. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            762
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Because the effect of regularizing the operator norm is more easily understood in the absence of batch normalization, we also performed experiments with a baseline that did not use batch normalization. ",
+        "bbox": [
+            174,
+            770,
+            823,
+            797
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another possibility that we wanted to study was that using a regularizer may make the process overall more stable, enabling a larger learning rate. We were generally interested in whether operator-norm regularization made the training process more robust to the choice of hyperparameters. ",
+        "bbox": [
+            176,
+            805,
+            825,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In one experiment, we started with the same baseline as the previous subsection, but disabled batch normalization. This baseline started with a learning rate of 0.1, which was multiplied by a factor 0.95 after every epoch. We tried all combinations of the following hyperparameters: (a) the norm of the ball projected onto (no projection, 0.5, 1.0, 1.5, 2.0); (b) the initial learning rate (0.001, 0.003, 0.01, 0.03, 0.1); (c) the minibatch size (32, 64); (d) the number of epochs per decay of the learning rate (1,2,3). We tried each of the 150 combinations of the hyperparameters, trained for 100 epochs, and measured the test error. The results are plotted in Figure 3a. The operator norm regularization improved the best result, and also made the process more robust to the choice of hyperparameters. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/0a6350eb054416feb2a9f086e2abc8aab36e4eed2bd1744a93c2d6e1d99dc11c.jpg",
+        "image_caption": [
+            "Figure 3: A scatterplot of the test errors obtained with different hyperparameter combinations, and different operator-norm regularizers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            148,
+            790,
+            337
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            391,
+            813,
+            406
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We conducted a similar experiment in the presence of batch normalization, except using learning rates 0.01, 0.03, 0.1, 0.2, and 0.3. Those results are shown in Figure 3b. Regularizing the operator norm helps, even in the presence of batch normalization. ",
+        "bbox": [
+            176,
+            412,
+            820,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It appears that operator-norm regularization and batch normalization are not redundant, and neither dominates the other. We were surprised by this. ",
+        "bbox": [
+            173,
+            462,
+            823,
+            489
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Comparison with reshaping $K$ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            507,
+            426,
+            520
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Section 1 we mentioned that Yoshida and Miyato (2017) approximated the linear transformation induced by $K$ by reshaping $K$ . This leads to an alternate regularization method — we compute the spectrum of the reshaped $K$ , and project it onto a ball using clipping, as above. We implemented this an experimented with it using the same network and hyperparameters as in Section 4.2 and found the following. ",
+        "bbox": [
+            176,
+            532,
+            825,
+            603
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• We clipped the singular values of the reshaped $K$ every 100 steps. We tried various constants for the clipped value (0.05, 0.1, 0.2, 0.5, 1.0), and found that the best accuracy we achieved, using 0.2, was the same as the accuracy we achieved in Section 4.2. • We clipped the singular values of the reshaped $K$ to these same values every step, and found that the best accuracy achieved was slightly worse than the accuracy achieved in the previous step. We observed similar behavior when we clipped norms using our method. • Most surprisingly, we found that clipping norms by our method on a GPU was about $2 5 \\%$ faster than clipping the singular values of the reshaped $K$ — when we clipped after every step, on the same machine, 10000 batches of CIFAR10 took 14490 seconds when we clipped the reshaped $K$ , whereas they took 11004 seconds with our exact method! One possible explanation is parallelization — clipping reshaped $K$ takes $O ( m ^ { 3 } k ^ { 2 } )$ flops, whereas our method does $m ^ { 2 }$ FFTs, followed by $\\bar { n ^ { 2 } } m \\times m$ SVDs, which takes $O ( m ^ { 3 } n ^ { 2 } )$ flops, but these can be parallelized and completed in as little as $O ( n ^ { 2 } \\log n + m ^ { 3 } )$ time. ",
+        "bbox": [
+            217,
+            614,
+            825,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Clearly this is only one dataset, and the results may not generalize to other sets. However it does suggest that finding the full spectrum of the convolutional layer may be no worse than computing heuristic approximations, both in classification accuracy and speed. ",
+        "bbox": [
+            176,
+            815,
+            823,
+            858
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            877,
+            374,
+            893
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank Tomer Koren, Nishal Shah, Yoram Singer and Chiyuan Zhang for valuable conversations. ",
+        "bbox": [
+            171,
+            909,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            274,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "P. L. Bartlett, D. J. Foster, and M. J. Telgarsky. Spectrally-normalized margin bounds for neural networks. In NIPS, pages 6240–6249, 2017. ",
+        "bbox": [
+            174,
+            123,
+            825,
+            150
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adel Bibi, Bernard Ghanem, Vladlen Koltun, and Rene Ranftl. Deep layers as stochastic solvers. ICLR, 2019. ",
+        "bbox": [
+            171,
+            157,
+            826,
+            172
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Boyd and J. Dattorro. Alternating projections, 2003. https://web.stanford.edu/class/ee392o/alt_proj.pdf. ",
+        "bbox": [
+            169,
+            179,
+            872,
+            194
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. P. Boyle and R. L. Dykstra. A method for finding projections onto the intersection of convex sets in hilbert spaces. In Advances in order restricted statistical inference, pages 28–47. Springer, 1986. ",
+        "bbox": [
+            173,
+            200,
+            828,
+            228
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "C. Chao. A note on block circulant matrices. Kyungpook Mathematical Journal, 14:97–100, 1974. ",
+        "bbox": [
+            173,
+            234,
+            758,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "W. Cheney and A. A. Goldstein. Proximity maps for convex sets. Proceedings of the American Mathematical Society, 10(3):448–450, 1959. ISSN 00029939, 10886826. URL http://www.jstor.org/stable/ 2032864. ",
+        "bbox": [
+            173,
+            256,
+            830,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. Cisse, P. Bojanowski, E. Grave, Y. Dauphin, and N. Usunier. Parseval networks: Improving robustness to adversarial examples. ICML, 2017. ",
+        "bbox": [
+            169,
+            301,
+            825,
+            329
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "H. Drucker and Y. Le Cun. Improving generalization performance using double backpropagation. IEEE Transactions on Neural Networks, 3(6):991–997, 1992. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            363
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "I. Goodfellow, Y. Bengio, and A. Courville. Deep Learning. MIT Press, 2016. http://www. deeplearningbook.org. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            398
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "H. Gouk, E. Frank, B. Pfahringer, and M. Cree. Regularisation of neural networks by enforcing lipschitz continuity. arXiv preprint arXiv:1804.04368, 2018a. ",
+        "bbox": [
+            173,
+            405,
+            823,
+            431
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "H. Gouk, B. Pfahringer, E. Frank, and M. Cree. MaxGain: Regularisation of neural networks by constraining activation magnitudes. arXiv preprint arXiv:1804.05965, 2018b. ",
+        "bbox": [
+            171,
+            438,
+            825,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "R. M. Gray. Toeplitz and circulant matrices: A review. Foundations and Trends® in Communications and Information Theory, 2(3):155–239, 2006. ",
+        "bbox": [
+            174,
+            472,
+            823,
+            500
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pages 630–645. Springer, 2016. http://download.tensorflow.org/models/official/resnet_v2_imagenet_checkpoint.tar.gz; downloaded on on 5/1/18. ",
+        "bbox": [
+            174,
+            506,
+            831,
+            558
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. Hein and M. Andriushchenko. Formal guarantees on the robustness of a classifier against adversarial manipulation. In NIPS, pages 2266–2276, 2017. ",
+        "bbox": [
+            169,
+            565,
+            825,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Hochreiter. Untersuchungen zu dynamischen neuronalen netzen. Diploma, Technische Universität München, 91:1, 1991. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Hochreiter, Y. Bengio, P. Frasconi, J. Schmidhuber, et al. Gradient flow in recurrent nets: the difficulty of learning long-term dependencies, 2001. ",
+        "bbox": [
+            173,
+            633,
+            823,
+            661
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "R. A. Horn and C. R. Johnson. Matrix Analysis. Cambridge University Press, New York, NY, USA, 2nd edition, 2012. ISBN 0521548233, 9780521548236. ",
+        "bbox": [
+            171,
+            666,
+            825,
+            694
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. K. Jain. Fundamentals of digital image processing. Englewood Cliffs, NJ: Prentice Hall„ 1989. ",
+        "bbox": [
+            171,
+            700,
+            758,
+            717
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            176,
+            723,
+            828,
+            750
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Lefkimmiatis, J. P. Ward, and M. Unser. Hessian Schatten-norm regularization for linear inverse problems. IEEE transactions on image processing, 22(5):1873–1888, 2013. ",
+        "bbox": [
+            169,
+            756,
+            825,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "T. Miyato, T. Kataoka, M. Koyama, and Y. Yoshida. Spectral normalization for generative adversarial networks. ICLR, 2018. ",
+        "bbox": [
+            174,
+            790,
+            823,
+            818
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. Pennington, S. Schoenholz, and S. Ganguli. Resurrecting the sigmoid in deep learning through dynamical isometry: theory and practice. In Advances in neural information processing systems, pages 4788–4798, 2017. ",
+        "bbox": [
+            173,
+            824,
+            825,
+            852
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. M. Saxe, J. L. McClelland, and S. Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv preprint arXiv:1312.6120, 2013. ",
+        "bbox": [
+            173,
+            858,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Y. Yoshida and T. Miyato. Spectral norm regularization for improving the generalizability of deep learning. arXiv preprint arXiv:1705.10941, 2017. ",
+        "bbox": [
+            171,
+            892,
+            823,
+            920
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A NumPy code for operator norm projection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            578,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "def Clip_OperatorNorm(kernel, input_shape, clip_to): transform_coefficients $=$ np.fft.fft2(kernel, input_shape, axes $\\displaystyle { \\varepsilon }$ [0, 1]) U, D, $\\texttt { V } =$ np.linalg.svd(transform_coefficients, compute_uv $\\mathbf { \\bar { \\Pi } } = \\mathbf { \\bar { \\Pi } }$ True, full_matrices $\\underline { { \\underline { { \\mathbf { \\Pi } } } } }$ False) D_clipped $=$ np.minimum(D, clip_to) ",
+        "bbox": [
+            171,
+            133,
+            923,
+            190
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "if kernel.shape[2] $>$ kernel.shape[3]: ",
+        "bbox": [
+            196,
+            190,
+            508,
+            203
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "clipped_transform_coefficients $=$ np.matmul(U, D_clipped[..., None] \\* V) else: ",
+        "bbox": [
+            183,
+            204,
+            820,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "clipped_transform_coefficients $=$ np.matmul(U \\* D_clipped[..., None, :], V) clipped_kernel $=$ np.fft.ifft2(clipped_transform_coefficients, axes $=$ [0, 1]).real return clipped_kernel[np.ix_(\\*[range(d) for d in kernel.shape])] ",
+        "bbox": [
+            191,
+            231,
+            870,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B Test error vs. training time ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            294,
+            450,
+            309
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the plots of test error vs. training time in our CIFAR-10 experiment. ",
+        "bbox": [
+            173,
+            325,
+            718,
+            340
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/16182abaa61eb2491c74d1791275021b6cb0a5a33588bd499de658f57826f6d3.jpg",
+        "image_caption": [
+            "Figure 4: Test error vs. training time for ResNet model (He et al., 2016) for CIFAR-10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            341,
+            358,
+            658,
+            559
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C The official pre-trained ResNet model ",
+        "bbox": [
+            173,
+            616,
+            544,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/670ced69ed852252c2545e4ebf004a4911c911a0667c1ac6d6e75836cc91b167.jpg",
+        "image_caption": [
+            "Figure 5: Plot of the singular values of the linear operators associated with the convolutional layers of the pretrained \"ResNet V2\" from the TensorFlow website. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            362,
+            665,
+            630,
+            823
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The singular values of the convolutional layers from the official “Resnet $\\mathbf { V } 2 ^ { \\mathbf { \\mathfrak { s } } }$ pre-trained model (He et al., 2016) are plotted in Figure 5. The singular values are ordered by value. Only layers with kernels larger than $1 \\times 1$ are plotted. The curves are plotted with a mixture of red and green; layers closer to the input are plotted with colors with a greater share of red. The transformations with the largest operator norms are closest to the inputs. As the data has undergone more rounds of processing, as we proceed through the layers, the number of non-negligible singular values increases for a while, but at the end, it tapers off. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/921efa0f13c6eee7ac71d664f437e5ccc2cc5a08dd2f7fe04e1bdf51684c6cc4.jpg",
+        "image_caption": [
+            "Figure 6: Plot of the ratio of singular values to maximum singular value of the linear operators associated with the convolutional layers of the pretrained \"ResNet V2\" from the TensorFlow website. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            118,
+            651,
+            306
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f31db2c8ee9490026570859907e73364cf336b1887958a36edfcea9e824d188.jpg",
+        "image_caption": [
+            "Figure 7: Plot of the ratio of singular values to maximum singular value of the linear operators associated with the convolutional layers of the pretrained \"ResNet V2\" normalized by size of the convolution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            378,
+            643,
+            565
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            647,
+            826,
+            704
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5, we plotted the singular values ordered by value. It can be observed that while singular values in the first layer are much larger than the rest, many layers have a lot of singular values that are pretty big. For example, most of the layers have at least 10000 singular values that are at least 1. To give a complementary view, Figure 6 presents a plot of the ratios of the singular values in each layer with the largest singular value in that layer. We see that the effective rank of the convolutional layers is larger closer to the inputs. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            794
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows that different convolutional layers have significantly different numbers of non-negligible singular values. A question that may arise is to what extent this was due to the fact that different layers simply are of different sizes, so that the total number of their singular values, tiny or not, was different. To look into this, instead of plotting the singular value ratios as a function of the rank of the singular values, as in the Figure 6, we normalized the values on the horizontal axis by dividing by the total number of singular values. The result is shown in Figure 7. ",
+        "bbox": [
+            173,
+            801,
+            825,
+            885
+        ],
+        "page_idx": 11
+    }
+]

parse/train/rkgNKkHtvB/rkgNKkHtvB.md

@@ -0,0 +1,274 @@
+# REFORMER: THE EFFICIENT TRANSFORMER
+
+Nikita Kitaev∗ U.C. Berkeley & Google Research kitaev@cs.berkeley.edu
+
+Łukasz Kaiser∗ Anselm Levskaya Google Research Google Research {lukaszkaiser,levskaya}@google.com
+
+# ABSTRACT
+
+Large Transformer models routinely achieve state-of-the-art results on a number of tasks but training these models can be prohibitively costly, especially on long sequences. We introduce two techniques to improve the efficiency of Transformers. For one, we replace dot-product attention by one that uses locality-sensitive hashing, changing its complexity from $\mathrm { O } ( L ^ { 2 } )$ to $\mathrm { O } ( L \log L )$ , where $L$ is the length of the sequence. Furthermore, we use reversible residual layers instead of the standard residuals, which allows storing activations only once in the training process instead of $N$ times, where $N$ is the number of layers. The resulting model, the Reformer, performs on par with Transformer models while being much more memory-efficient and much faster on long sequences.
+
+# 1 INTRODUCTION
+
+The Transformer architecture (Vaswani et al., 2017) is widely used in natural language processing and yields state-of-the-art results on a number of tasks. To obtain these results, researchers have resorted to training ever larger Transformer models. The number of parameters exceeds 0.5B per layer in the largest configuration reported in (Shazeer et al., 2018) while the number of layers goes up to 64 in (Al-Rfou et al., 2018). Transformer models are also used on increasingly long sequences. Up to 11 thousand tokens of text in a single example were processed in (Liu et al., 2018) and when processing other modalities, like music (Huang et al., 2018) and images (Parmar et al., 2018), even longer sequences are commonplace. These large-scale long-sequence models yield great results but strain resources to the point where some argue that this trend is breaking NLP research1. Many large Transformer models can only realistically be trained in large industrial research laboratories and such models trained with model parallelism cannot even be fine-tuned on a single GPU as their memory requirements demand a multi-accelerator hardware setup even for a single training step.
+
+Do large Transformer models fundamentally require such huge resources or are they simply inefficient? Consider the following calculation: the 0.5B parameters used in the largest reported Transformer layer account for 2GB of memory. Activations for 64K tokens with embedding size 1024 and batch size 8 account for $6 4 \mathrm { K } \times 1 \mathrm { K } \times 8 = 0 . 5 \mathrm { B }$ floats, requiring another 2GB of memory. If our memory use was only per-layer, then we should fairly easily fit a large Transformer even on sequences of length 64K on a single accelerator. Further, the whole corpus used to train BERT only requires 17GB to store. Why is it then that we cannot even fine-tune these models on single machines?
+
+The above estimate includes only per-layer memory and input activations cost and does not take into account the following major sources of memory use in the Transformer.
+
+• Memory in a model with $N$ layers is $N$ -times larger than in a single-layer model due to the fact that activations need to be stored for back-propagation. • Since the depth $d _ { f f }$ of intermediate feed-forward layers is often much larger than the depth $d _ { m o d e l }$ of attention activations, it accounts for a large fraction of memory use. • Attention on sequences of length $L$ is $\mathrm { O } ( L ^ { 2 } )$ in both computational and memory complexity, so even for a single sequence of 64K tokens can exhaust accelerator memory.
+
+We introduce the Reformer model which solves these problems using the following techniques:
+
+• Reversible layers, first introduced in Gomez et al. (2017), enable storing only a single copy of activations in the whole model, so the $N$ factor disappears.   
+• Splitting activations inside feed-forward layers and processing them in chunks removes the $d _ { f f }$ factor and saves memory inside feed-forward layers.   
+• Approximate attention computation based on locality-sensitive hashing replaces the $\mathrm { O } ( L ^ { 2 } )$ factor in attention layers with $\mathrm { O } ( L \log L )$ and so allows operating on long sequences.
+
+We study these techniques and show that they have negligible impact on the training process compared to the standard Transformer. Splitting activations in fact only affects the implementation; it is numerically identical to the layers used in the Transformer. Applying reversible residuals instead of the standard ones does change the model but has a negligible effect on training in all configurations we experimented with. Finally, locality-sensitive hashing in attention is a more major change that can influence the training dynamics, depending on the number of concurrent hashes used. We study this parameter and find a value which is both efficient to use and yields results very close to full attention.
+
+We experiment on a synthetic task, a text task (enwik8) with sequences of length 64K and an image generation task (imagenet-64 generation) with sequences of length 12K. In both cases we show that Reformer matches the results obtained with full Transformer but runs much faster, especially on the text task, and with orders of magnitude better memory efficiency.
+
+# 2 LOCALITY-SENSITIVE HASHING ATTENTION
+
+Dot-product attention. The standard attention used in the Transformer is the scaled dot-product attention (Vaswani et al., 2017). The input consists of queries and keys of dimension $d _ { k }$ , and values√ of dimension $d _ { v }$ . The dot products of the query with all keys are computed, scaled by $\sqrt { d _ { k } }$ , and a softmax function is applied to obtain the weights on the values. In practice, the attention function on a set of queries is computed simultaneously, packed together into a matrix $Q$ . Assuming the keys and values are also packed together into matrices $K$ and $V$ , the matrix of outputs is defined as:
+
+$$
+\mathrm { A t t e n t i o n } ( Q , K , V ) = \mathrm { s o f t m a x } ( \frac { Q K ^ { T } } { \sqrt { d _ { k } } } ) V
+$$
+
+Multi-head attention. In the Transformer, instead of performing a single attention function with $d _ { m o d e l }$ -dimensional keys, values and queries, one linearly projects the queries, keys and values $h$ times with different, learned linear projections to $d _ { k } , d _ { k }$ and $d _ { v }$ dimensions, respectively. Attention is applied to each of these projected versions of queries, keys and values in parallel, yielding $d _ { v }$ - dimensional output values. These are concatenated and once again projected, resulting in the final values. This mechanism is known as multi-head attention.
+
+Memory-efficient attention. To calculate the memory use of the attention mechanism, let us focus on the attention computation from Equation 1. Let us assume that Q, K and $\mathrm { v }$ all have the shape $\left[ b a t c h \_ s i z e , l e n g t h , d _ { m o d e l } \right]$ . The main issue is the term $Q K ^ { T }$ , which has the shape [batch size, length, length]. In the experimental section we train a model on sequences of length $6 4 K$ – in this case, even at batch-size of 1, this is a $6 4 K \times 6 4 K$ matrix, which in 32-bit floats would take 16GB of memory. This is impractical and has hindered the use of the Transformer for long sequences. But it is important to note that the $Q K ^ { T }$ matrix does not need to be fully materialized in memory. The attention can indeed be computed for each query $q _ { i }$ separately, only calculating $\mathrm { s o f t m a x } ( \frac { q _ { i } K ^ { T } } { \sqrt { d _ { k } } } ) V$ once in memory, and then re-computing it on the backward pass when needed for gradients. This way of computing attention may be less efficient but it only uses memory proportional to length. We use this memory-efficient implementation of attention to run the full-attention baselines presented in the experimental section.
+
+Where do Q, K, V come from? The multi-head attention described above operates on keys, queries and values, but usually we are only given a single tensor of activations A of the shape [batch size, length, $d _ { m o d e l } ]$ – e.g., coming from embedding the tokens in a sentence into vectors.
+
+![](images/933641c2e559997bd69cf9ce03c0b729d65931c290db258544018d21c672f8d7.jpg)  
+Figure 1: An angular locality sensitive hash uses random rotations of spherically projected points to establish buckets by an argmax over signed axes projections. In this highly simplified 2D depiction, two points $x$ and $y$ are unlikely to share the same hash buckets (above) for the three different angular hashes unless their spherical projections are close to one another (below).
+
+To build Q, K and V from A, the Transformer uses 3 different linear layers projecting A into Q, K and $\mathrm { v }$ with different parameters. For models with LSH attention, we want queries and keys (Q and K) to be identical. This is easily achieved by using the same linear layer to go from A to Q and K, and a separate one for V. We call a model that behaves like this a shared-QK Transformer. It turns out that sharing QK does not affect the performance of Transformer, even if we additionally normalize the length of the keys K, as we show in the experimental Section 5.
+
+Hashing attention. For the LSH attention, we start with two tensors, $\mathrm { Q } { = } \mathrm { K }$ and $\mathrm { v }$ of the shape [batch size, length, $d _ { m o d e l } ]$ . We keep the multi-head mechanism intact and focus on the attention computation from Equation 1. As already mentioned, the main issue is the term $Q K ^ { T }$ , which has the shape [batch size, length, length]. But note that we are actually only interested in softmax $\left( Q K ^ { T } \right)$ . Since softmax is dominated by the largest elements, for each query $q _ { i }$ we only need to focus on the keys in K that are closest to $q _ { i }$ . For example, if K is of length 64K, for each $q _ { i }$ we could only consider a small subset of, say, the 32 or 64 closest keys. That is much more efficient, but how can we find the nearest neighbors among the keys?
+
+Locality sensitive hashing. The problem of finding nearest neighbors quickly in high-dimensional spaces can be solved by locality-sensitive hashing (LSH). A hashing scheme that assigns each vector $x$ to a hash $h ( x )$ is called locality-sensitive if nearby vectors get the same hash with high probability and distant ones do not. In our case, we actually only require that nearby vectors get the same hash with high probability and that hash-buckets are of similar size with high probability.
+
+We achieve this by employing random projections as follows (see Figure 1). To get $b$ hashes, we first fix a random matrix $R$ of size $[ d _ { k } , b / 2 ]$ . We then define $h ( x ) = \arg \operatorname* { m a x } ( [ x R ; - x R ] )$ where $[ u ; v ]$ denotes the concatenation of two vectors. This method is a known LSH scheme (Andoni et al., 2015) and is easy to implement and apply to batches of vectors.
+
+LSH attention. Knowing our LSH scheme and the general idea of hashing attention, we will now formalize the LSH attention we use in this paper. We first rewrite the equation for normal attention, (1), for a single query position $i$ at a time:
+
+$$
+o _ { i } = \sum _ { j \in \mathcal { P } _ { i } } \exp \left( q _ { i } \cdot k _ { j } - z ( i , \mathcal { P } _ { i } ) \right) v _ { j }
+$$
+
+We introduce the notation $\mathcal { P } _ { i }$ to represent the set that the query at position $i$ attends to, and $z$ to denote the partition function (i.e. the normalizing term in the softmax). For clarity, we also omit scaling by $\sqrt { d _ { k } }$ .
+
+For batching purposes we typically perform attention over a larger set $\widetilde { \mathcal { P } } _ { i } = \{ 0 , 1 , \ldots , l \} \supseteq \mathcal { P } _ { i }$ while masking out elements not in $\mathcal { P } _ { i }$ :
+
+$$
+o _ { i } = \sum _ { j \in \widetilde { \mathcal { P } } _ { i } } \exp \left( q _ { i } \cdot k _ { j } - m ( j , \mathcal { P } _ { i } ) - z ( i , \mathcal { P } _ { i } ) \right) v _ { j } \quad \mathrm { ~ w h e r e ~ } m ( j , \mathcal { P } _ { i } ) = \left\{ \begin{array} { l l } { \infty } & { \mathrm { i f ~ } j \notin \mathcal { P } _ { i } } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+![](images/1e04a6a1048a7c4f8520f431a67d94733d4c42885c7030ea46659a056ee2e509.jpg)  
+Figure 2: Simplified depiction of LSH Attention showing the hash-bucketing, sorting, and chunking steps and the resulting causal attentions. (a-d) Attention matrices for these varieties of attention.
+
+Now we turn to LSH attention, which we can think of in terms of restricting the set $\mathcal { P } _ { i }$ of target items a query position $i$ can attend to, by only allowing attention within a single hash bucket.
+
+$$
+\mathcal { P } _ { i } = \{ j : h ( q _ { i } ) = h ( k _ { j } ) \}
+$$
+
+Figure 2(a-b) shows a schematic comparison of full-attention with a hashed variant. Part (a) depicts that the attention matrix for full attention is typically sparse, but the computation does not take advantage of this sparsity. In (b), the queries and keys have been sorted according to their hash bucket. Since similar items fall in the same bucket with high probability, the full attention pattern can be approximated by only allowing attention within each bucket.
+
+Hash buckets in this formulation tend to be uneven in size, which makes it difficult to batch across buckets. Moreover, the number of queries and the number of keys within a bucket may be unequal – in fact, it is possible for a bucket to contain many queries but no keys. To alleviate these issues, we first ensure that h(kj ) = h(qj ) by setting kj = $\begin{array} { r } { k _ { j } = \frac { \dot { q _ { j } } } { | | q _ { j } | | } } \end{array}$ . Next, we sort the queries by bucket number and, within each bucket, by sequence position; this defines a permutation where $i \mapsto s _ { i }$ after sorting. In the sorted attention matrix, pairs from the same bucket will cluster near the diagonal (as depicted in Figure $2 \mathrm { c }$ ). We can follow a batching approach where chunks of $m$ consecutive queries (after sorting) attend to each other, and one chunk back (Figure 2d). Following our earlier notation, this corresponds to setting:
+
+$$
+\widetilde { \mathcal { P } } _ { i } = \left\{ j : \left\lfloor { \frac { s _ { i } } { m } } \right\rfloor - 1 \leq \left\lfloor { \frac { s _ { j } } { m } } \right\rfloor \leq \left\lfloor { \frac { s _ { i } } { m } } \right\rfloor \right\}
+$$
+
+If $\operatorname* { m a x } _ { i } \left| \mathcal { P } _ { i } \right| < m$ , then $\mathcal { P } _ { i } \subseteq \widetilde { \mathcal { P } } _ { i }$ . In practice we set $\begin{array} { r } { m = \frac { 2 l } { n _ { b u c k e t s } } } \end{array}$ (where $l$ is the sequence length). The average bucket size is $\frac { l } { n _ { b u c k e t s } }$ , and we assume that the probability of a bucket growing to twice that size is sufficiently low. The overall process of LSH attention is summarized in Figure 2.
+
+Multi-round LSH attention. With hashing, there is always a small probability that similar items nevertheless fall in different buckets. This probability can be reduced by doing multiple rounds of hashing with $n _ { r o u n d s }$ distinct hash functions $\{ h ^ { ( 1 ) } , h ^ { \left( 2 \right) } , \ldots \}$ , such that:
+
+$$
+{ \mathcal P } _ { i } = \bigcup _ { r = 1 } ^ { n _ { r o u n d s } } { \mathcal P } _ { i } ^ { ( r ) } \qquad \mathrm { w h e r e } ~ { \mathcal P } _ { i } ^ { ( r ) } = \Big \{ j : h ^ { ( r ) } ( q _ { i } ) = h ^ { ( r ) } ( q _ { j } ) \Big \}
+$$
+
+The multi-round case essentially involves performing LSH attention $n _ { r o u n d s }$ times in parallel; the details of the procedure are described in in Appendix A.
+
+Causal masking for shared-QK attention. In a Transformer decoder, masking (denoted by $m ( j , \mathcal { P } _ { i } )$ in Equation 3) is used to prevent positions from attending into the future. To implement masking in LSH attention, we associate every query/key vector with a position index, re-order the position indices using the same permutations used to sort the query/key vectors, and then use a comparison operation to compute the mask.
+
+Table 1: Memory and time complexity of attention variants. We write $l$ for length, $b$ for batch size, $n _ { h }$ for the number of heads, $n _ { c }$ for the number of LSH chunks, $n _ { r }$ for the number of hash repetitions.   
+
+<table><tr><td>Attention Type</td><td>Memory Complexity</td><td>Time Complexity</td></tr><tr><td>Scaled Dot-Product</td><td>max(bnnldk,bnnl²)</td><td>max(bnnldk,bnnl2)</td></tr><tr><td>Memory-Efficient</td><td>max(bnnldk,bnnl²)</td><td>max(bnhldk,bnnl²)</td></tr><tr><td>LSH Attention</td><td>max(bnnldk,bnnlnr(4l/nc)2)</td><td>max(bnhldk,bnhnrl(4l/nc)²)</td></tr></table>
+
+Table 2: Accuracies on the duplication task of a 1-layer Transformer model with full attention and with locality-sensitive hashing attention using different number of parallel hashes.   
+
+<table><tr><td></td><td rowspan="2">Eval</td><td rowspan="2">Full Attention</td><td rowspan="2">LSH-8</td><td rowspan="2">LSH-4</td><td rowspan="2">LSH-2</td><td rowspan="2">LSH-1</td></tr><tr><td>Train</td></tr><tr><td>Full Attention</td><td></td><td>100%</td><td>94.8%</td><td>92.5%</td><td>76.9%</td><td>52.5%</td></tr><tr><td colspan="2">LSH-4</td><td>0.8%</td><td>100%</td><td>99.9%</td><td>99.4%</td><td>91.9%</td></tr><tr><td colspan="2">LSH-2</td><td>0.8%</td><td>100%</td><td>99.9%</td><td>98.1%</td><td>86.8%</td></tr><tr><td colspan="2">LSH-1</td><td>0.8%</td><td>99.9%</td><td>99.6%</td><td>94.8%</td><td>77.9%</td></tr></table>
+
+While attention to the future is not allowed, typical implementations of the Transformer do allow a position to attend to itself. Such behavior is undesirable in a shared-QK formulation because the dot-product of a query vector with itself will almost always be greater than the dot product of a query vector with a vector at another position. We therefore modify the masking to forbid a token from attending to itself, except in situations where a token has no other valid attention targets (e.g. the first token in a sequence).
+
+# 2.1 ANALYSIS ON A SYNTHETIC TASK
+
+To verify the performance of LSH attention and study its behavior, we start with the following synthetic task: duplicate a sequence of symbols. In this task, each training and testing example has the form $0 w 0 w$ where $w \in \bar { \{ 1 , \ldots , N \} ^ { * } }$ is a sequence of symbols ranging from 1 to $N$ (we use $N = 1 2 7$ in our experiments). An example with the word $w$ of length 3 is given below.
+
+<table><tr><td rowspan=1 colspan=1>Example:</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>19</td><td rowspan=1 colspan=1>113</td><td rowspan=1 colspan=1>72</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>19</td><td rowspan=1 colspan=1>113</td><td rowspan=1 colspan=1>72</td></tr></table>
+
+To study LSH attention, we train a language model on examples of the above form where each $w$ is of length 511 (so the whole input $0 w 0 w$ is of length 1024). As this is a language modeling task, we always predict the next symbol given all the previous ones, but we mask the loss and accuracy to only consider positions in the second half of the input, i.e., those that can actually be predicted.
+
+The above task can be solved perfectly (to accuracy $100 \%$ and loss 0) by a 1-layer Transformer model. Note though, that it requires non-local attention lookups, so it cannot be solved by any model relying on sparse attention with a limited span. To make it easy and fast to train but similar to models used in NLP, we use a 1-layer Transformer with $d _ { m o d e l } = d _ { f f } = 2 5 6$ and 4 heads. We train it for 150K steps in 4 different settings: with full attention, LSH attention with $n _ { r o u n d s } = 1$ , $n _ { r o u n d s } = 2$ and $n _ { r o u n d s } = 4$ .
+
+From the results summarized in Table 2 we see that a model trained with full attention can be immediately used with LSH attention, but at some loss of accuracy. When trained from scratch with LSH attention, the model trained with 4 hashes achieves almost perfect accuracy as well. Interestingly, the accuracy becomes perfect when evaluated with 8 hashes. It goes down when evaluated with 2 or 1 hashes. Models trained with less hashes show worse results but even the model trained with just 1 hash performs almost perfectly when evaluated with 8 hashes.
+
+# 3 REVERSIBLE TRANSFORMER
+
+As the above section shows, the complexity of attention can be reduced from square in length to linear, provided an approximation is acceptable. But it is clear from Table 1 that each field starts with a $b \cdot n _ { h } \cdot l$ term: the $b \cdot n _ { h } \cdot l \cdot d _ { k }$ , or alternatively $b \cdot l \cdot d _ { m o d e l }$ cost cannot be avoided. Indeed, the activations before each layer are already of the size $b \cdot l \cdot d _ { m o d e l }$ , so the memory use of the whole model with $n _ { l }$ layers is at least $b \cdot l \cdot d _ { m o d e l } \cdot n _ { l }$ . Even worse: inside the feed-forward layers of Transformer this goes up to $\boldsymbol { b } \cdot \boldsymbol { l } \cdot d _ { f f } \cdot n _ { l }$ . In a big Transformer it is usual to set $d _ { f f } = 4 K$ and $n _ { l } = 1 6$ so with $l = 6 4 K$ this again would use an impractical $1 6 G B$ of memory
+
+In this section, we show how to reduce this cost by first dealing with the $n _ { l }$ part of the term using reversible layers and then showing how chunking can allow us to handle the $d _ { f f }$ problem. The effects of each of these approaches on memory and time complexity are summarized in Table 3.
+
+RevNets. Reversible residual networks were introduced by Gomez et al. (2017) where it was shown that they can replace ResNets for image classification. The main idea is to allow the activations at any given layer to be recovered from the activations at the following layer, using only the model parameters. Rather than having to checkpoint intermediate values for use in the backward pass, layers can be reversed one-by-one as back-propagation proceeds from the output of the network to its input. Whereas a normal residual layer performs a function $x \mapsto y$ that operates on a single input and produces a single output and has the form $y = x + F ( x )$ , a reversible layer works on pairs of inputs/outputs: $( x _ { 1 } , x _ { 2 } ) \mapsto ( y _ { 1 } , y _ { 2 } )$ , and follows the equations:
+
+$$
+y _ { 1 } = x _ { 1 } + F ( x _ { 2 } ) y _ { 2 } = x _ { 2 } + G ( y _ { 1 } )
+$$
+
+A layer can be reversed by subtracting (rather than adding) the residuals:
+
+$$
+x _ { 2 } = y _ { 2 } - G ( y _ { 1 } ) x _ { 1 } = y _ { 1 } - F ( x _ { 2 } )
+$$
+
+Reversible Transformer. We apply the RevNet idea to the Transformer by combining the attention and feed-forward layers inside the revnet block. In the notation above, F becomes an attention layer while $\mathbf { G }$ becomes the feed-forward layer. Note that Layer Normalization (Ba et al., 2016) is moved inside the residual blocks.
+
+$$
+Y _ { 1 } = X _ { 1 } + \mathrm { A t t e n t i o n } ( X _ { 2 } ) \qquad Y _ { 2 } = X _ { 2 } + \mathrm { F e e d F o r w a r d } ( Y _ { 1 } )
+$$
+
+The reversible Transformer does not need to store activations in each layer and so gets rid of the $n _ { l }$ term. In Section 5 we show that it performs the same as the normal Transformer when using the same number of parameters; we achieve this by having both $x _ { 1 }$ and $x _ { 2 }$ have size $d _ { m o d e l }$ .
+
+Chunking. While reversibility covers the $n _ { l }$ term, the thicker layers can still use a lot of memory. The feed-forward layer in particular can use intermediate vectors of dimensionality $d _ { f f } = 4 K$ or higher. However, computations in feed-forward layers are completely independent across positions in a sequence, so the computation can be split into $c$ chunks:
+
+$$
+Y _ { 2 } = \left[ Y _ { 2 } ^ { ( 1 ) } ; \ldots ; Y _ { 2 } ^ { ( c ) } \right] = \left[ X _ { 2 } ^ { ( 1 ) } + { \mathrm { F e e d F o r w a r d } } ( Y _ { 1 } ^ { ( 1 ) } ) ; \ldots ; X _ { 2 } ^ { ( c ) } + { \mathrm { F e e d F o r w a r d } } ( Y _ { 1 } ^ { ( c ) } ) \right]
+$$
+
+This layer is typically batched by performing operations for all positions in parallel, but operating on one chunk at a time can reduce memory. The reverse computation in (8) and the backward pass are also chunked. In addition to the feed-forward layers, for models with large vocabulary (more than $d _ { m o d e l }$ word types) we also chunk the log-probabilities at the output and calculate the loss for sections of the sequence at a time.
+
+Chunking, large batches and parameter reuse. With chunking and reversible layers the memory we use for activations in the whole network is independent of the number of layers. The same is not true for parameters though as their number grows with the number of layers. This problem is remedied though because we can swap layer parameters to and from CPU memory when this layer is not computing. In a standard Transformer this would be inefficient because memory transfer to CPU is slow. The batch size multiplied by length in Reformer is much larger though and therefore the amount of compute done with the parameters amortizes the cost of their transfer.
+
+Table 3: Memory and time complexity of Transformer variants. We write $d _ { m o d e l }$ and $d _ { f f }$ for model depth and assume $d _ { f f } \geq d _ { m o d e l }$ ; $b$ stands for batch size, $l$ for length, $n _ { l }$ for the number of layers. We assume $n _ { c } = l / 3 2$ so $4 l / n _ { c } = 1 2 8$ and we write $c = 1 2 8 ^ { 2 }$ .   
+
+<table><tr><td>Model Type</td><td>Memory Complexity</td><td>Time Complexity</td></tr><tr><td>Transformer</td><td>max(bldff,bnnl²)nt</td><td>(bldff+bnnl²)nt</td></tr><tr><td>Reversible Transformer</td><td>max(bldff,bnhl²)</td><td>(bnhldff+bnnl2)nl</td></tr><tr><td>Chunked Reversible Transformer</td><td>max(bldmodet, bnnl2)</td><td>(bnnldff+bnnl²)nl</td></tr><tr><td>LSHTransformer</td><td>max(bldff,bnnlnrc)ni</td><td>(bldff+bnhnrlc)ni</td></tr><tr><td>Reformer</td><td>max(bldmodel,bnhlnrc)</td><td>(bldff+bnhnrlc)ni</td></tr></table>
+
+# 4 RELATED WORK
+
+The Transformer model introduced in (Vaswani et al., 2017) has been used widely in natural language tasks and further extended to model diverse data such as music scores (Huang et al., 2018), and images (Parmar et al., 2018; Ramachandran et al., 2019). Most notably, this model class has been applied successfully in the self-supervised training of extremely large language models (Devlin et al., 2018; Radford et al., 2019).
+
+Given the enormous computational requirements of state of the art sequence models, there has been increasing interest in finding methods to reduce the memory footprint and computational requirements of Transformer models. In addition to standard methods such as precision reduction and gradient checkpointing (Sohoni et al., 2019), more efficient versions of the Transformer model’s self-attention mechanism (Sukhbaatar et al., 2019a;b) have also recently been explored.
+
+In particular, leveraging sparsity in the attention layers has proved fruitful. OpenAI introduced the sparse Transformer (Child et al., 2019) which exploits a factorized sparse representation of attention. Using product-key attention to increase the key space has also been used to reduce memory requirements in the feed-forward layers with no loss in performance (Lample et al., 2019).
+
+Locality-sensitive hashing (LSH) has, to our knowledge, not been directly applied to Transformer attention layers before. But previous work using external memory with neural networks has dealt with memories of large sizes. The original implementation of memory networks (Weston et al., 2014) and later work on scaling it (Bordes et al., 2015; Chandar et al., 2016) used memory with size in the millions. The cost of doing so is that the memory must be fixed prior to training. Moreover, since during the beginning of training the model is unlikely to query the memory correctly, strong supervision is used to encourage the model to query memory locations that are useful. These hints are either given as additional supervising information by the task or determined heuristically as in Hill et al. (2015). The requirement that the memory be fixed before has been removed in Santoro et al. (2016) at the cost of memory size and later alleviated by Rae et al. (2016). The last paper considered memory lookups with approximate nearest neighbors including both LSH and random kd-trees, but only for lookups in external memory.
+
+# 5 EXPERIMENTS
+
+In this section we present experimental results demonstrating the techniques described above. We analyze the techniques one-by-one to make clear which combinations have impact on performance. We start by showing that reversible layers and shared query-key spaces do not impact performance, then proceed to analyze hashing attention and finally the full Reformer model.
+
+We ran our experiments on the imagenet64 and enwik8-64K tasks, where the latter is a variant of enwik8 that is chunked into subsequences of $2 ^ { 1 6 } \ : = \ : 6 4 K$ tokens. We use 3-layer models for our ablations so as to make it tractable to compare with the regular Transformer, which has high memory usage and performs full $O ( l ^ { 2 } )$ attention. All experiments have $d _ { m o d e l } = 1 0 2 4$ , $d _ { f f } = 4 0 9 6$ , $n _ { h e a d s } ~ = ~ 8$ , and a total batch size of 8 sequences. We used the Adafactor optimizer (Shazeer & Stern, 2018) for training these models. We also evaluate on the WMT 2014 English-to-German translation task, following the hyperparameters of Vaswani et al. (2017). Training for all experiments was parallelized across 8 devices (8 GPUs or 8 TPU v3 cores). Code for training our models is made publicly available.2
+
+![](images/c2fe4e4314fc0b82d2981ba18326ffd9fc27b3df97ee0b18eda40840efe41fac.jpg)  
+Figure 3: Effect of shared query-key space (left) and reversibility (right) on performance on enwik8 and imagenet64 training. The curves show bits per dim on held-out data.
+
+Table 4: BLEU scores on newstest2014 for WMT English-German (En–De). We additionally report detokenized BLEU scores as computed by sacreBLEU (Post, 2018).   
+
+<table><tr><td rowspan="2">Model</td><td colspan="3">sacreBLEU</td></tr><tr><td>BLEU</td><td>Uncased3</td><td>Cased4</td></tr><tr><td>Vaswani etal. (2017),base model</td><td>27.3</td><td></td><td></td></tr><tr><td>Vaswani et al. (2017), big</td><td>28.4</td><td></td><td></td></tr><tr><td>Ott et al. (2018), big</td><td>29.3</td><td></td><td></td></tr><tr><td>Reversible Transformer (base,10oK steps)</td><td>27.6</td><td>27.4</td><td>26.9</td></tr><tr><td>Reversible Transformer (base,5OoK steps,no weight sharing)</td><td>28.0</td><td>27.9</td><td>27.4</td></tr><tr><td>Reversible Transformer (big,3OOK steps,no weight sharing)</td><td>29.1</td><td>28.9</td><td>28.4</td></tr></table>
+
+Effect of sharing QK. We first consider the effect of shared-QK attention on a regular Transformer model. Shared-QK attention sets $\begin{array} { r } { k _ { j } ~ = ~ \frac { q _ { j } } { \parallel q _ { j } \parallel } } \end{array}$ and prevents tokens from attending to themselves (except when no other context is available). In the left part of Figure 3, we plot perplexity curves for both regular and shared-QK attention. A shared query-key space does not perform worse than regular attention; in fact, for enwik8 it appears to train slightly faster. In other words, we are not sacrificing accuracy by switching to shared-QK attention.
+
+Effect of reversible layers. In the two plots on the right in Figure 3, we compare a regular Transformer per Vaswani et al. (2017) with the reversible one describe in Section 3. The two models have identical parameter counts, and the learning curves likewise appear to be nearly the same. These results show that the memory savings in the reversible Transformer do not come at the expense of accuracy.
+
+Reversible layers in machine translation. We also evaluate reversible layers in the context of an encoder-decoder Transformer model for machine translation from English to German. We start by making both the encoder and the decoder fully reversible in the Transformer-base architecture, and see that the resulting model performs comparably to Vaswani et al. (2017) when trained for 100K steps. We also evaluate training for a greater number of steps and with a larger model. Reformer models are very memory-efficient, so for the latter two experiments we do not need to save memory by sharing embedding and output projection weight matrices throughout the model. Results are shown in Table 4. We do not apply LSH attention in this setting because examples are single sentences, and sentences tend to be relatively short. Our typical LSH attention configuration uses chunks of 128 tokens after hashing and sorting, whereas the examples in the WMT14 test set are all shorter than 128 tokens.
+
+![](images/da5d76906fcbfcc141fd40ccc521929fac0f14397c36dfbe9348757cafb44e35.jpg)  
+Figure 4: LSH attention performance as a function of hashing rounds on imagenet64.
+
+![](images/a6f457e38c79efcd959c9f60f3b2617e1d74b576a80218106af9af3bde2fe678.jpg)  
+Figure 5: Left: LSH attention performance as a function of number of layers on enwik8. Right: Speed of attention evaluation as a function of input length for full- and LSH- attention.
+
+LSH attention in Transformer. LSH attention is an approximation for full attention that, as evidenced in Figure 4, becomes more accurate as the number of hashes increases. At $n _ { r o u n d s } = 8$ , it already almost matches full attention. The computational cost of a model grows with the number of hashes, so this hyperparameter can be adjusted depending on the available compute budget. Additionally, as in Table 2, the number of hashes can be increased at evaluation time to produce more accurate results. On the right half of Figure 5, we plot the speed of different attention types vs. the sequence length, while holding the total number of tokens fixed. We see that while regular attention becomes slower at longer sequence length, LSH attention speed remains flat.
+
+Large Reformer models. To verify that the Reformer can indeed fit large models on a single core and train fast on long sequences, we train up to 20-layer big Reformers on enwik8 and imagenet64. As can be seen in Figure 5, these models fit into memory and train. We were not able to train Transformer baselines in this case as they are too slow and memory-hungry, but we see clear improvement with the number of layers. A 12-layer model on enwik8 trained for 20K steps with a dropout rate of 0.1 achieves 1.19 bits/dim on the test set. We also trained a 12-layer Reformer model for longer with further tuning and improvements and we reached 1.05 bits/dim on the enwiki8 test set.
+
+# 6 CONCLUSION
+
+Reformer combines the modeling capacity of a Transformer with an architecture that can be executed efficiently on long sequences and with small memory use even for models with a large number of layers. We believe that this will help large, richly-parameterized Transformer models become more widespread and accessible. Also, the ability to handle long sequences opens the way for the use of the Reformer on many generative tasks. In addition to generating very long coherent text, the Reformer can bring the power of Transformer models to other domains like time-series forecasting, music, image and video generation.
+
+# REFERENCES
+
+Rami Al-Rfou, Dokook Choe, Noah Constant, Mandy Guo, and Llion Jones. Character-level language modeling with deeper self-attention. CoRR, abs/1808.04444, 2018. URL http: //arxiv.org/abs/1808.04444.   
+Alexandr Andoni, Piotr Indyk, Thijs Laarhoven, Ilya P. Razenshteyn, and Ludwig Schmidt. Practical and optimal LSH for angular distance. CoRR, abs/1509.02897, 2015. URL http://arxiv. org/abs/1509.02897.   
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. URL http://arxiv.org/abs/1607.06450.   
+Antoine Bordes, Nicolas Usunier, Sumit Chopra, and Jason Weston. Large-scale simple question answering with memory networks. CoRR, abs/1506.02075, 2015. URL http://arxiv.org/ abs/1506.02075.   
+Sarath Chandar, Sungjin Ahn, Hugo Larochelle, Pascal Vincent, Gerald Tesauro, and Yoshua Bengio. Hierarchical memory networks. arXiv preprint arXiv:1605.07427, 2016.   
+Rewon Child, Scott Gray, Alec Radford, and Ilya Sutskever. Generating long sequences with sparse transformers. URL https://openai.com/blog/sparse-transformers, 2019.   
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. CoRR, abs/1810.04805, 2018. URL http://arxiv.org/abs/1810.04805.   
+Aidan N Gomez, Mengye Ren, Raquel Urtasun, and Roger B Grosse. The reversible residual network: Backpropagation without storing activations. In Advances in neural information processing systems, pp. 2214–2224, 2017.   
+Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. CoRR, abs/1511.02301, 2015. URL http://arxiv.org/abs/1511.02301.   
+Cheng-Zhi Anna Huang, Ashish Vaswani, Jakob Uszkoreit, Noam Shazeer, Curtis Hawthorne, Andrew M Dai, Matthew D Hoffman, and Douglas Eck. Music transformer: Generating music with long-term structure. arXiv preprint arXiv:1809.04281, 2018.   
+Guillaume Lample, Alexandre Sablayrolles, Marc’Aurelio Ranzato, Ludovic Denoyer, and Herve´ Jegou. Large memory layers with product keys. ´ CoRR, abs/1907.05242, 2019. URL http: //arxiv.org/abs/1907.05242.   
+Peter J. Liu, Mohammad Saleh, Etienne Pot, Ben Goodrich, Ryan Sepassi, Lukasz Kaiser, and Noam Shazeer. Generating wikipedia by summarizing long sequences. CoRR, abs/1801.10198, 2018. URL http://arxiv.org/abs/1801.10198.   
+Myle Ott, Sergey Edunov, David Grangier, and Michael Auli. Scaling neural machine translation. In Proceedings of the Third Conference on Machine Translation: Research Papers, pp. 1–9, Brussels, Belgium, October 2018. Association for Computational Linguistics. doi: 10.18653/v1/W18-6301. URL https://www.aclweb.org/anthology/W18-6301.
+
+Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Lukasz Kaiser, Noam Shazeer, and Alexander Ku. Image transformer. CoRR, abs/1802.05751, 2018. URL http://arxiv.org/abs/1802. 05751.
+
+Matt Post. A call for clarity in reporting BLEU scores. In Proceedings of the Third Conference on Machine Translation: Research Papers, pp. 186–191, Belgium, Brussels, October 2018. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/ W18-6319.
+
+Alec Radford, Jeff Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. 2019.
+
+Jack W Rae, Jonathan J Hunt, Tim Harley, Ivo Danihelka, Andrew Senior, Greg Wayne, Alex Graves, and Timothy P Lillicrap. Scaling memory-augmented neural networks with sparse reads and writes. In Advances in Neural Information Processing Systems, (NIPS), 2016.
+
+Prajit Ramachandran, Niki Parmar, Ashish Vaswani, Irwan Bello, Anselm Levskaya, and Jonathon Shlens. Stand-alone self-attention in vision models. CoRR, abs/1906.05909, 2019. URL http: //arxiv.org/abs/1906.05909.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy P. Lillicrap. Oneshot learning with memory-augmented neural networks. CoRR, abs/1605.06065, 2016. URL http://arxiv.org/abs/1605.06065.
+
+Noam Shazeer and Mitchell Stern. Adafactor: Adaptive learning rates with sublinear memory cost. CoRR, abs/1804.04235, 2018. URL http://arxiv.org/abs/1804.04235.
+
+Noam Shazeer, Youlong Cheng, Niki Parmar, Dustin Tran, Ashish Vaswani, Penporn Koanantakool, Peter Hawkins, HyoukJoong Lee, Mingsheng Hong, Cliff Young, Ryan Sepassi, and Blake Hechtman. Mesh-tensorflow: Deep learning for supercomputers. CoRR, abs/1811.02084, 2018. URL http://arxiv.org/abs/1811.02084.
+
+Nimit Sharad Sohoni, Christopher Richard Aberger, Megan Leszczynski, Jian Zhang, and Christopher Re. Low-memory neural network training: A technical report. ´ CoRR, abs/1904.10631, 2019. URL http://arxiv.org/abs/1904.10631.
+
+Sainbayar Sukhbaatar, Edouard Grave, Piotr Bojanowski, and Armand Joulin. Adaptive attention span in transformers. CoRR, abs/1905.07799, 2019a. URL http://arxiv.org/abs/ 1905.07799.
+
+Sainbayar Sukhbaatar, Edouard Grave, Guillaume Lample, Herve J ´ egou, and Armand Joulin. Aug- ´ menting self-attention with persistent memory. CoRR, abs/1907.01470, 2019b. URL http: //arxiv.org/abs/1907.01470.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, 2017. URL http: //arxiv.org/abs/1706.03762.
+
+Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. CoRR, abs/1410.3916, 2014. URL http://arxiv.org/abs/1410.3916.
+
+# A MULTI-ROUND LSH ATTENTION
+
+In this section we describe in more detail the multi-hash version of our LSH attention mechanism. We first repeat Equation (3) from the main text, which describes a general formulation of attention with sparsity:
+
+$$
+o _ { i } = \sum _ { j \in \widetilde { \mathcal { P } } _ { i } } \exp \left( q _ { i } \cdot k _ { j } - m ( j , \mathcal { P } _ { i } ) - z ( i , \mathcal { P } _ { i } ) \right) v _ { j } \quad \mathrm { ~ w h e r e ~ } m ( j , \mathcal { P } _ { i } ) = \left\{ \begin{array} { l l } { \infty } & { \mathrm { i f ~ } j \notin \mathcal { P } _ { i } } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+In the multi-round case, a query position $i$ can attend to key positions $\mathcal { P } _ { i }$ as defined in (6), which we also repeat here:
+
+$$
+{ \mathcal P } _ { i } = \bigcup _ { r = 1 } ^ { n _ { r o u n d s } } { \mathcal P } _ { i } ^ { ( r ) } \qquad \mathrm { w h e r e } ~ { \mathcal P } _ { i } ^ { ( r ) } = \Big \{ j : h ^ { ( r ) } ( q _ { i } ) = h ^ { ( r ) } ( q _ { j } ) \Big \}
+$$
+
+For batching purposes, attention is performed on chunks of sorted queries/keys:
+
+$$
+\widetilde { \mathcal { P } } _ { i } ^ { ( r ) } = \left\{ j : \left\lfloor \frac { s _ { i } ^ { ( r ) } } { m } \right\rfloor - 1 \leq \left\lfloor \frac { s _ { j } ^ { ( r ) } } { m } \right\rfloor \leq \left\lfloor \frac { s _ { i } ^ { ( r ) } } { m } \right\rfloor \right\}
+$$
+
+Combining (3) and (6) gives:
+
+$$
+\begin{array} { r l r } {  { \alpha _ { i } = \sum _ { j \in \Gamma } \exp ( q _ { i } \cdot k _ { j } - m ( j , \mathcal { P } _ { i } ) - z ( i , \mathcal { P } _ { j } ) ) \times } } \\ & { } & { \beta _ { i } \leq \frac { 1 } { \beta \epsilon _ { i } ^ { p ( \cdot ) } } , } \\ & { } & { \gamma = \sum _ { s = 1 } ^ { N _ { t } } \exp ( z ( i , \mathcal { P } _ { i } ^ { ( r ) } ) - z ( i , \mathcal { P } _ { j } ) ) \sum _ { j \in \Gamma } \frac { 1 } { N _ { t } } \frac { 1 } { N _ { t } } \exp ( q _ { i } \cdot k _ { i } - m ( j , \mathcal { P } _ { i } ^ { ( r ) } ) - z ( i , \mathcal { P } _ { j } ^ { ( r ) } ) ) \times } \\ & { } & { \exp ( z ( i , \mathcal { P } _ { i } ^ { ( r ) } ) - z ( i , \mathcal { P } _ { j } ^ { ( r ) } ) ) , } \\ & { } & { ( 1 3 , \exp ( z ( i , \mathcal { P } _ { i } ^ { ( r ) } ) - z ( i , \mathcal { P } _ { j } ) ) \alpha _ { i } ^ { ( r ) } } \\ & { } & { \exp ( z ( i , \mathcal { P } _ { i } ^ { ( r ) } ) - z ( i , \mathcal { P } _ { j } ^ { ( r ) } ) ) \exp ( z ( i , \mathcal { P } _ { i } ^ { ( r ) } ) ) \exp ( \mathrm { ~ \it 1 4 ~ } } \\ & { } & { \exp ( \phi ( i , k _ { j } - m ( i _ { j } ^ { ( r ) } ) - z ( i , \mathcal { P } _ { j } ^ { ( r ) } ) ) ) \exp _ { j } } \\ & { } & { \beta _ { i } \leq \mathrm { \it ~ \it ~ \it ~ \alpha ~ } _ { j } \leq \mathrm { \it ~ \it ~ \alpha ~ } _ { i } \leq \mathrm { \it ~ \it ~ \alpha ~ } _ { j } } \\ & { } &  \exp ( N _ { t } \exp N _ { i , j } + | \{ \begin{array} { l l } { \Gamma _ { j } ^ { ( r ) } \cdot \xi _ { j } \in \mathcal { P } _ { j } ^ { ( r ) } } \\ { \Gamma _ { j } ^ { ( r ) } \cdot \xi _ { j } \in \mathcal { P } _ { j } ^ { ( r ) } } \end{array} \} \mathrm { ~ a n d ~ } m _ { i j } ^  ( \end{array}
+$$
+
+Each round of LSH attention produces a vector $o _ { i } ^ { ( r ) }$ that can be computed independently from other rounds, except for the inclusion of a term $N _ { i , j }$ to avoid double-counting elements when constructing the union of $\mathcal { P } _ { i } ^ { ( r ) }$ sets. In our implementation we fold the $N _ { i , j }$ factor into the masking term $m _ { i , j } ^ { ( r ) }$ .
+
+We also modify $m _ { i , j _ { . } } ^ { ( r ) }$ to introduce a special case for $i = j$ . This case is added because causal masking in a standard Transformer allows position to attend to itself, which is not desirable in a shared-QK formulation. We set the mask to a large but finite value to disallow attention-in-place, except in the situation where a token has no other valid attention targets. For example, the first token in a sequence attends only to itself, because no prior context is available.

parse/train/rkgNKkHtvB/rkgNKkHtvB_content_list.json

@@ -0,0 +1,1316 @@
+[
+    {
+        "type": "text",
+        "text": "REFORMER: THE EFFICIENT TRANSFORMER ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            705,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nikita Kitaev∗ U.C. Berkeley & Google Research kitaev@cs.berkeley.edu ",
+        "bbox": [
+            183,
+            145,
+            413,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Łukasz Kaiser∗ Anselm Levskaya Google Research Google Research {lukaszkaiser,levskaya}@google.com ",
+        "bbox": [
+            437,
+            145,
+            803,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            223,
+            544,
+            238
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Large Transformer models routinely achieve state-of-the-art results on a number of tasks but training these models can be prohibitively costly, especially on long sequences. We introduce two techniques to improve the efficiency of Transformers. For one, we replace dot-product attention by one that uses locality-sensitive hashing, changing its complexity from $\\mathrm { O } ( L ^ { 2 } )$ to $\\mathrm { O } ( L \\log L )$ , where $L$ is the length of the sequence. Furthermore, we use reversible residual layers instead of the standard residuals, which allows storing activations only once in the training process instead of $N$ times, where $N$ is the number of layers. The resulting model, the Reformer, performs on par with Transformer models while being much more memory-efficient and much faster on long sequences. ",
+        "bbox": [
+            233,
+            256,
+            764,
+            395
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            424,
+            334,
+            439
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The Transformer architecture (Vaswani et al., 2017) is widely used in natural language processing and yields state-of-the-art results on a number of tasks. To obtain these results, researchers have resorted to training ever larger Transformer models. The number of parameters exceeds 0.5B per layer in the largest configuration reported in (Shazeer et al., 2018) while the number of layers goes up to 64 in (Al-Rfou et al., 2018). Transformer models are also used on increasingly long sequences. Up to 11 thousand tokens of text in a single example were processed in (Liu et al., 2018) and when processing other modalities, like music (Huang et al., 2018) and images (Parmar et al., 2018), even longer sequences are commonplace. These large-scale long-sequence models yield great results but strain resources to the point where some argue that this trend is breaking NLP research1. Many large Transformer models can only realistically be trained in large industrial research laboratories and such models trained with model parallelism cannot even be fine-tuned on a single GPU as their memory requirements demand a multi-accelerator hardware setup even for a single training step. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            622
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Do large Transformer models fundamentally require such huge resources or are they simply inefficient? Consider the following calculation: the 0.5B parameters used in the largest reported Transformer layer account for 2GB of memory. Activations for 64K tokens with embedding size 1024 and batch size 8 account for $6 4 \\mathrm { K } \\times 1 \\mathrm { K } \\times 8 = 0 . 5 \\mathrm { B }$ floats, requiring another 2GB of memory. If our memory use was only per-layer, then we should fairly easily fit a large Transformer even on sequences of length 64K on a single accelerator. Further, the whole corpus used to train BERT only requires 17GB to store. Why is it then that we cannot even fine-tune these models on single machines? ",
+        "bbox": [
+            173,
+            630,
+            825,
+            741
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The above estimate includes only per-layer memory and input activations cost and does not take into account the following major sources of memory use in the Transformer. ",
+        "bbox": [
+            174,
+            748,
+            823,
+            776
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Memory in a model with $N$ layers is $N$ -times larger than in a single-layer model due to the fact that activations need to be stored for back-propagation. • Since the depth $d _ { f f }$ of intermediate feed-forward layers is often much larger than the depth $d _ { m o d e l }$ of attention activations, it accounts for a large fraction of memory use. • Attention on sequences of length $L$ is $\\mathrm { O } ( L ^ { 2 } )$ in both computational and memory complexity, so even for a single sequence of 64K tokens can exhaust accelerator memory. ",
+        "bbox": [
+            215,
+            789,
+            826,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce the Reformer model which solves these problems using the following techniques: ",
+        "bbox": [
+            173,
+            103,
+            797,
+            118
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Reversible layers, first introduced in Gomez et al. (2017), enable storing only a single copy of activations in the whole model, so the $N$ factor disappears.   \n• Splitting activations inside feed-forward layers and processing them in chunks removes the $d _ { f f }$ factor and saves memory inside feed-forward layers.   \n• Approximate attention computation based on locality-sensitive hashing replaces the $\\mathrm { O } ( L ^ { 2 } )$ factor in attention layers with $\\mathrm { O } ( L \\log L )$ and so allows operating on long sequences. ",
+        "bbox": [
+            215,
+            130,
+            825,
+            227
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We study these techniques and show that they have negligible impact on the training process compared to the standard Transformer. Splitting activations in fact only affects the implementation; it is numerically identical to the layers used in the Transformer. Applying reversible residuals instead of the standard ones does change the model but has a negligible effect on training in all configurations we experimented with. Finally, locality-sensitive hashing in attention is a more major change that can influence the training dynamics, depending on the number of concurrent hashes used. We study this parameter and find a value which is both efficient to use and yields results very close to full attention. ",
+        "bbox": [
+            173,
+            238,
+            825,
+            349
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We experiment on a synthetic task, a text task (enwik8) with sequences of length 64K and an image generation task (imagenet-64 generation) with sequences of length 12K. In both cases we show that Reformer matches the results obtained with full Transformer but runs much faster, especially on the text task, and with orders of magnitude better memory efficiency. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            412
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 LOCALITY-SENSITIVE HASHING ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            433,
+            576,
+            449
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Dot-product attention. The standard attention used in the Transformer is the scaled dot-product attention (Vaswani et al., 2017). The input consists of queries and keys of dimension $d _ { k }$ , and values√ of dimension $d _ { v }$ . The dot products of the query with all keys are computed, scaled by $\\sqrt { d _ { k } }$ , and a softmax function is applied to obtain the weights on the values. In practice, the attention function on a set of queries is computed simultaneously, packed together into a matrix $Q$ . Assuming the keys and values are also packed together into matrices $K$ and $V$ , the matrix of outputs is defined as: ",
+        "bbox": [
+            173,
+            464,
+            825,
+            547
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9cb6853b84289d7f7cb3fce665cdc585ea953917672cf535fb92129ff9824f8e.jpg",
+        "text": "$$\n\\mathrm { A t t e n t i o n } ( Q , K , V ) = \\mathrm { s o f t m a x } ( \\frac { Q K ^ { T } } { \\sqrt { d _ { k } } } ) V\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            565,
+            642,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-head attention. In the Transformer, instead of performing a single attention function with $d _ { m o d e l }$ -dimensional keys, values and queries, one linearly projects the queries, keys and values $h$ times with different, learned linear projections to $d _ { k } , d _ { k }$ and $d _ { v }$ dimensions, respectively. Attention is applied to each of these projected versions of queries, keys and values in parallel, yielding $d _ { v }$ - dimensional output values. These are concatenated and once again projected, resulting in the final values. This mechanism is known as multi-head attention. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            694
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Memory-efficient attention. To calculate the memory use of the attention mechanism, let us focus on the attention computation from Equation 1. Let us assume that Q, K and $\\mathrm { v }$ all have the shape $\\left[ b a t c h \\_ s i z e , l e n g t h , d _ { m o d e l } \\right]$ . The main issue is the term $Q K ^ { T }$ , which has the shape [batch size, length, length]. In the experimental section we train a model on sequences of length $6 4 K$ – in this case, even at batch-size of 1, this is a $6 4 K \\times 6 4 K$ matrix, which in 32-bit floats would take 16GB of memory. This is impractical and has hindered the use of the Transformer for long sequences. But it is important to note that the $Q K ^ { T }$ matrix does not need to be fully materialized in memory. The attention can indeed be computed for each query $q _ { i }$ separately, only calculating $\\mathrm { s o f t m a x } ( \\frac { q _ { i } K ^ { T } } { \\sqrt { d _ { k } } } ) V$ once in memory, and then re-computing it on the backward pass when needed for gradients. This way of computing attention may be less efficient but it only uses memory proportional to length. We use this memory-efficient implementation of attention to run the full-attention baselines presented in the experimental section. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Where do Q, K, V come from? The multi-head attention described above operates on keys, queries and values, but usually we are only given a single tensor of activations A of the shape [batch size, length, $d _ { m o d e l } ]$ – e.g., coming from embedding the tokens in a sentence into vectors. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/933641c2e559997bd69cf9ce03c0b729d65931c290db258544018d21c672f8d7.jpg",
+        "image_caption": [
+            "Figure 1: An angular locality sensitive hash uses random rotations of spherically projected points to establish buckets by an argmax over signed axes projections. In this highly simplified 2D depiction, two points $x$ and $y$ are unlikely to share the same hash buckets (above) for the three different angular hashes unless their spherical projections are close to one another (below). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            98,
+            758,
+            272
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To build Q, K and V from A, the Transformer uses 3 different linear layers projecting A into Q, K and $\\mathrm { v }$ with different parameters. For models with LSH attention, we want queries and keys (Q and K) to be identical. This is easily achieved by using the same linear layer to go from A to Q and K, and a separate one for V. We call a model that behaves like this a shared-QK Transformer. It turns out that sharing QK does not affect the performance of Transformer, even if we additionally normalize the length of the keys K, as we show in the experimental Section 5. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            449
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hashing attention. For the LSH attention, we start with two tensors, $\\mathrm { Q } { = } \\mathrm { K }$ and $\\mathrm { v }$ of the shape [batch size, length, $d _ { m o d e l } ]$ . We keep the multi-head mechanism intact and focus on the attention computation from Equation 1. As already mentioned, the main issue is the term $Q K ^ { T }$ , which has the shape [batch size, length, length]. But note that we are actually only interested in softmax $\\left( Q K ^ { T } \\right)$ . Since softmax is dominated by the largest elements, for each query $q _ { i }$ we only need to focus on the keys in K that are closest to $q _ { i }$ . For example, if K is of length 64K, for each $q _ { i }$ we could only consider a small subset of, say, the 32 or 64 closest keys. That is much more efficient, but how can we find the nearest neighbors among the keys? ",
+        "bbox": [
+            173,
+            455,
+            825,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Locality sensitive hashing. The problem of finding nearest neighbors quickly in high-dimensional spaces can be solved by locality-sensitive hashing (LSH). A hashing scheme that assigns each vector $x$ to a hash $h ( x )$ is called locality-sensitive if nearby vectors get the same hash with high probability and distant ones do not. In our case, we actually only require that nearby vectors get the same hash with high probability and that hash-buckets are of similar size with high probability. ",
+        "bbox": [
+            174,
+            573,
+            825,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We achieve this by employing random projections as follows (see Figure 1). To get $b$ hashes, we first fix a random matrix $R$ of size $[ d _ { k } , b / 2 ]$ . We then define $h ( x ) = \\arg \\operatorname* { m a x } ( [ x R ; - x R ] )$ where $[ u ; v ]$ denotes the concatenation of two vectors. This method is a known LSH scheme (Andoni et al., 2015) and is easy to implement and apply to batches of vectors. ",
+        "bbox": [
+            173,
+            650,
+            825,
+            707
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "LSH attention. Knowing our LSH scheme and the general idea of hashing attention, we will now formalize the LSH attention we use in this paper. We first rewrite the equation for normal attention, (1), for a single query position $i$ at a time: ",
+        "bbox": [
+            173,
+            713,
+            825,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/525103dc3c8755e5e88c93e6a679f309047d2e85184d38540a79184a8bc54e82.jpg",
+        "text": "$$\no _ { i } = \\sum _ { j \\in \\mathcal { P } _ { i } } \\exp \\left( q _ { i } \\cdot k _ { j } - z ( i , \\mathcal { P } _ { i } ) \\right) v _ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            757,
+            496,
+            792
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We introduce the notation $\\mathcal { P } _ { i }$ to represent the set that the query at position $i$ attends to, and $z$ to denote the partition function (i.e. the normalizing term in the softmax). For clarity, we also omit scaling by $\\sqrt { d _ { k } }$ . ",
+        "bbox": [
+            173,
+            801,
+            825,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For batching purposes we typically perform attention over a larger set $\\widetilde { \\mathcal { P } } _ { i } = \\{ 0 , 1 , \\ldots , l \\} \\supseteq \\mathcal { P } _ { i }$ while masking out elements not in $\\mathcal { P } _ { i }$ : ",
+        "bbox": [
+            173,
+            851,
+            823,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/08f4522cdd3c1a8ddd1b481c92ad266a1a369c444b0e7912d6a3419871afbcbf.jpg",
+        "text": "$$\no _ { i } = \\sum _ { j \\in \\widetilde { \\mathcal { P } } _ { i } } \\exp \\left( q _ { i } \\cdot k _ { j } - m ( j , \\mathcal { P } _ { i } ) - z ( i , \\mathcal { P } _ { i } ) \\right) v _ { j } \\quad \\mathrm { ~ w h e r e ~ } m ( j , \\mathcal { P } _ { i } ) = \\left\\{ \\begin{array} { l l } { \\infty } & { \\mathrm { i f ~ } j \\notin \\mathcal { P } _ { i } } \\\\ { 0 } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            885,
+            782,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1e04a6a1048a7c4f8520f431a67d94733d4c42885c7030ea46659a056ee2e509.jpg",
+        "image_caption": [
+            "Figure 2: Simplified depiction of LSH Attention showing the hash-bucketing, sorting, and chunking steps and the resulting causal attentions. (a-d) Attention matrices for these varieties of attention. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            103,
+            789,
+            287
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Now we turn to LSH attention, which we can think of in terms of restricting the set $\\mathcal { P } _ { i }$ of target items a query position $i$ can attend to, by only allowing attention within a single hash bucket. ",
+        "bbox": [
+            176,
+            358,
+            820,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/132a1fc75b22088573f49deec2ae0e5c573305452abab541a04f5de22a1fc21b.jpg",
+        "text": "$$\n\\mathcal { P } _ { i } = \\{ j : h ( q _ { i } ) = h ( k _ { j } ) \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            393,
+            586,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 2(a-b) shows a schematic comparison of full-attention with a hashed variant. Part (a) depicts that the attention matrix for full attention is typically sparse, but the computation does not take advantage of this sparsity. In (b), the queries and keys have been sorted according to their hash bucket. Since similar items fall in the same bucket with high probability, the full attention pattern can be approximated by only allowing attention within each bucket. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hash buckets in this formulation tend to be uneven in size, which makes it difficult to batch across buckets. Moreover, the number of queries and the number of keys within a bucket may be unequal – in fact, it is possible for a bucket to contain many queries but no keys. To alleviate these issues, we first ensure that h(kj ) = h(qj ) by setting kj = $\\begin{array} { r } { k _ { j } = \\frac { \\dot { q _ { j } } } { | | q _ { j } | | } } \\end{array}$ . Next, we sort the queries by bucket number and, within each bucket, by sequence position; this defines a permutation where $i \\mapsto s _ { i }$ after sorting. In the sorted attention matrix, pairs from the same bucket will cluster near the diagonal (as depicted in Figure $2 \\mathrm { c }$ ). We can follow a batching approach where chunks of $m$ consecutive queries (after sorting) attend to each other, and one chunk back (Figure 2d). Following our earlier notation, this corresponds to setting: ",
+        "bbox": [
+            173,
+            502,
+            825,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/03268e04bb4e5c07fa9dc76659b0067e16a6ca4e5834cbc1fd41b4eeff5c39cb.jpg",
+        "text": "$$\n\\widetilde { \\mathcal { P } } _ { i } = \\left\\{ j : \\left\\lfloor { \\frac { s _ { i } } { m } } \\right\\rfloor - 1 \\leq \\left\\lfloor { \\frac { s _ { j } } { m } } \\right\\rfloor \\leq \\left\\lfloor { \\frac { s _ { i } } { m } } \\right\\rfloor \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            630,
+            630,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If $\\operatorname* { m a x } _ { i } \\left| \\mathcal { P } _ { i } \\right| < m$ , then $\\mathcal { P } _ { i } \\subseteq \\widetilde { \\mathcal { P } } _ { i }$ . In practice we set $\\begin{array} { r } { m = \\frac { 2 l } { n _ { b u c k e t s } } } \\end{array}$ (where $l$ is the sequence length). The average bucket size is $\\frac { l } { n _ { b u c k e t s } }$ , and we assume that the probability of a bucket growing to twice that size is sufficiently low. The overall process of LSH attention is summarized in Figure 2. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            713
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Multi-round LSH attention. With hashing, there is always a small probability that similar items nevertheless fall in different buckets. This probability can be reduced by doing multiple rounds of hashing with $n _ { r o u n d s }$ distinct hash functions $\\{ h ^ { ( 1 ) } , h ^ { \\left( 2 \\right) } , \\ldots \\}$ , such that: ",
+        "bbox": [
+            174,
+            719,
+            825,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ed32fa46b9d72dc92ab141aa5df595500b7b012f5bc737cb273b33143cd78bd0.jpg",
+        "text": "$$\n{ \\mathcal P } _ { i } = \\bigcup _ { r = 1 } ^ { n _ { r o u n d s } } { \\mathcal P } _ { i } ^ { ( r ) } \\qquad \\mathrm { w h e r e } ~ { \\mathcal P } _ { i } ^ { ( r ) } = \\Big \\{ j : h ^ { ( r ) } ( q _ { i } ) = h ^ { ( r ) } ( q _ { j } ) \\Big \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            770,
+            738,
+            813
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The multi-round case essentially involves performing LSH attention $n _ { r o u n d s }$ times in parallel; the details of the procedure are described in in Appendix A. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Causal masking for shared-QK attention. In a Transformer decoder, masking (denoted by $m ( j , \\mathcal { P } _ { i } )$ in Equation 3) is used to prevent positions from attending into the future. To implement masking in LSH attention, we associate every query/key vector with a position index, re-order the position indices using the same permutations used to sort the query/key vectors, and then use a comparison operation to compute the mask. ",
+        "bbox": [
+            173,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/24470169d739301dd482f090bfc26a0d6a989d04559e3a83297597120ba2219e.jpg",
+        "table_caption": [
+            "Table 1: Memory and time complexity of attention variants. We write $l$ for length, $b$ for batch size, $n _ { h }$ for the number of heads, $n _ { c }$ for the number of LSH chunks, $n _ { r }$ for the number of hash repetitions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attention Type</td><td>Memory Complexity</td><td>Time Complexity</td></tr><tr><td>Scaled Dot-Product</td><td>max(bnnldk,bnnl²)</td><td>max(bnnldk,bnnl2)</td></tr><tr><td>Memory-Efficient</td><td>max(bnnldk,bnnl²)</td><td>max(bnhldk,bnnl²)</td></tr><tr><td>LSH Attention</td><td>max(bnnldk,bnnlnr(4l/nc)2)</td><td>max(bnhldk,bnhnrl(4l/nc)²)</td></tr></table>",
+        "bbox": [
+            202,
+            145,
+            795,
+            208
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/e3bbe130dad74e831b3d58b32876d854487242e403c5ea97ca47c263e1a728d0.jpg",
+        "table_caption": [
+            "Table 2: Accuracies on the duplication task of a 1-layer Transformer model with full attention and with locality-sensitive hashing attention using different number of parallel hashes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td rowspan=\"2\">Eval</td><td rowspan=\"2\">Full Attention</td><td rowspan=\"2\">LSH-8</td><td rowspan=\"2\">LSH-4</td><td rowspan=\"2\">LSH-2</td><td rowspan=\"2\">LSH-1</td></tr><tr><td>Train</td></tr><tr><td>Full Attention</td><td></td><td>100%</td><td>94.8%</td><td>92.5%</td><td>76.9%</td><td>52.5%</td></tr><tr><td colspan=\"2\">LSH-4</td><td>0.8%</td><td>100%</td><td>99.9%</td><td>99.4%</td><td>91.9%</td></tr><tr><td colspan=\"2\">LSH-2</td><td>0.8%</td><td>100%</td><td>99.9%</td><td>98.1%</td><td>86.8%</td></tr><tr><td colspan=\"2\">LSH-1</td><td>0.8%</td><td>99.9%</td><td>99.6%</td><td>94.8%</td><td>77.9%</td></tr></table>",
+        "bbox": [
+            254,
+            282,
+            741,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While attention to the future is not allowed, typical implementations of the Transformer do allow a position to attend to itself. Such behavior is undesirable in a shared-QK formulation because the dot-product of a query vector with itself will almost always be greater than the dot product of a query vector with a vector at another position. We therefore modify the masking to forbid a token from attending to itself, except in situations where a token has no other valid attention targets (e.g. the first token in a sequence). ",
+        "bbox": [
+            173,
+            412,
+            825,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.1 ANALYSIS ON A SYNTHETIC TASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            447,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To verify the performance of LSH attention and study its behavior, we start with the following synthetic task: duplicate a sequence of symbols. In this task, each training and testing example has the form $0 w 0 w$ where $w \\in \\bar { \\{ 1 , \\ldots , N \\} ^ { * } }$ is a sequence of symbols ranging from 1 to $N$ (we use $N = 1 2 7$ in our experiments). An example with the word $w$ of length 3 is given below. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            616
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/696df21446f4bd78a9b2abf31dd3683a1734cf855a47daaa421e391d52ede6c2.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Example:</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>19</td><td rowspan=1 colspan=1>113</td><td rowspan=1 colspan=1>72</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>19</td><td rowspan=1 colspan=1>113</td><td rowspan=1 colspan=1>72</td></tr></table>",
+        "bbox": [
+            305,
+            642,
+            687,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To study LSH attention, we train a language model on examples of the above form where each $w$ is of length 511 (so the whole input $0 w 0 w$ is of length 1024). As this is a language modeling task, we always predict the next symbol given all the previous ones, but we mask the loss and accuracy to only consider positions in the second half of the input, i.e., those that can actually be predicted. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The above task can be solved perfectly (to accuracy $100 \\%$ and loss 0) by a 1-layer Transformer model. Note though, that it requires non-local attention lookups, so it cannot be solved by any model relying on sparse attention with a limited span. To make it easy and fast to train but similar to models used in NLP, we use a 1-layer Transformer with $d _ { m o d e l } = d _ { f f } = 2 5 6$ and 4 heads. We train it for 150K steps in 4 different settings: with full attention, LSH attention with $n _ { r o u n d s } = 1$ , $n _ { r o u n d s } = 2$ and $n _ { r o u n d s } = 4$ . ",
+        "bbox": [
+            173,
+            750,
+            825,
+            834
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "From the results summarized in Table 2 we see that a model trained with full attention can be immediately used with LSH attention, but at some loss of accuracy. When trained from scratch with LSH attention, the model trained with 4 hashes achieves almost perfect accuracy as well. Interestingly, the accuracy becomes perfect when evaluated with 8 hashes. It goes down when evaluated with 2 or 1 hashes. Models trained with less hashes show worse results but even the model trained with just 1 hash performs almost perfectly when evaluated with 8 hashes. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 REVERSIBLE TRANSFORMER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            446,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As the above section shows, the complexity of attention can be reduced from square in length to linear, provided an approximation is acceptable. But it is clear from Table 1 that each field starts with a $b \\cdot n _ { h } \\cdot l$ term: the $b \\cdot n _ { h } \\cdot l \\cdot d _ { k }$ , or alternatively $b \\cdot l \\cdot d _ { m o d e l }$ cost cannot be avoided. Indeed, the activations before each layer are already of the size $b \\cdot l \\cdot d _ { m o d e l }$ , so the memory use of the whole model with $n _ { l }$ layers is at least $b \\cdot l \\cdot d _ { m o d e l } \\cdot n _ { l }$ . Even worse: inside the feed-forward layers of Transformer this goes up to $\\boldsymbol { b } \\cdot \\boldsymbol { l } \\cdot d _ { f f } \\cdot n _ { l }$ . In a big Transformer it is usual to set $d _ { f f } = 4 K$ and $n _ { l } = 1 6$ so with $l = 6 4 K$ this again would use an impractical $1 6 G B$ of memory ",
+        "bbox": [
+            173,
+            133,
+            825,
+            233
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we show how to reduce this cost by first dealing with the $n _ { l }$ part of the term using reversible layers and then showing how chunking can allow us to handle the $d _ { f f }$ problem. The effects of each of these approaches on memory and time complexity are summarized in Table 3. ",
+        "bbox": [
+            174,
+            238,
+            823,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "RevNets. Reversible residual networks were introduced by Gomez et al. (2017) where it was shown that they can replace ResNets for image classification. The main idea is to allow the activations at any given layer to be recovered from the activations at the following layer, using only the model parameters. Rather than having to checkpoint intermediate values for use in the backward pass, layers can be reversed one-by-one as back-propagation proceeds from the output of the network to its input. Whereas a normal residual layer performs a function $x \\mapsto y$ that operates on a single input and produces a single output and has the form $y = x + F ( x )$ , a reversible layer works on pairs of inputs/outputs: $( x _ { 1 } , x _ { 2 } ) \\mapsto ( y _ { 1 } , y _ { 2 } )$ , and follows the equations: ",
+        "bbox": [
+            173,
+            287,
+            825,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9e3cd54d2f60af4e972bd8d8520244671774f629b0bac926627e4614217752f6.jpg",
+        "text": "$$\ny _ { 1 } = x _ { 1 } + F ( x _ { 2 } ) y _ { 2 } = x _ { 2 } + G ( y _ { 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            406,
+            686,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A layer can be reversed by subtracting (rather than adding) the residuals: ",
+        "bbox": [
+            173,
+            440,
+            651,
+            455
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ede7b87e7d7a707641831c268d6cf050d5f88e9f6e70adf497e8129d93d74e78.jpg",
+        "text": "$$\nx _ { 2 } = y _ { 2 } - G ( y _ { 1 } ) x _ { 1 } = y _ { 1 } - F ( x _ { 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            463,
+            686,
+            482
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Reversible Transformer. We apply the RevNet idea to the Transformer by combining the attention and feed-forward layers inside the revnet block. In the notation above, F becomes an attention layer while $\\mathbf { G }$ becomes the feed-forward layer. Note that Layer Normalization (Ba et al., 2016) is moved inside the residual blocks. ",
+        "bbox": [
+            173,
+            496,
+            825,
+            553
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/75b4d028a678d86bf0ee6e3647e153cef36cd85379afd04c356fb37787c36d96.jpg",
+        "text": "$$\nY _ { 1 } = X _ { 1 } + \\mathrm { A t t e n t i o n } ( X _ { 2 } ) \\qquad Y _ { 2 } = X _ { 2 } + \\mathrm { F e e d F o r w a r d } ( Y _ { 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            560,
+            736,
+            579
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The reversible Transformer does not need to store activations in each layer and so gets rid of the $n _ { l }$ term. In Section 5 we show that it performs the same as the normal Transformer when using the same number of parameters; we achieve this by having both $x _ { 1 }$ and $x _ { 2 }$ have size $d _ { m o d e l }$ . ",
+        "bbox": [
+            174,
+            593,
+            825,
+            637
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Chunking. While reversibility covers the $n _ { l }$ term, the thicker layers can still use a lot of memory. The feed-forward layer in particular can use intermediate vectors of dimensionality $d _ { f f } = 4 K$ or higher. However, computations in feed-forward layers are completely independent across positions in a sequence, so the computation can be split into $c$ chunks: ",
+        "bbox": [
+            174,
+            642,
+            825,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1e10308d22e821b8cd31af648d801fa0dba5dc03220433cba375c5431ea97066.jpg",
+        "text": "$$\nY _ { 2 } = \\left[ Y _ { 2 } ^ { ( 1 ) } ; \\ldots ; Y _ { 2 } ^ { ( c ) } \\right] = \\left[ X _ { 2 } ^ { ( 1 ) } + { \\mathrm { F e e d F o r w a r d } } ( Y _ { 1 } ^ { ( 1 ) } ) ; \\ldots ; X _ { 2 } ^ { ( c ) } + { \\mathrm { F e e d F o r w a r d } } ( Y _ { 1 } ^ { ( c ) } ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            707,
+            784,
+            734
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This layer is typically batched by performing operations for all positions in parallel, but operating on one chunk at a time can reduce memory. The reverse computation in (8) and the backward pass are also chunked. In addition to the feed-forward layers, for models with large vocabulary (more than $d _ { m o d e l }$ word types) we also chunk the log-probabilities at the output and calculate the loss for sections of the sequence at a time. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Chunking, large batches and parameter reuse. With chunking and reversible layers the memory we use for activations in the whole network is independent of the number of layers. The same is not true for parameters though as their number grows with the number of layers. This problem is remedied though because we can swap layer parameters to and from CPU memory when this layer is not computing. In a standard Transformer this would be inefficient because memory transfer to CPU is slow. The batch size multiplied by length in Reformer is much larger though and therefore the amount of compute done with the parameters amortizes the cost of their transfer. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/f0bb78213a31e944db874448563833dfc16a49d2bace547e66dac7e2a7626aee.jpg",
+        "table_caption": [
+            "Table 3: Memory and time complexity of Transformer variants. We write $d _ { m o d e l }$ and $d _ { f f }$ for model depth and assume $d _ { f f } \\geq d _ { m o d e l }$ ; $b$ stands for batch size, $l$ for length, $n _ { l }$ for the number of layers. We assume $n _ { c } = l / 3 2$ so $4 l / n _ { c } = 1 2 8$ and we write $c = 1 2 8 ^ { 2 }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model Type</td><td>Memory Complexity</td><td>Time Complexity</td></tr><tr><td>Transformer</td><td>max(bldff,bnnl²)nt</td><td>(bldff+bnnl²)nt</td></tr><tr><td>Reversible Transformer</td><td>max(bldff,bnhl²)</td><td>(bnhldff+bnnl2)nl</td></tr><tr><td>Chunked Reversible Transformer</td><td>max(bldmodet, bnnl2)</td><td>(bnnldff+bnnl²)nl</td></tr><tr><td>LSHTransformer</td><td>max(bldff,bnnlnrc)ni</td><td>(bldff+bnhnrlc)ni</td></tr><tr><td>Reformer</td><td>max(bldmodel,bnhlnrc)</td><td>(bldff+bnhnrlc)ni</td></tr></table>",
+        "bbox": [
+            210,
+            160,
+            789,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            284,
+            344,
+            300
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The Transformer model introduced in (Vaswani et al., 2017) has been used widely in natural language tasks and further extended to model diverse data such as music scores (Huang et al., 2018), and images (Parmar et al., 2018; Ramachandran et al., 2019). Most notably, this model class has been applied successfully in the self-supervised training of extremely large language models (Devlin et al., 2018; Radford et al., 2019). ",
+        "bbox": [
+            174,
+            319,
+            825,
+            388
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Given the enormous computational requirements of state of the art sequence models, there has been increasing interest in finding methods to reduce the memory footprint and computational requirements of Transformer models. In addition to standard methods such as precision reduction and gradient checkpointing (Sohoni et al., 2019), more efficient versions of the Transformer model’s self-attention mechanism (Sukhbaatar et al., 2019a;b) have also recently been explored. ",
+        "bbox": [
+            174,
+            396,
+            823,
+            465
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In particular, leveraging sparsity in the attention layers has proved fruitful. OpenAI introduced the sparse Transformer (Child et al., 2019) which exploits a factorized sparse representation of attention. Using product-key attention to increase the key space has also been used to reduce memory requirements in the feed-forward layers with no loss in performance (Lample et al., 2019). ",
+        "bbox": [
+            174,
+            473,
+            825,
+            529
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Locality-sensitive hashing (LSH) has, to our knowledge, not been directly applied to Transformer attention layers before. But previous work using external memory with neural networks has dealt with memories of large sizes. The original implementation of memory networks (Weston et al., 2014) and later work on scaling it (Bordes et al., 2015; Chandar et al., 2016) used memory with size in the millions. The cost of doing so is that the memory must be fixed prior to training. Moreover, since during the beginning of training the model is unlikely to query the memory correctly, strong supervision is used to encourage the model to query memory locations that are useful. These hints are either given as additional supervising information by the task or determined heuristically as in Hill et al. (2015). The requirement that the memory be fixed before has been removed in Santoro et al. (2016) at the cost of memory size and later alleviated by Rae et al. (2016). The last paper considered memory lookups with approximate nearest neighbors including both LSH and random kd-trees, but only for lookups in external memory. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            702
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            728,
+            326,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we present experimental results demonstrating the techniques described above. We analyze the techniques one-by-one to make clear which combinations have impact on performance. We start by showing that reversible layers and shared query-key spaces do not impact performance, then proceed to analyze hashing attention and finally the full Reformer model. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We ran our experiments on the imagenet64 and enwik8-64K tasks, where the latter is a variant of enwik8 that is chunked into subsequences of $2 ^ { 1 6 } \\ : = \\ : 6 4 K$ tokens. We use 3-layer models for our ablations so as to make it tractable to compare with the regular Transformer, which has high memory usage and performs full $O ( l ^ { 2 } )$ attention. All experiments have $d _ { m o d e l } = 1 0 2 4$ , $d _ { f f } = 4 0 9 6$ , $n _ { h e a d s } ~ = ~ 8$ , and a total batch size of 8 sequences. We used the Adafactor optimizer (Shazeer & Stern, 2018) for training these models. We also evaluate on the WMT 2014 English-to-German translation task, following the hyperparameters of Vaswani et al. (2017). Training for all experiments was parallelized across 8 devices (8 GPUs or 8 TPU v3 cores). Code for training our models is made publicly available.2 ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c2fe4e4314fc0b82d2981ba18326ffd9fc27b3df97ee0b18eda40840efe41fac.jpg",
+        "image_caption": [
+            "Figure 3: Effect of shared query-key space (left) and reversibility (right) on performance on enwik8 and imagenet64 training. The curves show bits per dim on held-out data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            104,
+            784,
+            367
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/296cf61e1a648082213a0790080061668c5c48262a7253f9397d3a0df41d9f52.jpg",
+        "table_caption": [
+            "Table 4: BLEU scores on newstest2014 for WMT English-German (En–De). We additionally report detokenized BLEU scores as computed by sacreBLEU (Post, 2018). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"3\">sacreBLEU</td></tr><tr><td>BLEU</td><td>Uncased3</td><td>Cased4</td></tr><tr><td>Vaswani etal. (2017),base model</td><td>27.3</td><td></td><td></td></tr><tr><td>Vaswani et al. (2017), big</td><td>28.4</td><td></td><td></td></tr><tr><td>Ott et al. (2018), big</td><td>29.3</td><td></td><td></td></tr><tr><td>Reversible Transformer (base,10oK steps)</td><td>27.6</td><td>27.4</td><td>26.9</td></tr><tr><td>Reversible Transformer (base,5OoK steps,no weight sharing)</td><td>28.0</td><td>27.9</td><td>27.4</td></tr><tr><td>Reversible Transformer (big,3OOK steps,no weight sharing)</td><td>29.1</td><td>28.9</td><td>28.4</td></tr></table>",
+        "bbox": [
+            178,
+            477,
+            820,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            622,
+            823,
+            651
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effect of sharing QK. We first consider the effect of shared-QK attention on a regular Transformer model. Shared-QK attention sets $\\begin{array} { r } { k _ { j } ~ = ~ \\frac { q _ { j } } { \\parallel q _ { j } \\parallel } } \\end{array}$ and prevents tokens from attending to themselves (except when no other context is available). In the left part of Figure 3, we plot perplexity curves for both regular and shared-QK attention. A shared query-key space does not perform worse than regular attention; in fact, for enwik8 it appears to train slightly faster. In other words, we are not sacrificing accuracy by switching to shared-QK attention. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            744
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effect of reversible layers. In the two plots on the right in Figure 3, we compare a regular Transformer per Vaswani et al. (2017) with the reversible one describe in Section 3. The two models have identical parameter counts, and the learning curves likewise appear to be nearly the same. These results show that the memory savings in the reversible Transformer do not come at the expense of accuracy. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Reversible layers in machine translation. We also evaluate reversible layers in the context of an encoder-decoder Transformer model for machine translation from English to German. We start by making both the encoder and the decoder fully reversible in the Transformer-base architecture, and see that the resulting model performs comparably to Vaswani et al. (2017) when trained for 100K steps. We also evaluate training for a greater number of steps and with a larger model. Reformer models are very memory-efficient, so for the latter two experiments we do not need to save memory by sharing embedding and output projection weight matrices throughout the model. Results are shown in Table 4. We do not apply LSH attention in this setting because examples are single sentences, and sentences tend to be relatively short. Our typical LSH attention configuration uses chunks of 128 tokens after hashing and sorting, whereas the examples in the WMT14 test set are all shorter than 128 tokens. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            871
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/da5d76906fcbfcc141fd40ccc521929fac0f14397c36dfbe9348757cafb44e35.jpg",
+        "image_caption": [
+            "Figure 4: LSH attention performance as a function of hashing rounds on imagenet64. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            108,
+            816,
+            297
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/a6f457e38c79efcd959c9f60f3b2617e1d74b576a80218106af9af3bde2fe678.jpg",
+        "image_caption": [
+            "Figure 5: Left: LSH attention performance as a function of number of layers on enwik8. Right: Speed of attention evaluation as a function of input length for full- and LSH- attention. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            362,
+            805,
+            502
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            589,
+            825,
+            700
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "LSH attention in Transformer. LSH attention is an approximation for full attention that, as evidenced in Figure 4, becomes more accurate as the number of hashes increases. At $n _ { r o u n d s } = 8$ , it already almost matches full attention. The computational cost of a model grows with the number of hashes, so this hyperparameter can be adjusted depending on the available compute budget. Additionally, as in Table 2, the number of hashes can be increased at evaluation time to produce more accurate results. On the right half of Figure 5, we plot the speed of different attention types vs. the sequence length, while holding the total number of tokens fixed. We see that while regular attention becomes slower at longer sequence length, LSH attention speed remains flat. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Large Reformer models. To verify that the Reformer can indeed fit large models on a single core and train fast on long sequences, we train up to 20-layer big Reformers on enwik8 and imagenet64. As can be seen in Figure 5, these models fit into memory and train. We were not able to train Transformer baselines in this case as they are too slow and memory-hungry, but we see clear improvement with the number of layers. A 12-layer model on enwik8 trained for 20K steps with a dropout rate of 0.1 achieves 1.19 bits/dim on the test set. We also trained a 12-layer Reformer model for longer with further tuning and improvements and we reached 1.05 bits/dim on the enwiki8 test set. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Reformer combines the modeling capacity of a Transformer with an architecture that can be executed efficiently on long sequences and with small memory use even for models with a large number of layers. We believe that this will help large, richly-parameterized Transformer models become more widespread and accessible. Also, the ability to handle long sequences opens the way for the use of the Reformer on many generative tasks. In addition to generating very long coherent text, the Reformer can bring the power of Transformer models to other domains like time-series forecasting, music, image and video generation. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            253,
+            285,
+            268
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rami Al-Rfou, Dokook Choe, Noah Constant, Mandy Guo, and Llion Jones. Character-level language modeling with deeper self-attention. CoRR, abs/1808.04444, 2018. URL http: //arxiv.org/abs/1808.04444.   \nAlexandr Andoni, Piotr Indyk, Thijs Laarhoven, Ilya P. Razenshteyn, and Ludwig Schmidt. Practical and optimal LSH for angular distance. CoRR, abs/1509.02897, 2015. URL http://arxiv. org/abs/1509.02897.   \nJimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. URL http://arxiv.org/abs/1607.06450.   \nAntoine Bordes, Nicolas Usunier, Sumit Chopra, and Jason Weston. Large-scale simple question answering with memory networks. CoRR, abs/1506.02075, 2015. URL http://arxiv.org/ abs/1506.02075.   \nSarath Chandar, Sungjin Ahn, Hugo Larochelle, Pascal Vincent, Gerald Tesauro, and Yoshua Bengio. Hierarchical memory networks. arXiv preprint arXiv:1605.07427, 2016.   \nRewon Child, Scott Gray, Alec Radford, and Ilya Sutskever. Generating long sequences with sparse transformers. URL https://openai.com/blog/sparse-transformers, 2019.   \nJacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. CoRR, abs/1810.04805, 2018. URL http://arxiv.org/abs/1810.04805.   \nAidan N Gomez, Mengye Ren, Raquel Urtasun, and Roger B Grosse. The reversible residual network: Backpropagation without storing activations. In Advances in neural information processing systems, pp. 2214–2224, 2017.   \nFelix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. CoRR, abs/1511.02301, 2015. URL http://arxiv.org/abs/1511.02301.   \nCheng-Zhi Anna Huang, Ashish Vaswani, Jakob Uszkoreit, Noam Shazeer, Curtis Hawthorne, Andrew M Dai, Matthew D Hoffman, and Douglas Eck. Music transformer: Generating music with long-term structure. arXiv preprint arXiv:1809.04281, 2018.   \nGuillaume Lample, Alexandre Sablayrolles, Marc’Aurelio Ranzato, Ludovic Denoyer, and Herve´ Jegou. Large memory layers with product keys. ´ CoRR, abs/1907.05242, 2019. URL http: //arxiv.org/abs/1907.05242.   \nPeter J. Liu, Mohammad Saleh, Etienne Pot, Ben Goodrich, Ryan Sepassi, Lukasz Kaiser, and Noam Shazeer. Generating wikipedia by summarizing long sequences. CoRR, abs/1801.10198, 2018. URL http://arxiv.org/abs/1801.10198.   \nMyle Ott, Sergey Edunov, David Grangier, and Michael Auli. Scaling neural machine translation. In Proceedings of the Third Conference on Machine Translation: Research Papers, pp. 1–9, Brussels, Belgium, October 2018. Association for Computational Linguistics. doi: 10.18653/v1/W18-6301. URL https://www.aclweb.org/anthology/W18-6301. ",
+        "bbox": [
+            171,
+            273,
+            826,
+            926
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Lukasz Kaiser, Noam Shazeer, and Alexander Ku. Image transformer. CoRR, abs/1802.05751, 2018. URL http://arxiv.org/abs/1802. 05751. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matt Post. A call for clarity in reporting BLEU scores. In Proceedings of the Third Conference on Machine Translation: Research Papers, pp. 186–191, Belgium, Brussels, October 2018. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/ W18-6319. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            210
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Jeff Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. 2019. ",
+        "bbox": [
+            173,
+            219,
+            823,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jack W Rae, Jonathan J Hunt, Tim Harley, Ivo Danihelka, Andrew Senior, Greg Wayne, Alex Graves, and Timothy P Lillicrap. Scaling memory-augmented neural networks with sparse reads and writes. In Advances in Neural Information Processing Systems, (NIPS), 2016. ",
+        "bbox": [
+            174,
+            257,
+            823,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Prajit Ramachandran, Niki Parmar, Ashish Vaswani, Irwan Bello, Anselm Levskaya, and Jonathon Shlens. Stand-alone self-attention in vision models. CoRR, abs/1906.05909, 2019. URL http: //arxiv.org/abs/1906.05909. ",
+        "bbox": [
+            174,
+            309,
+            823,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy P. Lillicrap. Oneshot learning with memory-augmented neural networks. CoRR, abs/1605.06065, 2016. URL http://arxiv.org/abs/1605.06065. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Noam Shazeer and Mitchell Stern. Adafactor: Adaptive learning rates with sublinear memory cost. CoRR, abs/1804.04235, 2018. URL http://arxiv.org/abs/1804.04235. ",
+        "bbox": [
+            173,
+            412,
+            823,
+            441
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Noam Shazeer, Youlong Cheng, Niki Parmar, Dustin Tran, Ashish Vaswani, Penporn Koanantakool, Peter Hawkins, HyoukJoong Lee, Mingsheng Hong, Cliff Young, Ryan Sepassi, and Blake Hechtman. Mesh-tensorflow: Deep learning for supercomputers. CoRR, abs/1811.02084, 2018. URL http://arxiv.org/abs/1811.02084. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            507
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nimit Sharad Sohoni, Christopher Richard Aberger, Megan Leszczynski, Jian Zhang, and Christopher Re. Low-memory neural network training: A technical report. ´ CoRR, abs/1904.10631, 2019. URL http://arxiv.org/abs/1904.10631. ",
+        "bbox": [
+            174,
+            516,
+            823,
+            559
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Edouard Grave, Piotr Bojanowski, and Armand Joulin. Adaptive attention span in transformers. CoRR, abs/1905.07799, 2019a. URL http://arxiv.org/abs/ 1905.07799. ",
+        "bbox": [
+            171,
+            568,
+            825,
+            609
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Edouard Grave, Guillaume Lample, Herve J ´ egou, and Armand Joulin. Aug- ´ menting self-attention with persistent memory. CoRR, abs/1907.01470, 2019b. URL http: //arxiv.org/abs/1907.01470. ",
+        "bbox": [
+            171,
+            619,
+            823,
+            661
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, 2017. URL http: //arxiv.org/abs/1706.03762. ",
+        "bbox": [
+            171,
+            670,
+            823,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. CoRR, abs/1410.3916, 2014. URL http://arxiv.org/abs/1410.3916. ",
+        "bbox": [
+            173,
+            723,
+            821,
+            751
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A MULTI-ROUND LSH ATTENTION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            482,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this section we describe in more detail the multi-hash version of our LSH attention mechanism. We first repeat Equation (3) from the main text, which describes a general formulation of attention with sparsity: ",
+        "bbox": [
+            174,
+            132,
+            825,
+            176
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c698a8ac04a86c2288eda3fd6b70b8d7f3fdaeebd217422220845a953a859c64.jpg",
+        "text": "$$\no _ { i } = \\sum _ { j \\in \\widetilde { \\mathcal { P } } _ { i } } \\exp \\left( q _ { i } \\cdot k _ { j } - m ( j , \\mathcal { P } _ { i } ) - z ( i , \\mathcal { P } _ { i } ) \\right) v _ { j } \\quad \\mathrm { ~ w h e r e ~ } m ( j , \\mathcal { P } _ { i } ) = \\left\\{ \\begin{array} { l l } { \\infty } & { \\mathrm { i f ~ } j \\notin \\mathcal { P } _ { i } } \\\\ { 0 } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            184,
+            782,
+            227
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In the multi-round case, a query position $i$ can attend to key positions $\\mathcal { P } _ { i }$ as defined in (6), which we also repeat here: ",
+        "bbox": [
+            171,
+            239,
+            825,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8bd9e21ce93bf29073f8ffb40510ff311dfb03738267269e1164385c3010bfa0.jpg",
+        "text": "$$\n{ \\mathcal P } _ { i } = \\bigcup _ { r = 1 } ^ { n _ { r o u n d s } } { \\mathcal P } _ { i } ^ { ( r ) } \\qquad \\mathrm { w h e r e } ~ { \\mathcal P } _ { i } ^ { ( r ) } = \\Big \\{ j : h ^ { ( r ) } ( q _ { i } ) = h ^ { ( r ) } ( q _ { j } ) \\Big \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            275,
+            740,
+            318
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For batching purposes, attention is performed on chunks of sorted queries/keys: ",
+        "bbox": [
+            173,
+            330,
+            694,
+            345
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4fcd4d809d819d6a82e4fdae9ab507c0d452b5d53b5a490aa2883cd260c33f43.jpg",
+        "text": "$$\n\\widetilde { \\mathcal { P } } _ { i } ^ { ( r ) } = \\left\\{ j : \\left\\lfloor \\frac { s _ { i } ^ { ( r ) } } { m } \\right\\rfloor - 1 \\leq \\left\\lfloor \\frac { s _ { j } ^ { ( r ) } } { m } \\right\\rfloor \\leq \\left\\lfloor \\frac { s _ { i } ^ { ( r ) } } { m } \\right\\rfloor \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            351,
+            661,
+            396
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Combining (3) and (6) gives: ",
+        "bbox": [
+            173,
+            407,
+            366,
+            422
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14e11b6d03f03c3ad5351eba38b21724ea66fab063e871cfe4504b5f335c2b02.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\alpha _ { i } = \\sum _ { j \\in \\Gamma } \\exp ( q _ { i } \\cdot k _ { j } - m ( j , \\mathcal { P } _ { i } ) - z ( i , \\mathcal { P } _ { j } ) ) \\times } } \\\\ & { } & { \\beta _ { i } \\leq \\frac { 1 } { \\beta \\epsilon _ { i } ^ { p ( \\cdot ) } } , } \\\\ & { } & { \\gamma = \\sum _ { s = 1 } ^ { N _ { t } } \\exp ( z ( i , \\mathcal { P } _ { i } ^ { ( r ) } ) - z ( i , \\mathcal { P } _ { j } ) ) \\sum _ { j \\in \\Gamma } \\frac { 1 } { N _ { t } } \\frac { 1 } { N _ { t } } \\exp ( q _ { i } \\cdot k _ { i } - m ( j , \\mathcal { P } _ { i } ^ { ( r ) } ) - z ( i , \\mathcal { P } _ { j } ^ { ( r ) } ) ) \\times } \\\\ & { } & { \\exp ( z ( i , \\mathcal { P } _ { i } ^ { ( r ) } ) - z ( i , \\mathcal { P } _ { j } ^ { ( r ) } ) ) , } \\\\ & { } & { ( 1 3 , \\exp ( z ( i , \\mathcal { P } _ { i } ^ { ( r ) } ) - z ( i , \\mathcal { P } _ { j } ) ) \\alpha _ { i } ^ { ( r ) } } \\\\ & { } & { \\exp ( z ( i , \\mathcal { P } _ { i } ^ { ( r ) } ) - z ( i , \\mathcal { P } _ { j } ^ { ( r ) } ) ) \\exp ( z ( i , \\mathcal { P } _ { i } ^ { ( r ) } ) ) \\exp ( \\mathrm { ~ \\it 1 4 ~ } } \\\\ & { } & { \\exp ( \\phi ( i , k _ { j } - m ( i _ { j } ^ { ( r ) } ) - z ( i , \\mathcal { P } _ { j } ^ { ( r ) } ) ) ) \\exp _ { j } } \\\\ & { } & { \\beta _ { i } \\leq \\mathrm { \\it ~ \\it ~ \\it ~ \\alpha ~ } _ { j } \\leq \\mathrm { \\it ~ \\it ~ \\alpha ~ } _ { i } \\leq \\mathrm { \\it ~ \\it ~ \\alpha ~ } _ { j } } \\\\ & { } &  \\exp ( N _ { t } \\exp N _ { i , j } + | \\{ \\begin{array} { l l } { \\Gamma _ { j } ^ { ( r ) } \\cdot \\xi _ { j } \\in \\mathcal { P } _ { j } ^ { ( r ) } } \\\\ { \\Gamma _ { j } ^ { ( r ) } \\cdot \\xi _ { j } \\in \\mathcal { P } _ { j } ^ { ( r ) } } \\end{array} \\} \\mathrm { ~ a n d ~ } m _ { i j } ^  ( \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            171,
+            428,
+            820,
+            674
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Each round of LSH attention produces a vector $o _ { i } ^ { ( r ) }$ that can be computed independently from other rounds, except for the inclusion of a term $N _ { i , j }$ to avoid double-counting elements when constructing the union of $\\mathcal { P } _ { i } ^ { ( r ) }$ sets. In our implementation we fold the $N _ { i , j }$ factor into the masking term $m _ { i , j } ^ { ( r ) }$ . ",
+        "bbox": [
+            173,
+            688,
+            823,
+            738
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We also modify $m _ { i , j _ { . } } ^ { ( r ) }$ to introduce a special case for $i = j$ . This case is added because causal masking in a standard Transformer allows position to attend to itself, which is not desirable in a shared-QK formulation. We set the mask to a large but finite value to disallow attention-in-place, except in the situation where a token has no other valid attention targets. For example, the first token in a sequence attends only to itself, because no prior context is available. ",
+        "bbox": [
+            173,
+            747,
+            825,
+            820
+        ],
+        "page_idx": 11
+    }
+]