Add files using upload-large-folder tool

parse/train/Byj72udxe/Byj72udxe.md

@@ -0,0 +1,297 @@
+# POINTER SENTINEL MIXTURE MODELS
+
+Stephen Merity, Caiming Xiong, James Bradbury & Richard Socher   
+MetaMind - A Salesforce Company   
+Palo Alto, CA, USA   
+{smerity,cxiong,james.bradbury,rsocher}@salesforce.com
+
+# ABSTRACT
+
+Recent neural network sequence models with softmax classifiers have achieved their best language modeling performance only with very large hidden states and large vocabularies. Even then they struggle to predict rare or unseen words even if the context makes the prediction unambiguous. We introduce the pointer sentinel mixture architecture for neural sequence models which has the ability to either reproduce a word from the recent context or produce a word from a standard softmax classifier. We explore applying the pointer sentinel mixture model to the LSTM, a standard recurrent neural network building block. Utilizing an LSTM that achieves 80.6 perplexity on the Penn Treebank, the pointer sentinel-LSTM model pushes perplexity down to 70.9 while using far fewer parameters than an LSTM that achieves similar results. In order to evaluate how well language models can exploit longer contexts and deal with more realistic vocabularies and corpora we also introduce the freely available WikiText corpus.1
+
+# 1 INTRODUCTION
+
+A major difficulty in language modeling is learning when to predict specific words from the immediate context. For instance, imagine a new person is introduced and two paragraphs later the context would allow one to very accurately predict this person’s name as the next word. For standard neural sequence models to predict this name, they would have to encode the name, store it for many time steps in their hidden state, and then decode it when appropriate. As the hidden state is limited in capacity and the optimization of such models suffer from the vanishing gradient problem, this is a lossy operation when performed over many timesteps. This is especially true for rare words.
+
+Models with soft attention or memory components have been proposed to help deal with this challenge, aiming to allow for the retrieval and use of relevant previous hidden states, in effect increasing hidden state capacity and providing a path for gradients not tied to timesteps. Even with attention, the standard softmax classifier that is being used in these models often struggles to correctly predict rare or previously unknown words.
+
+Pointer networks (Vinyals et al., 2015) provide one potential solution for rare and out of vocabulary (OoV) words as a pointer network uses attention to select an element from the input as output. This allows it to produce previously unseen input tokens. While pointer networks improve performance on rare words and long-term dependencies they are unable to select words that do not exist in the input.
+
+We introduce a mixture model, illustrated in Fig. 1, that combines the advantages of standard softmax classifiers with those of a pointer component for effective and efficient language modeling. Rather than relying on the RNN hidden state to decide when to use the pointer, as in the recent work of Gulc¸ehre et al. ¨ (2016), we allow the pointer component itself to decide when to use the softmax vocabulary through a sentinel. The model improves the state of the art perplexity on the Penn Treebank. Since this commonly used dataset is small and no other freely available alternative exists that allows for learning long range dependencies, we also introduce a new benchmark dataset for language modeling called WikiText.
+
+![](images/8c26dfca638e32eea73667de18d4a96eb9d4f36a18ee233fb6986050ddd64f47.jpg)  
+Figure 1: Illustration of the pointer sentinel-RNN mixture model. $g$ is the mixture gate which uses the sentinel to dictate how much probability mass to give to the vocabulary.
+
+# 2 THE POINTER SENTINEL FOR LANGUAGE MODELING
+
+Given a sequence of words $w _ { 1 } , \ldots , w _ { N - 1 }$ , our task is to predict the next word $w _ { N }$
+
+# 2.1 THE SOFTMAX-RNN COMPONENT
+
+Recurrent neural networks (RNNs) have seen widespread use for language modeling (Mikolov et al., 2010) due to their ability to, at least in theory, retain long term dependencies. RNNs employ the chain rule to factorize the joint probabilities over a sequence of tokens: $p ( w _ { 1 } , \dots , w _ { N } ) =$ $\begin{array} { r } { \prod _ { i = 1 } ^ { N } p ( w _ { i } | w _ { 1 } , \dots , w _ { i - 1 } ) } \end{array}$ . More precisely, at each time step $i$ , we compute the RNN hidden state $h _ { i }$ according to the previous hidden state $h _ { i - 1 }$ and the input $x _ { i }$ such that $h _ { i } = R N N ( x _ { i } , h _ { i - 1 } )$ . When all the $N - 1$ words have been processed by the RNN, the final state $h _ { { N - 1 } }$ is fed into a softmax layer which computes the probability over a vocabulary of possible words: $p _ { \mathrm { v o c a b } } ( w ) =$ softmax $\left( U h _ { N - 1 } \right)$ , where $\mathbf { \Psi } _ { p _ { \mathrm { v o c a b } } } \in \dot { \mathbb { R } } ^ { V }$ , $U \in \mathbf { \overline { { R } } } ^ { V \times H }$ , $H$ is the hidden size, and $V$ the vocabulary size. RNNs can suffer from the vanishing gradient problem. The LSTM (Hochreiter & Schmidhuber, 1997) architecture has been proposed to deal with this by updating the hidden state according to a set of gates. Our work focuses on the LSTM but can be applied to any RNN architecture that ends in a vocabulary softmax.
+
+# 2.2 THE POINTER NETWORK COMPONENT
+
+In this section, we propose a modification to pointer networks for language modeling. To predict the next word in the sequence, a pointer network would select the member of the input sequence $p ( w _ { 1 } , \dots , w _ { N - 1 } )$ with the maximal attention score as the output.
+
+The simplest way to compute an attention score for a specific hidden state is an inner product with all the past hidden states $h$ , with each hidden state $\boldsymbol { h } _ { i } ^ { \star } \in \mathbb { R } ^ { H }$ . However, if we want to compute such a score for the most recent word (since this word may be repeated), we need to include the last hidden state itself in this inner product. Taking the inner product of a vector with itself results in the vector’s magnitude squared, meaning the attention scores would be strongly biased towards the most recent word. Hence we project the current hidden state to a query vector $q$ first. To produce the query $q$ we compute $q = \mathrm { t a n h } ( W h _ { N - 1 } + b )$ , where $W \in \dot { \mathbb { R } ^ { H \times } } \mathbf { \check { \mathit { H } } }$ , $b \in \mathring { \mathbb { R } } ^ { H }$ , and $\boldsymbol { q } ^ { \mathbf { \lambda } } \in \mathbb { R } ^ { H }$ . To generate the pointer attention scores, we compute the match between the previous RNN output states $h _ { i }$ and the query $q$ by taking the inner product, followed by a softmax activation function to obtain a probability distribution:
+
+$$
+\begin{array} { r } { z _ { i } = q ^ { T } h _ { i } , } \\ { a = \mathrm { s o f t m a x } ( z ) , } \end{array}
+$$
+
+where $z \in \mathbb { R } ^ { L }$ , $a \in \mathbb { R } ^ { L }$ , and $L$ is the total number of hidden states. The probability mass assigned to a given word is the sum of the probability mass given to all token positions where the given word appears:
+
+$$
+p _ { \mathrm { p t r } } ( w ) = \sum _ { i \in I ( w , x ) } a _ { i } ,
+$$
+
+![](images/0171833abe0201710740ca22ff0191abc247c1cd6f229bbb5f4880daf49a948b.jpg)  
+Figure 2: Visualization of the pointer sentinel-RNN mixture model. The query, produced from applying an MLP to the last output of the RNN, is used by the pointer network to identify likely matching words from the past. The $\odot$ nodes are inner products between the query and the RNN hidden states. If the pointer component is not confident, probability mass can be directed to the RNN by increasing the value of the mixture gate $g$ via the sentinel, seen in grey. If $g = 1$ then only the RNN is used. If $g = 0$ then only the pointer is used.
+
+where $I ( w , x )$ results in all positions of the word $w$ in the input $x$ and $p _ { \mathrm { p t r } } \in \mathbb { R } ^ { V }$ . This technique, referred to as pointer sum attention, has been used for question answering (Kadlec et al., 2016).
+
+Given the length of the documents used in language modeling, it may not be feasible for the pointer network to evaluate an attention score for all the words back to the beginning of the dataset. Instead, we may elect to maintain only a window of the $L$ most recent words for the pointer to match against. The length $L$ of the window is a hyperparameter that can be tuned on a held out dataset or by empirically analyzing how frequently a word at position $t$ appears within the last $L$ words.
+
+To illustrate the advantages of this approach, consider a long article featuring two sentences President Obama discussed the economy and President Obama then flew to Prague. If the query was Which President is the article about?, probability mass could be applied to Obama in either sentence. If the question was instead Who flew to Prague?, only the latter occurrence of Obama provides the proper context. The attention sum model ensures that, as long as the entire attention probability mass is distributed on the occurrences of Obama, the pointer network can achieve zero loss. This flexibility provides supervision without forcing the model to put mass on supervision signals that may be incorrect or lack proper context.
+
+# 2.3 THE POINTER SENTINEL MIXTURE MODEL
+
+While pointer networks have proven to be effective, they cannot predict output words that are not present in the input, a common scenario in language modeling. We propose to resolve this by using a mixture model that combines a standard softmax with a pointer.
+
+Our mixture model has two base distributions: the softmax vocabulary of the RNN output and the positional vocabulary of the pointer model. We refer to these as the RNN component and the pointer component respectively. To combine the two base distributions, we use a gating function $\bar { g } \ : = \ : p ( z _ { i } \ : = \ : k | x _ { i } )$ where $z _ { i }$ is the latent variable stating which base distribution the data point belongs to. As we only have two base distributions, $g$ can produce a scalar in the range $[ 0 , 1 ]$ . A value of 0 implies that only the pointer is used and 1 means only the softmax-RNN is used.
+
+$$
+p ( y _ { i } | x _ { i } ) = g p _ { \mathrm { v o c a b } } ( y _ { i } | x _ { i } ) + ( 1 - g ) p _ { \mathrm { p t r } } ( y _ { i } | x _ { i } ) .
+$$
+
+While the models could be entirely separate, we re-use many of the parameters for the softmaxRNN and pointer components. This sharing minimizes the total number of parameters in the model and capitalizes on the pointer network’s supervision for the RNN component.
+
+# 2.4 DETAILS OF THE GATING FUNCTION
+
+To compute the new pointer sentinel gate $g$ , we modify the pointer component. In particular, we add an additional element to $z$ , the vector of attention scores as defined in Eq. 1. This element is computed using an inner product between the query and the sentinel2 vector $s \in \mathbb { R } ^ { H }$ . This change can be summarized by changing Eq. 2 to $a = \operatorname { \bar { s o f t m a x } } \left( \left[ z ; q ^ { T } s \right] \right)$ . We define $a \in \mathbb { R } ^ { V + 1 }$ to be the attention distribution over both the words in the pointer window as well as the sentinel state. We interpret the last element of this vector to be the gate value: $g = a [ V + 1 ]$ .
+
+Any probability mass assigned to $g$ is given to the standard softmax vocabulary of the RNN. The final updated, normalized pointer probability over the vocabulary in the window then becomes:
+
+$$
+p _ { \mathrm { p t r } } ( y _ { i } | x _ { i } ) = \frac { 1 } { 1 - g } a [ 1 : V ] ,
+$$
+
+where we denoted $[ 1 : V ]$ to mean the first $V$ elements of the vector. The final mixture model is the same as Eq. 4 but with the updated Eq. 5 for the pointer probability.
+
+This setup encourages the model to have both components compete: use pointers whenever possible and back-off to the standard softmax otherwise. By integrating the gating function into the pointer computation, it is influenced by both the RNN hidden state and the pointer window’s hidden states.
+
+# 2.5 MOTIVATION FOR THE SENTINEL AS GATING FUNCTION
+
+To make the best decision possible regarding which component to use the gating function must have as much context as possible. As we increase the window of words for the pointer component to consider, the RNN hidden state by itself isn’t guaranteed to accurately recall the identity or order of words it has recently seen (Adi et al., 2016). This is an obvious limitation of encoding a variable length sequence into a fixed dimensionality vector.
+
+If we want a pointer window where the length $L$ is in the hundreds, accurately modeling all of this information within the RNN hidden state is impractical. The position of specific words is also a vital feature as relevant words eventually fall out of the pointer component’s window. To correctly model this would require the RNN hidden state to store both the identity and position of each word in the pointer window. This is far beyond the capability of the fixed dimensionality RNN hidden state.
+
+For this reason, we integrate the gating function directly into the pointer network by use of the sentinel. The decision to back-off to the softmax vocabulary is then informed by both the query $q$ , generated using the RNN hidden state $h _ { N - 1 }$ , and from the contents of the hidden states in the pointer window itself. This allows the model to accurately query what hidden states are contained in the pointer window and avoid maintaining state for words that may have fallen out of the window.
+
+# 2.6 POINTER SENTINEL LOSS FUNCTION
+
+We minimize the cross-entropy loss of $\begin{array} { r } { - \sum _ { j } \hat { y _ { i j } } \log p \big ( y _ { i j } | x _ { i } \big ) } \end{array}$ , where $\hat { y } _ { i }$ is a one hot encoding of the correct output. During training, as $\hat { y } _ { i }$ is one hot, only a single mixed probability $p ( y _ { i j } )$ must be computed for calculating the loss. This can result in a far more efficient GPU implementation. At prediction time, when we want all values for $p ( y _ { i } | x _ { i } )$ , a maximum of $L$ word probabilities must be mixed, as there is a maximum of $L$ unique words in the pointer window of length $L$ . This mixing can occur on the CPU where random access indexing is more efficient than the GPU.
+
+Following the pointer sum attention network, the aim is to place probability mass from the attention mechanism on the correct output $\hat { y } _ { i }$ if it exists in the input. In the case of our mixture model the pointer loss instead becomes $\begin{array} { r } { - \log \left( g + \sum _ { i \in I ( y , x ) } a _ { i } \right) } \end{array}$ , where $I ( y , x )$ results in all positions of the correct output $y$ in the input $x$ . The gate $g$ may be assigned all probability mass if, for instance, the correct output $\hat { y } _ { i }$ exists only in the softmax-RNN vocabulary. There is no penalty if the model places the entire probability mass on any of the instances of the correct word in the input window. If the pointer component places the entirety of the probability mass on the gate $g$ , the pointer network incurs no penalty and the loss is entirely determined by the loss of the softmax-RNN component.
+
+Table 1: Statistics of the Penn Treebank, WikiText-2, and WikiText-103. The out of vocabulary $\left( \mathrm { O o V } \right)$ rate notes what percentage of tokens have been replaced by an $\left. u n k \right.$ token. The token count includes newlines which add to the structure of the WikiText datasets.   
+
+<table><tr><td rowspan="2"></td><td colspan="3">Penn Treebank Test</td><td colspan="3">WikiText-2 Test</td><td colspan="3">WikiText-103</td></tr><tr><td colspan="3">Train Valid</td><td colspan="3">Train Valid</td><td colspan="3">Train Valid</td></tr><tr><td>Articles</td><td>-</td><td>-</td><td>-</td><td>600</td><td>60</td><td>60</td><td>28,475</td><td>60</td><td>Test 60</td></tr><tr><td>Tokens</td><td>929k</td><td>73k 10,000</td><td>82k</td><td>2,088k</td><td>217k</td><td>245k</td><td>103,227k</td><td>217k</td><td>245k</td></tr><tr><td>Vocab size OoV rate</td><td colspan="3">4.8%</td><td></td><td colspan="3">33,278 2.6%</td><td colspan="3">267,735 0.4%</td></tr></table>
+
+# 2.7 PARAMETERS AND COMPUTATION TIME
+
+The pointer sentinel-LSTM mixture model results in a relatively minor increase in parameters and computation time, especially when compared to the model size required to achieve similar performance using a standard LSTM. The only two additional parameters required by the model are those required for computing $q$ , specifically $\dot { W } \in \mathbb { R } ^ { H \times H }$ and $\bar { b } \in \mathbb { R } ^ { H }$ , and the sentinel vector embedding, $s \in \mathbb { R } ^ { H }$ . This is independent of the depth of the RNN as the pointer component only interacts with the output of the final RNN layer. The additional $H ^ { 2 } + 2 H \bar { }$ parameters are minor compared to a single LSTM layer’s $8 H ^ { 2 } + 4 \dot { H }$ parameters. Most models also use multiple LSTM layers.
+
+In terms of additional computation, a pointer sentinel-LSTM of window size $L$ only requires computing the query $q$ (a linear layer with tanh activation), a total of $L$ parallelizable inner product calculations, and the attention scores for the $L$ resulting scalars via the softmax function.
+
+# 3 RELATED WORK
+
+Considerable research has been dedicated to the task of language modeling, from traditional machine learning techniques such as n-grams to deep neural sequence models.
+
+Mixture models composed of various knowledge sources have been proposed in the past for language modeling. Rosenfeld (1996) uses a maximum entropy model to combine a variety of information sources to improve language modeling on news text and speech. These information sources include complex overlapping n-gram distributions and n-gram caches that aim to capture rare words.
+
+Beyond n-grams, neural sequence models such as recurrent neural networks have been shown to achieve state of the art results (Mikolov et al., 2010). A variety of RNN regularization methods have been explored, including a number of dropout variations (Zaremba et al., 2014; Gal, 2015) which prevent overfitting of complex LSTM language models. Other work has modified the RNN architecture to better handle increased recurrence depth (Zilly et al., 2016).
+
+In order to increase capacity and minimize the impact of vanishing gradients, some language and translation models have also added a soft attention or memory component (Bahdanau et al., 2015; Sukhbaatar et al., 2015; Cheng et al., 2016; Kumar et al., 2016; Xiong et al., 2016; Ahn et al., 2016). These mechanisms allow for the retrieval and use of relevant previous hidden states. Soft attention mechanisms need to first encode the relevant word into a state vector and then decode it again, even if the output word is identical to the input word used to compute that hidden state or memory. A drawback to soft attention is that if, for instance, January and March are both equally attended candidates, the attention mechanism may blend the two vectors, resulting in a context vector closest to February (Kadlec et al., 2016). Even with attention, the standard softmax classifier being used in these models often struggles to correctly predict rare or previously unknown words.
+
+Attention-based pointer mechanisms were introduced in Vinyals et al. (2015) where the pointer network is able to select elements from the input as output. In the above example, only January or March would be available as options, as February does not appear in the input. The use of pointer networks have been shown to help with geometric problems (Vinyals et al., 2015), code generation (Ling et al., 2016), summarization (Gu et al., 2016; Gulc¸ehre et al. ¨ , 2016), question answering (Kadlec et al., 2016). While pointer networks improve performance on rare words and long-term dependencies they are unable to select words that do not exist in the input.
+
+Gulc¸ehre et al. ¨ (2016) introduce a pointer softmax model that can generate output from either the vocabulary softmax of an RNN or the location softmax of the pointer network. Not only does this allow for producing OoV words which are not in the input, the pointer softmax model is able to better deal with rare and unknown words than a model only featuring an RNN softmax. Rather than constructing a mixture model as in our work, they use a switching network to decide which component to use. For neural machine translation, the switching network is conditioned on the representation of the context of the source text and the hidden state of the decoder. The pointer network is not used as a source of information for the switching network as in our model. The pointer and RNN softmax are scaled according to the switching network and the word or location with the highest final attention score is selected for output. Although this approach uses both a pointer and RNN component, it is not a mixture model and does not combine the probabilities for a word if it occurs in both the pointer location softmax and the RNN vocabulary softmax. In our model the word probability is a mix of both the RNN and pointer components, allowing for better predictions when the context may be ambiguous.
+
+Extending this concept further, the latent predictor network (Ling et al., 2016) generates an output sequence conditioned on an arbitrary number of base models where each base model may have differing granularity. In their task of code generation, the output could be produced one character at a time using a standard softmax or instead copy entire words from referenced text fields using a pointer network. As opposed to Gulc¸ehre et al. ¨ (2016), all states which produce the same output are merged by summing their probabilities. The model requires a complex training process involving the forward-backward algorithm for Semi-Markov models to prevent an exponential path explosion.
+
+# 4 WIKITEXT - A BENCHMARK FOR LANGUAGE MODELING
+
+We first describe the most commonly used language modeling dataset and its pre-processing in order to then motivate the need for a new benchmark dataset.
+
+# 4.1 PENN TREEBANK
+
+In order to compare our model to the many recent neural language models, we conduct word-level prediction experiments on the Penn Treebank (PTB) dataset (Marcus et al., 1993), pre-processed by Mikolov et al. (2010). The dataset consists of $9 2 9 \mathrm { k }$ training, $7 3 \mathrm { k }$ validation, and ${ } ^ { 8 2 \mathrm { k } }$ test words. As part of the pre-processing performed by Mikolov et al. (2010), words were lower-cased, numbers were replaced with N, newlines were replaced with $\langle e o s \rangle$ , and all other punctuation was removed. The vocabulary is the most frequent 10k words with OoV tokens replaced by an $\left. u n k \right.$ token. For full statistics, refer to Table 1.
+
+# 4.2 REASONS FOR A NEW DATASET
+
+While the processed version of the PTB above has been frequently used for language modeling, it has many limitations. The tokens in PTB are all lower case, stripped of any punctuation, and limited to a vocabulary of only 10k words. These limitations mean that the PTB is unrealistic for real language use, especially when far larger vocabularies with many rare words are involved. The appendix contains a graph illustrating this using a Zipfian plot over the training partition of the PTB, with the curve stopping abruptly at the 10k limit. Given that accurately predicting rare words, such as named entities, is an important task for many applications, the lack of a long tail is problematic.
+
+Other larger scale language modeling datasets exist. Unfortunately, they either have restrictive licensing which prevents widespread use or have randomized sentence ordering (Chelba et al., 2013) which is unrealistic for most language use and prevents the effective learning and evaluation of longer term dependencies. Hence, we constructed a language modeling dataset using text extracted from Wikipedia and have made this available to the community.
+
+# 4.3 CONSTRUCTION AND PRE-PROCESSING
+
+We selected articles only fitting the Good or Featured article criteria specified by editors on Wikipedia. These articles have been reviewed by humans and are considered well written, factually accurate, broad in coverage, neutral in point of view, and stable. This resulted in 23,805 Good articles and 4,790 Featured articles. The text for each article was extracted using the Wikipedia API. Extracting text from Wikipedia mark-up is nontrivial due to the large number of macros in use, used for metric conversions, abbreviations, language notation, and date handling.
+
+Once extracted, specific sections which primarily featured lists were removed by default. Other minor bugs, such as sort keys and Edit buttons that leaked in from the HTML, were also removed. Mathematical formulae and $\mathrm { { I A T } _ { E } X }$ code were replaced with $\langle f o r m u l a \rangle$ tokens. Normalization and tokenization were performed using the Moses tokenizer (Koehn et al., 2007), slightly augmented to further split numbers $( 8 , 6 0 0  8 \ \textcircled { \omega } , @ \ 6 0 0 )$ and with some additional minor fixes. Following Chelba et al. (2013) a vocabulary was constructed by discarding all words with a count below 3. Words outside of the vocabulary were mapped to the $\left. u n k \right.$ token, also a part of the vocabulary.
+
+# 4.4 STATISTICS
+
+The full WikiText dataset is over 103 million words in size, a hundred times larger than the PTB. It is also a tenth the size of the One Billion Word Benchmark (Chelba et al., 2013), one of the largest publicly available language modeling benchmarks, whilst consisting of articles that allow for the capture and usage of longer term dependencies as might be found in many real world tasks.
+
+The dataset is available in two different sizes: WikiText-2 and WikiText-103. Both feature punctuation, original casing, a larger vocabulary, and numbers. WikiText-2 is two times the size of the Penn Treebank dataset. WikiText-103 features all extracted articles. Both datasets use the same articles for validation and testing, only differing in the vocabularies. For full statistics, refer to Table 1.
+
+# 5 EXPERIMENTS
+
+# 5.1 TRAINING DETAILS
+
+As the pointer sentinel mixture model uses the outputs of the RNN from up to $L$ timesteps back, this presents a challenge for training. If we do not regenerate the stale historical outputs of the RNN when we update the gradients, backpropagation through these stale outputs may result in incorrect gradient updates. If we do regenerate all stale outputs of the RNN, the training process is far slower. As we can make no theoretical guarantees on the impact of stale outputs on gradient updates, we opt to regenerate the window of RNN outputs used by the pointer component after each gradient update.
+
+We also use truncated backpropagation through time (BPTT) in a different manner to many other RNN language models. Truncated BPTT allows for practical time-efficient training of RNN models but has fundamental trade-offs that are rarely discussed. For running truncated BPTT, BPTT is run for $k _ { 2 }$ timesteps once every $k _ { 1 }$ timesteps. For many RNN language modeling training schemes, $k _ { 1 } = k _ { 2 }$ , meaning that every $k$ timesteps truncated BPTT is performed for the $k$ previous timesteps. This results in only a single RNN output receiving backpropagation for $k$ timesteps, with the other extreme being that the first token receives backpropagation for 0 timesteps. As such, most words in the training data will never experience a full backpropagation for $k$ timesteps.
+
+In our task, the pointer component always looks $L$ timesteps into the past if $L$ past timesteps are available. We select $k _ { 1 } = 1$ and $k _ { 2 } = L$ such that for each timestep we perform backpropagation for $L$ timesteps and advance one timestep at a time. Only the loss for the final predicted word is used for backpropagation through the window.
+
+# 5.2 MODEL DETAILS
+
+Our experimental setup reflects that of Zaremba et al. (2014) and Gal (2015). We increased the number of timesteps used during training from 35 to 100, matching the length of the window $L$ . Batch size was increased to 32 from 20. We also halve the learning rate when validation perplexity is worse than the previous iteration, stopping training when validation perplexity fails to improve for three epochs or when 64 epochs are reached. The gradients are rescaled if their global norm exceeds 1 (Pascanu et al., 2013b).3 We evaluate the medium model configuration which features a two layer
+
+Table 2: Single model perplexity on validation and test sets for the Penn Treebank language modeling task. For our models and the models of Zaremba et al. (2014) and Gal (2015), medium and large refer to a 650 and 1500 unit two layer LSTM respectively. Parameter numbers with $^ \ddag$ are estimates based upon our understanding of the model and with reference to Kim et al. (2016).   
+
+<table><tr><td>Model</td><td>Parameters</td><td>Validation</td><td>Test</td></tr><tr><td>Mikolov &amp; Zweig (2012) - KN-5</td><td>2M</td><td></td><td>141.2</td></tr><tr><td>Mikolov &amp; Zweig (2012) - KN5 + cache</td><td>2M</td><td></td><td>125.7</td></tr><tr><td>Mikolov&amp;Zweig g(2012) -RNN</td><td>6M</td><td></td><td>124.7</td></tr><tr><td>Mikolov&amp;Zweig g(2012)-RNN-LDA</td><td>7M</td><td></td><td>113.7</td></tr><tr><td>Mikolov &amp; Zweig ( g(2012) - RNN-LDA + KN-5 +cache</td><td>9M</td><td></td><td>92.0</td></tr><tr><td>Pascanu et al. (2013a) - Deep RNN</td><td>6M</td><td></td><td>107.5</td></tr><tr><td>Cheng et al. (2014) - Sum-Prod Net</td><td>5Mt</td><td>一</td><td>100.0</td></tr><tr><td>Zaremba et al. (2014) - LSTM (medium) Zaremba et al. (2014) - LSTM (large)</td><td>20M</td><td>86.2</td><td>82.7</td></tr><tr><td>Gal (2015) - Variational LSTM (medium, untied)</td><td>66M</td><td>82.2</td><td>78.4</td></tr><tr><td>Gal (2015) - Variational LSTM (medium,untied, MC)</td><td>20M 20M</td><td>81.9 ± 0.2</td><td>79.7 ± 0.1</td></tr><tr><td>Gal (2015) - Variational LSTM (large,untied)</td><td>66M</td><td>一</td><td>78.6 ±0.1</td></tr><tr><td>Gal (2015) - Variational LSTM (large,untied, MC)</td><td></td><td>77.9 ± 0.3</td><td>75.2 ± 0.2</td></tr><tr><td>Kim etal. (2016) - CharCNN</td><td>66M 19M</td><td>1</td><td>73.4± 0.0</td></tr><tr><td>Zilly et al. (2016) - Variational RHN</td><td>32M</td><td>一</td><td>78.9</td></tr><tr><td></td><td></td><td>72.8</td><td>71.3</td></tr><tr><td>Zoneout + Variational LSTM (medium)</td><td>20M</td><td>84.4</td><td>80.6</td></tr><tr><td>Pointer Sentinel-LSTM (medium)</td><td>21M</td><td>72.4</td><td>70.9</td></tr></table>
+
+LSTM of hidden size 650. We compare against the large model configuration which features a two layer LSTM of hidden size 1500.
+
+We produce results for two model types, an LSTM model that uses dropout regularization and the pointer sentinel-LSTM model. The variants of dropout used were zoneout (Krueger et al., 2016) and variational inference based dropout (Gal, 2015). Zoneout, which stochastically forces some recurrent units to maintain their previous values, was used for the recurrent connections within the LSTM. Variational inference based dropout, where the dropout mask for a layer is locked across timesteps, was used on the input to each RNN layer and also on the output of the final RNN layer. We used a value of 0.5 for both dropout connections.
+
+# 5.3 COMPARISON OVER PENN TREEBANK
+
+Table 2 compares the pointer sentinel-LSTM to a variety of other models on the Penn Treebank dataset. The pointer sentinel-LSTM achieves the lowest perplexity, followed by the recent Recurrent Highway Networks (Zilly et al., 2016). The medium pointer sentinel-LSTM model also achieves lower perplexity than the large LSTM models. Note that the best performing large variational LSTM model uses computationally intensive Monte Carlo (MC) dropout averaging. Monte Carlo dropout averaging is a general improvement for any sequence model that uses dropout but comes at a greatly increased test time cost. In Gal (2015) it requires rerunning the test model with 1000 different dropout masks. The pointer sentinel-LSTM is able to achieve these results with far fewer parameters than other models with comparable performance, specifically with less than a third the parameters used in the large variational LSTM models.
+
+We also test a variational LSTM that uses zoneout, which serves as the RNN component of our pointer sentinel-LSTM mixture. This variational LSTM model performs BPTT for the same length $L$ as the pointer sentinel-LSTM, where $L = 1 0 0$ timesteps. The results for this model ablation are worse than that of Gal (2015)’s variational LSTM without Monte Carlo dropout averaging.
+
+# 5.4 COMPARISON OVER WIKITEXT-2
+
+As WikiText-2 is being introduced in this dataset, there are no existing baselines. We provide two baselines to compare the pointer sentinel-LSTM against: our variational LSTM using zoneout and
+
+<table><tr><td>Model</td><td>Parameters</td><td>Validation</td><td>Test</td></tr><tr><td>Variational LSTM implementation from Gal (2015)</td><td>20M</td><td>101.7</td><td>96.3</td></tr><tr><td>Zoneout + Variational LSTM</td><td>20M</td><td>108.7</td><td>100.9</td></tr><tr><td>Pointer Sentinel-LSTM</td><td>21M</td><td>84.8</td><td>80.8</td></tr></table>
+
+Table 3: Single model perplexity on validation and test sets for the WikiText-2 language modeling task. All compared models use a two layer LSTM with a hidden size of 650.
+
+the medium variational LSTM used in Gal (2015).4 Attempts to run the Gal (2015) large model variant, a two layer LSTM with hidden size 1500, resulted in out of memory errors on a 12GB K80 GPU, likely due to the increased vocabulary size. We chose the best hyperparameters from PTB experiments for all models. Table 3 shows a similar gain made by the pointer sentinel-LSTM over the variational LSTM models. The variational LSTM from Gal (2015) again beats out the variational LSTM used as a base for our experiments.
+
+# 6 ANALYSIS
+
+# 6.1 IMPACT ON RARE WORDS
+
+A hypothesis as to why the pointer sentinel-LSTM can outperform an LSTM is that the pointer component allows the model to effectively reproduce rare words. The RNN may better use hidden state capacity by relying on the pointer component. The pointer component may also allow for a sharper selection of a single word than may be possible using only the softmax.
+
+The appendix contains a graph which shows the improvement of perplexity when comparing the LSTM to the pointer sentinel-LSTM. Words are split across buckets according to frequency. As the words become rarer, the pointer sentinel-LSTM has stronger improvements in perplexity. Even on the Penn Treebank, where there is a relative absence of rare words due to only selecting the most frequent 10k words, we can see the pointer sentinel-LSTM mixture model provides a direct benefit.
+
+While the improvements are largest on rare words, we can see the pointer sentinel-LSTM is still helpful on relatively frequent words. This may be the pointer component directly selecting the word or through the pointer supervision signal improving the RNN by allowing gradients to flow directly to other occurrences of the word in that window.
+
+# 6.2 QUALITATIVE ANALYSIS OF POINTER USAGE
+
+In a qualitative analysis, we visualized the gate use and pointer attention for a variety of examples in the validation set, focusing on predictions where the gate primarily used the pointer component. These visualizations are available in the appendix.
+
+As expected, the pointer component is heavily used for rare names such as Seidman (23 times in training), Iverson (7 times in training), and Rosenthal (3 times in training). The pointer component was also heavily used when it came to other named entity names such as companies like Honeywell (8 times in training) and Integrated (41 times in training, though due to lowercasing of words this includes integrated circuits, fully integrated, and other generic usage). Surprisingly, the pointer component was also used for many frequent tokens. For selecting units of measurement (tons, kilograms, . . . ) or the short scale of numbers (thousands, millions, billions, . . . ), the pointer would refer to recent usage. This is to be expected, especially when phrases are of the form increased from N tons to N tons. The model can even be found relying on a mixture of the softmax and the pointer for predicting frequent verbs such as said.
+
+Finally, the pointer component can be seen pointing to words at the very end of the 100 word window (position 97), a far longer horizon than the 35 steps that most language models truncate their backpropagation training to. This illustrates why the gating function must be integrated into the pointer component. If the gating function could only use the RNN hidden state, it would need to be wary of words that were near the tail of the pointer, especially if it was not able to accurately track exactly how long it was since seeing a word. By integrating the gating function into the pointer component, we avoid the RNN hidden state having to maintain this intensive bookkeeping.
+
+# 7 CONCLUSION
+
+We introduced the pointer sentinel mixture model and the WikiText language modeling dataset. The pointer sentinel mixture model can be applied to any classifier that ends in a softmax, including various recurrent neural network building blocks. When applied to a standard LSTM, the pointer sentinel-LSTM achieves state of the art results in language modeling over the Penn Treebank while using few additional parameters and little additional computational complexity at prediction time.
+
+We have also motivated the need to move from Penn Treebank to a new language modeling dataset for long range dependencies, providing WikiText-2 and WikiText-103 as potential options. We hope these new datasets can serve as a platform to improve handling of rare words and the usage of long term dependencies in language modeling.
+
+# REFERENCES
+
+Yossi Adi, Einat Kermany, Yonatan Belinkov, Ofer Lavi, and Yoav Goldberg. Fine-grained Analysis of Sentence Embeddings Using Auxiliary Prediction Tasks. arXiv preprint arXiv:1608.04207, 2016.   
+Sungjin Ahn, Heeyoul Choi, Tanel Parnamaa, and Yoshua Bengio. A Neural Knowledge Language ¨ Model. CoRR, abs/1608.00318, 2016.   
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural Machine Translation by Jointly Learning to Align and Translate. In ICLR, 2015.   
+Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One Billion Word Benchmark for Measuring Progress in Statistical Language Modeling. arXiv preprint arXiv:1312.3005, 2013.   
+Jianpeng Cheng, Li Dong, and Mirella Lapata. Long Short-Term Memory-Networks for Machine Reading. CoRR, abs/1601.06733, 2016.   
+Wei-Chen Cheng, Stanley Kok, Hoai Vu Pham, Hai Leong Chieu, and Kian Ming Adam Chai. Language Modeling with Sum-Product Networks. In INTERSPEECH, 2014.   
+Yarin Gal. A Theoretically Grounded Application of Dropout in Recurrent Neural Networks. arXiv preprint arXiv:1512.05287, 2015.   
+Jiatao Gu, Zhengdong Lu, Hang Li, and Victor O. K. Li. Incorporating Copying Mechanism in Sequence-to-Sequence Learning. CoRR, abs/1603.06393, 2016.   
+C¸ aglar Gulc¸ehre, Sungjin Ahn, Ramesh Nallapati, Bowen Zhou, and Yoshua Bengio. Pointing the ¨ Unknown Words. arXiv preprint arXiv:1603.08148, 2016.   
+Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural Computation, 9(8): 1735–1780, Nov 1997. ISSN 0899-7667.   
+Rudolf Kadlec, Martin Schmid, Ondrej Bajgar, and Jan Kleindienst. Text Understanding with the Attention Sum Reader Network. arXiv preprint arXiv:1603.01547, 2016.   
+Yoon Kim, Yacine Jernite, David Sontag, and Alexander M. Rush. Character-aware neural language models. CoRR, abs/1508.06615, 2016.   
+Philipp Koehn, Hieu Hoang, Alexandra Birch, Chris Callison-Burch, Marcello Federico, Nicola Bertoldi, Brooke Cowan, Wade Shen, Christine Moran, Richard Zens, Chris Dyer, Ondej Bojar, Alexandra Constantin, and Evan Herbst. Moses: Open Source Toolkit for Statistical Machine Translation. In ACL, 2007.
+
+David Krueger, Tegan Maharaj, Janos Kram ´ ar, Mohammad Pezeshki, Nicolas Ballas, Nan Rosemary ´ Ke, Anirudh Goyal, Yoshua Bengio, Hugo Larochelle, Aaron Courville, et al. Zoneout: Regularizing RNNs by Randomly Preserving Hidden Activations. arXiv preprint arXiv:1606.01305, 2016.
+
+Ankit Kumar, Ozan Irsoy, Peter Ondruska, Mohit Iyyer, James Bradbury, Ishaan Gulrajani, Victor Zhong, Romain Paulus, and Richard Socher. Ask me anything: Dynamic memory networks for natural language processing. In ICML, 2016.
+
+Wang Ling, Edward Grefenstette, Karl Moritz Hermann, Tomas Kocisk ´ y, Andrew Senior, ´ Fumin Wang, and Phil Blunsom. Latent Predictor Networks for Code Generation. CoRR, abs/1603.06744, 2016.
+
+Mitchell P. Marcus, Beatrice Santorini, and Mary Ann Marcinkiewicz. Building a Large Annotated Corpus of English: The Penn Treebank. Computational Linguistics, 19:313–330, 1993.
+
+Tomas Mikolov and Geoffrey Zweig. Context dependent recurrent neural network language model. In SLT, 2012.
+
+Tomas Mikolov, Martin Karafiat, Luk ´ as Burget, Jan Cernock ´ y, and Sanjeev Khudanpur. Recurrent ´ neural network based language model. In INTERSPEECH, 2010.
+
+Razvan Pascanu, C¸ aglar Gulc¸ehre, Kyunghyun Cho, and Yoshua Bengio. How to Construct Deep ¨ Recurrent Neural Networks. CoRR, abs/1312.6026, 2013a.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In ICML, 2013b.
+
+Roni Rosenfeld. A Maximum Entropy Approach to Adaptive Statistical Language Modeling. 1996.
+
+Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-To-End Memory Networks. In NIPS, 2015.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015.
+
+Caiming Xiong, Stephen Merity, and Richard Socher. Dynamic Memory Networks for Visual and Textual Question Answering. In ICML, 2016.
+
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.
+
+Julian Georg Zilly, Rupesh Kumar Srivastava, Jan Koutn´ık, and Jurgen Schmidhuber. Recurrent ¨ Highway Networks. arXiv preprint arXiv:1607.03474, 2016.
+
+# APPENDIX
+
+![](images/c45d689e3a9e29ba2e76713a83dcf9f4d4092e2ed8fea40c92d7c483e5b46e8e.jpg)  
+Figure A1: Mean difference in log perplexity on PTB when using the pointer sentinel-LSTM compared to the LSTM model. Words were sorted by frequency and split into equal sized buckets.
+
+# POINTER USAGE ON THE PENN TREEBANK
+
+For a qualitative analysis, we visualize how the pointer component is used within the pointer sentinel mixture model. The gate refers to the result of the gating function, with 1 indicating the RNN component is exclusively used whilst 0 indicates the pointer component is exclusively used. We begin with predictions that are using the RNN component primarily and move to ones that use the pointer component primarily.
+
+![](images/bfe1101a2fb87f4dcc5d4a29f6b3f7d8300c9eaa08d693f87d33a6263f3313bb.jpg)  
+Figure A2: In predicting the fall season has been a good one especially for those retailers, the pointer component suggests many words from the historical window that would fit - retailers, investments, chains, and institutions. The gate is still primarily weighted towards the RNN component however.
+
+![](images/74f8b37f282e29b8fa0aba935aeef9ab0765afe5633d21f65b8558f8effb4fca.jpg)  
+Figure A3: In predicting the national cancer institute also projected that overall u.s. mortality, the pointer component is focused on mortality and rates, both of which would fit. The gate is still primarily weighted towards the RNN component.
+
+![](images/29f2ee31d97f97d485e728471fd2cd3eb34ab3a8f310dc8086e09059401473fd.jpg)  
+Figure A4: In predicting people do n’t seem to be unhappy with it he said, the pointer component correctly selects said and is almost equally weighted with the RNN component. This is surprising given how frequent the word said is used within the Penn Treebank.
+
+![](images/ef168c7e1ca9bc89964097cbd337eb2c1028caa5e8e233bb485daa4283e232c1.jpg)  
+Figure A5: For predicting the federal government has had to pump in $\$ 1$ N billion, the pointer component focuses on the recent usage of billion with highly similar context. The pointer component is also relied upon more heavily than the RNN component - surprising given the frequency of billion within the Penn Treebank and that the usage was quite recent.
+
+![](images/dd311d97c72a9f4fa21add99ecf8515494eb4cc97c98fcb7f45e7fd312eb7776.jpg)  
+Figure A6: For predicting $\left. u n k \right.$ ’s ghost sometimes runs through the e ring dressed like gen. noriega, the pointer component reaches 97 timesteps back to retrieve gen. douglas. Unfortunately this prediction is incorrect but without additional context a human would have guessed the same word. This additionally illustrates why the gating function must be integrated into the pointer component. The named entity gen. douglas would have fallen out of the window in only four more timesteps, a fact that the RNN hidden state would not be able to accurately retain for almost 100 timesteps.
+
+![](images/12273399d0022a69702f98b310adb69608c6c1657321fc3e0ec1618d18640606.jpg)  
+Figure A7: For predicting mr. iverson, the pointer component has learned the ability to point to the last name of the most recent named entity. The named entity also occurs 45 timesteps ago, which is longer than the 35 steps that most language models truncate their backpropagation to.
+
+![](images/81f496401397d434510e2273937e7d5a166e9cb126ae3d3fa7dc1987293081e2.jpg)  
+Figure A8: For predicting mr. rosenthal, the pointer is almost exclusively used and reaches back 65 timesteps to identify bruce rosenthal as the person speaking, correctly only selecting the last name.
+
+![](images/5244179d618289042f46d23f44db0ec07e116e8a3e2a4f736497656a6a7b8d86.jpg)  
+Figure A9: For predicting in composite trading on the new york stock exchange yesterday integrated, the company Integrated and the $\left. u n k \right.$ token are primarily attended to by the pointer component, with nearly the full prediction being determined by the pointer component.
+
+# ZIPFIAN PLOT OVER PTB AND WIKITEXT-2
+
+![](images/fef900b9bfea3ce6d1b68bfa9dc98ab50ad06567225c817639d232fbc434491e.jpg)  
+Figure A10: Zipfian plot over the training partition in Penn Treebank and WikiText-2 datasets. Notice the severe drop on the Penn Treebank when the vocabulary hits $1 0 ^ { 4 }$ . Two thirds of the vocabulary in WikiText-2 are past the vocabulary cut-off of the Penn Treebank.
+
+ZIPFIAN PLOT OVER WIKITEXT-103
+
+![](images/750b091fb947314259a95c5ff06b556058e55aa11164e7c6a76439cd5d72c9cf.jpg)  
+Figure A11: Zipfian plot over the training partition in the WikiText-103 dataset. With the dataset containing over 100 million tokens, there is reasonable coverage of the long tail of the vocabulary.

parse/train/Byj72udxe/Byj72udxe_content_list.json

@@ -0,0 +1,1557 @@
+[
+    {
+        "type": "text",
+        "text": "POINTER SENTINEL MIXTURE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            648,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury & Richard Socher   \nMetaMind - A Salesforce Company   \nPalo Alto, CA, USA   \n{smerity,cxiong,james.bradbury,rsocher}@salesforce.com ",
+        "bbox": [
+            184,
+            143,
+            712,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            237,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent neural network sequence models with softmax classifiers have achieved their best language modeling performance only with very large hidden states and large vocabularies. Even then they struggle to predict rare or unseen words even if the context makes the prediction unambiguous. We introduce the pointer sentinel mixture architecture for neural sequence models which has the ability to either reproduce a word from the recent context or produce a word from a standard softmax classifier. We explore applying the pointer sentinel mixture model to the LSTM, a standard recurrent neural network building block. Utilizing an LSTM that achieves 80.6 perplexity on the Penn Treebank, the pointer sentinel-LSTM model pushes perplexity down to 70.9 while using far fewer parameters than an LSTM that achieves similar results. In order to evaluate how well language models can exploit longer contexts and deal with more realistic vocabularies and corpora we also introduce the freely available WikiText corpus.1 ",
+        "bbox": [
+            233,
+            272,
+            764,
+            452
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            487,
+            336,
+            503
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A major difficulty in language modeling is learning when to predict specific words from the immediate context. For instance, imagine a new person is introduced and two paragraphs later the context would allow one to very accurately predict this person’s name as the next word. For standard neural sequence models to predict this name, they would have to encode the name, store it for many time steps in their hidden state, and then decode it when appropriate. As the hidden state is limited in capacity and the optimization of such models suffer from the vanishing gradient problem, this is a lossy operation when performed over many timesteps. This is especially true for rare words. ",
+        "bbox": [
+            174,
+            521,
+            825,
+            619
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Models with soft attention or memory components have been proposed to help deal with this challenge, aiming to allow for the retrieval and use of relevant previous hidden states, in effect increasing hidden state capacity and providing a path for gradients not tied to timesteps. Even with attention, the standard softmax classifier that is being used in these models often struggles to correctly predict rare or previously unknown words. ",
+        "bbox": [
+            176,
+            627,
+            823,
+            695
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pointer networks (Vinyals et al., 2015) provide one potential solution for rare and out of vocabulary (OoV) words as a pointer network uses attention to select an element from the input as output. This allows it to produce previously unseen input tokens. While pointer networks improve performance on rare words and long-term dependencies they are unable to select words that do not exist in the input. ",
+        "bbox": [
+            174,
+            703,
+            823,
+            772
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce a mixture model, illustrated in Fig. 1, that combines the advantages of standard softmax classifiers with those of a pointer component for effective and efficient language modeling. Rather than relying on the RNN hidden state to decide when to use the pointer, as in the recent work of Gulc¸ehre et al. ¨ (2016), we allow the pointer component itself to decide when to use the softmax vocabulary through a sentinel. The model improves the state of the art perplexity on the Penn Treebank. Since this commonly used dataset is small and no other freely available alternative exists that allows for learning long range dependencies, we also introduce a new benchmark dataset for language modeling called WikiText. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            891
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c26dfca638e32eea73667de18d4a96eb9d4f36a18ee233fb6986050ddd64f47.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the pointer sentinel-RNN mixture model. $g$ is the mixture gate which uses the sentinel to dictate how much probability mass to give to the vocabulary. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            305,
+            98,
+            692,
+            246
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 THE POINTER SENTINEL FOR LANGUAGE MODELING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            313,
+            650,
+            329
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a sequence of words $w _ { 1 } , \\ldots , w _ { N - 1 }$ , our task is to predict the next word $w _ { N }$ ",
+        "bbox": [
+            176,
+            343,
+            717,
+            358
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 THE SOFTMAX-RNN COMPONENT",
+        "text_level": 1,
+        "bbox": [
+            176,
+            375,
+            454,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recurrent neural networks (RNNs) have seen widespread use for language modeling (Mikolov et al., 2010) due to their ability to, at least in theory, retain long term dependencies. RNNs employ the chain rule to factorize the joint probabilities over a sequence of tokens: $p ( w _ { 1 } , \\dots , w _ { N } ) =$ $\\begin{array} { r } { \\prod _ { i = 1 } ^ { N } p ( w _ { i } | w _ { 1 } , \\dots , w _ { i - 1 } ) } \\end{array}$ . More precisely, at each time step $i$ , we compute the RNN hidden state $h _ { i }$ according to the previous hidden state $h _ { i - 1 }$ and the input $x _ { i }$ such that $h _ { i } = R N N ( x _ { i } , h _ { i - 1 } )$ . When all the $N - 1$ words have been processed by the RNN, the final state $h _ { { N - 1 } }$ is fed into a softmax layer which computes the probability over a vocabulary of possible words: $p _ { \\mathrm { v o c a b } } ( w ) =$ softmax $\\left( U h _ { N - 1 } \\right)$ , where $\\mathbf { \\Psi } _ { p _ { \\mathrm { v o c a b } } } \\in \\dot { \\mathbb { R } } ^ { V }$ , $U \\in \\mathbf { \\overline { { R } } } ^ { V \\times H }$ , $H$ is the hidden size, and $V$ the vocabulary size. RNNs can suffer from the vanishing gradient problem. The LSTM (Hochreiter & Schmidhuber, 1997) architecture has been proposed to deal with this by updating the hidden state according to a set of gates. Our work focuses on the LSTM but can be applied to any RNN architecture that ends in a vocabulary softmax. ",
+        "bbox": [
+            173,
+            400,
+            825,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 THE POINTER NETWORK COMPONENT",
+        "text_level": 1,
+        "bbox": [
+            176,
+            585,
+            482,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose a modification to pointer networks for language modeling. To predict the next word in the sequence, a pointer network would select the member of the input sequence $p ( w _ { 1 } , \\dots , w _ { N - 1 } )$ with the maximal attention score as the output. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The simplest way to compute an attention score for a specific hidden state is an inner product with all the past hidden states $h$ , with each hidden state $\\boldsymbol { h } _ { i } ^ { \\star } \\in \\mathbb { R } ^ { H }$ . However, if we want to compute such a score for the most recent word (since this word may be repeated), we need to include the last hidden state itself in this inner product. Taking the inner product of a vector with itself results in the vector’s magnitude squared, meaning the attention scores would be strongly biased towards the most recent word. Hence we project the current hidden state to a query vector $q$ first. To produce the query $q$ we compute $q = \\mathrm { t a n h } ( W h _ { N - 1 } + b )$ , where $W \\in \\dot { \\mathbb { R } ^ { H \\times } } \\mathbf { \\check { \\mathit { H } } }$ , $b \\in \\mathring { \\mathbb { R } } ^ { H }$ , and $\\boldsymbol { q } ^ { \\mathbf { \\lambda } } \\in \\mathbb { R } ^ { H }$ . To generate the pointer attention scores, we compute the match between the previous RNN output states $h _ { i }$ and the query $q$ by taking the inner product, followed by a softmax activation function to obtain a probability distribution: ",
+        "bbox": [
+            173,
+            661,
+            825,
+            800
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/469059124895a99c3ee85d7a23fb0904355a5368933e17f10525830a22cc6c19.jpg",
+        "text": "$$\n\\begin{array} { r } { z _ { i } = q ^ { T } h _ { i } , } \\\\ { a = \\mathrm { s o f t m a x } ( z ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            801,
+            539,
+            839
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $z \\in \\mathbb { R } ^ { L }$ , $a \\in \\mathbb { R } ^ { L }$ , and $L$ is the total number of hidden states. The probability mass assigned to a given word is the sum of the probability mass given to all token positions where the given word appears: ",
+        "bbox": [
+            174,
+            840,
+            826,
+            883
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c49f022a82926ffd594334936d27746c2f690ba865c32c91e4335746848bf3ae.jpg",
+        "text": "$$\np _ { \\mathrm { p t r } } ( w ) = \\sum _ { i \\in I ( w , x ) } a _ { i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            885,
+            570,
+            921
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/0171833abe0201710740ca22ff0191abc247c1cd6f229bbb5f4880daf49a948b.jpg",
+        "image_caption": [
+            "Figure 2: Visualization of the pointer sentinel-RNN mixture model. The query, produced from applying an MLP to the last output of the RNN, is used by the pointer network to identify likely matching words from the past. The $\\odot$ nodes are inner products between the query and the RNN hidden states. If the pointer component is not confident, probability mass can be directed to the RNN by increasing the value of the mixture gate $g$ via the sentinel, seen in grey. If $g = 1$ then only the RNN is used. If $g = 0$ then only the pointer is used. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            103,
+            722,
+            260
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $I ( w , x )$ results in all positions of the word $w$ in the input $x$ and $p _ { \\mathrm { p t r } } \\in \\mathbb { R } ^ { V }$ . This technique, referred to as pointer sum attention, has been used for question answering (Kadlec et al., 2016). ",
+        "bbox": [
+            174,
+            383,
+            821,
+            412
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given the length of the documents used in language modeling, it may not be feasible for the pointer network to evaluate an attention score for all the words back to the beginning of the dataset. Instead, we may elect to maintain only a window of the $L$ most recent words for the pointer to match against. The length $L$ of the window is a hyperparameter that can be tuned on a held out dataset or by empirically analyzing how frequently a word at position $t$ appears within the last $L$ words. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To illustrate the advantages of this approach, consider a long article featuring two sentences President Obama discussed the economy and President Obama then flew to Prague. If the query was Which President is the article about?, probability mass could be applied to Obama in either sentence. If the question was instead Who flew to Prague?, only the latter occurrence of Obama provides the proper context. The attention sum model ensures that, as long as the entire attention probability mass is distributed on the occurrences of Obama, the pointer network can achieve zero loss. This flexibility provides supervision without forcing the model to put mass on supervision signals that may be incorrect or lack proper context. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            607
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 THE POINTER SENTINEL MIXTURE MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            623,
+            514,
+            638
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While pointer networks have proven to be effective, they cannot predict output words that are not present in the input, a common scenario in language modeling. We propose to resolve this by using a mixture model that combines a standard softmax with a pointer. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            691
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our mixture model has two base distributions: the softmax vocabulary of the RNN output and the positional vocabulary of the pointer model. We refer to these as the RNN component and the pointer component respectively. To combine the two base distributions, we use a gating function $\\bar { g } \\ : = \\ : p ( z _ { i } \\ : = \\ : k | x _ { i } )$ where $z _ { i }$ is the latent variable stating which base distribution the data point belongs to. As we only have two base distributions, $g$ can produce a scalar in the range $[ 0 , 1 ]$ . A value of 0 implies that only the pointer is used and 1 means only the softmax-RNN is used. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb2b3c050181bba3b3a4a7f5601676418f3c1cf66a90cacb6cc22dd22fb2ceac.jpg",
+        "text": "$$\np ( y _ { i } | x _ { i } ) = g p _ { \\mathrm { v o c a b } } ( y _ { i } | x _ { i } ) + ( 1 - g ) p _ { \\mathrm { p t r } } ( y _ { i } | x _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            787,
+            658,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the models could be entirely separate, we re-use many of the parameters for the softmaxRNN and pointer components. This sharing minimizes the total number of parameters in the model and capitalizes on the pointer network’s supervision for the RNN component. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 DETAILS OF THE GATING FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            468,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To compute the new pointer sentinel gate $g$ , we modify the pointer component. In particular, we add an additional element to $z$ , the vector of attention scores as defined in Eq. 1. This element is computed using an inner product between the query and the sentinel2 vector $s \\in \\mathbb { R } ^ { H }$ . This change can be summarized by changing Eq. 2 to $a = \\operatorname { \\bar { s o f t m a x } } \\left( \\left[ z ; q ^ { T } s \\right] \\right)$ . We define $a \\in \\mathbb { R } ^ { V + 1 }$ to be the attention distribution over both the words in the pointer window as well as the sentinel state. We interpret the last element of this vector to be the gate value: $g = a [ V + 1 ]$ . ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Any probability mass assigned to $g$ is given to the standard softmax vocabulary of the RNN. The final updated, normalized pointer probability over the vocabulary in the window then becomes: ",
+        "bbox": [
+            171,
+            166,
+            823,
+            195
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b60657368b68e271cad13cfea9f485c207b1c64656bcc81124ecf7ea8b6fd18e.jpg",
+        "text": "$$\np _ { \\mathrm { p t r } } ( y _ { i } | x _ { i } ) = \\frac { 1 } { 1 - g } a [ 1 : V ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            205,
+            596,
+            238
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where we denoted $[ 1 : V ]$ to mean the first $V$ elements of the vector. The final mixture model is the same as Eq. 4 but with the updated Eq. 5 for the pointer probability. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This setup encourages the model to have both components compete: use pointers whenever possible and back-off to the standard softmax otherwise. By integrating the gating function into the pointer computation, it is influenced by both the RNN hidden state and the pointer window’s hidden states. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            327
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.5 MOTIVATION FOR THE SENTINEL AS GATING FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            349,
+            604,
+            364
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To make the best decision possible regarding which component to use the gating function must have as much context as possible. As we increase the window of words for the pointer component to consider, the RNN hidden state by itself isn’t guaranteed to accurately recall the identity or order of words it has recently seen (Adi et al., 2016). This is an obvious limitation of encoding a variable length sequence into a fixed dimensionality vector. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If we want a pointer window where the length $L$ is in the hundreds, accurately modeling all of this information within the RNN hidden state is impractical. The position of specific words is also a vital feature as relevant words eventually fall out of the pointer component’s window. To correctly model this would require the RNN hidden state to store both the identity and position of each word in the pointer window. This is far beyond the capability of the fixed dimensionality RNN hidden state. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For this reason, we integrate the gating function directly into the pointer network by use of the sentinel. The decision to back-off to the softmax vocabulary is then informed by both the query $q$ , generated using the RNN hidden state $h _ { N - 1 }$ , and from the contents of the hidden states in the pointer window itself. This allows the model to accurately query what hidden states are contained in the pointer window and avoid maintaining state for words that may have fallen out of the window. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            602
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.6 POINTER SENTINEL LOSS FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            623,
+            472,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We minimize the cross-entropy loss of $\\begin{array} { r } { - \\sum _ { j } \\hat { y _ { i j } } \\log p \\big ( y _ { i j } | x _ { i } \\big ) } \\end{array}$ , where $\\hat { y } _ { i }$ is a one hot encoding of the correct output. During training, as $\\hat { y } _ { i }$ is one hot, only a single mixed probability $p ( y _ { i j } )$ must be computed for calculating the loss. This can result in a far more efficient GPU implementation. At prediction time, when we want all values for $p ( y _ { i } | x _ { i } )$ , a maximum of $L$ word probabilities must be mixed, as there is a maximum of $L$ unique words in the pointer window of length $L$ . This mixing can occur on the CPU where random access indexing is more efficient than the GPU. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following the pointer sum attention network, the aim is to place probability mass from the attention mechanism on the correct output $\\hat { y } _ { i }$ if it exists in the input. In the case of our mixture model the pointer loss instead becomes $\\begin{array} { r } { - \\log \\left( g + \\sum _ { i \\in I ( y , x ) } a _ { i } \\right) } \\end{array}$ , where $I ( y , x )$ results in all positions of the correct output $y$ in the input $x$ . The gate $g$ may be assigned all probability mass if, for instance, the correct output $\\hat { y } _ { i }$ exists only in the softmax-RNN vocabulary. There is no penalty if the model places the entire probability mass on any of the instances of the correct word in the input window. If the pointer component places the entirety of the probability mass on the gate $g$ , the pointer network incurs no penalty and the loss is entirely determined by the loss of the softmax-RNN component. ",
+        "bbox": [
+            173,
+            744,
+            825,
+            864
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/2771546fc5355020a468b7b395918ab24c46037349e76a1b1f3768a9a2b4eafb.jpg",
+        "table_caption": [
+            "Table 1: Statistics of the Penn Treebank, WikiText-2, and WikiText-103. The out of vocabulary $\\left( \\mathrm { O o V } \\right)$ rate notes what percentage of tokens have been replaced by an $\\left. u n k \\right.$ token. The token count includes newlines which add to the structure of the WikiText datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">Penn Treebank Test</td><td colspan=\"3\">WikiText-2 Test</td><td colspan=\"3\">WikiText-103</td></tr><tr><td colspan=\"3\">Train Valid</td><td colspan=\"3\">Train Valid</td><td colspan=\"3\">Train Valid</td></tr><tr><td>Articles</td><td>-</td><td>-</td><td>-</td><td>600</td><td>60</td><td>60</td><td>28,475</td><td>60</td><td>Test 60</td></tr><tr><td>Tokens</td><td>929k</td><td>73k 10,000</td><td>82k</td><td>2,088k</td><td>217k</td><td>245k</td><td>103,227k</td><td>217k</td><td>245k</td></tr><tr><td>Vocab size OoV rate</td><td colspan=\"3\">4.8%</td><td></td><td colspan=\"3\">33,278 2.6%</td><td colspan=\"3\">267,735 0.4%</td></tr></table>",
+        "bbox": [
+            215,
+            101,
+            779,
+            199
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.7 PARAMETERS AND COMPUTATION TIME ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            281,
+            491,
+            295
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The pointer sentinel-LSTM mixture model results in a relatively minor increase in parameters and computation time, especially when compared to the model size required to achieve similar performance using a standard LSTM. The only two additional parameters required by the model are those required for computing $q$ , specifically $\\dot { W } \\in \\mathbb { R } ^ { H \\times H }$ and $\\bar { b } \\in \\mathbb { R } ^ { H }$ , and the sentinel vector embedding, $s \\in \\mathbb { R } ^ { H }$ . This is independent of the depth of the RNN as the pointer component only interacts with the output of the final RNN layer. The additional $H ^ { 2 } + 2 H \\bar { }$ parameters are minor compared to a single LSTM layer’s $8 H ^ { 2 } + 4 \\dot { H }$ parameters. Most models also use multiple LSTM layers. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            405
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In terms of additional computation, a pointer sentinel-LSTM of window size $L$ only requires computing the query $q$ (a linear layer with tanh activation), a total of $L$ parallelizable inner product calculations, and the attention scores for the $L$ resulting scalars via the softmax function. ",
+        "bbox": [
+            176,
+            411,
+            825,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            344,
+            489
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Considerable research has been dedicated to the task of language modeling, from traditional machine learning techniques such as n-grams to deep neural sequence models. ",
+        "bbox": [
+            173,
+            506,
+            823,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Mixture models composed of various knowledge sources have been proposed in the past for language modeling. Rosenfeld (1996) uses a maximum entropy model to combine a variety of information sources to improve language modeling on news text and speech. These information sources include complex overlapping n-gram distributions and n-gram caches that aim to capture rare words. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Beyond n-grams, neural sequence models such as recurrent neural networks have been shown to achieve state of the art results (Mikolov et al., 2010). A variety of RNN regularization methods have been explored, including a number of dropout variations (Zaremba et al., 2014; Gal, 2015) which prevent overfitting of complex LSTM language models. Other work has modified the RNN architecture to better handle increased recurrence depth (Zilly et al., 2016). ",
+        "bbox": [
+            174,
+            603,
+            825,
+            674
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to increase capacity and minimize the impact of vanishing gradients, some language and translation models have also added a soft attention or memory component (Bahdanau et al., 2015; Sukhbaatar et al., 2015; Cheng et al., 2016; Kumar et al., 2016; Xiong et al., 2016; Ahn et al., 2016). These mechanisms allow for the retrieval and use of relevant previous hidden states. Soft attention mechanisms need to first encode the relevant word into a state vector and then decode it again, even if the output word is identical to the input word used to compute that hidden state or memory. A drawback to soft attention is that if, for instance, January and March are both equally attended candidates, the attention mechanism may blend the two vectors, resulting in a context vector closest to February (Kadlec et al., 2016). Even with attention, the standard softmax classifier being used in these models often struggles to correctly predict rare or previously unknown words. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Attention-based pointer mechanisms were introduced in Vinyals et al. (2015) where the pointer network is able to select elements from the input as output. In the above example, only January or March would be available as options, as February does not appear in the input. The use of pointer networks have been shown to help with geometric problems (Vinyals et al., 2015), code generation (Ling et al., 2016), summarization (Gu et al., 2016; Gulc¸ehre et al. ¨ , 2016), question answering (Kadlec et al., 2016). While pointer networks improve performance on rare words and long-term dependencies they are unable to select words that do not exist in the input. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Gulc¸ehre et al. ¨ (2016) introduce a pointer softmax model that can generate output from either the vocabulary softmax of an RNN or the location softmax of the pointer network. Not only does this allow for producing OoV words which are not in the input, the pointer softmax model is able to better deal with rare and unknown words than a model only featuring an RNN softmax. Rather than constructing a mixture model as in our work, they use a switching network to decide which component to use. For neural machine translation, the switching network is conditioned on the representation of the context of the source text and the hidden state of the decoder. The pointer network is not used as a source of information for the switching network as in our model. The pointer and RNN softmax are scaled according to the switching network and the word or location with the highest final attention score is selected for output. Although this approach uses both a pointer and RNN component, it is not a mixture model and does not combine the probabilities for a word if it occurs in both the pointer location softmax and the RNN vocabulary softmax. In our model the word probability is a mix of both the RNN and pointer components, allowing for better predictions when the context may be ambiguous. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Extending this concept further, the latent predictor network (Ling et al., 2016) generates an output sequence conditioned on an arbitrary number of base models where each base model may have differing granularity. In their task of code generation, the output could be produced one character at a time using a standard softmax or instead copy entire words from referenced text fields using a pointer network. As opposed to Gulc¸ehre et al. ¨ (2016), all states which produce the same output are merged by summing their probabilities. The model requires a complex training process involving the forward-backward algorithm for Semi-Markov models to prevent an exponential path explosion. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            402
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 WIKITEXT - A BENCHMARK FOR LANGUAGE MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            681,
+            438
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first describe the most commonly used language modeling dataset and its pre-processing in order to then motivate the need for a new benchmark dataset. ",
+        "bbox": [
+            173,
+            454,
+            823,
+            481
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 PENN TREEBANK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            498,
+            334,
+            512
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to compare our model to the many recent neural language models, we conduct word-level prediction experiments on the Penn Treebank (PTB) dataset (Marcus et al., 1993), pre-processed by Mikolov et al. (2010). The dataset consists of $9 2 9 \\mathrm { k }$ training, $7 3 \\mathrm { k }$ validation, and ${ } ^ { 8 2 \\mathrm { k } }$ test words. As part of the pre-processing performed by Mikolov et al. (2010), words were lower-cased, numbers were replaced with N, newlines were replaced with $\\langle e o s \\rangle$ , and all other punctuation was removed. The vocabulary is the most frequent 10k words with OoV tokens replaced by an $\\left. u n k \\right.$ token. For full statistics, refer to Table 1. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            622
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 REASONS FOR A NEW DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            638,
+            434,
+            652
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While the processed version of the PTB above has been frequently used for language modeling, it has many limitations. The tokens in PTB are all lower case, stripped of any punctuation, and limited to a vocabulary of only 10k words. These limitations mean that the PTB is unrealistic for real language use, especially when far larger vocabularies with many rare words are involved. The appendix contains a graph illustrating this using a Zipfian plot over the training partition of the PTB, with the curve stopping abruptly at the 10k limit. Given that accurately predicting rare words, such as named entities, is an important task for many applications, the lack of a long tail is problematic. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Other larger scale language modeling datasets exist. Unfortunately, they either have restrictive licensing which prevents widespread use or have randomized sentence ordering (Chelba et al., 2013) which is unrealistic for most language use and prevents the effective learning and evaluation of longer term dependencies. Hence, we constructed a language modeling dataset using text extracted from Wikipedia and have made this available to the community. ",
+        "bbox": [
+            176,
+            768,
+            825,
+            838
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 CONSTRUCTION AND PRE-PROCESSING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            486,
+            869
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We selected articles only fitting the Good or Featured article criteria specified by editors on Wikipedia. These articles have been reviewed by humans and are considered well written, factually accurate, broad in coverage, neutral in point of view, and stable. This resulted in 23,805 Good articles and 4,790 Featured articles. The text for each article was extracted using the Wikipedia API. Extracting text from Wikipedia mark-up is nontrivial due to the large number of macros in use, used for metric conversions, abbreviations, language notation, and date handling. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Once extracted, specific sections which primarily featured lists were removed by default. Other minor bugs, such as sort keys and Edit buttons that leaked in from the HTML, were also removed. Mathematical formulae and $\\mathrm { { I A T } _ { E } X }$ code were replaced with $\\langle f o r m u l a \\rangle$ tokens. Normalization and tokenization were performed using the Moses tokenizer (Koehn et al., 2007), slightly augmented to further split numbers $( 8 , 6 0 0  8 \\ \\textcircled { \\omega } , @ \\ 6 0 0 )$ and with some additional minor fixes. Following Chelba et al. (2013) a vocabulary was constructed by discarding all words with a count below 3. Words outside of the vocabulary were mapped to the $\\left. u n k \\right.$ token, also a part of the vocabulary. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 STATISTICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            268,
+            294,
+            282
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The full WikiText dataset is over 103 million words in size, a hundred times larger than the PTB. It is also a tenth the size of the One Billion Word Benchmark (Chelba et al., 2013), one of the largest publicly available language modeling benchmarks, whilst consisting of articles that allow for the capture and usage of longer term dependencies as might be found in many real world tasks. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            349
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The dataset is available in two different sizes: WikiText-2 and WikiText-103. Both feature punctuation, original casing, a larger vocabulary, and numbers. WikiText-2 is two times the size of the Penn Treebank dataset. WikiText-103 features all extracted articles. Both datasets use the same articles for validation and testing, only differing in the vocabularies. For full statistics, refer to Table 1. ",
+        "bbox": [
+            174,
+            357,
+            823,
+            412
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            434,
+            326,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            467,
+            351,
+            481
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As the pointer sentinel mixture model uses the outputs of the RNN from up to $L$ timesteps back, this presents a challenge for training. If we do not regenerate the stale historical outputs of the RNN when we update the gradients, backpropagation through these stale outputs may result in incorrect gradient updates. If we do regenerate all stale outputs of the RNN, the training process is far slower. As we can make no theoretical guarantees on the impact of stale outputs on gradient updates, we opt to regenerate the window of RNN outputs used by the pointer component after each gradient update. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            577
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also use truncated backpropagation through time (BPTT) in a different manner to many other RNN language models. Truncated BPTT allows for practical time-efficient training of RNN models but has fundamental trade-offs that are rarely discussed. For running truncated BPTT, BPTT is run for $k _ { 2 }$ timesteps once every $k _ { 1 }$ timesteps. For many RNN language modeling training schemes, $k _ { 1 } = k _ { 2 }$ , meaning that every $k$ timesteps truncated BPTT is performed for the $k$ previous timesteps. This results in only a single RNN output receiving backpropagation for $k$ timesteps, with the other extreme being that the first token receives backpropagation for 0 timesteps. As such, most words in the training data will never experience a full backpropagation for $k$ timesteps. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            695
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our task, the pointer component always looks $L$ timesteps into the past if $L$ past timesteps are available. We select $k _ { 1 } = 1$ and $k _ { 2 } = L$ such that for each timestep we perform backpropagation for $L$ timesteps and advance one timestep at a time. Only the loss for the final predicted word is used for backpropagation through the window. ",
+        "bbox": [
+            174,
+            702,
+            823,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 MODEL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            775,
+            333,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our experimental setup reflects that of Zaremba et al. (2014) and Gal (2015). We increased the number of timesteps used during training from 35 to 100, matching the length of the window $L$ . Batch size was increased to 32 from 20. We also halve the learning rate when validation perplexity is worse than the previous iteration, stopping training when validation perplexity fails to improve for three epochs or when 64 epochs are reached. The gradients are rescaled if their global norm exceeds 1 (Pascanu et al., 2013b).3 We evaluate the medium model configuration which features a two layer ",
+        "bbox": [
+            174,
+            801,
+            825,
+            886
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/bb3d98ce30f7ae806c74c7ce5a6ac5f840f0ca0c2ae8bbfe76910b06718261a4.jpg",
+        "table_caption": [
+            "Table 2: Single model perplexity on validation and test sets for the Penn Treebank language modeling task. For our models and the models of Zaremba et al. (2014) and Gal (2015), medium and large refer to a 650 and 1500 unit two layer LSTM respectively. Parameter numbers with $^ \\ddag$ are estimates based upon our understanding of the model and with reference to Kim et al. (2016). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Parameters</td><td>Validation</td><td>Test</td></tr><tr><td>Mikolov &amp; Zweig (2012) - KN-5</td><td>2M</td><td></td><td>141.2</td></tr><tr><td>Mikolov &amp; Zweig (2012) - KN5 + cache</td><td>2M</td><td></td><td>125.7</td></tr><tr><td>Mikolov&amp;Zweig g(2012) -RNN</td><td>6M</td><td></td><td>124.7</td></tr><tr><td>Mikolov&amp;Zweig g(2012)-RNN-LDA</td><td>7M</td><td></td><td>113.7</td></tr><tr><td>Mikolov &amp; Zweig ( g(2012) - RNN-LDA + KN-5 +cache</td><td>9M</td><td></td><td>92.0</td></tr><tr><td>Pascanu et al. (2013a) - Deep RNN</td><td>6M</td><td></td><td>107.5</td></tr><tr><td>Cheng et al. (2014) - Sum-Prod Net</td><td>5Mt</td><td>一</td><td>100.0</td></tr><tr><td>Zaremba et al. (2014) - LSTM (medium) Zaremba et al. (2014) - LSTM (large)</td><td>20M</td><td>86.2</td><td>82.7</td></tr><tr><td>Gal (2015) - Variational LSTM (medium, untied)</td><td>66M</td><td>82.2</td><td>78.4</td></tr><tr><td>Gal (2015) - Variational LSTM (medium,untied, MC)</td><td>20M 20M</td><td>81.9 ± 0.2</td><td>79.7 ± 0.1</td></tr><tr><td>Gal (2015) - Variational LSTM (large,untied)</td><td>66M</td><td>一</td><td>78.6 ±0.1</td></tr><tr><td>Gal (2015) - Variational LSTM (large,untied, MC)</td><td></td><td>77.9 ± 0.3</td><td>75.2 ± 0.2</td></tr><tr><td>Kim etal. (2016) - CharCNN</td><td>66M 19M</td><td>1</td><td>73.4± 0.0</td></tr><tr><td>Zilly et al. (2016) - Variational RHN</td><td>32M</td><td>一</td><td>78.9</td></tr><tr><td></td><td></td><td>72.8</td><td>71.3</td></tr><tr><td>Zoneout + Variational LSTM (medium)</td><td>20M</td><td>84.4</td><td>80.6</td></tr><tr><td>Pointer Sentinel-LSTM (medium)</td><td>21M</td><td>72.4</td><td>70.9</td></tr></table>",
+        "bbox": [
+            191,
+            102,
+            803,
+            357
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "LSTM of hidden size 650. We compare against the large model configuration which features a two layer LSTM of hidden size 1500. ",
+        "bbox": [
+            173,
+            455,
+            823,
+            483
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We produce results for two model types, an LSTM model that uses dropout regularization and the pointer sentinel-LSTM model. The variants of dropout used were zoneout (Krueger et al., 2016) and variational inference based dropout (Gal, 2015). Zoneout, which stochastically forces some recurrent units to maintain their previous values, was used for the recurrent connections within the LSTM. Variational inference based dropout, where the dropout mask for a layer is locked across timesteps, was used on the input to each RNN layer and also on the output of the final RNN layer. We used a value of 0.5 for both dropout connections. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            588
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 COMPARISON OVER PENN TREEBANK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            612,
+            475,
+            626
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2 compares the pointer sentinel-LSTM to a variety of other models on the Penn Treebank dataset. The pointer sentinel-LSTM achieves the lowest perplexity, followed by the recent Recurrent Highway Networks (Zilly et al., 2016). The medium pointer sentinel-LSTM model also achieves lower perplexity than the large LSTM models. Note that the best performing large variational LSTM model uses computationally intensive Monte Carlo (MC) dropout averaging. Monte Carlo dropout averaging is a general improvement for any sequence model that uses dropout but comes at a greatly increased test time cost. In Gal (2015) it requires rerunning the test model with 1000 different dropout masks. The pointer sentinel-LSTM is able to achieve these results with far fewer parameters than other models with comparable performance, specifically with less than a third the parameters used in the large variational LSTM models. ",
+        "bbox": [
+            174,
+            640,
+            825,
+            780
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also test a variational LSTM that uses zoneout, which serves as the RNN component of our pointer sentinel-LSTM mixture. This variational LSTM model performs BPTT for the same length $L$ as the pointer sentinel-LSTM, where $L = 1 0 0$ timesteps. The results for this model ablation are worse than that of Gal (2015)’s variational LSTM without Monte Carlo dropout averaging. ",
+        "bbox": [
+            176,
+            787,
+            825,
+            843
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 COMPARISON OVER WIKITEXT-2 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            866,
+            442,
+            881
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As WikiText-2 is being introduced in this dataset, there are no existing baselines. We provide two baselines to compare the pointer sentinel-LSTM against: our variational LSTM using zoneout and ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e118bfa88fa9949d7520597d73dce917db8fa9e729b242dd65df300d0c46b6ab.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Parameters</td><td>Validation</td><td>Test</td></tr><tr><td>Variational LSTM implementation from Gal (2015)</td><td>20M</td><td>101.7</td><td>96.3</td></tr><tr><td>Zoneout + Variational LSTM</td><td>20M</td><td>108.7</td><td>100.9</td></tr><tr><td>Pointer Sentinel-LSTM</td><td>21M</td><td>84.8</td><td>80.8</td></tr></table>",
+        "bbox": [
+            220,
+            101,
+            774,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Single model perplexity on validation and test sets for the WikiText-2 language modeling task. All compared models use a two layer LSTM with a hidden size of 650. ",
+        "bbox": [
+            173,
+            184,
+            821,
+            213
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "the medium variational LSTM used in Gal (2015).4 Attempts to run the Gal (2015) large model variant, a two layer LSTM with hidden size 1500, resulted in out of memory errors on a 12GB K80 GPU, likely due to the increased vocabulary size. We chose the best hyperparameters from PTB experiments for all models. Table 3 shows a similar gain made by the pointer sentinel-LSTM over the variational LSTM models. The variational LSTM from Gal (2015) again beats out the variational LSTM used as a base for our experiments. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            306
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            329,
+            290,
+            344
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.1 IMPACT ON RARE WORDS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            361,
+            395,
+            376
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A hypothesis as to why the pointer sentinel-LSTM can outperform an LSTM is that the pointer component allows the model to effectively reproduce rare words. The RNN may better use hidden state capacity by relying on the pointer component. The pointer component may also allow for a sharper selection of a single word than may be possible using only the softmax. ",
+        "bbox": [
+            176,
+            388,
+            825,
+            444
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The appendix contains a graph which shows the improvement of perplexity when comparing the LSTM to the pointer sentinel-LSTM. Words are split across buckets according to frequency. As the words become rarer, the pointer sentinel-LSTM has stronger improvements in perplexity. Even on the Penn Treebank, where there is a relative absence of rare words due to only selecting the most frequent 10k words, we can see the pointer sentinel-LSTM mixture model provides a direct benefit. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            522
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While the improvements are largest on rare words, we can see the pointer sentinel-LSTM is still helpful on relatively frequent words. This may be the pointer component directly selecting the word or through the pointer supervision signal improving the RNN by allowing gradients to flow directly to other occurrences of the word in that window. ",
+        "bbox": [
+            176,
+            529,
+            823,
+            584
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 QUALITATIVE ANALYSIS OF POINTER USAGE ",
+        "text_level": 1,
+        "bbox": [
+            179,
+            604,
+            526,
+            618
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In a qualitative analysis, we visualized the gate use and pointer attention for a variety of examples in the validation set, focusing on predictions where the gate primarily used the pointer component. These visualizations are available in the appendix. ",
+        "bbox": [
+            176,
+            631,
+            825,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As expected, the pointer component is heavily used for rare names such as Seidman (23 times in training), Iverson (7 times in training), and Rosenthal (3 times in training). The pointer component was also heavily used when it came to other named entity names such as companies like Honeywell (8 times in training) and Integrated (41 times in training, though due to lowercasing of words this includes integrated circuits, fully integrated, and other generic usage). Surprisingly, the pointer component was also used for many frequent tokens. For selecting units of measurement (tons, kilograms, . . . ) or the short scale of numbers (thousands, millions, billions, . . . ), the pointer would refer to recent usage. This is to be expected, especially when phrases are of the form increased from N tons to N tons. The model can even be found relying on a mixture of the softmax and the pointer for predicting frequent verbs such as said. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, the pointer component can be seen pointing to words at the very end of the 100 word window (position 97), a far longer horizon than the 35 steps that most language models truncate their backpropagation training to. This illustrates why the gating function must be integrated into the pointer component. If the gating function could only use the RNN hidden state, it would need to be wary of words that were near the tail of the pointer, especially if it was not able to accurately track exactly how long it was since seeing a word. By integrating the gating function into the pointer component, we avoid the RNN hidden state having to maintain this intensive bookkeeping. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            895
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            152,
+            318,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We introduced the pointer sentinel mixture model and the WikiText language modeling dataset. The pointer sentinel mixture model can be applied to any classifier that ends in a softmax, including various recurrent neural network building blocks. When applied to a standard LSTM, the pointer sentinel-LSTM achieves state of the art results in language modeling over the Penn Treebank while using few additional parameters and little additional computational complexity at prediction time. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have also motivated the need to move from Penn Treebank to a new language modeling dataset for long range dependencies, providing WikiText-2 and WikiText-103 as potential options. We hope these new datasets can serve as a platform to improve handling of rare words and the usage of long term dependencies in language modeling. ",
+        "bbox": [
+            176,
+            262,
+            825,
+            318
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            340,
+            285,
+            356
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yossi Adi, Einat Kermany, Yonatan Belinkov, Ofer Lavi, and Yoav Goldberg. Fine-grained Analysis of Sentence Embeddings Using Auxiliary Prediction Tasks. arXiv preprint arXiv:1608.04207, 2016.   \nSungjin Ahn, Heeyoul Choi, Tanel Parnamaa, and Yoshua Bengio. A Neural Knowledge Language ¨ Model. CoRR, abs/1608.00318, 2016.   \nDzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural Machine Translation by Jointly Learning to Align and Translate. In ICLR, 2015.   \nCiprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One Billion Word Benchmark for Measuring Progress in Statistical Language Modeling. arXiv preprint arXiv:1312.3005, 2013.   \nJianpeng Cheng, Li Dong, and Mirella Lapata. Long Short-Term Memory-Networks for Machine Reading. CoRR, abs/1601.06733, 2016.   \nWei-Chen Cheng, Stanley Kok, Hoai Vu Pham, Hai Leong Chieu, and Kian Ming Adam Chai. Language Modeling with Sum-Product Networks. In INTERSPEECH, 2014.   \nYarin Gal. A Theoretically Grounded Application of Dropout in Recurrent Neural Networks. arXiv preprint arXiv:1512.05287, 2015.   \nJiatao Gu, Zhengdong Lu, Hang Li, and Victor O. K. Li. Incorporating Copying Mechanism in Sequence-to-Sequence Learning. CoRR, abs/1603.06393, 2016.   \nC¸ aglar Gulc¸ehre, Sungjin Ahn, Ramesh Nallapati, Bowen Zhou, and Yoshua Bengio. Pointing the ¨ Unknown Words. arXiv preprint arXiv:1603.08148, 2016.   \nSepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural Computation, 9(8): 1735–1780, Nov 1997. ISSN 0899-7667.   \nRudolf Kadlec, Martin Schmid, Ondrej Bajgar, and Jan Kleindienst. Text Understanding with the Attention Sum Reader Network. arXiv preprint arXiv:1603.01547, 2016.   \nYoon Kim, Yacine Jernite, David Sontag, and Alexander M. Rush. Character-aware neural language models. CoRR, abs/1508.06615, 2016.   \nPhilipp Koehn, Hieu Hoang, Alexandra Birch, Chris Callison-Burch, Marcello Federico, Nicola Bertoldi, Brooke Cowan, Wade Shen, Christine Moran, Richard Zens, Chris Dyer, Ondej Bojar, Alexandra Constantin, and Evan Herbst. Moses: Open Source Toolkit for Statistical Machine Translation. In ACL, 2007. ",
+        "bbox": [
+            171,
+            358,
+            826,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Krueger, Tegan Maharaj, Janos Kram ´ ar, Mohammad Pezeshki, Nicolas Ballas, Nan Rosemary ´ Ke, Anirudh Goyal, Yoshua Bengio, Hugo Larochelle, Aaron Courville, et al. Zoneout: Regularizing RNNs by Randomly Preserving Hidden Activations. arXiv preprint arXiv:1606.01305, 2016. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ankit Kumar, Ozan Irsoy, Peter Ondruska, Mohit Iyyer, James Bradbury, Ishaan Gulrajani, Victor Zhong, Romain Paulus, and Richard Socher. Ask me anything: Dynamic memory networks for natural language processing. In ICML, 2016. ",
+        "bbox": [
+            176,
+            169,
+            825,
+            212
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wang Ling, Edward Grefenstette, Karl Moritz Hermann, Tomas Kocisk ´ y, Andrew Senior, ´ Fumin Wang, and Phil Blunsom. Latent Predictor Networks for Code Generation. CoRR, abs/1603.06744, 2016. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            262
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P. Marcus, Beatrice Santorini, and Mary Ann Marcinkiewicz. Building a Large Annotated Corpus of English: The Penn Treebank. Computational Linguistics, 19:313–330, 1993. ",
+        "bbox": [
+            174,
+            272,
+            823,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov and Geoffrey Zweig. Context dependent recurrent neural network language model. In SLT, 2012. ",
+        "bbox": [
+            174,
+            309,
+            821,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Martin Karafiat, Luk ´ as Burget, Jan Cernock ´ y, and Sanjeev Khudanpur. Recurrent ´ neural network based language model. In INTERSPEECH, 2010. ",
+        "bbox": [
+            173,
+            347,
+            821,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, C¸ aglar Gulc¸ehre, Kyunghyun Cho, and Yoshua Bengio. How to Construct Deep ¨ Recurrent Neural Networks. CoRR, abs/1312.6026, 2013a. ",
+        "bbox": [
+            173,
+            385,
+            825,
+            414
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In ICML, 2013b. ",
+        "bbox": [
+            174,
+            422,
+            821,
+            452
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Roni Rosenfeld. A Maximum Entropy Approach to Adaptive Statistical Language Modeling. 1996. ",
+        "bbox": [
+            173,
+            460,
+            821,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-To-End Memory Networks. In NIPS, 2015. ",
+        "bbox": [
+            173,
+            484,
+            823,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015. ",
+        "bbox": [
+            173,
+            522,
+            823,
+            551
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Caiming Xiong, Stephen Merity, and Richard Socher. Dynamic Memory Networks for Visual and Textual Question Answering. In ICML, 2016. ",
+        "bbox": [
+            174,
+            560,
+            823,
+            589
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014. ",
+        "bbox": [
+            174,
+            597,
+            821,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Julian Georg Zilly, Rupesh Kumar Srivastava, Jan Koutn´ık, and Jurgen Schmidhuber. Recurrent ¨ Highway Networks. arXiv preprint arXiv:1607.03474, 2016. ",
+        "bbox": [
+            173,
+            636,
+            823,
+            665
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            263,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/c45d689e3a9e29ba2e76713a83dcf9f4d4092e2ed8fea40c92d7c483e5b46e8e.jpg",
+        "image_caption": [
+            "Figure A1: Mean difference in log perplexity on PTB when using the pointer sentinel-LSTM compared to the LSTM model. Words were sorted by frequency and split into equal sized buckets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            191,
+            761,
+            532
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "POINTER USAGE ON THE PENN TREEBANK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            470,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For a qualitative analysis, we visualize how the pointer component is used within the pointer sentinel mixture model. The gate refers to the result of the gating function, with 1 indicating the RNN component is exclusively used whilst 0 indicates the pointer component is exclusively used. We begin with predictions that are using the RNN component primarily and move to ones that use the pointer component primarily. ",
+        "bbox": [
+            173,
+            128,
+            825,
+            200
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/bfe1101a2fb87f4dcc5d4a29f6b3f7d8300c9eaa08d693f87d33a6263f3313bb.jpg",
+        "image_caption": [
+            "Figure A2: In predicting the fall season has been a good one especially for those retailers, the pointer component suggests many words from the historical window that would fit - retailers, investments, chains, and institutions. The gate is still primarily weighted towards the RNN component however. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            217,
+            818,
+            273
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/74f8b37f282e29b8fa0aba935aeef9ab0765afe5633d21f65b8558f8effb4fca.jpg",
+        "image_caption": [
+            "Figure A3: In predicting the national cancer institute also projected that overall u.s. mortality, the pointer component is focused on mortality and rates, both of which would fit. The gate is still primarily weighted towards the RNN component. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            381,
+            816,
+            435
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/29f2ee31d97f97d485e728471fd2cd3eb34ab3a8f310dc8086e09059401473fd.jpg",
+        "image_caption": [
+            "Figure A4: In predicting people do n’t seem to be unhappy with it he said, the pointer component correctly selects said and is almost equally weighted with the RNN component. This is surprising given how frequent the word said is used within the Penn Treebank. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            534,
+            816,
+            582
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/ef168c7e1ca9bc89964097cbd337eb2c1028caa5e8e233bb485daa4283e232c1.jpg",
+        "image_caption": [
+            "Figure A5: For predicting the federal government has had to pump in $\\$ 1$ N billion, the pointer component focuses on the recent usage of billion with highly similar context. The pointer component is also relied upon more heavily than the RNN component - surprising given the frequency of billion within the Penn Treebank and that the usage was quite recent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            54,
+            818,
+            167
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd311d97c72a9f4fa21add99ecf8515494eb4cc97c98fcb7f45e7fd312eb7776.jpg",
+        "image_caption": [
+            "Figure A6: For predicting $\\left. u n k \\right.$ ’s ghost sometimes runs through the e ring dressed like gen. noriega, the pointer component reaches 97 timesteps back to retrieve gen. douglas. Unfortunately this prediction is incorrect but without additional context a human would have guessed the same word. This additionally illustrates why the gating function must be integrated into the pointer component. The named entity gen. douglas would have fallen out of the window in only four more timesteps, a fact that the RNN hidden state would not be able to accurately retain for almost 100 timesteps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            286,
+            816,
+            333
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/12273399d0022a69702f98b310adb69608c6c1657321fc3e0ec1618d18640606.jpg",
+        "image_caption": [
+            "Figure A7: For predicting mr. iverson, the pointer component has learned the ability to point to the last name of the most recent named entity. The named entity also occurs 45 timesteps ago, which is longer than the 35 steps that most language models truncate their backpropagation to. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            483,
+            816,
+            534
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/81f496401397d434510e2273937e7d5a166e9cb126ae3d3fa7dc1987293081e2.jpg",
+        "image_caption": [
+            "Figure A8: For predicting mr. rosenthal, the pointer is almost exclusively used and reaches back 65 timesteps to identify bruce rosenthal as the person speaking, correctly only selecting the last name. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            640,
+            816,
+            703
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/5244179d618289042f46d23f44db0ec07e116e8a3e2a4f736497656a6a7b8d86.jpg",
+        "image_caption": [
+            "Figure A9: For predicting in composite trading on the new york stock exchange yesterday integrated, the company Integrated and the $\\left. u n k \\right.$ token are primarily attended to by the pointer component, with nearly the full prediction being determined by the pointer component. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            785,
+            816,
+            837
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "ZIPFIAN PLOT OVER PTB AND WIKITEXT-2",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            478,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/fef900b9bfea3ce6d1b68bfa9dc98ab50ad06567225c817639d232fbc434491e.jpg",
+        "image_caption": [
+            "Figure A10: Zipfian plot over the training partition in Penn Treebank and WikiText-2 datasets. Notice the severe drop on the Penn Treebank when the vocabulary hits $1 0 ^ { 4 }$ . Two thirds of the vocabulary in WikiText-2 are past the vocabulary cut-off of the Penn Treebank. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            137,
+            880,
+            356
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "ZIPFIAN PLOT OVER WIKITEXT-103 ",
+        "bbox": [
+            174,
+            445,
+            424,
+            459
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/750b091fb947314259a95c5ff06b556058e55aa11164e7c6a76439cd5d72c9cf.jpg",
+        "image_caption": [
+            "Figure A11: Zipfian plot over the training partition in the WikiText-103 dataset. With the dataset containing over 100 million tokens, there is reasonable coverage of the long tail of the vocabulary. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            481,
+            712,
+            732
+        ],
+        "page_idx": 14
+    }
+]

parse/train/HyRVBzap-/HyRVBzap-.md

@@ -0,0 +1,307 @@
+# CASCADE ADVERSARIAL MACHINE LEARNING REGULARIZED WITH A UNIFIED EMBEDDING
+
+Taesik Na, Jong Hwan Ko & Saibal Mukhopadhyay
+
+School of Electrical and Computer Engineering   
+Georgia Institute of Technology   
+Atlanta, GA 30332, USA   
+{taesik.na, jonghwan.ko, smukhopadhyay6}@gatech.edu
+
+# ABSTRACT
+
+Injecting adversarial examples during training, known as adversarial training, can improve robustness against one-step attacks, but not for unknown iterative attacks. To address this challenge, we first show iteratively generated adversarial images easily transfer between networks trained with the same strategy. Inspired by this observation, we propose cascade adversarial training, which transfers the knowledge of the end results of adversarial training. We train a network from scratch by injecting iteratively generated adversarial images crafted from already defended networks in addition to one-step adversarial images from the network being trained. We also propose to utilize embedding space for both classification and low-level (pixel-level) similarity learning to ignore unknown pixel level perturbation. During training, we inject adversarial images without replacing their corresponding clean images and penalize the distance between the two embeddings (clean and adversarial). Experimental results show that cascade adversarial training together with our proposed low-level similarity learning efficiently enhances the robustness against iterative attacks, but at the expense of decreased robustness against one-step attacks. We show that combining those two techniques can also improve robustness under the worst case black box attack scenario.
+
+# 1 INTRODUCTION
+
+Injecting adversarial examples during training (adversarial training), (Goodfellow et al., 2015; Kurakin et al., 2017; Huang et al., 2015) increases the robustness of a network against adversarial attacks. The networks trained with one-step methods have shown noticeable robustness against onestep attacks, but, limited robustness against iterative attacks at test time. To address this challenge, we have made the following contributions:
+
+Cascade adversarial training: We first show that iteratively generated adversarial images transfer well between networks when the source and the target networks are trained with the same training method. Inspired by this observation, we propose cascade adversarial training which transfers the knowledge of the end results of adversarial training. In particular, we train a network by injecting iter FGSM images (section 2.1) crafted from an already defended network (a network trained with adversarial training) in addition to the one-step adversarial images crafted from the network being trained. The concept of using already trained networks for adversarial training is also introduced in (Tramer et al., 2017). In their work, purely trained networks are used as another source networks \` to generate one-step adversarial examples for training. On the contrary, our cascade adversarial training uses already defended network for iter FGSM images generation.
+
+Low level similarity learning: We advance the previous data augmentation approach (Kurakin et al., 2017) by adding additional regularization in deep features to encourage a network to be insensitive to adversarial perturbation. In particular, we inject adversarial images in the mini batch without replacing their corresponding clean images and penalize distance between embeddings from the clean and the adversarial examples. There are past examples of using embedding space for learning similarity of high level features like face similarity between two different images (Schroff et al., 2015; Parkhi et al., 2015; Wen et al., 2016). Instead, we use the embedding space for learning similarity of the pixel level differences between two similar images. The intuition of using this regularization is that small difference on input should not drastically change the high level feature representation.
+
+Analysis of adversarial training: We train ResNet models (He et al., 2016) on MNIST (LeCun & Cortes, 2010) and CIFAR10 dataset (Krizhevsky, 2009) using the proposed adversarial training. We first show low level similarity learning improves robustness of the network against adversarial images generated by one-step and iterative methods compared to the prior work. We show that modifying the weight of the distance measure in the loss function can help control trade-off between accuracies for the clean and adversarial examples.
+
+Together with cascade adversarial training and low-level similarity learning, we achieve accuracy increase against unknown iterative attacks, but at the expense of decreased accuracy for one-step attacks. We also show our cascade adversarial training and low level similarity learning provide much better robustness against black box attack.
+
+# 2 BACKGROUND ON ADVERSARIAL ATTACKS
+
+# 2.1 ATTACK METHODS
+
+One-step fast gradient sign method (FGSM), referred to as “step FGSM”, generates adversarial image $\bar { X } ^ { a d v }$ by adding sign of the gradients w.r.t. the clean image $\boldsymbol { X }$ multiplied by $\epsilon \in [ 0 , 2 5 5 ]$ as shown below (Goodfellow et al., 2015):
+
+$$
+X ^ { a d v } = X + \epsilon \mathrm { s i g n } ( \nabla _ { X } J ( X , y _ { t r u e } ) )
+$$
+
+One-step target class method generates $X ^ { a d v }$ by subtracting sign of the gradients computed on a target false label as follows:
+
+$$
+X ^ { a d v } = X - \epsilon \mathrm { s i g n } ( \nabla _ { X } J ( X , y _ { t a r g e t } ) )
+$$
+
+We use least likely class $y _ { L L }$ as a target class and refer this method as “step ll”.
+
+Basic iterative method, referred to as “iter FGSM”, applies FGSM with small $\alpha$ multiple times.
+
+$$
+X _ { 0 } ^ { a d v } = X , \quad X _ { N } ^ { a d v } = C l i p _ { X , \epsilon } \{ X _ { N - 1 } ^ { a d v } + \alpha \ \mathrm { s i g n } ( \nabla _ { X _ { N - 1 } ^ { a d v } } J ( X _ { N - 1 } ^ { a d v } , y _ { t r u e } ) ) \}
+$$
+
+We use $\alpha = 1$ , number of iterations $N$ to be $\operatorname* { m i n } ( \epsilon + 4 , 1 . 2 5 \epsilon ) . ~ C l i p _ { X , \epsilon }$ is elementwise clipping function where the input is clipped to the range $[ \mathrm { m a x } ( 0 , X - \epsilon ) , \mathrm { m i n } ( 2 5 5 , X + \epsilon ) ]$ .
+
+Iterative least-likely class method, referred to as “iter ll”, is to apply “step ll” with small $\alpha$ multiple times.
+
+$$
+X _ { 0 } ^ { a d v } = X , \quad X _ { N } ^ { a d v } = C l i p _ { X , \epsilon } \{ X _ { N - 1 } ^ { a d v } - \alpha \ \mathrm { s i g n } ( \nabla _ { X _ { N - 1 } ^ { a d v } } J ( X _ { N - 1 } ^ { a d v } , y _ { L L } ) ) \}
+$$
+
+Carlini and Wagner attack (Carlini & Wagner, 2017) referred to as $\mathbf { \tilde { \Sigma } } ^ { 6 6 } \mathbf { C } \mathbf { W } ^ { \prime } $ solves an optimization problem which minimizes both an objective function $f$ (such that attack is success if and only if $\stackrel { \bullet } { f } ( X ^ { a d v } ) < 0 )$ and a distance measure between $X ^ { a d v }$ and $\boldsymbol { X }$ .
+
+Black box attack is performed by testing accuracy on a target network with the adversarial images crafted from a source network different from the target network. Lower accuracy means successful black-box attack. When we use the same network for both target and source network, we call this as white-box attack.
+
+# 2.2 DEFENSE METHODS
+
+Adversarial training (Kurakin et al., 2017): is a form of data augmentation where it injects adversarial examples during training. In this method, $k$ examples are taken from the mini batch $B$ (size of $m$ ) and the adversarial examples are generated with one of step method. The $k$ adversarial examples replaces the corresponding clean examples when making mini batch. Below we refer this adversarial training method as “Kurakin’s”.
+
+Table 1: CIFAR10 test results $( \% )$ under black box attacks for ${ \epsilon } { = } 1 6$ . Source networks share the same initialization which is different from the target networks. {Target: R20, $\mathsf { R } 2 0 _ { K }$ : standard, Kurakin’s, Source: $\mathbf { R } 2 0 \mathbf { _ 2 }$ , $\mathbf { R } 2 0 _ { K 2 }$ : standard, Kurakin’s.}   
+
+<table><tr><td rowspan="2">Target</td><td colspan="2">Source: step-FGSM</td><td colspan="2">Source: iter_FGSM</td></tr><tr><td>R202</td><td>R20K2</td><td>R202</td><td>R20K2</td></tr><tr><td>R20</td><td>16.2</td><td>31.6</td><td>2.7</td><td>60.1</td></tr><tr><td>R20K</td><td>66.7</td><td>82.7</td><td>55.8</td><td>28.5</td></tr></table>
+
+![](images/9574ecbaff76aa59c142821a74b75ca57db11c28bc841935cae1c0896257b6aa.jpg)  
+Figure 1: Correlation between adversarial noises from different networks for each $\epsilon$ . Shaded region shows $\pm 0 . 1$ standard deviation of each line.
+
+Ensemble adversarial training (Tramer et al., 2017): \` is essentially the same with the adversarial training, but uses several pre-trained vanilla networks to generate one-step adversarial examples for training. Below we refer this adversarial training method as “Ensemble”.
+
+# 3 PROPOSED APPROACH
+
+# 3.1 TRANSFERABILITY ANALYSIS
+
+We first show transferability between purely trained networks and adversarially trained networks under black box attack. We use ResNet (He et al., 2016) models for CIFAR10 classification. We first train 20-layer ResNets with different methods (standard training, adversarial training (Kurakin et al., 2017)) and use those as target networks. We re-train networks (standard training and adversarial training) with the different initialization from the target networks, and use the trained networks as source networks. Experimental details and model descriptions can be found in Appendix A and B. In table 1, we report test accuracies under black box attack.
+
+Transferability (step attack): We first observe that high robustness against one-step attack between defended networks $( \mathsf { R } 2 0 _ { K 2 } \ldots \mathsf { R } 2 0 _ { K } )$ ), and low robustness between undefended networks $( \mathsf { R 2 0 _ { 2 } }$ - $> { \textrm R } 2 0 \AA ,$ ). This observation shows that error surfaces of neural networks are driven by the training method and networks trained with the same method end up similar optimum states.
+
+It is noteworthy to observe that the accuracies against step attack from the undefended network $( \mathsf { R } 2 0 _ { 2 } )$ are always lower than those from defended network $( \mathsf { R } 2 0 _ { K { \bf 2 } } )$ . Possible explanation for this would be that adversarial training tweaks gradient seen from the clean image to point toward weaker adversarial point along that gradient direction. As a result, one-step adversarial images from defended networks become weaker than those from undefended network.
+
+Transferability (iterative attack): We observe “iter FGSM” attack remains very strong even under the black box attack scenario but only between undefended networks or defended networks. This is because iter FGSM noises $( X ^ { a d v } – X )$ from defended networks resemble each other. As shown in figure 1, we observe higher correlation between iter FGSM noises from a defended network $( \mathsf { R } 2 0 \kappa )$ and those from another defended network $( \mathsf { R } 2 0 _ { K   { \bf 2 } } )$ ).
+
+Difficulty of defense/attack under the black box attack scenario: As seen from this observation, it is efficient to attack an undefended/defended network with iter FGSM examples crafted from another undefended/defended network. Thus, when we want to build a robust network under the black box attack scenario, it is desired to check accuracies for the adversarial examples crafted from other networks trained with the same strategy.
+
+# 3.2 CASCADE ADVERSARIAL TRAINING
+
+Inspired by the observation that iter FGSM images transfer well between defended networks, we propose cascade adversarial training, which trains a network by injecting iter FGSM images crafted from an already defended network. We hypothesize that the network being trained with cascade adversarial training will learn to avoid such adversarial perturbation, enhancing robustness against iter FGSM attack. The intuition behind this proposed method is that we transfer the knowledge of the end results of adversarial training. In particular, we train a network by injecting iter FGSM images crafted from already defended network in addition to the one-step adversarial images crafted from the network being trained.
+
+![](images/3e15aca655600181f36bed5f1e7e2e1f2bf9f8ad5a8ba6aba416917d887a4350.jpg)  
+Figure 2: Cascade adversarial training regularized with a unified embedding.
+
+![](images/94897954e10187615eda8e565cf77b8ca80a2765e4e1577dda4e06d5b6bda6a3.jpg)  
+Figure 3: (Left) Bidirectional loss. (Right) Pivot loss.
+
+# 3.3 REGULARIZATION WITH A UNIFIED EMBEDDING
+
+We advance the algorithm proposed in (Kurakin et al., 2017) by adding low level similarity learning. Unlike (Kurakin et al., 2017), we include the clean examples used for generating adversarial images in the mini batch. Once one step forward pass is performed with the mini batch, embeddings are followed by the softmax layer for the cross entropy loss for the standard classification. At the same time, we take clean embeddings and adversarial embeddings, and minimize the distance between the two with the distance based loss.
+
+The distance based loss encourages two similar images (clean and adversarial) to produce the same outputs, not necessarily the true labels. Thus, low-level similarity learning can be considered as an unsupervised learning. By adding regularization in higher embedding layer, convolution filters gradually learn how to ignore such pixel-level perturbation. We have applied regularization on lower layers with an assumption that low level pixel perturbation can be ignored in lower hierarchy of networks. However, adding regularization term on higher embedding layer right before the softmax layer showed best performance. The more convolutional filters have chance to learn such similarity, the better the performance. Note that cross entropy doesn’t encourage two similar images to produce the same output labels. Standard image classification using cross entropy compares ground truth labels with outputs of a network regardless of how similar training images are.
+
+The entire training process combining cascade adversarial training and low level similarity learning is shown in figure 2. We define the total loss as follows:
+
+$$
+L o s s = \frac { 1 } { ( m - k ) + \lambda k } \Bigg ( \sum _ { i = 1 } ^ { m - k } L ( { \bf X } _ { i } | y _ { i } ) + \lambda \sum _ { i = 1 } ^ { k } L ( { \bf X } _ { i } ^ { a d v } | y _ { i } ) \Bigg ) + \lambda _ { 2 } \sum _ { i = 1 } ^ { k } L _ { d i s t } ( E _ { i } ^ { a d v } , E _ { i } )
+$$
+
+$\mathbf { \mathcal { E } } _ { i }$ and $E _ { i } ^ { a d v }$ are the resulting embeddings from $X _ { i }$ and $X _ { i } ^ { a d v }$ , respectively. $m$ is the size of the mini batch, $k \left( \leq m / 2 \right)$ is the number of adversarial images in the mini batch. $\lambda$ is the parameter to control the relative weight of classification loss for adversarial images. $\lambda _ { 2 }$ is the parameter to control the relative weight of the distance based loss $L _ { d i s t }$ in the total loss.
+
+Bidirectional loss minimizes the distance between the two embeddings by moving both clean and adversarial embeddings as shown in the left side of the figure 3.
+
+$$
+L _ { d i s t } ( \pmb { { E } } _ { i } ^ { a d v } , \pmb { { E } } _ { i } ) = | | \pmb { { E } } _ { i } ^ { a d v } - \pmb { { E } } _ { i } | | _ { N } ^ { N } , \quad N \in { 1 , 2 \quad i = 1 , 2 , . . . , k }
+$$
+
+Table 2: MNIST test results $( \% )$ for 20-layer ResNet models $\prime { \epsilon } = 0 . 3 { ^ { * } } 2 5 5$ at test time). $\{ { \bf R } 2 0 { \bf M }$ : standard training, ${ \mathrm { R } } 2 0 { \mathrm { M } } _ { K }$ : Kurakin’s adversarial training, ${ \bf R } 2 0 { \bf M } _ { B }$ : Bidirectional loss, ${ \bf R } 2 0 { \bf M } _ { P }$ : P ivot loss. $\}$ CW $L _ { \infty }$ attack is performed with 100 test samples (10 samples per each class) and the number of adversarial examples with $\epsilon > 0 . 3 ^ { * } 2 5 5$ is reported. Additional details for CW attack can be found in Appendix F   
+
+<table><tr><td>Model</td><td>clean</td><td>step_ll</td><td>step_FGSM</td><td>iter_ll</td><td>iter_FGSM</td><td>CW</td></tr><tr><td>R20M</td><td>99.6</td><td>9.7</td><td>10.3</td><td>0.0</td><td>0.0</td><td>0</td></tr><tr><td>R20MK</td><td>99.6</td><td>96.7</td><td>94.5</td><td>89.0</td><td>60.2</td><td>46</td></tr><tr><td>R20Mb (Ours)</td><td>99.5</td><td>97.3</td><td>96.2</td><td>97.2</td><td>88.5</td><td>81</td></tr><tr><td>R20Mp (Ours)</td><td>99.5</td><td>97.1</td><td>95.7</td><td>96.9</td><td>88.9</td><td>82</td></tr></table>
+
+We tried $N = 1$ , 2 and found not much difference between the two. We report the results with $N =$ 2 for the rest of the paper otherwise noted. When $N = 2$ , $L _ { d i s t }$ becomes L2 loss.
+
+Pivot loss minimizes the distance between the two embeddings by moving only the adversarial embeddings as shown in the right side of the figure 3.
+
+$$
+L _ { d i s t } ( \pmb { { E } } _ { i } ^ { a d v } | \pmb { { E } } _ { i } ) = | | \pmb { { E } } _ { i } ^ { a d v } - \pmb { { E } } _ { i } | | _ { N } ^ { N } , \quad N \in { 1 , 2 \quad i = 1 , 2 , . . . , k }
+$$
+
+In this case, clean embeddings ( $\mathbf { \mathcal { E } } _ { i }$ ) serve as pivots to the adversarial embeddings. In particular, we don’t back-propagate through the clean embeddings for the distance based loss. The intuition behind the use of pivot loss is that the embedding from a clean image can be treated as the ground truth embedding.
+
+# 4 LOW LEVEL SIMILARITY LEARNING ANALYSIS
+
+# 4.1 EXPERIMENTAL RESULTS ON MNIST
+
+We first analyze the effect of low level similarity learning on MNIST. We train ResNet models (He et al., 2016) with different methods (standard training, Kurakin’s adversarial training and adversarial training with our distance based loss). Experimental details can be found in Appendix A.
+
+Table 2 shows the accuracy results for MNIST test dataset for different types of attack methods. As shown in the table, our method achieves better accuracy than Kurakin’s method for all types of attacks with a little sacrifice on the accuracy for the clean images. Even though adversarial training is done only with “step ll”, additional regularization increases robustness against unknown “step FGSM”, “iter ll”, “iter FGSM” and CW $L _ { \infty }$ attacks. This shows that our low-level similarity learning can successfully regularize the one-step adversarial perturbation and its vicinity for simple image classification like MNIST.
+
+# 4.2 EMBEDDING SPACE VISUALIZATION
+
+To visualize the embedding space, we modify 20-layer ResNet model where the last fully connected layer $\left( 6 4 \mathbf { x } 1 0 \right)$ is changed to two fully connected layers ( $6 4 \mathrm { x } 2$ and 2x10). We re-train networks with standard training, Kurakin’s method and our pivot loss on MNIST. 1 In figure 4, we draw embeddings (dimension $^ { 1 = 2 }$ ) between two fully connected layers. As seen from this figure, adversarial images from the network trained with standard training cross the decision boundary easily as $\epsilon$ increases. With Kurakin’s adversarial training, the distances between clean and adversarial embeddings are minimized compared to standard training. And our pivot loss further minimizes distance between the clean and adversarial embeddings. Note that our pivot loss also decreases absolute value of the embeddings, thus, higher $\lambda _ { 2 }$ will eventually result in overlap between distinct embedding distributions. We also observe that intra class variation of the clean embeddings are also minimized for the network trained with our pivot loss as shown in the scatter plot in figure 4 (c).
+
+![](images/03d39dce6fed9b5b8ffb7ae3b4de76e2f07a5e1bf76cb53aab54a3b3914a9521.jpg)  
+Figure 4: Embedding space visualization for modified ResNet models trained on MNIST. $\mathbf { X }$ -axis and y-axis show first and second dimension of embeddings respectively. Scatter plot shows first 100 clean embeddings per each class on MNIST test set. Each arrow shows difference between two embeddings (one from iter FGSM image () and the other from $( \epsilon { + } 8 ) ,$ ). We draw arrows from $\epsilon = 0$ to $\epsilon = 7 6$ $( \approx 0 . 3 ^ { * } 2 5 5 )$ ) for one sample image per each class. We observe differences between clean and corresponding adversarial embeddings are minimized for the network trained with pivot loss.
+
+# 4.3 EFFECT OF $\lambda _ { 2 }$ ON CIFAR10
+
+We train 20-layer ResNet models with pivot loss and various $\lambda _ { \mathrm { 2 } } \mathrm { s }$ for CIFAR10 dataset to study effects of the weight of the distance measure in the loss function. Figure 5 shows that a higher $\lambda _ { 2 }$ increases accuracy of the iteratively generated adversarial images. However, it reduces accuracy on the clean images, and increasing $\lambda _ { 2 }$ above 0.3 even results in divergence of the training. This is because embedding distributions of different classes will eventually overlap since absolute value of the embedding will be decreased as $\lambda _ { 2 }$ increases as seen from the section 4.2. In this experiment, we show that there exists clear trade-off between accuracy for the clean images and that for the adversarial images, and we recommend using a very high $\lambda _ { 2 }$ only under strong adversarial environment.
+
+![](images/c7c186c5dd4d21b6bfbfbcbee29ca466d12198bfbe2a9938e520a56b1e3d928b.jpg)  
+Figure 5: Accuracy vs. $\lambda _ { 2 }$
+
+# 5 CASCADE ADVERSARIAL TRAINING ANALYSIS
+
+# 5.1 SOURCE NETWORK SELECTION
+
+We further study the transferability of iter FGSM images between various architectures. To this end, we first train 56-layer ResNet networks (Kurakin’s, pivot loss) with the same initialization. Then we train another 56-layer ResNet network (Kurakin’s) with different initialization. We repeat the training for the 110-layer ResNet networks. We measure correlation between iter FGSM noises from different networks.
+
+![](images/34d7075ba0af839593f33f5d84485be6ec355dc2d545d65ab9e3441ef984ed68.jpg)  
+Figure 6 (a) shows correlation between iter FGSM noises crafted from Kurakin’s network and those from Pivot network with the same initialization. Conjectured from (Kurakin et al., 2017), we observe high corre  
+Figure 6: Correlation between iter FGSM noises crafted from different networks for each . Correlation is averaged over randomly chosen 128 images from CIFAR10 test-set.
+
+Table 3: CIFAR10 test results $( \% )$ for 110-layer ResNet models. CW $L _ { \infty }$ attack is performed with 100 test samples (10 samples per each class) and the number of adversarial examples with $\epsilon > 2$ or 4 is reported. $\{ \mathrm { R 1 1 0 } _ { K }$ : Kurakin’s, $\mathrm { R } 1 0 _ { P }$ : P ivot loss, $\mathrm { R } 1 1 0 _ { E }$ : Ensemble training, $\mathrm { R 1 1 0 } _ { K , C }$ : Kurakin’s and $C$ ascade training, $\mathrm { R 1 1 0 } _ { P , E }$ : P ivot loss and Ensemble training, and $\mathrm { R 1 1 0 } _ { P , C }$ : P ivot loss and Cascade training}   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">clean</td><td colspan="2">step_ll</td><td colspan="2">step_FGSM</td><td colspan="2">iter_FGSM</td><td colspan="2">CW</td></tr><tr><td>e=2</td><td>∈=16</td><td>e=2</td><td>∈=16</td><td>e=2</td><td>∈=4</td><td>∈=2</td><td>e=4</td></tr><tr><td>R110K</td><td>92.3</td><td>88.3</td><td>90.7</td><td>86.0</td><td>95.2</td><td>59.4</td><td>9.2</td><td>25</td><td>4</td></tr><tr><td>R110p (Ours)</td><td>92.3</td><td>86.0</td><td>89.4</td><td>81.6</td><td>91.6</td><td>64.1</td><td>20.9</td><td>32</td><td>7</td></tr><tr><td>R110E</td><td>92.3</td><td>86.3</td><td>74.3</td><td>84.1</td><td>72.9</td><td>63.5</td><td>21.1</td><td>24</td><td>6</td></tr><tr><td>R110k,c (Ours)</td><td>92.3</td><td>86.2</td><td>72.8</td><td>82.6</td><td>66.7</td><td>69.3</td><td>33.4</td><td>20</td><td>5</td></tr><tr><td>R110p,ε (Ours)</td><td>91.3</td><td>84.0</td><td>65.7</td><td>77.6</td><td>54.5</td><td>66.8</td><td>38.3</td><td>38</td><td>16</td></tr><tr><td>R110p,c (Ours)</td><td>91.5</td><td>85.7</td><td>76.4</td><td>82.4</td><td>69.1</td><td>73.5</td><td>42.5</td><td>27</td><td>15</td></tr></table>
+
+lation between iter FGSM noises from networks with the same initialization. Correlation between iter FGSM noises from the networks with different initialization, however, becomes lower as the network is deeper as shown in figure 6 (b). Since the degree of freedom increases as the network size increases, adversarially trained networks prone to end up with different states, thus, making transfer rate lower. To maximize the benefit of the cascade adversarial training, we propose to use the same initialization for a cascade network and a source network used for iterative adversarial examples generation.
+
+# 5.2 WHITE BOX ATTACK ANALYSIS
+
+We first compare a network trained with Kurakin’s method and that with pivot loss. We train 110- layer ResNet models with/without pivot loss and report accuracy in table 3. We observe our lowlevel similarity learning further improves robustness against iterative attacks compared to Kurakin’s adversarial training. However, the accuracy improvements against iterative attacks (iter FGSM, CW) are limited, showing regularization effect of low-level similarity learning is not sufficient for the iterative attacks on complex color images like CIFAR10. This is different from MNIST test cases where we observed significant accuracy increase for iterative attacks only with pivot loss. We observe label leaking phenomenon reported in (Kurakin et al., 2017) happens even though we don’t train a network with step FGSM images. Additional analysis for this phenomenon is explained in Appendix D.
+
+Next, we train a network from scratch with iter FGSM examples crafted from the defended network, $\mathrm { R } 1 0 _ { P }$ . We use the same initialization used in $\mathrm { R } 1 1 0 _ { P }$ as discussed in 5.1. In particular, iter FGSM images are crafted from $\mathrm { R } 1 0 _ { P }$ with CIFAR10 training images for $\epsilon = 1 , 2 , . . . , 1 6$ , and those are used randomly together with step ll examples from the network being trained. We train cascade networks with/without pivot loss. We also train networks with ensemble adversarial training (Tramer et al., \` 2017) with/without pivot loss for comparison. The implementation details for the trained models can be found in Appendix B.
+
+We find several meaningful observations in table 3. First, ensemble and cascade models show improved accuracy against iterative attack although at the expense of decreased accuracy for onestep attacks compared to the baseline defended network $( \mathrm { R } 1 1 0 _ { K } )$ ). Additional data augmentation from other networks enhances the robustness against iterative attack, weakening label leaking effect caused by one-step adversarial training.
+
+Second, our low-level similarity learning $( \mathrm { R } 1 1 0 _ { P , E }$ , $\operatorname { R 1 1 0 } _ { P , C } )$ ) further enhances robustness against iterative attacks including fully unknown CW attack (especially for $\epsilon { = } 4$ ). Additional knowledge learned from data augmentation through cascade/ensemble adversarial training enables networks to learn partial knowledge of perturbations generated by an iterative method. And the learned iterative perturbations become regularized further with our low-level similarity learning making networks robust against unknown iterative attacks.
+
+Table 4: CIFAR10 test results $( \% )$ for 110-layer ResNet models under black box attacks $\left( \epsilon = 1 6 \right)$ . {Target: same networks in table 3 and $\mathrm { R } 1 1 0 _ { K }$ : Kurakin’s, Source: re-trained baseline, Kurakin’s, cascade and ensemble networks with/without pivot loss. Source networks use the different initialization from the target networks. Additional details of the models can be found in Appendix B.}   
+
+<table><tr><td rowspan="2">Target</td><td colspan="7">Source: iter_FGSM</td></tr><tr><td>R1102</td><td>R110K2</td><td>R110E2</td><td>R110p2</td><td>R110K,C2</td><td>R110p,E2</td><td>R110p,C2</td></tr><tr><td>R110K</td><td>70.5</td><td>73.2</td><td>27.9</td><td>77.0</td><td>67.3</td><td>54.6</td><td>80.8</td></tr><tr><td>R110E</td><td>77.9</td><td>79.5</td><td>55.8</td><td>79.0</td><td>68.2</td><td>54.7</td><td>82.7</td></tr><tr><td>R110p (Ours)</td><td>75.9</td><td>75.6</td><td>39.6</td><td>78.5</td><td>68.3</td><td>61.3</td><td>83.3</td></tr><tr><td>R110k,c (Ours)</td><td>56.4</td><td>80.2</td><td>61.1</td><td>79.5</td><td>67.4</td><td>62.6</td><td>82.1</td></tr><tr><td>R110p,E (Ours)</td><td>78.2</td><td>82.1</td><td>67.7</td><td>81.7</td><td>73.4</td><td>68.4</td><td>83.8</td></tr><tr><td>R110p,C (Ours)</td><td>71.9</td><td>80.4</td><td>63.9</td><td>80.1</td><td>71.1</td><td>64.2</td><td>83.0</td></tr></table>
+
+Third, our low-level similarity learning serves as a good regularizer for adversarial images, but not for the clean images for ensemble/cascade models (reduced accuracy for the clean images for $\mathrm { R 1 1 0 } _ { P , E }$ and $\mathrm { R 1 1 0 } _ { P , C }$ in table 3). Compared to pure adversarial training with one-step adversarial examples, the network sees more various adversarial perturbations during training as a result of ensemble and cascade training. Those perturbations are prone to end up embeddings in the vicinity of decision boundary more often than perturbations caused by one-step adversarial training. Pivot loss pulls the vicinity of those adversarial embeddings toward their corresponding clean embeddings. During this process, clean embeddings from other classes might also be moved toward the decision boundary which results in decreased accuracy for the clean images.
+
+# 5.3 BLACK BOX ATTACK ANALYSIS
+
+We finally perform black box attack analysis for the cascade/ensemble networks with/without pivot loss. We report black box attack accuracy with the source networks trained with the same method, but with different initialization from the target networks. The reason for this is adversarial examples transfer well between networks trained with the same strategy as observed in section 3.1. We re-train 110-layer ResNet models using Kurakin’s, cascade and ensemble adversarial training with/without low-level similarity learning and use those networks as source networks for black-box attacks. Baseline 110-layer ResNet model is also included as a source network. Target networks are the same networks used in table 3. We found iter FGSM attack resulted in lower accuracy than step FGSM attack, thus, report iter FGSM attack only in table 4.
+
+We first observe that iter FGSM attack from ensemble models $( \mathrm { R } 1 1 0 _ { E 2 }$ , $\mathrm { R 1 1 0 } _ { P , E 2 } )$ is strong (results in lower accuracy) compared to that from any other trained networks. 2 Since ensemble models learn various perturbation during training, adversarial noises crafted from those networks might be more general for other networks making them transfer easily between defended networks.
+
+Second, cascade adversarial training breaks chicken and egg problem. (In section 3.1, we found that it is efficient to use a defended network as a source network to attack another defended network.) Even though the transferability between defended networks is reduced for deeper networks, cascade network $( \mathrm { R } 1 1 0 _ { K , C } )$ shows worst case performance against the attack not from a defended network, but from a purely trained network $\mathbf { ( R 1 1 0 _ { 2 } ) }$ . Possible solution to further improve the worst case robustness would be to use more than one network as source networks (including pure/defended networks) for iter FGSM images generation for cascade adversarial training.
+
+Third, ensemble/cascade networks together with our low-level similarity learning $( \mathrm { R } 1 1 0 _ { P , E }$ , $\mathrm { R 1 1 0 } _ { P , C } )$ show better worst case accuracy under black box attack scenario. This shows that enhancing robustness against iterative white box attack also improves robustness against iterative black box attack.
+
+# 6 CONCLUSION
+
+We performed through transfer analysis and showed iter FGSM images transfer easily between networks trained with the same strategy. We exploited this and proposed cascade adversarial training, a method to train a network with iter FGSM adversarial images crafted from already defended networks. We also proposed adversarial training regularized with a unified embedding for classification and low- level similarity learning by penalizing distance between the clean and their corresponding adversarial embeddings. Combining those two techniques (low level similarity learning $^ +$ cascade adversarial training) with deeper networks further improved robustness against iterative attacks for both white-box and black-box attacks.
+
+However, there is still a gap between accuracy for the clean images and that for the adversarial images. Improving robustness against both one-step and iterative attacks still remains challenging since it is shown to be difficult to train networks robust for both one-step and iterative attacks simultaneously. Future research is necessary to further improve the robustness against iterative attack without sacrificing the accuracy for step attacks or clean images under both white-box attack and black-box attack scenarios.
+
+# ACKNOWLEDGMENTS
+
+We thank Alexey Kurakin of Google Brain and Li Chen of Intel for comments that greatly improved the manuscript. The research reported here was supported in part by the Defense Advanced Research Projects Agency (DARPA) under contract number HR0011-17-2-0045. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of DARPA.
+
+# REFERENCES
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, 2017.
+
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In Proceedings of the International Conference on Learning Representations (ICLR), 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV, USA, June 27-30, 2016, pp. 770–778, 2016. doi: 10.1109/CVPR.2016.90. URL http://dx.doi.org/10.1109/CVPR.2016.90.
+
+Ruitong Huang, Bing Xu, Dale Schuurmans, and Csaba Szepesvari. Learning with a strong adver-´ sary. CoRR, abs/1511.03034, 2015. URL http://arxiv.org/abs/1511.03034.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Alexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial machine learning at scale. In Proceedings of the International Conference on Learning Representations (ICLR), 2017.
+
+Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/.
+
+O. M. Parkhi, A. Vedaldi, and A. Zisserman. Deep face recognition. In Proceedings of the British Machine Vision Conference (BMVC), 2015.
+
+Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensem- \` ble adversarial training: Attacks and defenses. CoRR, abs/1705.07204, 2017. URL http: //arxiv.org/abs/1705.07204.
+
+Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In Computer Vision - ECCV 2016 - 14th European Conference, Amsterdam, The Netherlands, October 11-14, 2016, Proceedings, Part VII, pp. 499– 515, 2016. doi: 10.1007/978-3-319-46478-7 31. URL http://dx.doi.org/10.1007/ 978-3-319-46478-7_31.
+
+# A EXPERIMENTAL SETUP
+
+We scale down the image values to [0,1] and don’t perform any data augmentation for MNIST. For CIFAR10, we scale down the image values to [0,1] and subtract per-pixel mean values. We perform $2 4 \times 2 4$ random crop and random flip on $3 2 \mathrm { x } 3 2 $ original images. We generate adversarial images with “step ll” after these steps otherwise noted.
+
+We use stochastic gradient descent (SGD) optimizer with momentum of 0.9, weight decay of 0.0001 and mini batch size of 128. For adversarial training, we generate $k = 6 4$ adversarial examples among 128 images in one mini-batch. We start with a learning rate of 0.1, divide it by 10 at $4 \mathrm { k }$ and 6k iterations, and terminate training at 8k iterations for MNIST, and $4 8 \mathrm { k }$ and $7 2 \mathrm { k }$ iterations, and terminate training at 94k iterations for CIFAR10. 3
+
+We also found that initialization affects the training results slightly as in (Kurakin et al., 2017), thus, we pre-train the networks 2 and 10 epochs for MNIST and CIFAR10, and use these as initial starting points for different configurations. We use $m a x \_ e = 0 . 3 ^ { * } 2 5 5$ and 16 for MNIST and CIFAR10 respectively.
+
+# B MODEL DESCRIPTIONS
+
+We summarize the model names used in this paper in table 5. For ensemble adversarial training, pre-trained networks as in table 7 together with the network being trained are used to generate onestep adversarial examples during training. For cascade adversarial training, pre-trained defended networks as in table 6 are used to generate iter FGSM images, and the network being trained is used to generate one-step adversarial examples during training.
+
+Table 5: Model descriptions   
+Table 6: Ensemble model description   
+
+<table><tr><td colspan="5">Initialization</td></tr><tr><td>Dataset</td><td>ResNet</td><td>Group</td><td>Training</td><td>Model</td></tr><tr><td rowspan="2">MNIST</td><td rowspan="2">20-layer</td><td rowspan="2">A</td><td>standard training Kurakin&#x27;s</td><td>R20M R20MK</td></tr><tr><td>Bidirection loss</td><td>R20MB</td></tr><tr><td rowspan="10"></td><td rowspan="10">20-layer</td><td rowspan="4"></td><td>Pivot loss</td><td>R20Mp</td></tr><tr><td> standard training</td><td>R20</td></tr><tr><td>Kurakin&#x27;s</td><td>R20K</td></tr><tr><td>Ensemble training</td><td>R20E</td></tr><tr><td rowspan="6">B</td><td>Bidirection loss Pivot loss</td><td>R20B R20p</td></tr><tr><td>Kurakin&#x27;s &amp; Cascade training</td><td>R20K,C</td></tr><tr><td></td><td></td></tr><tr><td>Pivot loss &amp; Ensemble training</td><td>R20p,E</td></tr><tr><td>Pivot loss &amp; Cascade training</td><td>R20p,C</td></tr><tr><td> standard training</td><td>R202</td></tr><tr><td rowspan="7">CIFAR10 56-layer</td><td rowspan="7"></td><td>C</td><td>Kurakin&#x27;s</td><td>R20K2</td></tr><tr><td>D</td><td>Pivot loss standard training</td><td>R20p2 R203</td></tr><tr><td>E</td><td> standard training</td><td>R204</td></tr><tr><td>F</td><td>Kurakin&#x27;s</td><td>R56K R56p</td></tr><tr><td></td><td>Pivot loss</td><td></td></tr><tr><td>G</td><td>Kurakin&#x27;s</td><td>R56K2</td></tr><tr><td></td><td></td><td></td></tr><tr><td rowspan="7">110-layer</td><td rowspan="7"></td><td rowspan="7">H</td><td> standard training</td><td>R110</td></tr><tr><td>Kurakin&#x27;s</td><td>R110K</td></tr><tr><td>Pivot loss Ensemble training</td><td>R110p R110E</td></tr><tr><td>Kurakin&#x27;s &amp; Cascade training</td><td></td></tr><tr><td></td><td>R110K,C</td></tr><tr><td>Pivot loss &amp; Ensemble training</td><td>R110p,E</td></tr><tr><td>Pivot loss &amp; Cascade training</td><td>R110p,C</td></tr><tr><td rowspan="5"></td><td rowspan="5">I</td><td>standard training Kurakin&#x27;s</td><td>R1102</td></tr><tr><td></td><td>R110k2</td></tr><tr><td>Ensemble training</td><td>R110E2</td></tr><tr><td>Pivot loss</td><td>R110p2</td></tr><tr><td>Kurakin&#x27;s &amp; Cascade training Pivot loss &amp; Ensemble training</td><td>R110k,C2 R110p,E2</td></tr><tr><td rowspan="5"></td><td>J</td><td>Pivot loss &amp; Cascade training</td><td>R110p,C2</td></tr><tr><td></td><td>standard training</td><td>R1103</td></tr><tr><td>K</td><td>standard training</td><td>R1104</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>
+
+Table 7: Cascade model description   
+
+<table><tr><td>Ensemble models</td><td>Pre-trained models</td></tr><tr><td>R20E,R20p,E,R110E,R110P,E R110E2,R110P,E2</td><td>R203,R110g R204,R1104</td></tr></table>
+
+<table><tr><td>Cascade models</td><td>Pre-trained model</td></tr><tr><td>R20K,c,R20p,C</td><td>R20p</td></tr><tr><td>R110K,c,R110p,C</td><td>R110p</td></tr><tr><td>R110K,c2,R110P,C2</td><td>R110p2</td></tr></table>
+
+![](images/a63d4cd60c68a6ff53d587a7bfc58f89eb11f682c0bbc103d1fd3a001a954254.jpg)  
+Figure 7: Argument to the softmax vs. $\epsilon$ in test time. “step ll”, “step FGSM” and ”random sign” methods were used to generate test-time adversarial images. Arguments to the softmax were measured by changing $\epsilon$ for each test method and averaged over randomly chosen 128 images from CIFAR10 test-set. Blue line represents true class and the red line represents mean of the false classes. Shaded region shows $\pm \nobreakspace 1 \nobreakspace$ standard deviation of each line.
+
+We draw average value of the argument to the softmax layer for the true class and the false classes to visualize how the adversarial training works as in figure 7. Standard training, as expected, shows dramatic drop in the values for the true class as we increase $\epsilon$ in “step ll” or “step FGSM direction. With adversarial training, we observe that the value drop is limited at small $\epsilon$ and our method even increases the value in certain range upto ${ \epsilon } { = } 1 0$ . Note that adversarial training is not the same as the gradient masking.As illustrated in figure 7, it exposes gradient information, however, quickly distort gradients along the sign of the gradient (“step ll” or “step FGSM) direction. We also observe improved results (broader margins than baseline) for “random sign” added images even though we didn’t inject random sign added images during training. Overall shape of the argument to the softmax layer in our case becomes smoother than Kurakin’s method, suggesting our method is good for pixel level regularization. Even though actual value of the embeddings for the true class in our case is smaller than that in Kurakin’s, the standard deviation of our case is less than Kurakin’s, making better margin between the true class and false classes.
+
+![](images/bb0f617516f1c753274ff6e6c797bcd0df9ac1a88e8bee55ff5efc872dab5a74.jpg)  
+Figure 8: Averaged Pearson’s correlation coefficient between the gradients w.r.t. two images. Correlation were measured by changing $\epsilon$ for each adversarial image and averaged over randomly chosen 128 images from CIFAR10 test-set. Shaded region represents $\pm \ : 0 . 5$ standard deviation of each line.
+
+We observe accuracies for the “step FGSM” adversarial images become higher than those for the clean images (“label leaking” phenomenon) by training with “step FGSM” examples as in (Kurakin et al., 2017). Interestingly, we also observe “label leaking” phenomenon even without providing true labels for adversarial images generation. We argue that “label leaking” is a natural result of the adversarial training.
+
+To understand the nature of adversarial training, we measure correlation between gradients w.r.t. different images (i.e. clean vs. adversarial) as a measure of error surface similarity. We measure correlation between gradients w.r.t. (1) clean vs. “step ll” image, (2) clean vs. “step FGSM” image, (3) clean vs. “random sign” added image, and (4) “step ll” image vs. “step FGSM” image for three trained networks (a) R20, (b) $\mathsf { R } 2 0 _ { K }$ and (c) ${ \mathrm { R } } 2 0 _ { P }$ (Ours) in table 5. Figure 8 draws average value of correlations for each case.
+
+Meaning of the correlation: In order to make strong adversarial images with “step FGSM” method, correlation between the gradient w.r.t. the clean image and the gradient w.r.t. its corresponding adversarial image should remain high since the “step FGSM” method only use the gradient w.r.t. the clean image $( \epsilon { = } 0 )$ . Lower correlation means perturbing the adversarial image at $\epsilon$ further to the gradient (seen from the clean image) direction is no longer efficient.
+
+Results of adversarial training: We observe that (1) and (2) become quickly lower than (3) as $\epsilon$ increases. This means that, when we move toward the steepest (gradient) direction on the error surface, gradient is more quickly uncorrelated with the gradient w.r.t. the clean image than when we move to random direction. As a result of adversarial training, this uncorrelation is observed at a lower $\epsilon$ making one-step attack less efficient even with small perturbation. (1), (2) and (3) for our case are slightly lower than Kurakin’s method at the same $\epsilon$ which means that our method is better at defending one-step attacks than Kurakin’s.
+
+Error surface similarity between “step ll” and “step FGSM” images: We also observe (4) remains high with higher $\epsilon$ for all trained networks. This means that the error surface (gradient) of the “step ll” image and that of its corresponding ���step FGSM” image resemble each other. That is the reason why we get the robustness against “step FGSM” method only by training with “step ll” method and vice versa. (4) for our case is slightly higher than Kurakin’s method at the same $\epsilon$ and that means our similarity learning tends to make error surfaces of the adversarial images with “step ll” and “step FGSM” method to be more similar.
+
+Analysis of label leaking phenomenon: Interestingly, (2) becomes slightly negative in certain range $1 < \epsilon < 3$ for Kurakin’s, and $1 < \epsilon < 4$ for Pivot (Ours) ) and this could be the possible reason for “label leaking” phenomenon. For example, let’s assume that we have a perturbed image (by “step FGSM” method) at $\epsilon$ where the correlation between the gradients w.r.t. that image and the corresponding clean image is negative. Further increase of $\epsilon$ with the gradient (w.r.t. the clean image) direction actually decreases the loss resulting in increased accuracy (label leaking phenomenon). Due to the error surface similarity between “step ll” and “step FGSM” images and this negative correlation effect, however, label leaking phenomenon can always happen for the networks trained with one-step adversarial examples.
+
+# E ADDITIONAL BLACK BOX ATTACK RESULTS
+
+Table 8: CIFAR10 test results $( \% )$ under black box attacks between the network with the same initialization $\scriptstyle \left( \epsilon = 1 6 \right) \}$   
+
+<table><tr><td rowspan="2">Target</td><td colspan="3">Source: step_FGSM</td><td colspan="3">Source: iter_FGSM</td></tr><tr><td>R20</td><td>R20K</td><td>R20p</td><td>R20</td><td>R20K</td><td>R20p</td></tr><tr><td>R20</td><td>12.2</td><td>27.4</td><td>27.5</td><td>0.0</td><td>45.9</td><td>44.7</td></tr><tr><td>R20K</td><td>65.7</td><td>81.5</td><td>81.8</td><td>51.5</td><td>0.0</td><td>18.2</td></tr><tr><td>R20p</td><td>58.1</td><td>89.3</td><td>91.7</td><td>48.9</td><td>13.4</td><td>0.0</td></tr></table>
+
+Table 8 shows that black box attack between trained networks with the same initialization tends to be more successful than that between networks with different initialization as explained in (Kurakin et al., 2017).
+
+Table 9: CIFAR10 test results $( \% )$ under black box attacks for ${ \epsilon } { = } 1 6$ . {Target and Source networks are switched from the table 1}   
+
+<table><tr><td rowspan="2">Target</td><td colspan="3">Source: step-FGSM</td><td colspan="3">Source: iter_FGSM</td></tr><tr><td>R20</td><td>R20K</td><td>R20p</td><td>R20</td><td>R20K</td><td>R20p</td></tr><tr><td>R202</td><td>17.9</td><td>33.9</td><td>34.5</td><td>4.1</td><td>54.8</td><td>54.3</td></tr><tr><td>R20K2</td><td>65.0</td><td>84.6</td><td>84.5</td><td>61.2</td><td>25.3</td><td>30.4</td></tr><tr><td>R20p2</td><td>66.4</td><td>88.2</td><td>87.2</td><td>61.6</td><td>27.7</td><td>36.1</td></tr></table>
+
+In table 9, our method $( \mathsf { R } 2 0 _ { P 2 } )$ is always better at one-step and iterative black box attack from defended networks $( \mathsf { R } 2 0 _ { K } , \mathsf { R } 2 0 _ { P } )$ and undefended network (R20) than Kurakin’s method $( { \bf R } 2 0 _ { B { \bf 2 } } )$ . However, it is hard to tell which method is better than the other one as explained in the main paper.
+
+Table 10: CIFAR10 test results $( \% )$ for cascade networks under black box attacks for ${ \epsilon } { = } 1 6$ . {Target and Source: Please see the model descriptions in Appendix B.}   
+
+<table><tr><td rowspan="2">Target</td><td colspan="7">Source: iter_FGSM</td></tr><tr><td>R110</td><td>R110K</td><td>R110E</td><td>R110p</td><td>R110K,C</td><td>R110p,E</td><td>R110p,C</td></tr><tr><td>R110K2</td><td>80.5</td><td>72.7</td><td>49.3</td><td>68.0</td><td>49.6</td><td>41.0</td><td>67.9</td></tr><tr><td>R110E2</td><td>82.7</td><td>59.1</td><td>39.5</td><td>59.6</td><td>51.5</td><td>40.3</td><td>69.6</td></tr><tr><td>R110p2 (Ours)</td><td>80.3</td><td>75.9</td><td>54.2</td><td>72.2</td><td>54.9</td><td>44.3</td><td>72.4</td></tr><tr><td>R110k,C2 (Ours)</td><td>62.1</td><td>74.7</td><td>61.5</td><td>72.3</td><td>46.5</td><td>39.0</td><td>67.9</td></tr><tr><td>R110p,E2 (Ours)</td><td>81.5</td><td>79.0</td><td>50.0</td><td>77.3</td><td>56.9</td><td>45.5</td><td>75.2</td></tr><tr><td>R110p,c2 (Ours)</td><td>72.2</td><td>76.4</td><td>60.6</td><td>73.8</td><td>51.0</td><td>40.9</td><td>72.0</td></tr></table>
+
+In table 10, we show black box attack accuracies with the source and the target networks switched from the table 4. We also observe that networks trained with both low-level similarity learning and cascade/ensemble adversarial training $( \mathrm { R } 1 1 0 _ { P , C 2 }$ , $\mathbf { R } 1 1 0 _ { P , E 2 } )$ show better worst-case performance than other networks. Overall, iter FGSM images crafted from ensemble model families $( \mathrm { R } 1 1 0 _ { E }$ , $\operatorname { R 1 1 0 } _ { P , E } )$ remain strong on the defended networks.
+
+![](images/ab53c2fe8209182e38731b9aaaef260818586606f8ae3b9ef8464c393141354e.jpg)  
+Figure 9: Cumulative distribution function vs. $\epsilon$ for 100 test adversarial examples generated by CW $L _ { \infty }$ attack. Lower CDF value for a fixed $\epsilon$ means the better defense.
+
+Carlini and Wagner (CW) $L _ { \infty }$ attack solves the following optimization problem for every input $\boldsymbol { X }$
+
+$$
+m i n i m i z e \quad c \cdot f ( X + \pmb { \delta } ) + \sum _ { i } [ ( | \delta _ { i } | - \tau ) ^ { + } ]
+$$
+
+where, the function $f$ is defined such that attack is success if and only if $f ( X + \delta ) < 0 , \mathfrak { c }$ δ is the target perturbation defined as $X ^ { a d v } - X$ , $c$ is the parameter to control the relative weight of function $f$ in the total cost function, and $\tau$ is the control threshold used to penalize any terms that exceed $\tau$ .
+
+Since CW $L _ { \infty }$ attack is computationally expensive, we only use 100 test examples (10 examples per each class). We search adversarial example $X ^ { a d v }$ with $c \in \{ 0 . 1 , 0 . 2 , 0 . 5 , 1 , 2 , 5 , 1 0 , 2 0 \}$ and $\tau \in \ \{ 0 . 0 2 , 0 . 0 4 , . . . , 0 . 6 \}$ for MNIST and $c ~ \in ~ \{ 0 . 1 , 0 . 3 , 1 , 3 , 1 0 , 3 0 , 1 0 0 \}$ and $\tau \_ { \in }$ $\{ 0 . 0 0 1 , 0 . 0 0 \dot { 2 } , . . . , 0 . 0 1 , 0 . 0 1 2 , . . . , 0 . 0 2 , 0 . 0 2 4 , . . . , 0 . 0 4 , 0 . 0 4 8 , . . . , 0 . 0 8 \}$ for CIFAR10. We use Adam optimizer with an initial learning rate of $0 . 0 1 / c$ since we found constant initial learning rate for $c \cdot f ( \pmb { X } + \pmb { \delta } )$ term is critical for successful adversarial images generation. We terminate the search after 2,000 iterations for each $\boldsymbol { X }$ , $c$ and $\tau$ . If $f ( X + \delta ) < 0$ and the resulting $| | \delta | | _ { \infty }$ is lower than the current best distance, we update $X ^ { a d v }$ .
+
+Figure 9 shows cumulative distribution function of $\epsilon$ for 100 successful adversarial examples per each network. We report the number of adversarial examples with $\epsilon > 0 . 3 ^ { * } 2 5 5$ for MNIST and that with $\epsilon > 2$ or 4 for CIFAR10. As seen from this figure, our approaches provide robust defense against CW $L _ { \infty }$ attack compared to other approaches.

parse/train/HyRVBzap-/HyRVBzap-_content_list.json

@@ -0,0 +1,1591 @@
+[
+    {
+        "type": "text",
+        "text": "CASCADE ADVERSARIAL MACHINE LEARNING REGULARIZED WITH A UNIFIED EMBEDDING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Taesik Na, Jong Hwan Ko & Saibal Mukhopadhyay ",
+        "bbox": [
+            184,
+            170,
+            545,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "School of Electrical and Computer Engineering   \nGeorgia Institute of Technology   \nAtlanta, GA 30332, USA   \n{taesik.na, jonghwan.ko, smukhopadhyay6}@gatech.edu ",
+        "bbox": [
+            184,
+            186,
+            681,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Injecting adversarial examples during training, known as adversarial training, can improve robustness against one-step attacks, but not for unknown iterative attacks. To address this challenge, we first show iteratively generated adversarial images easily transfer between networks trained with the same strategy. Inspired by this observation, we propose cascade adversarial training, which transfers the knowledge of the end results of adversarial training. We train a network from scratch by injecting iteratively generated adversarial images crafted from already defended networks in addition to one-step adversarial images from the network being trained. We also propose to utilize embedding space for both classification and low-level (pixel-level) similarity learning to ignore unknown pixel level perturbation. During training, we inject adversarial images without replacing their corresponding clean images and penalize the distance between the two embeddings (clean and adversarial). Experimental results show that cascade adversarial training together with our proposed low-level similarity learning efficiently enhances the robustness against iterative attacks, but at the expense of decreased robustness against one-step attacks. We show that combining those two techniques can also improve robustness under the worst case black box attack scenario. ",
+        "bbox": [
+            233,
+            309,
+            764,
+            544
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            571,
+            336,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Injecting adversarial examples during training (adversarial training), (Goodfellow et al., 2015; Kurakin et al., 2017; Huang et al., 2015) increases the robustness of a network against adversarial attacks. The networks trained with one-step methods have shown noticeable robustness against onestep attacks, but, limited robustness against iterative attacks at test time. To address this challenge, we have made the following contributions: ",
+        "bbox": [
+            174,
+            603,
+            823,
+            672
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Cascade adversarial training: We first show that iteratively generated adversarial images transfer well between networks when the source and the target networks are trained with the same training method. Inspired by this observation, we propose cascade adversarial training which transfers the knowledge of the end results of adversarial training. In particular, we train a network by injecting iter FGSM images (section 2.1) crafted from an already defended network (a network trained with adversarial training) in addition to the one-step adversarial images crafted from the network being trained. The concept of using already trained networks for adversarial training is also introduced in (Tramer et al., 2017). In their work, purely trained networks are used as another source networks \\` to generate one-step adversarial examples for training. On the contrary, our cascade adversarial training uses already defended network for iter FGSM images generation. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Low level similarity learning: We advance the previous data augmentation approach (Kurakin et al., 2017) by adding additional regularization in deep features to encourage a network to be insensitive to adversarial perturbation. In particular, we inject adversarial images in the mini batch without replacing their corresponding clean images and penalize distance between embeddings from the clean and the adversarial examples. There are past examples of using embedding space for learning similarity of high level features like face similarity between two different images (Schroff et al., 2015; Parkhi et al., 2015; Wen et al., 2016). Instead, we use the embedding space for learning similarity of the pixel level differences between two similar images. The intuition of using this regularization is that small difference on input should not drastically change the high level feature representation. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            821,
+            145
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Analysis of adversarial training: We train ResNet models (He et al., 2016) on MNIST (LeCun & Cortes, 2010) and CIFAR10 dataset (Krizhevsky, 2009) using the proposed adversarial training. We first show low level similarity learning improves robustness of the network against adversarial images generated by one-step and iterative methods compared to the prior work. We show that modifying the weight of the distance measure in the loss function can help control trade-off between accuracies for the clean and adversarial examples. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Together with cascade adversarial training and low-level similarity learning, we achieve accuracy increase against unknown iterative attacks, but at the expense of decreased accuracy for one-step attacks. We also show our cascade adversarial training and low level similarity learning provide much better robustness against black box attack. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            299
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ON ADVERSARIAL ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            320,
+            566,
+            335
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 ATTACK METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            351,
+            348,
+            364
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One-step fast gradient sign method (FGSM), referred to as “step FGSM”, generates adversarial image $\\bar { X } ^ { a d v }$ by adding sign of the gradients w.r.t. the clean image $\\boldsymbol { X }$ multiplied by $\\epsilon \\in [ 0 , 2 5 5 ]$ as shown below (Goodfellow et al., 2015): ",
+        "bbox": [
+            173,
+            376,
+            826,
+            419
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1255c66c34121c9e4885dd473449c158936c386b948fa1100acba8edc69c7df4.jpg",
+        "text": "$$\nX ^ { a d v } = X + \\epsilon \\mathrm { s i g n } ( \\nabla _ { X } J ( X , y _ { t r u e } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            424,
+            629,
+            443
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One-step target class method generates $X ^ { a d v }$ by subtracting sign of the gradients computed on a target false label as follows: ",
+        "bbox": [
+            169,
+            455,
+            825,
+            483
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c3704a86ae00977475deb3f9b3530a6ae7b3b615e0f4866c59366e0ca11c381.jpg",
+        "text": "$$\nX ^ { a d v } = X - \\epsilon \\mathrm { s i g n } ( \\nabla _ { X } J ( X , y _ { t a r g e t } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            489,
+            633,
+            508
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We use least likely class $y _ { L L }$ as a target class and refer this method as “step ll”. ",
+        "bbox": [
+            174,
+            522,
+            694,
+            537
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Basic iterative method, referred to as “iter FGSM”, applies FGSM with small $\\alpha$ multiple times. ",
+        "bbox": [
+            169,
+            542,
+            807,
+            559
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b3e1127ee0213428c760a8433ad9167027e7c56ff6f39bbd5924f62d731f5ab.jpg",
+        "text": "$$\nX _ { 0 } ^ { a d v } = X , \\quad X _ { N } ^ { a d v } = C l i p _ { X , \\epsilon } \\{ X _ { N - 1 } ^ { a d v } + \\alpha \\ \\mathrm { s i g n } ( \\nabla _ { X _ { N - 1 } ^ { a d v } } J ( X _ { N - 1 } ^ { a d v } , y _ { t r u e } ) ) \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            564,
+            756,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We use $\\alpha = 1$ , number of iterations $N$ to be $\\operatorname* { m i n } ( \\epsilon + 4 , 1 . 2 5 \\epsilon ) . ~ C l i p _ { X , \\epsilon }$ is elementwise clipping function where the input is clipped to the range $[ \\mathrm { m a x } ( 0 , X - \\epsilon ) , \\mathrm { m i n } ( 2 5 5 , X + \\epsilon ) ]$ . ",
+        "bbox": [
+            173,
+            599,
+            823,
+            630
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Iterative least-likely class method, referred to as “iter ll”, is to apply “step ll” with small $\\alpha$ multiple times. ",
+        "bbox": [
+            173,
+            636,
+            823,
+            665
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6eb0a38899718bb27efd5684809622afb0fef795ffc29528a6180b900f0e4d25.jpg",
+        "text": "$$\nX _ { 0 } ^ { a d v } = X , \\quad X _ { N } ^ { a d v } = C l i p _ { X , \\epsilon } \\{ X _ { N - 1 } ^ { a d v } - \\alpha \\ \\mathrm { s i g n } ( \\nabla _ { X _ { N - 1 } ^ { a d v } } J ( X _ { N - 1 } ^ { a d v } , y _ { L L } ) ) \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            670,
+            753,
+            693
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Carlini and Wagner attack (Carlini & Wagner, 2017) referred to as $\\mathbf { \\tilde { \\Sigma } } ^ { 6 6 } \\mathbf { C } \\mathbf { W } ^ { \\prime } $ solves an optimization problem which minimizes both an objective function $f$ (such that attack is success if and only if $\\stackrel { \\bullet } { f } ( X ^ { a d v } ) < 0 )$ and a distance measure between $X ^ { a d v }$ and $\\boldsymbol { X }$ . ",
+        "bbox": [
+            174,
+            705,
+            825,
+            748
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Black box attack is performed by testing accuracy on a target network with the adversarial images crafted from a source network different from the target network. Lower accuracy means successful black-box attack. When we use the same network for both target and source network, we call this as white-box attack. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 DEFENSE METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            356,
+            843
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training (Kurakin et al., 2017): is a form of data augmentation where it injects adversarial examples during training. In this method, $k$ examples are taken from the mini batch $B$ (size of $m$ ) and the adversarial examples are generated with one of step method. The $k$ adversarial examples replaces the corresponding clean examples when making mini batch. Below we refer this adversarial training method as “Kurakin’s”. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/aea920e27ab8fdce7f5e623a12d60e754f7868ac8c75a3056a62de968ed1bb8d.jpg",
+        "table_caption": [
+            "Table 1: CIFAR10 test results $( \\% )$ under black box attacks for ${ \\epsilon } { = } 1 6$ . Source networks share the same initialization which is different from the target networks. {Target: R20, $\\mathsf { R } 2 0 _ { K }$ : standard, Kurakin’s, Source: $\\mathbf { R } 2 0 \\mathbf { _ 2 }$ , $\\mathbf { R } 2 0 _ { K 2 }$ : standard, Kurakin’s.} "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Target</td><td colspan=\"2\">Source: step-FGSM</td><td colspan=\"2\">Source: iter_FGSM</td></tr><tr><td>R202</td><td>R20K2</td><td>R202</td><td>R20K2</td></tr><tr><td>R20</td><td>16.2</td><td>31.6</td><td>2.7</td><td>60.1</td></tr><tr><td>R20K</td><td>66.7</td><td>82.7</td><td>55.8</td><td>28.5</td></tr></table>",
+        "bbox": [
+            173,
+            204,
+            532,
+            276
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/9574ecbaff76aa59c142821a74b75ca57db11c28bc841935cae1c0896257b6aa.jpg",
+        "image_caption": [
+            "Figure 1: Correlation between adversarial noises from different networks for each $\\epsilon$ . Shaded region shows $\\pm 0 . 1$ standard deviation of each line. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            552,
+            103,
+            820,
+            204
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Ensemble adversarial training (Tramer et al., 2017): \\` is essentially the same with the adversarial training, but uses several pre-trained vanilla networks to generate one-step adversarial examples for training. Below we refer this adversarial training method as “Ensemble”. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            343
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROPOSED APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            363,
+            393,
+            378
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 TRANSFERABILITY ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            395,
+            423,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first show transferability between purely trained networks and adversarially trained networks under black box attack. We use ResNet (He et al., 2016) models for CIFAR10 classification. We first train 20-layer ResNets with different methods (standard training, adversarial training (Kurakin et al., 2017)) and use those as target networks. We re-train networks (standard training and adversarial training) with the different initialization from the target networks, and use the trained networks as source networks. Experimental details and model descriptions can be found in Appendix A and B. In table 1, we report test accuracies under black box attack. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            517
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transferability (step attack): We first observe that high robustness against one-step attack between defended networks $( \\mathsf { R } 2 0 _ { K 2 } \\ldots \\mathsf { R } 2 0 _ { K } )$ ), and low robustness between undefended networks $( \\mathsf { R 2 0 _ { 2 } }$ - $> { \\textrm R } 2 0 \\AA ,$ ). This observation shows that error surfaces of neural networks are driven by the training method and networks trained with the same method end up similar optimum states. ",
+        "bbox": [
+            174,
+            525,
+            823,
+            580
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is noteworthy to observe that the accuracies against step attack from the undefended network $( \\mathsf { R } 2 0 _ { 2 } )$ are always lower than those from defended network $( \\mathsf { R } 2 0 _ { K { \\bf 2 } } )$ . Possible explanation for this would be that adversarial training tweaks gradient seen from the clean image to point toward weaker adversarial point along that gradient direction. As a result, one-step adversarial images from defended networks become weaker than those from undefended network. ",
+        "bbox": [
+            174,
+            588,
+            823,
+            657
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transferability (iterative attack): We observe “iter FGSM” attack remains very strong even under the black box attack scenario but only between undefended networks or defended networks. This is because iter FGSM noises $( X ^ { a d v } – X )$ from defended networks resemble each other. As shown in figure 1, we observe higher correlation between iter FGSM noises from a defended network $( \\mathsf { R } 2 0 \\kappa )$ and those from another defended network $( \\mathsf { R } 2 0 _ { K   { \\bf 2 } } )$ ). ",
+        "bbox": [
+            174,
+            665,
+            825,
+            734
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Difficulty of defense/attack under the black box attack scenario: As seen from this observation, it is efficient to attack an undefended/defended network with iter FGSM examples crafted from another undefended/defended network. Thus, when we want to build a robust network under the black box attack scenario, it is desired to check accuracies for the adversarial examples crafted from other networks trained with the same strategy. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            811
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 CASCADE ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            465,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the observation that iter FGSM images transfer well between defended networks, we propose cascade adversarial training, which trains a network by injecting iter FGSM images crafted from an already defended network. We hypothesize that the network being trained with cascade adversarial training will learn to avoid such adversarial perturbation, enhancing robustness against iter FGSM attack. The intuition behind this proposed method is that we transfer the knowledge of the end results of adversarial training. In particular, we train a network by injecting iter FGSM images crafted from already defended network in addition to the one-step adversarial images crafted from the network being trained. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e15aca655600181f36bed5f1e7e2e1f2bf9f8ad5a8ba6aba416917d887a4350.jpg",
+        "image_caption": [
+            "Figure 2: Cascade adversarial training regularized with a unified embedding. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            98,
+            785,
+            237
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/94897954e10187615eda8e565cf77b8ca80a2765e4e1577dda4e06d5b6bda6a3.jpg",
+        "image_caption": [
+            "Figure 3: (Left) Bidirectional loss. (Right) Pivot loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            294,
+            273,
+            709,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            397,
+            825,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 REGULARIZATION WITH A UNIFIED EMBEDDING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            457,
+            552,
+            472
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We advance the algorithm proposed in (Kurakin et al., 2017) by adding low level similarity learning. Unlike (Kurakin et al., 2017), we include the clean examples used for generating adversarial images in the mini batch. Once one step forward pass is performed with the mini batch, embeddings are followed by the softmax layer for the cross entropy loss for the standard classification. At the same time, we take clean embeddings and adversarial embeddings, and minimize the distance between the two with the distance based loss. ",
+        "bbox": [
+            174,
+            482,
+            825,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The distance based loss encourages two similar images (clean and adversarial) to produce the same outputs, not necessarily the true labels. Thus, low-level similarity learning can be considered as an unsupervised learning. By adding regularization in higher embedding layer, convolution filters gradually learn how to ignore such pixel-level perturbation. We have applied regularization on lower layers with an assumption that low level pixel perturbation can be ignored in lower hierarchy of networks. However, adding regularization term on higher embedding layer right before the softmax layer showed best performance. The more convolutional filters have chance to learn such similarity, the better the performance. Note that cross entropy doesn’t encourage two similar images to produce the same output labels. Standard image classification using cross entropy compares ground truth labels with outputs of a network regardless of how similar training images are. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            713
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The entire training process combining cascade adversarial training and low level similarity learning is shown in figure 2. We define the total loss as follows: ",
+        "bbox": [
+            173,
+            718,
+            823,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/05961acf28424a1591ec2f03701fa08a08759e475106beffa1aa7bca3f6ec615.jpg",
+        "text": "$$\nL o s s = \\frac { 1 } { ( m - k ) + \\lambda k } \\Bigg ( \\sum _ { i = 1 } ^ { m - k } L ( { \\bf X } _ { i } | y _ { i } ) + \\lambda \\sum _ { i = 1 } ^ { k } L ( { \\bf X } _ { i } ^ { a d v } | y _ { i } ) \\Bigg ) + \\lambda _ { 2 } \\sum _ { i = 1 } ^ { k } L _ { d i s t } ( E _ { i } ^ { a d v } , E _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            752,
+            795,
+            796
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { \\mathcal { E } } _ { i }$ and $E _ { i } ^ { a d v }$ are the resulting embeddings from $X _ { i }$ and $X _ { i } ^ { a d v }$ , respectively. $m$ is the size of the mini batch, $k \\left( \\leq m / 2 \\right)$ is the number of adversarial images in the mini batch. $\\lambda$ is the parameter to control the relative weight of classification loss for adversarial images. $\\lambda _ { 2 }$ is the parameter to control the relative weight of the distance based loss $L _ { d i s t }$ in the total loss. ",
+        "bbox": [
+            174,
+            809,
+            823,
+            866
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Bidirectional loss minimizes the distance between the two embeddings by moving both clean and adversarial embeddings as shown in the left side of the figure 3. ",
+        "bbox": [
+            173,
+            872,
+            821,
+            901
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4d7acae9b01aadbad4425654117f9ae7745fe9216f3c571a1defe3e5244383e.jpg",
+        "text": "$$\nL _ { d i s t } ( \\pmb { { E } } _ { i } ^ { a d v } , \\pmb { { E } } _ { i } ) = | | \\pmb { { E } } _ { i } ^ { a d v } - \\pmb { { E } } _ { i } | | _ { N } ^ { N } , \\quad N \\in { 1 , 2 \\quad i = 1 , 2 , . . . , k }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            906,
+            712,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/c673904c52bc36a2ac20b6ef79b31fbb15ba9161edb999ffb29ed9aa24e870aa.jpg",
+        "table_caption": [
+            "Table 2: MNIST test results $( \\% )$ for 20-layer ResNet models $\\prime { \\epsilon } = 0 . 3 { ^ { * } } 2 5 5$ at test time). $\\{ { \\bf R } 2 0 { \\bf M }$ : standard training, ${ \\mathrm { R } } 2 0 { \\mathrm { M } } _ { K }$ : Kurakin’s adversarial training, ${ \\bf R } 2 0 { \\bf M } _ { B }$ : Bidirectional loss, ${ \\bf R } 2 0 { \\bf M } _ { P }$ : P ivot loss. $\\}$ CW $L _ { \\infty }$ attack is performed with 100 test samples (10 samples per each class) and the number of adversarial examples with $\\epsilon > 0 . 3 ^ { * } 2 5 5$ is reported. Additional details for CW attack can be found in Appendix F "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>clean</td><td>step_ll</td><td>step_FGSM</td><td>iter_ll</td><td>iter_FGSM</td><td>CW</td></tr><tr><td>R20M</td><td>99.6</td><td>9.7</td><td>10.3</td><td>0.0</td><td>0.0</td><td>0</td></tr><tr><td>R20MK</td><td>99.6</td><td>96.7</td><td>94.5</td><td>89.0</td><td>60.2</td><td>46</td></tr><tr><td>R20Mb (Ours)</td><td>99.5</td><td>97.3</td><td>96.2</td><td>97.2</td><td>88.5</td><td>81</td></tr><tr><td>R20Mp (Ours)</td><td>99.5</td><td>97.1</td><td>95.7</td><td>96.9</td><td>88.9</td><td>82</td></tr></table>",
+        "bbox": [
+            233,
+            188,
+            763,
+            268
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We tried $N = 1$ , 2 and found not much difference between the two. We report the results with $N =$ 2 for the rest of the paper otherwise noted. When $N = 2$ , $L _ { d i s t }$ becomes L2 loss. ",
+        "bbox": [
+            174,
+            299,
+            823,
+            327
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pivot loss minimizes the distance between the two embeddings by moving only the adversarial embeddings as shown in the right side of the figure 3. ",
+        "bbox": [
+            173,
+            334,
+            821,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65a51d48749309a44e801c21f9dca81d780b27d1739d48e04acf44c349841c79.jpg",
+        "text": "$$\nL _ { d i s t } ( \\pmb { { E } } _ { i } ^ { a d v } | \\pmb { { E } } _ { i } ) = | | \\pmb { { E } } _ { i } ^ { a d v } - \\pmb { { E } } _ { i } | | _ { N } ^ { N } , \\quad N \\in { 1 , 2 \\quad i = 1 , 2 , . . . , k }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            367,
+            710,
+            387
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this case, clean embeddings ( $\\mathbf { \\mathcal { E } } _ { i }$ ) serve as pivots to the adversarial embeddings. In particular, we don’t back-propagate through the clean embeddings for the distance based loss. The intuition behind the use of pivot loss is that the embedding from a clean image can be treated as the ground truth embedding. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 LOW LEVEL SIMILARITY LEARNING ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            476,
+            601,
+            492
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL RESULTS ON MNIST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            506,
+            473,
+            521
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first analyze the effect of low level similarity learning on MNIST. We train ResNet models (He et al., 2016) with different methods (standard training, Kurakin’s adversarial training and adversarial training with our distance based loss). Experimental details can be found in Appendix A. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            574
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows the accuracy results for MNIST test dataset for different types of attack methods. As shown in the table, our method achieves better accuracy than Kurakin’s method for all types of attacks with a little sacrifice on the accuracy for the clean images. Even though adversarial training is done only with “step ll”, additional regularization increases robustness against unknown “step FGSM”, “iter ll”, “iter FGSM” and CW $L _ { \\infty }$ attacks. This shows that our low-level similarity learning can successfully regularize the one-step adversarial perturbation and its vicinity for simple image classification like MNIST. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 EMBEDDING SPACE VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            695,
+            465,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To visualize the embedding space, we modify 20-layer ResNet model where the last fully connected layer $\\left( 6 4 \\mathbf { x } 1 0 \\right)$ is changed to two fully connected layers ( $6 4 \\mathrm { x } 2$ and 2x10). We re-train networks with standard training, Kurakin’s method and our pivot loss on MNIST. 1 In figure 4, we draw embeddings (dimension $^ { 1 = 2 }$ ) between two fully connected layers. As seen from this figure, adversarial images from the network trained with standard training cross the decision boundary easily as $\\epsilon$ increases. With Kurakin’s adversarial training, the distances between clean and adversarial embeddings are minimized compared to standard training. And our pivot loss further minimizes distance between the clean and adversarial embeddings. Note that our pivot loss also decreases absolute value of the embeddings, thus, higher $\\lambda _ { 2 }$ will eventually result in overlap between distinct embedding distributions. We also observe that intra class variation of the clean embeddings are also minimized for the network trained with our pivot loss as shown in the scatter plot in figure 4 (c). ",
+        "bbox": [
+            174,
+            722,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/03d39dce6fed9b5b8ffb7ae3b4de76e2f07a5e1bf76cb53aab54a3b3914a9521.jpg",
+        "image_caption": [
+            "Figure 4: Embedding space visualization for modified ResNet models trained on MNIST. $\\mathbf { X }$ -axis and y-axis show first and second dimension of embeddings respectively. Scatter plot shows first 100 clean embeddings per each class on MNIST test set. Each arrow shows difference between two embeddings (one from iter FGSM image (\u000f) and the other from $( \\epsilon { + } 8 ) ,$ ). We draw arrows from $\\epsilon = 0$ to $\\epsilon = 7 6$ $( \\approx 0 . 3 ^ { * } 2 5 5 )$ ) for one sample image per each class. We observe differences between clean and corresponding adversarial embeddings are minimized for the network trained with pivot loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            114,
+            825,
+            251
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 EFFECT OF $\\lambda _ { 2 }$ ON CIFAR10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            376,
+            408,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train 20-layer ResNet models with pivot loss and various $\\lambda _ { \\mathrm { 2 } } \\mathrm { s }$ for CIFAR10 dataset to study effects of the weight of the distance measure in the loss function. Figure 5 shows that a higher $\\lambda _ { 2 }$ increases accuracy of the iteratively generated adversarial images. However, it reduces accuracy on the clean images, and increasing $\\lambda _ { 2 }$ above 0.3 even results in divergence of the training. This is because embedding distributions of different classes will eventually overlap since absolute value of the embedding will be decreased as $\\lambda _ { 2 }$ increases as seen from the section 4.2. In this experiment, we show that there exists clear trade-off between accuracy for the clean images and that for the adversarial images, and we recommend using a very high $\\lambda _ { 2 }$ only under strong adversarial environment. ",
+        "bbox": [
+            174,
+            404,
+            589,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c7c186c5dd4d21b6bfbfbcbee29ca466d12198bfbe2a9938e520a56b1e3d928b.jpg",
+        "image_caption": [
+            "Figure 5: Accuracy vs. $\\lambda _ { 2 }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            599,
+            406,
+            816,
+            531
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 CASCADE ADVERSARIAL TRAINING ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            598,
+            622
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 SOURCE NETWORK SELECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            434,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We further study the transferability of iter FGSM images between various architectures. To this end, we first train 56-layer ResNet networks (Kurakin’s, pivot loss) with the same initialization. Then we train another 56-layer ResNet network (Kurakin’s) with different initialization. We repeat the training for the 110-layer ResNet networks. We measure correlation between iter FGSM noises from different networks. ",
+        "bbox": [
+            174,
+            666,
+            419,
+            832
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/34d7075ba0af839593f33f5d84485be6ec355dc2d545d65ab9e3441ef984ed68.jpg",
+        "image_caption": [
+            "Figure 6 (a) shows correlation between iter FGSM noises crafted from Kurakin’s network and those from Pivot network with the same initialization. Conjectured from (Kurakin et al., 2017), we observe high corre",
+            "Figure 6: Correlation between iter FGSM noises crafted from different networks for each \u000f. Correlation is averaged over randomly chosen 128 images from CIFAR10 test-set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            433,
+            674,
+            823,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/635c6aa003fe8ab801de926562c927629e2d923031927c6371924d96ec1dc1ef.jpg",
+        "table_caption": [
+            "Table 3: CIFAR10 test results $( \\% )$ for 110-layer ResNet models. CW $L _ { \\infty }$ attack is performed with 100 test samples (10 samples per each class) and the number of adversarial examples with $\\epsilon > 2$ or 4 is reported. $\\{ \\mathrm { R 1 1 0 } _ { K }$ : Kurakin’s, $\\mathrm { R } 1 0 _ { P }$ : P ivot loss, $\\mathrm { R } 1 1 0 _ { E }$ : Ensemble training, $\\mathrm { R 1 1 0 } _ { K , C }$ : Kurakin’s and $C$ ascade training, $\\mathrm { R 1 1 0 } _ { P , E }$ : P ivot loss and Ensemble training, and $\\mathrm { R 1 1 0 } _ { P , C }$ : P ivot loss and Cascade training} "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">clean</td><td colspan=\"2\">step_ll</td><td colspan=\"2\">step_FGSM</td><td colspan=\"2\">iter_FGSM</td><td colspan=\"2\">CW</td></tr><tr><td>e=2</td><td>∈=16</td><td>e=2</td><td>∈=16</td><td>e=2</td><td>∈=4</td><td>∈=2</td><td>e=4</td></tr><tr><td>R110K</td><td>92.3</td><td>88.3</td><td>90.7</td><td>86.0</td><td>95.2</td><td>59.4</td><td>9.2</td><td>25</td><td>4</td></tr><tr><td>R110p (Ours)</td><td>92.3</td><td>86.0</td><td>89.4</td><td>81.6</td><td>91.6</td><td>64.1</td><td>20.9</td><td>32</td><td>7</td></tr><tr><td>R110E</td><td>92.3</td><td>86.3</td><td>74.3</td><td>84.1</td><td>72.9</td><td>63.5</td><td>21.1</td><td>24</td><td>6</td></tr><tr><td>R110k,c (Ours)</td><td>92.3</td><td>86.2</td><td>72.8</td><td>82.6</td><td>66.7</td><td>69.3</td><td>33.4</td><td>20</td><td>5</td></tr><tr><td>R110p,ε (Ours)</td><td>91.3</td><td>84.0</td><td>65.7</td><td>77.6</td><td>54.5</td><td>66.8</td><td>38.3</td><td>38</td><td>16</td></tr><tr><td>R110p,c (Ours)</td><td>91.5</td><td>85.7</td><td>76.4</td><td>82.4</td><td>69.1</td><td>73.5</td><td>42.5</td><td>27</td><td>15</td></tr></table>",
+        "bbox": [
+            215,
+            188,
+            784,
+            321
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "lation between iter FGSM noises from networks with the same initialization. Correlation between iter FGSM noises from the networks with different initialization, however, becomes lower as the network is deeper as shown in figure 6 (b). Since the degree of freedom increases as the network size increases, adversarially trained networks prone to end up with different states, thus, making transfer rate lower. To maximize the benefit of the cascade adversarial training, we propose to use the same initialization for a cascade network and a source network used for iterative adversarial examples generation. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            458
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 WHITE BOX ATTACK ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            434,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first compare a network trained with Kurakin’s method and that with pivot loss. We train 110- layer ResNet models with/without pivot loss and report accuracy in table 3. We observe our lowlevel similarity learning further improves robustness against iterative attacks compared to Kurakin’s adversarial training. However, the accuracy improvements against iterative attacks (iter FGSM, CW) are limited, showing regularization effect of low-level similarity learning is not sufficient for the iterative attacks on complex color images like CIFAR10. This is different from MNIST test cases where we observed significant accuracy increase for iterative attacks only with pivot loss. We observe label leaking phenomenon reported in (Kurakin et al., 2017) happens even though we don’t train a network with step FGSM images. Additional analysis for this phenomenon is explained in Appendix D. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            651
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, we train a network from scratch with iter FGSM examples crafted from the defended network, $\\mathrm { R } 1 0 _ { P }$ . We use the same initialization used in $\\mathrm { R } 1 1 0 _ { P }$ as discussed in 5.1. In particular, iter FGSM images are crafted from $\\mathrm { R } 1 0 _ { P }$ with CIFAR10 training images for $\\epsilon = 1 , 2 , . . . , 1 6$ , and those are used randomly together with step ll examples from the network being trained. We train cascade networks with/without pivot loss. We also train networks with ensemble adversarial training (Tramer et al., \\` 2017) with/without pivot loss for comparison. The implementation details for the trained models can be found in Appendix B. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We find several meaningful observations in table 3. First, ensemble and cascade models show improved accuracy against iterative attack although at the expense of decreased accuracy for onestep attacks compared to the baseline defended network $( \\mathrm { R } 1 1 0 _ { K } )$ ). Additional data augmentation from other networks enhances the robustness against iterative attack, weakening label leaking effect caused by one-step adversarial training. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Second, our low-level similarity learning $( \\mathrm { R } 1 1 0 _ { P , E }$ , $\\operatorname { R 1 1 0 } _ { P , C } )$ ) further enhances robustness against iterative attacks including fully unknown CW attack (especially for $\\epsilon { = } 4$ ). Additional knowledge learned from data augmentation through cascade/ensemble adversarial training enables networks to learn partial knowledge of perturbations generated by an iterative method. And the learned iterative perturbations become regularized further with our low-level similarity learning making networks robust against unknown iterative attacks. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c739090c30b8cd33548e9102c900feae48e9493fde03b6171e4d1dfecec11039.jpg",
+        "table_caption": [
+            "Table 4: CIFAR10 test results $( \\% )$ for 110-layer ResNet models under black box attacks $\\left( \\epsilon = 1 6 \\right)$ . {Target: same networks in table 3 and $\\mathrm { R } 1 1 0 _ { K }$ : Kurakin’s, Source: re-trained baseline, Kurakin’s, cascade and ensemble networks with/without pivot loss. Source networks use the different initialization from the target networks. Additional details of the models can be found in Appendix B.} "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Target</td><td colspan=\"7\">Source: iter_FGSM</td></tr><tr><td>R1102</td><td>R110K2</td><td>R110E2</td><td>R110p2</td><td>R110K,C2</td><td>R110p,E2</td><td>R110p,C2</td></tr><tr><td>R110K</td><td>70.5</td><td>73.2</td><td>27.9</td><td>77.0</td><td>67.3</td><td>54.6</td><td>80.8</td></tr><tr><td>R110E</td><td>77.9</td><td>79.5</td><td>55.8</td><td>79.0</td><td>68.2</td><td>54.7</td><td>82.7</td></tr><tr><td>R110p (Ours)</td><td>75.9</td><td>75.6</td><td>39.6</td><td>78.5</td><td>68.3</td><td>61.3</td><td>83.3</td></tr><tr><td>R110k,c (Ours)</td><td>56.4</td><td>80.2</td><td>61.1</td><td>79.5</td><td>67.4</td><td>62.6</td><td>82.1</td></tr><tr><td>R110p,E (Ours)</td><td>78.2</td><td>82.1</td><td>67.7</td><td>81.7</td><td>73.4</td><td>68.4</td><td>83.8</td></tr><tr><td>R110p,C (Ours)</td><td>71.9</td><td>80.4</td><td>63.9</td><td>80.1</td><td>71.1</td><td>64.2</td><td>83.0</td></tr></table>",
+        "bbox": [
+            189,
+            174,
+            810,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Third, our low-level similarity learning serves as a good regularizer for adversarial images, but not for the clean images for ensemble/cascade models (reduced accuracy for the clean images for $\\mathrm { R 1 1 0 } _ { P , E }$ and $\\mathrm { R 1 1 0 } _ { P , C }$ in table 3). Compared to pure adversarial training with one-step adversarial examples, the network sees more various adversarial perturbations during training as a result of ensemble and cascade training. Those perturbations are prone to end up embeddings in the vicinity of decision boundary more often than perturbations caused by one-step adversarial training. Pivot loss pulls the vicinity of those adversarial embeddings toward their corresponding clean embeddings. During this process, clean embeddings from other classes might also be moved toward the decision boundary which results in decreased accuracy for the clean images. ",
+        "bbox": [
+            173,
+            340,
+            825,
+            465
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 BLACK BOX ATTACK ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            434,
+            505
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We finally perform black box attack analysis for the cascade/ensemble networks with/without pivot loss. We report black box attack accuracy with the source networks trained with the same method, but with different initialization from the target networks. The reason for this is adversarial examples transfer well between networks trained with the same strategy as observed in section 3.1. We re-train 110-layer ResNet models using Kurakin’s, cascade and ensemble adversarial training with/without low-level similarity learning and use those networks as source networks for black-box attacks. Baseline 110-layer ResNet model is also included as a source network. Target networks are the same networks used in table 3. We found iter FGSM attack resulted in lower accuracy than step FGSM attack, thus, report iter FGSM attack only in table 4. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            645
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first observe that iter FGSM attack from ensemble models $( \\mathrm { R } 1 1 0 _ { E 2 }$ , $\\mathrm { R 1 1 0 } _ { P , E 2 } )$ is strong (results in lower accuracy) compared to that from any other trained networks. 2 Since ensemble models learn various perturbation during training, adversarial noises crafted from those networks might be more general for other networks making them transfer easily between defended networks. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            708
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Second, cascade adversarial training breaks chicken and egg problem. (In section 3.1, we found that it is efficient to use a defended network as a source network to attack another defended network.) Even though the transferability between defended networks is reduced for deeper networks, cascade network $( \\mathrm { R } 1 1 0 _ { K , C } )$ shows worst case performance against the attack not from a defended network, but from a purely trained network $\\mathbf { ( R 1 1 0 _ { 2 } ) }$ . Possible solution to further improve the worst case robustness would be to use more than one network as source networks (including pure/defended networks) for iter FGSM images generation for cascade adversarial training. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            814
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Third, ensemble/cascade networks together with our low-level similarity learning $( \\mathrm { R } 1 1 0 _ { P , E }$ , $\\mathrm { R 1 1 0 } _ { P , C } )$ show better worst case accuracy under black box attack scenario. This shows that enhancing robustness against iterative white box attack also improves robustness against iterative black box attack. ",
+        "bbox": [
+            174,
+            820,
+            823,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We performed through transfer analysis and showed iter FGSM images transfer easily between networks trained with the same strategy. We exploited this and proposed cascade adversarial training, a method to train a network with iter FGSM adversarial images crafted from already defended networks. We also proposed adversarial training regularized with a unified embedding for classification and low- level similarity learning by penalizing distance between the clean and their corresponding adversarial embeddings. Combining those two techniques (low level similarity learning $^ +$ cascade adversarial training) with deeper networks further improved robustness against iterative attacks for both white-box and black-box attacks. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            244
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "However, there is still a gap between accuracy for the clean images and that for the adversarial images. Improving robustness against both one-step and iterative attacks still remains challenging since it is shown to be difficult to train networks robust for both one-step and iterative attacks simultaneously. Future research is necessary to further improve the robustness against iterative attack without sacrificing the accuracy for step attacks or clean images under both white-box attack and black-box attack scenarios. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            335
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            354,
+            326,
+            367
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank Alexey Kurakin of Google Brain and Li Chen of Intel for comments that greatly improved the manuscript. The research reported here was supported in part by the Defense Advanced Research Projects Agency (DARPA) under contract number HR0011-17-2-0045. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of DARPA. ",
+        "bbox": [
+            174,
+            378,
+            825,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            470,
+            285,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, 2017. ",
+        "bbox": [
+            174,
+            494,
+            823,
+            522
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In Proceedings of the International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            174,
+            531,
+            823,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV, USA, June 27-30, 2016, pp. 770–778, 2016. doi: 10.1109/CVPR.2016.90. URL http://dx.doi.org/10.1109/CVPR.2016.90. ",
+        "bbox": [
+            173,
+            584,
+            823,
+            641
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ruitong Huang, Bing Xu, Dale Schuurmans, and Csaba Szepesvari. Learning with a strong adver-´ sary. CoRR, abs/1511.03034, 2015. URL http://arxiv.org/abs/1511.03034. ",
+        "bbox": [
+            173,
+            650,
+            820,
+            680
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009. ",
+        "bbox": [
+            173,
+            689,
+            805,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial machine learning at scale. In Proceedings of the International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            713,
+            823,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/. ",
+        "bbox": [
+            173,
+            751,
+            820,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "O. M. Parkhi, A. Vedaldi, and A. Zisserman. Deep face recognition. In Proceedings of the British Machine Vision Conference (BMVC), 2015. ",
+        "bbox": [
+            171,
+            790,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015. ",
+        "bbox": [
+            173,
+            828,
+            823,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensem- \\` ble adversarial training: Attacks and defenses. CoRR, abs/1705.07204, 2017. URL http: //arxiv.org/abs/1705.07204. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In Computer Vision - ECCV 2016 - 14th European Conference, Amsterdam, The Netherlands, October 11-14, 2016, Proceedings, Part VII, pp. 499– 515, 2016. doi: 10.1007/978-3-319-46478-7 31. URL http://dx.doi.org/10.1007/ 978-3-319-46478-7_31. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            403,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We scale down the image values to [0,1] and don’t perform any data augmentation for MNIST. For CIFAR10, we scale down the image values to [0,1] and subtract per-pixel mean values. We perform $2 4 \\times 2 4$ random crop and random flip on $3 2 \\mathrm { x } 3 2 $ original images. We generate adversarial images with “step ll” after these steps otherwise noted. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            189
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We use stochastic gradient descent (SGD) optimizer with momentum of 0.9, weight decay of 0.0001 and mini batch size of 128. For adversarial training, we generate $k = 6 4$ adversarial examples among 128 images in one mini-batch. We start with a learning rate of 0.1, divide it by 10 at $4 \\mathrm { k }$ and 6k iterations, and terminate training at 8k iterations for MNIST, and $4 8 \\mathrm { k }$ and $7 2 \\mathrm { k }$ iterations, and terminate training at 94k iterations for CIFAR10. 3 ",
+        "bbox": [
+            174,
+            195,
+            825,
+            266
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We also found that initialization affects the training results slightly as in (Kurakin et al., 2017), thus, we pre-train the networks 2 and 10 epochs for MNIST and CIFAR10, and use these as initial starting points for different configurations. We use $m a x \\_ e = 0 . 3 ^ { * } 2 5 5$ and 16 for MNIST and CIFAR10 respectively. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            329
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B MODEL DESCRIPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            349,
+            401,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We summarize the model names used in this paper in table 5. For ensemble adversarial training, pre-trained networks as in table 7 together with the network being trained are used to generate onestep adversarial examples during training. For cascade adversarial training, pre-trained defended networks as in table 6 are used to generate iter FGSM images, and the network being trained is used to generate one-step adversarial examples during training. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            450
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/6563234a98d2b1b419bf55c8773833ffa6f401037be1b161549906d5475fba30.jpg",
+        "table_caption": [
+            "Table 5: Model descriptions ",
+            "Table 6: Ensemble model description "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"5\">Initialization</td></tr><tr><td>Dataset</td><td>ResNet</td><td>Group</td><td>Training</td><td>Model</td></tr><tr><td rowspan=\"2\">MNIST</td><td rowspan=\"2\">20-layer</td><td rowspan=\"2\">A</td><td>standard training Kurakin&#x27;s</td><td>R20M R20MK</td></tr><tr><td>Bidirection loss</td><td>R20MB</td></tr><tr><td rowspan=\"10\"></td><td rowspan=\"10\">20-layer</td><td rowspan=\"4\"></td><td>Pivot loss</td><td>R20Mp</td></tr><tr><td> standard training</td><td>R20</td></tr><tr><td>Kurakin&#x27;s</td><td>R20K</td></tr><tr><td>Ensemble training</td><td>R20E</td></tr><tr><td rowspan=\"6\">B</td><td>Bidirection loss Pivot loss</td><td>R20B R20p</td></tr><tr><td>Kurakin&#x27;s &amp; Cascade training</td><td>R20K,C</td></tr><tr><td></td><td></td></tr><tr><td>Pivot loss &amp; Ensemble training</td><td>R20p,E</td></tr><tr><td>Pivot loss &amp; Cascade training</td><td>R20p,C</td></tr><tr><td> standard training</td><td>R202</td></tr><tr><td rowspan=\"7\">CIFAR10 56-layer</td><td rowspan=\"7\"></td><td>C</td><td>Kurakin&#x27;s</td><td>R20K2</td></tr><tr><td>D</td><td>Pivot loss standard training</td><td>R20p2 R203</td></tr><tr><td>E</td><td> standard training</td><td>R204</td></tr><tr><td>F</td><td>Kurakin&#x27;s</td><td>R56K R56p</td></tr><tr><td></td><td>Pivot loss</td><td></td></tr><tr><td>G</td><td>Kurakin&#x27;s</td><td>R56K2</td></tr><tr><td></td><td></td><td></td></tr><tr><td rowspan=\"7\">110-layer</td><td rowspan=\"7\"></td><td rowspan=\"7\">H</td><td> standard training</td><td>R110</td></tr><tr><td>Kurakin&#x27;s</td><td>R110K</td></tr><tr><td>Pivot loss Ensemble training</td><td>R110p R110E</td></tr><tr><td>Kurakin&#x27;s &amp; Cascade training</td><td></td></tr><tr><td></td><td>R110K,C</td></tr><tr><td>Pivot loss &amp; Ensemble training</td><td>R110p,E</td></tr><tr><td>Pivot loss &amp; Cascade training</td><td>R110p,C</td></tr><tr><td rowspan=\"5\"></td><td rowspan=\"5\">I</td><td>standard training Kurakin&#x27;s</td><td>R1102</td></tr><tr><td></td><td>R110k2</td></tr><tr><td>Ensemble training</td><td>R110E2</td></tr><tr><td>Pivot loss</td><td>R110p2</td></tr><tr><td>Kurakin&#x27;s &amp; Cascade training Pivot loss &amp; Ensemble training</td><td>R110k,C2 R110p,E2</td></tr><tr><td rowspan=\"5\"></td><td>J</td><td>Pivot loss &amp; Cascade training</td><td>R110p,C2</td></tr><tr><td></td><td>standard training</td><td>R1103</td></tr><tr><td>K</td><td>standard training</td><td>R1104</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            209,
+            130,
+            789,
+            736
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/61ea47e7a72ef68e291fac78da5b31bedcb666f76f13ac434011d7fd2ae6f1fe.jpg",
+        "table_caption": [
+            "Table 7: Cascade model description "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Ensemble models</td><td>Pre-trained models</td></tr><tr><td>R20E,R20p,E,R110E,R110P,E R110E2,R110P,E2</td><td>R203,R110g R204,R1104</td></tr></table>",
+        "bbox": [
+            305,
+            768,
+            692,
+            820
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d5bc4d9e93eb2629ea11b02196b809f6a3f4f5abfad465b7319e8a39cae28f2.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Cascade models</td><td>Pre-trained model</td></tr><tr><td>R20K,c,R20p,C</td><td>R20p</td></tr><tr><td>R110K,c,R110p,C</td><td>R110p</td></tr><tr><td>R110K,c2,R110P,C2</td><td>R110p2</td></tr></table>",
+        "bbox": [
+            344,
+            854,
+            651,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/a63d4cd60c68a6ff53d587a7bfc58f89eb11f682c0bbc103d1fd3a001a954254.jpg",
+        "image_caption": [
+            "Figure 7: Argument to the softmax vs. $\\epsilon$ in test time. “step ll”, “step FGSM” and ”random sign” methods were used to generate test-time adversarial images. Arguments to the softmax were measured by changing $\\epsilon$ for each test method and averaged over randomly chosen 128 images from CIFAR10 test-set. Blue line represents true class and the red line represents mean of the false classes. Shaded region shows $\\pm \\nobreakspace 1 \\nobreakspace$ standard deviation of each line. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            145,
+            826,
+            570
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We draw average value of the argument to the softmax layer for the true class and the false classes to visualize how the adversarial training works as in figure 7. Standard training, as expected, shows dramatic drop in the values for the true class as we increase $\\epsilon$ in “step ll” or “step FGSM direction. With adversarial training, we observe that the value drop is limited at small $\\epsilon$ and our method even increases the value in certain range upto ${ \\epsilon } { = } 1 0$ . Note that adversarial training is not the same as the gradient masking.As illustrated in figure 7, it exposes gradient information, however, quickly distort gradients along the sign of the gradient (“step ll” or “step FGSM) direction. We also observe improved results (broader margins than baseline) for “random sign” added images even though we didn’t inject random sign added images during training. Overall shape of the argument to the softmax layer in our case becomes smoother than Kurakin’s method, suggesting our method is good for pixel level regularization. Even though actual value of the embeddings for the true class in our case is smaller than that in Kurakin’s, the standard deviation of our case is less than Kurakin’s, making better margin between the true class and false classes. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            848
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb0f617516f1c753274ff6e6c797bcd0df9ac1a88e8bee55ff5efc872dab5a74.jpg",
+        "image_caption": [
+            "Figure 8: Averaged Pearson’s correlation coefficient between the gradients w.r.t. two images. Correlation were measured by changing $\\epsilon$ for each adversarial image and averaged over randomly chosen 128 images from CIFAR10 test-set. Shaded region represents $\\pm \\ : 0 . 5$ standard deviation of each line. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            169,
+            825,
+            304
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We observe accuracies for the “step FGSM” adversarial images become higher than those for the clean images (“label leaking” phenomenon) by training with “step FGSM” examples as in (Kurakin et al., 2017). Interestingly, we also observe “label leaking” phenomenon even without providing true labels for adversarial images generation. We argue that “label leaking” is a natural result of the adversarial training. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            444
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To understand the nature of adversarial training, we measure correlation between gradients w.r.t. different images (i.e. clean vs. adversarial) as a measure of error surface similarity. We measure correlation between gradients w.r.t. (1) clean vs. “step ll” image, (2) clean vs. “step FGSM” image, (3) clean vs. “random sign” added image, and (4) “step ll” image vs. “step FGSM” image for three trained networks (a) R20, (b) $\\mathsf { R } 2 0 _ { K }$ and (c) ${ \\mathrm { R } } 2 0 _ { P }$ (Ours) in table 5. Figure 8 draws average value of correlations for each case. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            534
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Meaning of the correlation: In order to make strong adversarial images with “step FGSM” method, correlation between the gradient w.r.t. the clean image and the gradient w.r.t. its corresponding adversarial image should remain high since the “step FGSM” method only use the gradient w.r.t. the clean image $( \\epsilon { = } 0 )$ . Lower correlation means perturbing the adversarial image at $\\epsilon$ further to the gradient (seen from the clean image) direction is no longer efficient. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            611
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Results of adversarial training: We observe that (1) and (2) become quickly lower than (3) as $\\epsilon$ increases. This means that, when we move toward the steepest (gradient) direction on the error surface, gradient is more quickly uncorrelated with the gradient w.r.t. the clean image than when we move to random direction. As a result of adversarial training, this uncorrelation is observed at a lower $\\epsilon$ making one-step attack less efficient even with small perturbation. (1), (2) and (3) for our case are slightly lower than Kurakin’s method at the same $\\epsilon$ which means that our method is better at defending one-step attacks than Kurakin’s. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            715
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Error surface similarity between “step ll” and “step FGSM” images: We also observe (4) remains high with higher $\\epsilon$ for all trained networks. This means that the error surface (gradient) of the “step ll” image and that of its corresponding “step FGSM” image resemble each other. That is the reason why we get the robustness against “step FGSM” method only by training with “step ll” method and vice versa. (4) for our case is slightly higher than Kurakin’s method at the same $\\epsilon$ and that means our similarity learning tends to make error surfaces of the adversarial images with “step ll” and “step FGSM” method to be more similar. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            819
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Analysis of label leaking phenomenon: Interestingly, (2) becomes slightly negative in certain range $1 < \\epsilon < 3$ for Kurakin’s, and $1 < \\epsilon < 4$ for Pivot (Ours) ) and this could be the possible reason for “label leaking” phenomenon. For example, let’s assume that we have a perturbed image (by “step FGSM” method) at $\\epsilon$ where the correlation between the gradients w.r.t. that image and the corresponding clean image is negative. Further increase of $\\epsilon$ with the gradient (w.r.t. the clean image) direction actually decreases the loss resulting in increased accuracy (label leaking phenomenon). Due to the error surface similarity between “step ll” and “step FGSM” images and this negative correlation effect, however, label leaking phenomenon can always happen for the networks trained with one-step adversarial examples. ",
+        "bbox": [
+            173,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E ADDITIONAL BLACK BOX ATTACK RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            151,
+            578,
+            170
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/b57587db05d54f989662ee35c8d48e2d69d44fda8d60a095327d85851b575a1a.jpg",
+        "table_caption": [
+            "Table 8: CIFAR10 test results $( \\% )$ under black box attacks between the network with the same initialization $\\scriptstyle \\left( \\epsilon = 1 6 \\right) \\}$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Target</td><td colspan=\"3\">Source: step_FGSM</td><td colspan=\"3\">Source: iter_FGSM</td></tr><tr><td>R20</td><td>R20K</td><td>R20p</td><td>R20</td><td>R20K</td><td>R20p</td></tr><tr><td>R20</td><td>12.2</td><td>27.4</td><td>27.5</td><td>0.0</td><td>45.9</td><td>44.7</td></tr><tr><td>R20K</td><td>65.7</td><td>81.5</td><td>81.8</td><td>51.5</td><td>0.0</td><td>18.2</td></tr><tr><td>R20p</td><td>58.1</td><td>89.3</td><td>91.7</td><td>48.9</td><td>13.4</td><td>0.0</td></tr></table>",
+        "bbox": [
+            299,
+            229,
+            699,
+            318
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 8 shows that black box attack between trained networks with the same initialization tends to be more successful than that between networks with different initialization as explained in (Kurakin et al., 2017). ",
+        "bbox": [
+            174,
+            337,
+            823,
+            378
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/fe92bfdf334b84af237151b801dbe6b25b9ef4b200fd5ece97ae0d14392d78bc.jpg",
+        "table_caption": [
+            "Table 9: CIFAR10 test results $( \\% )$ under black box attacks for ${ \\epsilon } { = } 1 6$ . {Target and Source networks are switched from the table 1} "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Target</td><td colspan=\"3\">Source: step-FGSM</td><td colspan=\"3\">Source: iter_FGSM</td></tr><tr><td>R20</td><td>R20K</td><td>R20p</td><td>R20</td><td>R20K</td><td>R20p</td></tr><tr><td>R202</td><td>17.9</td><td>33.9</td><td>34.5</td><td>4.1</td><td>54.8</td><td>54.3</td></tr><tr><td>R20K2</td><td>65.0</td><td>84.6</td><td>84.5</td><td>61.2</td><td>25.3</td><td>30.4</td></tr><tr><td>R20p2</td><td>66.4</td><td>88.2</td><td>87.2</td><td>61.6</td><td>27.7</td><td>36.1</td></tr></table>",
+        "bbox": [
+            295,
+            435,
+            702,
+            521
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In table 9, our method $( \\mathsf { R } 2 0 _ { P 2 } )$ is always better at one-step and iterative black box attack from defended networks $( \\mathsf { R } 2 0 _ { K } , \\mathsf { R } 2 0 _ { P } )$ and undefended network (R20) than Kurakin’s method $( { \\bf R } 2 0 _ { B { \\bf 2 } } )$ . However, it is hard to tell which method is better than the other one as explained in the main paper. ",
+        "bbox": [
+            178,
+            540,
+            821,
+            582
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/19b43217da7077fd6e2e2eff14dc27cd85d13f61c08c35e6d2732ef97907066a.jpg",
+        "table_caption": [
+            "Table 10: CIFAR10 test results $( \\% )$ for cascade networks under black box attacks for ${ \\epsilon } { = } 1 6$ . {Target and Source: Please see the model descriptions in Appendix B.} "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Target</td><td colspan=\"7\">Source: iter_FGSM</td></tr><tr><td>R110</td><td>R110K</td><td>R110E</td><td>R110p</td><td>R110K,C</td><td>R110p,E</td><td>R110p,C</td></tr><tr><td>R110K2</td><td>80.5</td><td>72.7</td><td>49.3</td><td>68.0</td><td>49.6</td><td>41.0</td><td>67.9</td></tr><tr><td>R110E2</td><td>82.7</td><td>59.1</td><td>39.5</td><td>59.6</td><td>51.5</td><td>40.3</td><td>69.6</td></tr><tr><td>R110p2 (Ours)</td><td>80.3</td><td>75.9</td><td>54.2</td><td>72.2</td><td>54.9</td><td>44.3</td><td>72.4</td></tr><tr><td>R110k,C2 (Ours)</td><td>62.1</td><td>74.7</td><td>61.5</td><td>72.3</td><td>46.5</td><td>39.0</td><td>67.9</td></tr><tr><td>R110p,E2 (Ours)</td><td>81.5</td><td>79.0</td><td>50.0</td><td>77.3</td><td>56.9</td><td>45.5</td><td>75.2</td></tr><tr><td>R110p,c2 (Ours)</td><td>72.2</td><td>76.4</td><td>60.6</td><td>73.8</td><td>51.0</td><td>40.9</td><td>72.0</td></tr></table>",
+        "bbox": [
+            210,
+            638,
+            787,
+            766
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In table 10, we show black box attack accuracies with the source and the target networks switched from the table 4. We also observe that networks trained with both low-level similarity learning and cascade/ensemble adversarial training $( \\mathrm { R } 1 1 0 _ { P , C 2 }$ , $\\mathbf { R } 1 1 0 _ { P , E 2 } )$ show better worst-case performance than other networks. Overall, iter FGSM images crafted from ensemble model families $( \\mathrm { R } 1 1 0 _ { E }$ , $\\operatorname { R 1 1 0 } _ { P , E } )$ remain strong on the defended networks. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            854
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/ab53c2fe8209182e38731b9aaaef260818586606f8ae3b9ef8464c393141354e.jpg",
+        "image_caption": [
+            "Figure 9: Cumulative distribution function vs. $\\epsilon$ for 100 test adversarial examples generated by CW $L _ { \\infty }$ attack. Lower CDF value for a fixed $\\epsilon$ means the better defense. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            147,
+            825,
+            290
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Carlini and Wagner (CW) $L _ { \\infty }$ attack solves the following optimization problem for every input $\\boldsymbol { X }$ ",
+        "bbox": [
+            173,
+            343,
+            820,
+            359
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/74e24b878b8dc6c29f71fb22a4989b093871e569b0819a2be05ce3a62d8f184a.jpg",
+        "text": "$$\nm i n i m i z e \\quad c \\cdot f ( X + \\pmb { \\delta } ) + \\sum _ { i } [ ( | \\delta _ { i } | - \\tau ) ^ { + } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            364,
+            651,
+            398
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "where, the function $f$ is defined such that attack is success if and only if $f ( X + \\delta ) < 0 , \\mathfrak { c }$ δ is the target perturbation defined as $X ^ { a d v } - X$ , $c$ is the parameter to control the relative weight of function $f$ in the total cost function, and $\\tau$ is the control threshold used to penalize any terms that exceed $\\tau$ . ",
+        "bbox": [
+            174,
+            424,
+            825,
+            467
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Since CW $L _ { \\infty }$ attack is computationally expensive, we only use 100 test examples (10 examples per each class). We search adversarial example $X ^ { a d v }$ with $c \\in \\{ 0 . 1 , 0 . 2 , 0 . 5 , 1 , 2 , 5 , 1 0 , 2 0 \\}$ and $\\tau \\in \\ \\{ 0 . 0 2 , 0 . 0 4 , . . . , 0 . 6 \\}$ for MNIST and $c ~ \\in ~ \\{ 0 . 1 , 0 . 3 , 1 , 3 , 1 0 , 3 0 , 1 0 0 \\}$ and $\\tau \\_ { \\in }$ $\\{ 0 . 0 0 1 , 0 . 0 0 \\dot { 2 } , . . . , 0 . 0 1 , 0 . 0 1 2 , . . . , 0 . 0 2 , 0 . 0 2 4 , . . . , 0 . 0 4 , 0 . 0 4 8 , . . . , 0 . 0 8 \\}$ for CIFAR10. We use Adam optimizer with an initial learning rate of $0 . 0 1 / c$ since we found constant initial learning rate for $c \\cdot f ( \\pmb { X } + \\pmb { \\delta } )$ term is critical for successful adversarial images generation. We terminate the search after 2,000 iterations for each $\\boldsymbol { X }$ , $c$ and $\\tau$ . If $f ( X + \\delta ) < 0$ and the resulting $| | \\delta | | _ { \\infty }$ is lower than the current best distance, we update $X ^ { a d v }$ . ",
+        "bbox": [
+            173,
+            472,
+            825,
+            585
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Figure 9 shows cumulative distribution function of $\\epsilon$ for 100 successful adversarial examples per each network. We report the number of adversarial examples with $\\epsilon > 0 . 3 ^ { * } 2 5 5$ for MNIST and that with $\\epsilon > 2$ or 4 for CIFAR10. As seen from this figure, our approaches provide robust defense against CW $L _ { \\infty }$ attack compared to other approaches. ",
+        "bbox": [
+            173,
+            590,
+            825,
+            647
+        ],
+        "page_idx": 15
+    }
+]

parse/train/RO4DM85Z4P7/RO4DM85Z4P7.md

@@ -0,0 +1,192 @@
+# XIRL: Cross-embodiment Inverse Reinforcement Learning
+
+Kevin Zakka1,3⇤, Andy $\mathbf { Z e n g } ^ { 2 }$ , Pete Florence2, Jonathan Tompson2, Jeannette $\mathbf { B o h g } ^ { 1 }$ , and Debidatta Dwibedi2 1Stanford University, 2Robotics at Google, 3UC Berkeley
+
+Abstract: We investigate the visual cross-embodiment imitation setting, in which agents learn policies from videos of other agents (such as humans) demonstrating the same task, but with stark differences in their embodiments – shape, actions, end-effector dynamics, etc. In this work, we demonstrate that it is possible to automatically discover and learn vision-based reward functions from cross-embodiment demonstration videos that are robust to these differences. Specifically, we present a self-supervised method for Crossembodiment Inverse Reinforcement Learning (XIRL) that leverages temporal cycleconsistency constraints to learn deep visual embeddings that capture task progression from offline videos of demonstrations across multiple expert agents, each performing the same task differently due to embodiment differences. Prior to our work, producing rewards from self-supervised embeddings typically required alignment with a reference trajectory, which may be difficult to acquire under stark embodiment differences. We show empirically that if the embeddings are aware of task progress, simply taking the negative distance between the current state and goal state in the learned embedding space is useful as a reward for training policies with reinforcement learning. We find our learned reward function not only works for embodiments seen during training, but also generalizes to entirely new embodiments. Additionally, when transferring real-world human demonstrations to a simulated robot, we find that XIRL is more sample efficient than current best methods. Qualitative results, code, and datasets are available at https://x-irl.github.io
+
+Keywords: inverse reinforcement learning, imitation learning, self-supervised learning
+
+# 1 Introduction
+
+The ability to learn new tasks from third-person demonstrations holds the potential to enable robots to leverage the vast quantities of tutorial videos that can be gleaned from the world-wide web (e.g., YouTube videos). However, distilling diverse and unstructured videos into motor skills with vision-based policies can be daunting – as the videos themselves are often not only captured from different camera viewpoints in different environments, but also with different experts that may use different tools, objects, or strategies to perform the same task. Perhaps most critically, there often exists a clear embodiment gap between the human expert demonstrator, and the robot hardware that executes the learned policies. One approach to close this gap is to learn a mapping between the human and robot embodiment [1], which is a non-trivial intermediate problem in itself.
+
+Despite considerable progress in learning policies with paired observations and actions (e.g., collected via teleoperation) [2, 3], much less work has been done in getting robots to learn policies from tasks defined only by third-person observations of demonstrations [4, 5, 6]. This is a surprisingly challenging problem, as different embodiments are likely to use unique strategies that suit them and allow them to make progress on a given task. For example, if asked to “place five pens into a cup”, a human hand is likely to scoop up all pens before slipping them into the cup, whereas a two-fingered gripper might instead need to pick and place each pen individually. Both strategies complete the task, but generate different state-action trajectories. In this setting, it may be difficult to acquire labeled frame-to-frame correspondences between expert demonstration videos and learned embodiments [6], particularly across a multitude of embodiments or experts. The approach we investigate instead is whether we can successfully learn tasks through a learned notion of task progress that is invariant to the embodiment performing the task.
+
+![](images/80a7e6efe913971b206ca18932e755e85617cbe2190ac680c41ec9b31c2e8a60.jpg)  
+Figure 1. Cross-embodiment Inverse Reinforcement Learning. We learn embodiment-invariant visual representations from offline video demonstrations (stick agents on the left) using TCC [7], then use the trained encoder to generate embodiment-invariant visual reward functions that can be used to learn policies on new embodiments (gripper on the right) with reinforcement learning.
+
+In this work, we propose to enable agents to imitate video demonstrations of experts – including ones with different embodiments – by using a task-specific, embodiment-invariant reward formulation trained via temporal cycle-consistency (TCC) [7]. We demonstrate how we can leverage an encoder trained with TCC to define dense rewards for downstream reinforcement learning (RL) policies via simple distances in the learned embedding space. Simulated experiments across four different embodiments show that these learned rewards are capable of generalizing to new embodiments, enabling unseen agents to learn the task via reinforcement, and surprisingly in some cases, exceeding the sample efficiency of the same agent learned with ground truth sparse rewards. We also demonstrate the effectiveness of our approach for learning robot policies using human demonstrations on the State Pusher environment from [6], where our reward is first learned on real-world human demonstrations, then used to teach a Sawyer arm how to perform the task in simulation.
+
+Our contributions are as follows: (i) We introduce Cross-embodiment Inverse Reinforcement Learning (XIRL), an effective, label-free framework for tackling cross-embodiment visual imitation learning. Our core contribution is to use self-supervised learning on third-person demonstration videos to define dense reward functions amenable for downstream reinforcement learning policies, (ii) Along with XIRL, we release a cross-embodiment imitation learning benchmark, X-MAGICAL, which features multiple simulated agents with different embodiments performing the same manipulation task, including one thousand expert demonstrations for each agent, (iii) We show that XIRL significantly outperforms alternative methods on both the X-MAGICAL benchmark and the human-to-robot transfer benchmark from [6], and discuss our observations, which point to interesting areas for future research, (iv) Finally, we introduce a real-world dataset, X-REAL (Cross-embodiment Real demonstrations), of a manipulation task performed with nine different embodiments, which can be used to evaluate cross-embodiment reward learning methods2.
+
+# 2 Related Work
+
+Traditional formulations of imitation learning [8, 1, 9] assume access to a corpus of expert demonstration data which includes both state and action trajectories of the expert policy. In the context of third-person imitation learning, including when learning from expert agents with different embodiments, obtaining access to ground-truth actions is difficult or impossible3.
+
+Inferring expert actions. To address this issue, several approaches either try to infer expert actions [10, 11, 12] – for example by training an inverse dynamics model on agent interaction data [10] – or employ forward prediction on the next state to imitate the expert without direct action supervision [13]. While these methods successfully address learning from observation-only demonstrations, they either do not support skill transfer to different policy embodiments at all, or they cannot take advantage of multiple embodiments in order to improve generalization to unseen policy configurations. We explicitly address these problems in this work.
+
+Imitation via learned reward functions. In contrast to imitation via supervised methods, such as BCO [10], a recent body of work [4, 5, 14, 6, 15] has focused on learning reward functions from expert video data and then training RL policies to maximize this reward. In [4], the authors combine ImageNet pre-trained visual features with an L2-norm distance reward to match policy and expert observations in a latent feature space. In their follow-up work [5], the reward is computed in a viewpoint-invariant representation that is self-supervised on video data. While both these methods are compelling in their use of cheap unlabeled data to learn invariant rewards, the use of a time index as a heuristic for defining weak correspondence is a constraining limitation for tasks that need to be executed at different speeds, or are not strictly monotonic (e.g., have ambiguous sub-task ordering). In [14] a dense reward is learned via unsupervised learning on YouTube data and the authors make no assumption about time alignment. However, in their work, the expert and learned policy are executed in the same domain and embodiment, an assumption we relax in our work. Framed in a multi-task learning setting, [16] propose training policies with morphologically different embodiments first on a similar set of proxy tasks, in order to learn a latent space to map between domains, and then sharing skills on a held-out task from one policy to another. A time-index heuristic is used to define a metric reward when performing RL training of the new task. In our work, the learned embedding finds correspondences in a fully-unsupervised fashion, without the need for such strict time alignment. In [17], a small sub-set of states is human labeled for goal success and a convolutional network is then trained to detect successful task completion from image observations, where on-policy samples are used as negatives for the classifier. By contrast, our learned embedding encodes task progress in its latent representation without the use of expensive human labels.
+
+Imitation via domain adaptation. An additional category of approaches to third-person imitation learning are those that perform domain adaptation of expert observations [18, 19, 20, 21]. For instance, in [18] a CycleGAN [22] architecture is used to perform pixel-level image-to-image translation between policy domains, which is then used to construct a reward function for a model-based RL algorithm. A similar model-free approach is proposed in [19]. In [20], a generative model is used to predict robot high-level sub-goals conditioned on a third-person demonstration video, and a lower-level control policy is trained in a task-agnostic manner. Similarly, [21] uses high level task conditioning from zero-shot transfer of expert demonstrations, but they use KL matching to perform both high and low-level imitation. In contrast to these methods, the unsupervised TCC alignment in this work avoids performing explicit domain adaptation or pixel-level image translation by instead learning a robust and invariant feature space in a fully offline fashion.
+
+Reinforcement learning with demonstrations. Recent work in offline-reinforcement learning [6] explicitly tackles the problem of policy embodiment and domain shift. Their method, Reinforcement Learning from Videos (RLV), uses a labelled collection of expert-policy state pairs in conjunction with adversarial training to learn an inverse dynamics model jointly optimized with the policy. In contrast, we avoid the limitation of collecting human-labeled dense state correspondences by using a self-supervised algorithm (i.e., TCC [7]) which uses cycle-consistency to automatically learn the correspondence between states of two domains. We also show that this formulation improves generalization to unseen embodiments. Since the problem setup is similar to ours, we also compare to their method as a baseline.
+
+# 3 Approach
+
+Our overall XIRL framework (Figure 1) addresses the cross-embodiment visual imitation problem (Section 3.1). The framework consists of first using TCC to self-supervise embodiment-invariant visual representations (Section 3.2), then using a novel embodiment-invariant visual reward function (Section 3.3) to perform cross-embodiment visual imitation via reinforcement learning (Section 3.4).
+
+# 3.1 Problem Formulation
+
+Our objective is to extract an agent-invariant definition of a task, via a learned reward function, from a dataset of videos of separate agents performing the same task. In particular, we are interested in agents that may solve the task in entirely different ways due to differences in their end-effector, shapes, dynamics, etc., which we refer to as embodiment differences. For example, consider how differently a vacuum gripper and a parallel-jaw gripper will grasp an object as a result of their respective end-effectors. Such a setup is quite common in robotic imitation learning, where we might have access to observation data of humans demonstrating a task, but want to teach a robot to perform it. It is very likely that the way the human executes the task will diverge from how the robot would execute it.
+
+We define a dataset of multiple agents performing the same task $T$ as $\textstyle D = \bigcup _ { i = 1 } ^ { n } D _ { i }$ , where $D _ { i }$ is an agent-specific dataset containing observations of only agent $i$ performing task $T$ . Each agent’s dataset $D _ { i }$ is a collection of videos defined as ${ { D } _ { i } } = \{ v _ { i } ^ { 1 } , v _ { i } ^ { 2 } . . . v _ { i } ^ { K } \}$ , where $v _ { i } ^ { j }$ represents the video of the $j ^ { t h }$ demonstration of agent $i$ successfully performing the task $T$ . We would like to highlight that $D$ only contains observation data, i.e., it does not store the actions taken by the respective agents. We use self-supervised representation learning techniques to learn task-specific representations from this dataset.
+
+![](images/d83a8d2ebcb5bc6f49888dea08e985c5543dca5689bfd625916e473bff58dfa5.jpg)  
+Figure 2. Difference in state distributions of the across different embodiments performing the same task in X-MAGICAL (Section 4.1).
+
+# 3.2 Representation Learning
+
+In this work, we use TCC [7] to learn task-specific representations in a self-supervised way. The method has been shown to learn useful representations on videos of the same action for temporally fine-grained downstream tasks. In their paper, the authors show that TCC representations can predict frame-level task progress, such as predicting how much water is in a cup during pouring, without requiring any human annotations. Task progress can provide dense signals for learning a new task and we would like to bake this property into our learned reward. Another advantage of TCC is that it does not require supervision for frame-level alignment (i.e., which frames in two videos correspond to each other). Such frame-to-frame correspondences are required by a prior method, RLV [6], to achieve successful reinforcement learning on the considered tasks, but we would like to avoid this type of manual supervision.
+
+We train an image encoder $\phi$ , that ingests an image $I$ and returns an embedding vector $\phi ( I )$ , using TCC. TCC assumes that there exist semantic temporal correspondences between two video sequences, even though they are not labeled and the actions may be executed at different speeds. Note that in our case, the assumption holds since all sequences in our dataset originate from the same task. Furthermore, even if two different agents accomplish the task very differently, there will be a common set of states or frames that will temporally correspond. When we apply the TCC loss, we compare frames of one agent performing the task with frames from another, and search for temporal similarities in how both execute the task. By performing multiple such comparisons and cycling-back (described in the next paragraph), TCC encodes task progress in its latent representation, a property that is useful for learning task-specific, yet embodiment-invariant reward functions. For completeness, we describe the training technique below.
+
+We define a dataset $D _ { \mathrm { a l l } } = \{ v _ { 1 } , v _ { 2 } . . . v _ { N } \}$ that contains the videos of all agents executing the same task $T$ . We are able to merge the datasets of different agents since TCC does not require embodiment labels (i.e., IDs) during training. We first sample a random batch of videos and embed all their frames using the aforementioned image encoder $\phi$ . For each video $v _ { i }$ , this results in a sequence of embeddings $V _ { i } { = } \{ \phi ( v _ { i } ^ { 1 } ) , \phi ( v _ { i } ^ { 2 } ) { \ldots } , \phi ( v _ { i } ^ { L _ { i } } ) \}$ , where $L _ { i }$ is the length of the $i ^ { t h }$ video. From this mini-batch of sequences of video frame embeddings, we choose a pair of sequences $V _ { i }$ and $V _ { j }$ and compute their TCC loss. In particular, we randomly sample a frame embedding from sequence $V _ { i } -$ say $V _ { i } ^ { t }$ corresponding to the $t ^ { t h }$ frame of video $v _ { i }$ – and compute the soft nearest-neighbor of $V _ { i } ^ { t }$ in sequence $V _ { j }$ in the embedding space as follows:
+
+$$
+\widetilde { V _ { i j } ^ { t } } = \sum _ { k } ^ { L _ { j } } \alpha _ { k } V _ { j } ^ { k } , \quad \mathrm { w h e r e } \quad \alpha _ { k } = \frac { e ^ { - \| V _ { i } ^ { t } - V _ { j } ^ { k } \| ^ { 2 } } } { \sum _ { k } ^ { L _ { j } } e ^ { - \| V _ { i } ^ { t } - V _ { j } ^ { k } \| ^ { 2 } } }
+$$
+
+We then cycle-back [7] to the first sequence $V _ { i }$ by computing the soft-nearest neighbor of $\widetilde { V _ { i j } ^ { t } }$ with all the frames in $V _ { i }$ . The probability of cycling-back to the $k ^ { t h }$ frame in $V _ { i }$ can be computed as:
+
+$$
+\beta _ { i j t } ^ { k } = \frac { e ^ { - \| \widetilde { V _ { i j } ^ { t } } - V _ { i } ^ { k } \| ^ { 2 } } } { \sum _ { k } ^ { L _ { i } } e ^ { - \| \widetilde { V _ { i j } ^ { t } } - V _ { i } ^ { k } \| ^ { 2 } } }
+$$
+
+The expected frame index we cycle-back to is then $\begin{array} { r } { \mu _ { i j } ^ { t } = \sum _ { k } ^ { L _ { i } } \beta _ { i j t } ^ { k } k } \end{array}$ . Since we know the index of the frame that started the cycle, in this case $t$ , we can minimize the mean-squared (MSE) error loss between $t$ and the closest index retrieved via soft-nearest neighbor, i.e., $\widetilde { V _ { i j } ^ { t } }$ . The loss for a single frame is thus: $L _ { i j } ^ { t } = ( \mu _ { i j } ^ { t } - t ) ^ { 2 }$ . Finally, we minimize the average loss $L$ over all frames in video $v _ { i }$ with all other videos in the dataset $v _ { j }$ , defined as $\begin{array} { r } { L = \sum _ { i j t } L _ { i j } ^ { t } } \end{array}$ .
+
+Table 1. Statistics of Demos of the X-MAGICAL Embodiments   
+
+<table><tr><td>Embodiment</td><td>Mean ± Std.Dev. Demo Length (no. of frames)</td></tr><tr><td>Long-stick</td><td>48.0 ±28.5</td></tr><tr><td>Medium-stick</td><td>59.9 ±27.9</td></tr><tr><td>Short-stick</td><td>81.7 ±35.0</td></tr><tr><td>Gripper</td><td>110.8 ±39.8</td></tr></table>
+
+# 3.3 Reward Function
+
+Once the encoder $\phi$ has been trained on demonstrations of different agents performing the same task $T$ , we want to use it to transfer information about the task from one agent to another. We do this by leveraging $\phi$ to generate rewards via distances to goal observations in the learned embedding space. Specifically, we define the goal embedding $g$ as the mean embedding of the last frame of all the demonstration videos in our offline dataset $D _ { \mathrm { a l l } }$ . Concretely, $\scriptstyle g = \sum _ { i = 1 } ^ { N } \phi ( v _ { i } ^ { L _ { i } } ) \neq N$ , where $L _ { i }$ is the length of video $v _ { i }$ . Our reward $r$ then is the scaled negative distance of the current state embedding to the goal embedding $g$ i.e., $r ( s ) =$ $- 1 / \kappa \cdot \| \phi ( s ) - g \| _ { 2 } ^ { 2 }$ , where $\phi ( s )$ is the state embedding at the current timestep and $\kappa$ is a scale parameter that ensures the distances are in a range amenable for training reinforcement learning algorithms [23]. We found it effective to set $\kappa$ to be the average distance of the first frame’s embedding to the goal embedding for all the demonstrations in the dataset. Defining $r$ in this manner gives us several advantages: (a) it is dense, encoding both task completion and task progress, (b) it does not require any correspondence with a reference trajectory [5, 14] and (c) it sidesteps the need for a finite library of reference trajectories, unlike prior work [5, 16] that define time-indexed rewards relative to some reference trajectory. Thus, agents with trajectories of varying lengths (due to embodiment-specific constraints) can efficiently leverage this reward because the learned encoder can map different strategies to a common notion of task progress.
+
+# 3.4 Reinforcement Learning
+
+Using the pre-trained frozen encoder $\phi$ , we define a Markov Decision Process (MDP) for any agent as the tuple $\langle \bar { \boldsymbol { S } } , \boldsymbol { A } , \boldsymbol { P } , \boldsymbol { r } \rangle$ where $s$ is the set of possible states, $\mathcal { A }$ is the set of possible actions, $P$ is the state transition probability matrix encoding the dynamics of the environment (including the agent) and $r$ is the learned reward function (defined in Section 3.3). Notice how we are able to use the same reward function $r$ for any agent – even ones that the encoder may not have seen during training. Furthermore, this reward function solely depends on the learned encoder. Hence, the task represented by the MDP now depends solely on how well the encoder has learned task-specific representations since we do not use the environment reward to either define the task or learn the policy. This is an important distinction because we are expecting the encoder to generalize to new states that an agent might encounter during training, as the expert demonstrations in our dataset only contain successful trajectories. It is also possible to augment sparse rewards (which only define task success or failure) with our learned dense reward while training policies.
+
+# 4 Experimental Setup
+
+# 4.1 X-MAGICAL Benchmark
+
+We introduce a cross-embodiment imitation learning benchmark, X-MAGICAL, which is based on the imitation learning benchmark MAGICAL [24], implemented on top of the physics engine PyMunk [25]. In this work, we consider a simplified 2D equivalent of a common household robotic sweeping task, wherein an agent has to push three objects into a predefined zone in the environment (colored in pink). We choose this task specifically because its long-horizon nature highlights how different agent embodiments can generate entirely different trajectories. The reward in this environment is defined as the fraction of debris swept into the zone at the end of the episode.
+
+Multiple Embodiments in X-MAGICAL. We create multiple embodiments by designing agents with different shapes and end-effectors that induce variations in how each agent solves a task. In Figure 1, we show three of these embodiments and some sample trajectories that solve the sweeping task. Please see Appendix B for a detailed description of the benchmark. Three agents are shaped like a stick and they differ only in length. We call them short-stick, medium-stick and long-stick based on the length of their body. The agent in the last row is called gripper: it is circular in shape and has two arms that can actuate. All agents are capable of two actions - a rotation around their axis and a translation in a forward/backward direction along this axis (similar to the agent in the MAGICAL benchmark). All agents have a two-dimensional action space and use force and torque control to change their position and orientation respectively. The gripper agent has an additional degree of freedom for opening or closing its fingers. The default state of the gripper’s fingers is open. For all agents, the state representation is a 16-dimensional vector with the following information: $( { \bar { x } } , y )$ position of the agent, $( \cos \bar { \theta } , \sin \theta _ { . } ^ { \cdot }$ ) where $\theta$ is the agent’s 2D orientation, and for each of the three debris: its $( x , y )$ position, its distance to the agent and its distance to the goal zone. We frame-stack [26] three consecutive state vectors to encode temporal and velocity information, resulting in a final state dimension of 48.
+
+Demonstrations and Different Embodiment Strategies in X-MAGICAL. To learn task-specific representations for this task, we collect 1000 demonstrations per agent, where each demonstration consists in sweeping all three debris, initialized with random positions, into the target zone. This is the dataset $D _ { \mathrm { a l l } }$ (described in Section 3.1) containing observation-only agent-specific demonstrations. In Figure 2, we highlight the differences that exist between the trajectories taken by these agents. Figure 2a shows a heat map of the frequency of visits (state visitation count) of each agent at every 2D position in the grid, across all demonstrations in the dataset. We plot the 2D projection of the state visitation count onto the $X Y$ plane with a bin width of 0.1. Yellow encodes higher state visitation whereas blue encodes lower state visitation. We observe that agent long-stick has less coverage of the environment as opposed to agent gripper, which has significantly more coverage. Similarly, we show the distribution of debris locations for all agents across all demonstrations in Figure 2b. In Figure 2c, we plot a randomly sampled trajectory from each agent’s demonstration pool. We use transparency to encode the start (lighter) and end (darker) of the trajectory. It is clear from this figure that each agent solves the task in a different manner. Additionally, there is a significant difference in the time taken by each agent to execute this task, as shown in Table 1. Agent long-stick is able to finish the task the quickest because of its long shape that can sweep all the debris at once, while agents short-stick and gripper take longer because they have to frequently push or grasp one debris at a time. These differences are the types of challenges that a representation must overcome to successfully generalize across embodiments. As such, X-MAGICAL serves to create a highly simplified version of a real-world scenario where we might want to learn new tasks from an observation dataset of humans performing these tasks in highly diverse ways.
+
+# 4.2 Baselines
+
+Here, we describe the alternative reward functions we baseline our method against, color coded to match their appearance in Figs. 3, 4, and 5. 1) ImageNet: We use an ImageNet pre-trained ResNet-18 encoder with no additional self-supervised training, i.e., we load the pre-trained weights, discard the classification head, and use the 512-dimensional embedding space from the previous layer. 2) Goal classifier: We follow [27] and train a goal frame classifier on a binary classification task where the last frame of all the demonstrations is considered positive and all the others are considered negatives. We use the output probabilities of the classifier as the reward function. 3) LIFS: We implement the method from [16] which learns a feature space that is invariant to different embodiments using a contrastive loss function paired with an autoencoding loss. 4) TCN: single-view Time-Contrastive Network (TCN) [5] with positive and negative frame windows of 1 and 4 respectively. For more details regarding baseline implementations, see Appendix D.1.1.
+
+# 4.3 Implementation Details
+
+Our encoder for all experiments and methods is a ResNet-18 [28] initialized with ImageNet pre-trained weights. We replace the classification head with an embedding layer outputting a 32-dimensional vector. The encoder is trained on images of resolution $2 2 4 \times 2 2 4$ with ADAM [29] and a learning rate of $1 0 ^ { - 5 }$ Note that our learned reward is agnostic to the RL algorithm used – in this work, we opt for Soft-Actor Critic (SAC) [30], which is a reinforcement learning algorithm that has been successfully used to train policies for continuous control tasks [31]. Once the TCC encoder is trained, we use it to embed the observation frames as the agent interacts with the environment.
+
+# 5 Experiments
+
+We execute a series of experiments to evaluate whether the learned reward functions are effective at visual imitation. Specifically, our experiments seek to answer the following questions: first (Section 5.1), in the same-embodiment case, where the demonstration dataset $D$ contains the embodiment of the learning agent, does our method enable successful reinforcement learning for that agent? Next (Section 5.2), we investigate our primary interest, the cross-embodiment case, where the demonstration dataset $D$ does not contain the embodiment of the learning agent. To additionally test our approach using real-world data (Section 5.3), we use the dataset from [6] to leverage real-world human demonstrations to learn policies in simulation. Note that each embodiment’s performance is evaluated over 50 episodes and all figures plot the mean performance over 5 random seeds, with a standard deviation shading of $\pm 0 . 5$ . Videos of our results are in the supplementary video.
+
+![](images/43e882c2e5c9ae9bc4a4cb89eead1e6c094266389993350975196c84fc86b2ae.jpg)
+
+![](images/aad585723541b372d579fefbbb51f0a4e09326d6305a358a51fe8ad3884e021e.jpg)  
+Figure 3. Same-embodiment setting: Comparison of XIRL with other baseline reward functions, using SAC [30] for RL policy learning on the X-MAGICAL sweeping task.   
+Figure 4. Cross-embodiment setting: XIRL performs favorably when compared with other baseline reward functions, trained on observation-only demonstrations from different embodiments. Each agent{long-stick, medium-stick, short-stick, gripper} is shown using demonstrations from the other 3 embodiments, with SAC [30] for RL policy learning on the X-MAGICAL sweeping task.
+
+# 5.1 Results on Learning from Same-Embodiment Demonstrations
+
+In this experiment, we want to validate whether our approach of using a reward function trained with TCC is good enough to train agents to perform the task defined in a dataset of expert demonstrations. Note that the learned reward function has to be robust enough such that it can provide a useful signal for new states an agent might encounter while learning a policy and interacting with the environment. In Figure 3, we compare our method XIRL with baselines described in Section 4.2. We find XIRL is more sample-efficient than the other learned reward baselines. We attribute this sample efficiency to the fact that the TCC embeddings encode task progress which helps the agent learn to reach for objects and goal zones while interacting with the environment, rather than exploring in a purely random manner. This experiment provides evidence that XIRL’s reward function is suitable for downstream reinforcement learning.
+
+# 5.2 Results on Learning from Cross-Embodiment Demonstrations
+
+After verifying that XIRL works on the embodiments it was trained with, we move to the experiments that answer the core question in our work: can XIRL generalize to unseen embodiments? In this section we conduct experiments where the reward function is learned using embodiments that are different from the ones on which the policy is trained. As noted in Table 1, the timescales with which the agents execute the task can vary significantly. We conduct four experiments, each one corresponding to holding-out one agent from the expert demonstration set. In each such experiment, we train an encoder on demonstrations from the remaining three agents. We compare with reward functions learned using TCN, LIFS, and goal frame classifiers. While both TCC and TCN are contrastive losses, the former makes explicit comparisons across different embodiments, whereas the latter implicitly relies on an encoder shared across embodiments to learn the cross-embodiment representation. In Figure 4, we show that XIRL generalizes to new agents significantly better than the other learned reward baselines.
+
+# 5.3 Results on Learning from Real-World Cross-Embodiment Demonstrations
+
+In this experiment, we test how well we can learn rewards from more challenging real-world human demonstration videos. To do so, we use the dataset and State Pusher environment introduced in [6]. We train two XIRL encoders: XIRL (sim only) trained on 5 teleoperated simulated trajectories (i.e., no domain shift) and XIRL (real only) trained solely on the real-world human demonstrations without using any form of human labeling of paired frames. We compare our results to training the policy on the sparse reward from the environment and the RLV method presented in [6]. As demonstrated in Figure 5, we find our approach can improve the sample-efficiency of learning in the environment, compared to using RLV or solely the environment reward.
+
+# 5.4 Qualitative comparison between learned reward functions vs. handcrafted rewards
+
+In Figures 6 and 7, we visualize and compare the XIRL reward function with the environment’s reward (ground truth) for the Sweeping task from X-MAGICAL (see Sec. 4.1 for details) and the State Pusher and Drawer Opening tasks from $[ 6 ] ^ { 4 }$ . We find that the learned reward is highly correlated with the ground truth reward from the environment for both successful demos (first column in Figures 6 and 7) and unsuccessful demos (second column in Figures 6 and 7). It is especially encouraging to see that in a sparser reward environment like the Drawer Opening task, XIRL provides a dense signal that should allow the agent to learn the task more efficiently. Additionally, we can see that in the example of the failed collision trajectory (i.e., second row third column in Fig. 7), where the arm collides with the drawer rather than opening it, XIRL is able to provide it with a partial reward (i.e., for correctly moving towards the drawer) as opposed to the environment reward which remains zero.
+
+![](images/336f6e56fadde7992fbb34f9016b8184166d06e85e5dd38fc2086c18cc15eab3.jpg)  
+Figure 5. Real-world-demo cross-embodiment setting: Comparison of XIRL with baselines using the simulated State Pusher environment from [6]. XIRL (real only) leverages real-world demonstration videos of humans (left, row 2) to teach a robot arm in sim (left, row 1), but unlike [6], we do not use human-labeled data of paired frame correspondences. $\mathrm { R L V ^ { \ast } }$ denotes results taken verbatim from [6] which uses a different implementation of SAC for RL policy learning.
+
+![](images/7dc35f5c98241570164e1208386c3d21140466f479c4540f2cf56d7b06bd8fa5.jpg)
+
+![](images/af497430173dbd9d9ebdd0f01e8662f043721632071535ec3723b518aa43e7bc.jpg)  
+Figure 6. X-MAGICAL demo cross-embodiment setting: Visualizing our learned reward function XIRL vs. the environment’s sparse reward on a successful and unsuccessful demonstration, for the short-stick agent on the X-MAGICAL sweeping task. The learned reward was trained on the three other agents.   
+Figure 7. Real-world-demo cross-embodiment setting: Visualizing our learned XIRL reward function vs. the environment’s sparse reward on the State Pusher (top) and Drawer Opening (bottom) tasks from [6].
+
+# 6 Conclusion
+
+This paper presents XIRL, a framework for learning vision-based reward functions from videos of expert demonstrators exhibiting different embodiments. XIRL uses TCC to self-supervise a deep visual encoder from videos, and uses this encoder to generate rewards via simple distances to goal observations in the embedding space. XIRL enables unseen agents with new embodiments to learn the demonstrated tasks via IRL. Reward functions from XIRL are fully self-supervised from videos, and we can successfully learn tasks without requiring manually paired video frames [6] between the demonstrator and learner. In this sense, our method presents favorable scalability to an arbitrary number of embodiments or experts with varying skill levels. Experiments show that policies learned via XIRL are more sample efficient than multiple baseline alternatives, including TCN [5], LIFS [16], and RLV [6]. While our experiments demonstrate promising results for learning policies in simulated environments using rewards learned from both simulated and real-world videos, we have yet to show policy learning on a real robot, which we look forward to trying post-COVID.
+
+# Acknowledgments
+
+We would like to thank Alex Nichol, Nick Hynes, Sean Kirmani, Brent Yi and Jimmy Wu for fruitful technical discussions, Sam Toyer for invaluable help with setting up the simulated benchmark, and Karl Schmeckpeper for discussions and help related to RLV.
+
+# References
+
+[1] B. D. Argall, S. Chernova, M. Veloso, and B. Browning. A survey of robot learning from demonstration. Robotics and autonomous systems, 57(5), 2009. 1, 2, 11   
+[2] T. Zhang, Z. McCarthy, O. Jow, D. Lee, X. Chen, K. Goldberg, and P. Abbeel. Deep imitation learning for complex manipulation tasks from virtual reality teleoperation. In ICRA. IEEE, 2018. 1   
+[3] P. Florence, L. Manuelli, and R. Tedrake. Self-supervised correspondence in visuomotor policy learning. IEEE RAL, 5(2), 2019. 1   
+[4] P. Sermanet, K. Xu, and S. Levine. Unsupervised perceptual rewards for imitation learning. arXiv preprint arXiv:1612.06699, 2016. 1, 2, 11   
+[5] P. Sermanet, C. Lynch, Y. Chebotar, J. Hsu, E. Jang, S. Schaal, and S. Levine. Time-contrastive networks: Self-supervised learning from video. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pages 1134–1141. IEEE, 2018. 1, 2, 3, 5, 6, 8, 11, 16   
+[6] K. Schmeckpeper, O. Rybkin, K. Daniilidis, S. Levine, and C. Finn. Reinforcement learning with videos: Combining offline observations with interaction, 2020. 1, 2, 3, 4, 6, 7, 8, 11, 20   
+[7] D. Dwibedi, Y. Aytar, J. Tompson, P. Sermanet, and A. Zisserman. Temporal cycle-consistency learning. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019. 2, 3, 4, 12, 16   
+[8] C. Atkeson and S. Schaal. Robot learning from demonstration. In ICML, 1997. 2, 11   
+[9] T. Osa, J. Pajarinen, G. Neumann, J. Bagnell, P. Abbeel, and J. Peters. An algorithmic perspective on imitation learning. Found. Trends Robotics, 7:1–179, 2018. 2, 11   
+[10] F. Torabi, G. Warnell, and P. Stone. Behavioral cloning from observation. In IJCAI, 2018. 2, 11   
+[11] A. D. Edwards, H. Sahni, Y. Schroecker, and C. L. Isbell. Imitating latent policies from observation. arXiv preprint arXiv:1805.07914, 2018. 2, 11   
+[12] I. Radosavovic, X. Wang, L. Pinto, and J. Malik. State-only imitation learning for dexterous manipulation. arXiv preprint arXiv:2004.04650, 2020. 2, 11   
+[13] D. Pathak, P. Mahmoudieh, G. Luo, P. Agrawal, D. Chen, Y. Shentu, E. Shelhamer, J. Malik, A. A. Efros, and T. Darrell. Zero-shot visual imitation. In Proceedings of the IEEE conference on computer vision and pattern recognition workshops, pages 2050–2053, 2018. 2, 11   
+[14] Y. Aytar, T. Pfaff, D. Budden, T. Paine, Z. Wang, and N. de Freitas. Playing hard exploration games by watching youtube. In Advances in Neural Information Processing Systems, pages 2930–2941, 2018. 2, 3, 5, 11   
+[15] O. Mees, M. Merklinger, G. Kalweit, and W. Burgard. Adversarial skill networks: Unsupervised robot skill learning from video. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 4188–4194. IEEE, 2020. 2, 11   
+[16] A. Gupta, C. Devin, Y. Liu, P. Abbeel, and S. Levine. Learning invariant feature spaces to transfer skills with reinforcement learning, 2017. 3, 5, 6, 8, 11, 16   
+[17] A. Singh, L. Yang, K. Hartikainen, C. Finn, and S. Levine. End-to-end robotic reinforcement learning without reward engineering. arXiv preprint arXiv:1904.07854, 2019. 3, 11   
+[18] L. Smith, N. Dhawan, M. Zhang, P. Abbeel, and S. Levine. Avid: Learning multi-stage tasks via pixel-level translation of human videos. arXiv preprint arXiv:1912.04443, 2019. 3, 11   
+[19] Y. Liu, A. Gupta, P. Abbeel, and S. Levine. Imitation from observation: Learning to imitate behaviors from raw video via context translation. In ICRA. IEEE, 2018. 3, 11   
+[20] P. Sharma, D. Pathak, and A. Gupta. Third-person visual imitation learning via decoupled hierarchical controller. In Advances in Neural Information Processing Systems, pages 2597–2607, 2019. 3, 11   
+[21] D. Hejna, L. Pinto, and P. Abbeel. Hierarchically decoupled imitation for morphological transfer. In International Conference on Machine Learning, pages 4159–4171. PMLR, 2020. 3, 11   
+[22] J.-Y. Zhu, T. Park, P. Isola, and A. A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In ICCV, 2017. 3, 11   
+[23] P. Henderson, R. Islam, P. Bachman, J. Pineau, D. Precup, and D. Meger. Deep reinforcement learning that matters. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018. 5   
+[24] S. Toyer, R. Shah, A. Critch, and S. Russell. The magical benchmark for robust imitation. arXiv preprint arXiv:2011.00401, 2020. 5, 12   
+[25] V. Blomqvist. Pymunk: A easy-to-use pythonic rigid body 2d physics library (version 6.0.0), 2007. URL https://www.pymunk.org. 5   
+[26] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, et al. Human-level control through deep reinforcement learning. nature, 518(7540): 529–533, 2015. 6   
+[27] M. Vecerik, O. Sushkov, D. Barker, T. Rothorl, T. Hester, and J. Scholz. A practical approach to insertion with ¨ variable socket position using deep reinforcement learning. In 2019 International Conference on Robotics and Automation (ICRA), pages 754–760. IEEE, 2019. 6, 15, 16   
+[28] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2016. 6   
+[29] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint:1412.6980, 2014. 6   
+[30] T. Haarnoja, A. Zhou, P. Abbeel, and S. Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. arXiv preprint arXiv:1801.01290, 2018. 6, 7, 17   
+[31] T. Haarnoja, A. Zhou, K. Hartikainen, G. Tucker, S. Ha, J. Tan, V. Kumar, H. Zhu, A. Gupta, P. Abbeel, and S. Levine. Soft actor-critic algorithms and applications. arXiv preprint arXiv:1812.05905, 2018. 6   
+[32] C. Yang, X. Ma, W. Huang, F. Sun, H. Liu, J. Huang, and C. Gan. Imitation learning from observations by minimizing inverse dynamics disagreement. ArXiv, abs/1910.04417, 2019. 11   
+[33] L. Shao, T. Migimatsu, Q. Zhang, K. Yang, and J. Bohg. Concept2robot: Learning manipulation concepts from instructions and human demonstrations. Robotics: Science and Systems, 2020. 11   
+[34] G. Berseth and C. Pal. Visual imitation learning with recurrent siamese networks. ArXiv, abs/1901.07186, 2019. 11   
+[35] B. D. Ziebart, A. L. Maas, J. A. Bagnell, and A. K. Dey. Maximum entropy inverse reinforcement learning. In Aaai, volume 8, pages 1433–1438. Chicago, IL, USA, 2008. 11   
+[36] B. D. Ziebart, J. A. Bagnell, and A. K. Dey. Modeling interaction via the principle of maximum causal entropy. In ICML, 2010. 11   
+[37] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial networks. arXiv preprint arXiv:1406.2661, 2014. 11   
+[38] J. Ho and S. Ermon. Generative adversarial imitation learning. In NeurIPS, 2016. 11   
+[39] F. Torabi, G. Warnell, and P. Stone. Generative adversarial imitation from observation. arXiv preprint arXiv:1807.06158, 2018. 11   
+[40] B. C. Stadie, P. Abbeel, and I. Sutskever. Third-person imitation learning. arXiv:1703.01703, 2017. 11   
+[41] Y. Lu and J. Tompson. Adail: Adaptive adversarial imitation learning. NeurIPS Workshop on Learning Transferable Skills,, 2019. 11   
+[42] F. Liu, Z. Ling, T. Mu, and H. Su. State alignment-based imitation learning. arXiv preprint arXiv:1911.10947, 2019. 11   
+[43] W. Sun, A. Vemula, B. Boots, and J. Bagnell. Provably efficient imitation learning from observation alone. ArXiv, abs/1905.10948, 2019. 11   
+[44] K. Kim, Y. Gu, J. Song, S. Zhao, and S. Ermon. Domain adaptive imitation learning. arXiv, 2020. 11   
+[45] A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. Kopf, E. Yang, Z. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala. Pytorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems 32. Curran Associates, Inc., 2019. 14   
+[46] A. Buslaev, A. Parinov, E. Khvedchenya, V. Iglovikov, and A. A. Kalinin. Albumentations: fast and flexible image augmentations. arXiv e-prints, 2018. 16   
+[47] D. Yarats and I. Kostrikov. Soft actor-critic (sac) implementation in pytorch. https://github.com/ denisyarats/pytorch_sac, 2020. 17   
+[48] H. van Hasselt, A. Guez, and D. Silver. Deep reinforcement learning with double q-learning. arXiv e-prints, 2015. 17   
+[49] S. Fujimoto, H. van Hoof, and D. Meger. Addressing function approximation error in actor-critic methods. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018, 2018. 17   
+[50] A. M. Saxe, J. L. McClelland, and S. Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv e-prints, 2013. 17   
+[51] T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020. 17, 18

parse/train/RO4DM85Z4P7/RO4DM85Z4P7_content_list.json

@@ -0,0 +1,816 @@
+[
+    {
+        "type": "text",
+        "text": "XIRL: Cross-embodiment Inverse Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            202,
+            101,
+            797,
+            150
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kevin Zakka1,3⇤, Andy $\\mathbf { Z e n g } ^ { 2 }$ , Pete Florence2, Jonathan Tompson2, Jeannette $\\mathbf { B o h g } ^ { 1 }$ , and Debidatta Dwibedi2 1Stanford University, 2Robotics at Google, 3UC Berkeley ",
+        "bbox": [
+            281,
+            180,
+            717,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract: We investigate the visual cross-embodiment imitation setting, in which agents learn policies from videos of other agents (such as humans) demonstrating the same task, but with stark differences in their embodiments – shape, actions, end-effector dynamics, etc. In this work, we demonstrate that it is possible to automatically discover and learn vision-based reward functions from cross-embodiment demonstration videos that are robust to these differences. Specifically, we present a self-supervised method for Crossembodiment Inverse Reinforcement Learning (XIRL) that leverages temporal cycleconsistency constraints to learn deep visual embeddings that capture task progression from offline videos of demonstrations across multiple expert agents, each performing the same task differently due to embodiment differences. Prior to our work, producing rewards from self-supervised embeddings typically required alignment with a reference trajectory, which may be difficult to acquire under stark embodiment differences. We show empirically that if the embeddings are aware of task progress, simply taking the negative distance between the current state and goal state in the learned embedding space is useful as a reward for training policies with reinforcement learning. We find our learned reward function not only works for embodiments seen during training, but also generalizes to entirely new embodiments. Additionally, when transferring real-world human demonstrations to a simulated robot, we find that XIRL is more sample efficient than current best methods. Qualitative results, code, and datasets are available at https://x-irl.github.io ",
+        "bbox": [
+            233,
+            273,
+            766,
+            526
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Keywords: inverse reinforcement learning, imitation learning, self-supervised learning ",
+        "bbox": [
+            233,
+            540,
+            763,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            570,
+            305,
+            587
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The ability to learn new tasks from third-person demonstrations holds the potential to enable robots to leverage the vast quantities of tutorial videos that can be gleaned from the world-wide web (e.g., YouTube videos). However, distilling diverse and unstructured videos into motor skills with vision-based policies can be daunting – as the videos themselves are often not only captured from different camera viewpoints in different environments, but also with different experts that may use different tools, objects, or strategies to perform the same task. Perhaps most critically, there often exists a clear embodiment gap between the human expert demonstrator, and the robot hardware that executes the learned policies. One approach to close this gap is to learn a mapping between the human and robot embodiment [1], which is a non-trivial intermediate problem in itself. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite considerable progress in learning policies with paired observations and actions (e.g., collected via teleoperation) [2, 3], much less work has been done in getting robots to learn policies from tasks defined only by third-person observations of demonstrations [4, 5, 6]. This is a surprisingly challenging problem, as different embodiments are likely to use unique strategies that suit them and allow them to make progress on a given task. For example, if asked to “place five pens into a cup”, a human hand is likely to scoop up all pens before slipping them into the cup, whereas a two-fingered gripper might instead need to pick and place each pen individually. Both strategies complete the task, but generate different state-action trajectories. In this setting, it may be difficult to acquire labeled frame-to-frame correspondences between expert demonstration videos and learned embodiments [6], particularly across a multitude of embodiments or experts. The approach we investigate instead is whether we can successfully learn tasks through a learned notion of task progress that is invariant to the embodiment performing the task. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/80a7e6efe913971b206ca18932e755e85617cbe2190ac680c41ec9b31c2e8a60.jpg",
+        "image_caption": [
+            "Figure 1. Cross-embodiment Inverse Reinforcement Learning. We learn embodiment-invariant visual representations from offline video demonstrations (stick agents on the left) using TCC [7], then use the trained encoder to generate embodiment-invariant visual reward functions that can be used to learn policies on new embodiments (gripper on the right) with reinforcement learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            92,
+            821,
+            300
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose to enable agents to imitate video demonstrations of experts – including ones with different embodiments – by using a task-specific, embodiment-invariant reward formulation trained via temporal cycle-consistency (TCC) [7]. We demonstrate how we can leverage an encoder trained with TCC to define dense rewards for downstream reinforcement learning (RL) policies via simple distances in the learned embedding space. Simulated experiments across four different embodiments show that these learned rewards are capable of generalizing to new embodiments, enabling unseen agents to learn the task via reinforcement, and surprisingly in some cases, exceeding the sample efficiency of the same agent learned with ground truth sparse rewards. We also demonstrate the effectiveness of our approach for learning robot policies using human demonstrations on the State Pusher environment from [6], where our reward is first learned on real-world human demonstrations, then used to teach a Sawyer arm how to perform the task in simulation. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            477
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are as follows: (i) We introduce Cross-embodiment Inverse Reinforcement Learning (XIRL), an effective, label-free framework for tackling cross-embodiment visual imitation learning. Our core contribution is to use self-supervised learning on third-person demonstration videos to define dense reward functions amenable for downstream reinforcement learning policies, (ii) Along with XIRL, we release a cross-embodiment imitation learning benchmark, X-MAGICAL, which features multiple simulated agents with different embodiments performing the same manipulation task, including one thousand expert demonstrations for each agent, (iii) We show that XIRL significantly outperforms alternative methods on both the X-MAGICAL benchmark and the human-to-robot transfer benchmark from [6], and discuss our observations, which point to interesting areas for future research, (iv) Finally, we introduce a real-world dataset, X-REAL (Cross-embodiment Real demonstrations), of a manipulation task performed with nine different embodiments, which can be used to evaluate cross-embodiment reward learning methods2. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            631
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            641,
+            315,
+            657
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Traditional formulations of imitation learning [8, 1, 9] assume access to a corpus of expert demonstration data which includes both state and action trajectories of the expert policy. In the context of third-person imitation learning, including when learning from expert agents with different embodiments, obtaining access to ground-truth actions is difficult or impossible3. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Inferring expert actions. To address this issue, several approaches either try to infer expert actions [10, 11, 12] – for example by training an inverse dynamics model on agent interaction data [10] – or employ forward prediction on the next state to imitate the expert without direct action supervision [13]. While these methods successfully address learning from observation-only demonstrations, they either do not support skill transfer to different policy embodiments at all, or they cannot take advantage of multiple embodiments in order to improve generalization to unseen policy configurations. We explicitly address these problems in this work. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            809
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Imitation via learned reward functions. In contrast to imitation via supervised methods, such as BCO [10], a recent body of work [4, 5, 14, 6, 15] has focused on learning reward functions from expert video data and then training RL policies to maximize this reward. In [4], the authors combine ImageNet pre-trained visual features with an L2-norm distance reward to match policy and expert observations in a latent feature space. In their follow-up work [5], the reward is computed in a viewpoint-invariant representation that is self-supervised on video data. While both these methods are compelling in their use of cheap unlabeled data to learn invariant rewards, the use of a time index as a heuristic for defining weak correspondence is a constraining limitation for tasks that need to be executed at different speeds, or are not strictly monotonic (e.g., have ambiguous sub-task ordering). In [14] a dense reward is learned via unsupervised learning on YouTube data and the authors make no assumption about time alignment. However, in their work, the expert and learned policy are executed in the same domain and embodiment, an assumption we relax in our work. Framed in a multi-task learning setting, [16] propose training policies with morphologically different embodiments first on a similar set of proxy tasks, in order to learn a latent space to map between domains, and then sharing skills on a held-out task from one policy to another. A time-index heuristic is used to define a metric reward when performing RL training of the new task. In our work, the learned embedding finds correspondences in a fully-unsupervised fashion, without the need for such strict time alignment. In [17], a small sub-set of states is human labeled for goal success and a convolutional network is then trained to detect successful task completion from image observations, where on-policy samples are used as negatives for the classifier. By contrast, our learned embedding encodes task progress in its latent representation without the use of expensive human labels. ",
+        "bbox": [
+            174,
+            814,
+            823,
+            867
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Imitation via domain adaptation. An additional category of approaches to third-person imitation learning are those that perform domain adaptation of expert observations [18, 19, 20, 21]. For instance, in [18] a CycleGAN [22] architecture is used to perform pixel-level image-to-image translation between policy domains, which is then used to construct a reward function for a model-based RL algorithm. A similar model-free approach is proposed in [19]. In [20], a generative model is used to predict robot high-level sub-goals conditioned on a third-person demonstration video, and a lower-level control policy is trained in a task-agnostic manner. Similarly, [21] uses high level task conditioning from zero-shot transfer of expert demonstrations, but they use KL matching to perform both high and low-level imitation. In contrast to these methods, the unsupervised TCC alignment in this work avoids performing explicit domain adaptation or pixel-level image translation by instead learning a robust and invariant feature space in a fully offline fashion. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            443
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning with demonstrations. Recent work in offline-reinforcement learning [6] explicitly tackles the problem of policy embodiment and domain shift. Their method, Reinforcement Learning from Videos (RLV), uses a labelled collection of expert-policy state pairs in conjunction with adversarial training to learn an inverse dynamics model jointly optimized with the policy. In contrast, we avoid the limitation of collecting human-labeled dense state correspondences by using a self-supervised algorithm (i.e., TCC [7]) which uses cycle-consistency to automatically learn the correspondence between states of two domains. We also show that this formulation improves generalization to unseen embodiments. Since the problem setup is similar to ours, we also compare to their method as a baseline. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Approach ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            565,
+            284,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our overall XIRL framework (Figure 1) addresses the cross-embodiment visual imitation problem (Section 3.1). The framework consists of first using TCC to self-supervise embodiment-invariant visual representations (Section 3.2), then using a novel embodiment-invariant visual reward function (Section 3.3) to perform cross-embodiment visual imitation via reinforcement learning (Section 3.4). ",
+        "bbox": [
+            174,
+            592,
+            825,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Problem Formulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            652,
+            354,
+            666
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our objective is to extract an agent-invariant definition of a task, via a learned reward function, from a dataset of videos of separate agents performing the same task. In particular, we are interested in agents that may solve the task in entirely different ways due to differences in their end-effector, shapes, dynamics, etc., which we refer to as embodiment differences. For example, consider how differently a vacuum gripper and a parallel-jaw gripper will grasp an object as a result of their respective end-effectors. Such a setup is quite common in robotic imitation learning, where we might have access to observation data of humans demonstrating a task, but want to teach a robot to perform it. It is very likely that the way the human executes the task will diverge from how the robot would execute it. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            780
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define a dataset of multiple agents performing the same task $T$ as $\\textstyle D = \\bigcup _ { i = 1 } ^ { n } D _ { i }$ , where $D _ { i }$ is an agent-specific dataset containing observations of only agent $i$ performing task $T$ . Each agent’s dataset $D _ { i }$ is a collection of videos defined as ${ { D } _ { i } } = \\{ v _ { i } ^ { 1 } , v _ { i } ^ { 2 } . . . v _ { i } ^ { K } \\}$ , where $v _ { i } ^ { j }$ represents the video of the $j ^ { t h }$ demonstration of agent $i$ successfully performing the task $T$ . We would like to highlight that $D$ only contains observation data, i.e., it does not store the actions taken by the respective agents. We use self-supervised representation learning techniques to learn task-specific representations from this dataset. ",
+        "bbox": [
+            174,
+            785,
+            823,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d83a8d2ebcb5bc6f49888dea08e985c5543dca5689bfd625916e473bff58dfa5.jpg",
+        "image_caption": [
+            "Figure 2. Difference in state distributions of the across different embodiments performing the same task in X-MAGICAL (Section 4.1). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            87,
+            797,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Representation Learning ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            270,
+            379,
+            284
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work, we use TCC [7] to learn task-specific representations in a self-supervised way. The method has been shown to learn useful representations on videos of the same action for temporally fine-grained downstream tasks. In their paper, the authors show that TCC representations can predict frame-level task progress, such as predicting how much water is in a cup during pouring, without requiring any human annotations. Task progress can provide dense signals for learning a new task and we would like to bake this property into our learned reward. Another advantage of TCC is that it does not require supervision for frame-level alignment (i.e., which frames in two videos correspond to each other). Such frame-to-frame correspondences are required by a prior method, RLV [6], to achieve successful reinforcement learning on the considered tasks, but we would like to avoid this type of manual supervision. ",
+        "bbox": [
+            173,
+            290,
+            825,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We train an image encoder $\\phi$ , that ingests an image $I$ and returns an embedding vector $\\phi ( I )$ , using TCC. TCC assumes that there exist semantic temporal correspondences between two video sequences, even though they are not labeled and the actions may be executed at different speeds. Note that in our case, the assumption holds since all sequences in our dataset originate from the same task. Furthermore, even if two different agents accomplish the task very differently, there will be a common set of states or frames that will temporally correspond. When we apply the TCC loss, we compare frames of one agent performing the task with frames from another, and search for temporal similarities in how both execute the task. By performing multiple such comparisons and cycling-back (described in the next paragraph), TCC encodes task progress in its latent representation, a property that is useful for learning task-specific, yet embodiment-invariant reward functions. For completeness, we describe the training technique below. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            550
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We define a dataset $D _ { \\mathrm { a l l } } = \\{ v _ { 1 } , v _ { 2 } . . . v _ { N } \\}$ that contains the videos of all agents executing the same task $T$ . We are able to merge the datasets of different agents since TCC does not require embodiment labels (i.e., IDs) during training. We first sample a random batch of videos and embed all their frames using the aforementioned image encoder $\\phi$ . For each video $v _ { i }$ , this results in a sequence of embeddings $V _ { i } { = } \\{ \\phi ( v _ { i } ^ { 1 } ) , \\phi ( v _ { i } ^ { 2 } ) { \\ldots } , \\phi ( v _ { i } ^ { L _ { i } } ) \\}$ , where $L _ { i }$ is the length of the $i ^ { t h }$ video. From this mini-batch of sequences of video frame embeddings, we choose a pair of sequences $V _ { i }$ and $V _ { j }$ and compute their TCC loss. In particular, we randomly sample a frame embedding from sequence $V _ { i } -$ say $V _ { i } ^ { t }$ corresponding to the $t ^ { t h }$ frame of video $v _ { i }$ – and compute the soft nearest-neighbor of $V _ { i } ^ { t }$ in sequence $V _ { j }$ in the embedding space as follows: ",
+        "bbox": [
+            173,
+            555,
+            825,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1aa1ecc85f3ff03327a4b6dddcafdcba98280d3be0b009e0bbd148da1397a899.jpg",
+        "text": "$$\n\\widetilde { V _ { i j } ^ { t } } = \\sum _ { k } ^ { L _ { j } } \\alpha _ { k } V _ { j } ^ { k } , \\quad \\mathrm { w h e r e } \\quad \\alpha _ { k } = \\frac { e ^ { - \\| V _ { i } ^ { t } - V _ { j } ^ { k } \\| ^ { 2 } } } { \\sum _ { k } ^ { L _ { j } } e ^ { - \\| V _ { i } ^ { t } - V _ { j } ^ { k } \\| ^ { 2 } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            678,
+            661,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We then cycle-back [7] to the first sequence $V _ { i }$ by computing the soft-nearest neighbor of $\\widetilde { V _ { i j } ^ { t } }$ with all the frames in $V _ { i }$ . The probability of cycling-back to the $k ^ { t h }$ frame in $V _ { i }$ can be computed as: ",
+        "bbox": [
+            173,
+            733,
+            826,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5cf53c96374e1685f1e050502ffcece393d71ff448300d600ba1331a904ec29b.jpg",
+        "text": "$$\n\\beta _ { i j t } ^ { k } = \\frac { e ^ { - \\| \\widetilde { V _ { i j } ^ { t } } - V _ { i } ^ { k } \\| ^ { 2 } } } { \\sum _ { k } ^ { L _ { i } } e ^ { - \\| \\widetilde { V _ { i j } ^ { t } } - V _ { i } ^ { k } \\| ^ { 2 } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            773,
+            578,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The expected frame index we cycle-back to is then $\\begin{array} { r } { \\mu _ { i j } ^ { t } = \\sum _ { k } ^ { L _ { i } } \\beta _ { i j t } ^ { k } k } \\end{array}$ . Since we know the index of the frame that started the cycle, in this case $t$ , we can minimize the mean-squared (MSE) error loss between $t$ and the closest index retrieved via soft-nearest neighbor, i.e., $\\widetilde { V _ { i j } ^ { t } }$ . The loss for a single frame is thus: $L _ { i j } ^ { t } = ( \\mu _ { i j } ^ { t } - t ) ^ { 2 }$ . Finally, we minimize the average loss $L$ over all frames in video $v _ { i }$ with all other videos in the dataset $v _ { j }$ , defined as $\\begin{array} { r } { L = \\sum _ { i j t } L _ { i j } ^ { t } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            829,
+            825,
+            915
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/e8a8a00b088bfc240df0ba0bc685c6840d6d6dd62347522e1e34bdf89585ff9e.jpg",
+        "table_caption": [
+            "Table 1. Statistics of Demos of the X-MAGICAL Embodiments "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Embodiment</td><td>Mean ± Std.Dev. Demo Length (no. of frames)</td></tr><tr><td>Long-stick</td><td>48.0 ±28.5</td></tr><tr><td>Medium-stick</td><td>59.9 ±27.9</td></tr><tr><td>Short-stick</td><td>81.7 ±35.0</td></tr><tr><td>Gripper</td><td>110.8 ±39.8</td></tr></table>",
+        "bbox": [
+            339,
+            119,
+            653,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Reward Function ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            236,
+            328,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Once the encoder $\\phi$ has been trained on demonstrations of different agents performing the same task $T$ , we want to use it to transfer information about the task from one agent to another. We do this by leveraging $\\phi$ to generate rewards via distances to goal observations in the learned embedding space. Specifically, we define the goal embedding $g$ as the mean embedding of the last frame of all the demonstration videos in our offline dataset $D _ { \\mathrm { a l l } }$ . Concretely, $\\scriptstyle g = \\sum _ { i = 1 } ^ { N } \\phi ( v _ { i } ^ { L _ { i } } ) \\neq N$ , where $L _ { i }$ is the length of video $v _ { i }$ . Our reward $r$ then is the scaled negative distance of the current state embedding to the goal embedding $g$ i.e., $r ( s ) =$ $- 1 / \\kappa \\cdot \\| \\phi ( s ) - g \\| _ { 2 } ^ { 2 }$ , where $\\phi ( s )$ is the state embedding at the current timestep and $\\kappa$ is a scale parameter that ensures the distances are in a range amenable for training reinforcement learning algorithms [23]. We found it effective to set $\\kappa$ to be the average distance of the first frame’s embedding to the goal embedding for all the demonstrations in the dataset. Defining $r$ in this manner gives us several advantages: (a) it is dense, encoding both task completion and task progress, (b) it does not require any correspondence with a reference trajectory [5, 14] and (c) it sidesteps the need for a finite library of reference trajectories, unlike prior work [5, 16] that define time-indexed rewards relative to some reference trajectory. Thus, agents with trajectories of varying lengths (due to embodiment-specific constraints) can efficiently leverage this reward because the learned encoder can map different strategies to a common notion of task progress. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            460
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            467,
+            375,
+            482
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using the pre-trained frozen encoder $\\phi$ , we define a Markov Decision Process (MDP) for any agent as the tuple $\\langle \\bar { \\boldsymbol { S } } , \\boldsymbol { A } , \\boldsymbol { P } , \\boldsymbol { r } \\rangle$ where $s$ is the set of possible states, $\\mathcal { A }$ is the set of possible actions, $P$ is the state transition probability matrix encoding the dynamics of the environment (including the agent) and $r$ is the learned reward function (defined in Section 3.3). Notice how we are able to use the same reward function $r$ for any agent – even ones that the encoder may not have seen during training. Furthermore, this reward function solely depends on the learned encoder. Hence, the task represented by the MDP now depends solely on how well the encoder has learned task-specific representations since we do not use the environment reward to either define the task or learn the policy. This is an important distinction because we are expecting the encoder to generalize to new states that an agent might encounter during training, as the expert demonstrations in our dataset only contain successful trajectories. It is also possible to augment sparse rewards (which only define task success or failure) with our learned dense reward while training policies. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            635
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            645,
+            362,
+            662
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 X-MAGICAL Benchmark ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            670,
+            387,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We introduce a cross-embodiment imitation learning benchmark, X-MAGICAL, which is based on the imitation learning benchmark MAGICAL [24], implemented on top of the physics engine PyMunk [25]. In this work, we consider a simplified 2D equivalent of a common household robotic sweeping task, wherein an agent has to push three objects into a predefined zone in the environment (colored in pink). We choose this task specifically because its long-horizon nature highlights how different agent embodiments can generate entirely different trajectories. The reward in this environment is defined as the fraction of debris swept into the zone at the end of the episode. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Multiple Embodiments in X-MAGICAL. We create multiple embodiments by designing agents with different shapes and end-effectors that induce variations in how each agent solves a task. In Figure 1, we show three of these embodiments and some sample trajectories that solve the sweeping task. Please see Appendix B for a detailed description of the benchmark. Three agents are shaped like a stick and they differ only in length. We call them short-stick, medium-stick and long-stick based on the length of their body. The agent in the last row is called gripper: it is circular in shape and has two arms that can actuate. All agents are capable of two actions - a rotation around their axis and a translation in a forward/backward direction along this axis (similar to the agent in the MAGICAL benchmark). All agents have a two-dimensional action space and use force and torque control to change their position and orientation respectively. The gripper agent has an additional degree of freedom for opening or closing its fingers. The default state of the gripper’s fingers is open. For all agents, the state representation is a 16-dimensional vector with the following information: $( { \\bar { x } } , y )$ position of the agent, $( \\cos \\bar { \\theta } , \\sin \\theta _ { . } ^ { \\cdot }$ ) where $\\theta$ is the agent’s 2D orientation, and for each of the three debris: its $( x , y )$ position, its distance to the agent and its distance to the goal zone. We frame-stack [26] three consecutive state vectors to encode temporal and velocity information, resulting in a final state dimension of 48. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            171
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Demonstrations and Different Embodiment Strategies in X-MAGICAL. To learn task-specific representations for this task, we collect 1000 demonstrations per agent, where each demonstration consists in sweeping all three debris, initialized with random positions, into the target zone. This is the dataset $D _ { \\mathrm { a l l } }$ (described in Section 3.1) containing observation-only agent-specific demonstrations. In Figure 2, we highlight the differences that exist between the trajectories taken by these agents. Figure 2a shows a heat map of the frequency of visits (state visitation count) of each agent at every 2D position in the grid, across all demonstrations in the dataset. We plot the 2D projection of the state visitation count onto the $X Y$ plane with a bin width of 0.1. Yellow encodes higher state visitation whereas blue encodes lower state visitation. We observe that agent long-stick has less coverage of the environment as opposed to agent gripper, which has significantly more coverage. Similarly, we show the distribution of debris locations for all agents across all demonstrations in Figure 2b. In Figure 2c, we plot a randomly sampled trajectory from each agent’s demonstration pool. We use transparency to encode the start (lighter) and end (darker) of the trajectory. It is clear from this figure that each agent solves the task in a different manner. Additionally, there is a significant difference in the time taken by each agent to execute this task, as shown in Table 1. Agent long-stick is able to finish the task the quickest because of its long shape that can sweep all the debris at once, while agents short-stick and gripper take longer because they have to frequently push or grasp one debris at a time. These differences are the types of challenges that a representation must overcome to successfully generalize across embodiments. As such, X-MAGICAL serves to create a highly simplified version of a real-world scenario where we might want to learn new tasks from an observation dataset of humans performing these tasks in highly diverse ways. ",
+        "bbox": [
+            174,
+            178,
+            825,
+            429
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Baselines ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            436,
+            272,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, we describe the alternative reward functions we baseline our method against, color coded to match their appearance in Figs. 3, 4, and 5. 1) ImageNet: We use an ImageNet pre-trained ResNet-18 encoder with no additional self-supervised training, i.e., we load the pre-trained weights, discard the classification head, and use the 512-dimensional embedding space from the previous layer. 2) Goal classifier: We follow [27] and train a goal frame classifier on a binary classification task where the last frame of all the demonstrations is considered positive and all the others are considered negatives. We use the output probabilities of the classifier as the reward function. 3) LIFS: We implement the method from [16] which learns a feature space that is invariant to different embodiments using a contrastive loss function paired with an autoencoding loss. 4) TCN: single-view Time-Contrastive Network (TCN) [5] with positive and negative frame windows of 1 and 4 respectively. For more details regarding baseline implementations, see Appendix D.1.1. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            598,
+            366,
+            613
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our encoder for all experiments and methods is a ResNet-18 [28] initialized with ImageNet pre-trained weights. We replace the classification head with an embedding layer outputting a 32-dimensional vector. The encoder is trained on images of resolution $2 2 4 \\times 2 2 4$ with ADAM [29] and a learning rate of $1 0 ^ { - 5 }$ Note that our learned reward is agnostic to the RL algorithm used – in this work, we opt for Soft-Actor Critic (SAC) [30], which is a reinforcement learning algorithm that has been successfully used to train policies for continuous control tasks [31]. Once the TCC encoder is trained, we use it to embed the observation frames as the agent interacts with the environment. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            723,
+            307,
+            739
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We execute a series of experiments to evaluate whether the learned reward functions are effective at visual imitation. Specifically, our experiments seek to answer the following questions: first (Section 5.1), in the same-embodiment case, where the demonstration dataset $D$ contains the embodiment of the learning agent, does our method enable successful reinforcement learning for that agent? Next (Section 5.2), we investigate our primary interest, the cross-embodiment case, where the demonstration dataset $D$ does not contain the embodiment of the learning agent. To additionally test our approach using real-world data (Section 5.3), we use the dataset from [6] to leverage real-world human demonstrations to learn policies in simulation. Note that each embodiment’s performance is evaluated over 50 episodes and all figures plot the mean performance over 5 random seeds, with a standard deviation shading of $\\pm 0 . 5$ . Videos of our results are in the supplementary video. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            881
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/43e882c2e5c9ae9bc4a4cb89eead1e6c094266389993350975196c84fc86b2ae.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            90,
+            821,
+            195
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/aad585723541b372d579fefbbb51f0a4e09326d6305a358a51fe8ad3884e021e.jpg",
+        "image_caption": [
+            "Figure 3. Same-embodiment setting: Comparison of XIRL with other baseline reward functions, using SAC [30] for RL policy learning on the X-MAGICAL sweeping task. ",
+            "Figure 4. Cross-embodiment setting: XIRL performs favorably when compared with other baseline reward functions, trained on observation-only demonstrations from different embodiments. Each agent{long-stick, medium-stick, short-stick, gripper} is shown using demonstrations from the other 3 embodiments, with SAC [30] for RL policy learning on the X-MAGICAL sweeping task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            224,
+            821,
+            329
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Results on Learning from Same-Embodiment Demonstrations ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            368,
+            622,
+            382
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we want to validate whether our approach of using a reward function trained with TCC is good enough to train agents to perform the task defined in a dataset of expert demonstrations. Note that the learned reward function has to be robust enough such that it can provide a useful signal for new states an agent might encounter while learning a policy and interacting with the environment. In Figure 3, we compare our method XIRL with baselines described in Section 4.2. We find XIRL is more sample-efficient than the other learned reward baselines. We attribute this sample efficiency to the fact that the TCC embeddings encode task progress which helps the agent learn to reach for objects and goal zones while interacting with the environment, rather than exploring in a purely random manner. This experiment provides evidence that XIRL’s reward function is suitable for downstream reinforcement learning. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            507
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 Results on Learning from Cross-Embodiment Demonstrations ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            515,
+            622,
+            530
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "After verifying that XIRL works on the embodiments it was trained with, we move to the experiments that answer the core question in our work: can XIRL generalize to unseen embodiments? In this section we conduct experiments where the reward function is learned using embodiments that are different from the ones on which the policy is trained. As noted in Table 1, the timescales with which the agents execute the task can vary significantly. We conduct four experiments, each one corresponding to holding-out one agent from the expert demonstration set. In each such experiment, we train an encoder on demonstrations from the remaining three agents. We compare with reward functions learned using TCN, LIFS, and goal frame classifiers. While both TCC and TCN are contrastive losses, the former makes explicit comparisons across different embodiments, whereas the latter implicitly relies on an encoder shared across embodiments to learn the cross-embodiment representation. In Figure 4, we show that XIRL generalizes to new agents significantly better than the other learned reward baselines. ",
+        "bbox": [
+            173,
+            536,
+            825,
+            683
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 Results on Learning from Real-World Cross-Embodiment Demonstrations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            689,
+            702,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we test how well we can learn rewards from more challenging real-world human demonstration videos. To do so, we use the dataset and State Pusher environment introduced in [6]. We train two XIRL encoders: XIRL (sim only) trained on 5 teleoperated simulated trajectories (i.e., no domain shift) and XIRL (real only) trained solely on the real-world human demonstrations without using any form of human labeling of paired frames. We compare our results to training the policy on the sparse reward from the environment and the RLV method presented in [6]. As demonstrated in Figure 5, we find our approach can improve the sample-efficiency of learning in the environment, compared to using RLV or solely the environment reward. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            818
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.4 Qualitative comparison between learned reward functions vs. handcrafted rewards ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            824,
+            759,
+            839
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Figures 6 and 7, we visualize and compare the XIRL reward function with the environment’s reward (ground truth) for the Sweeping task from X-MAGICAL (see Sec. 4.1 for details) and the State Pusher and Drawer Opening tasks from $[ 6 ] ^ { 4 }$ . We find that the learned reward is highly correlated with the ground truth reward from the environment for both successful demos (first column in Figures 6 and 7) and unsuccessful demos (second column in Figures 6 and 7). It is especially encouraging to see that in a sparser reward environment like the Drawer Opening task, XIRL provides a dense signal that should allow the agent to learn the task more efficiently. Additionally, we can see that in the example of the failed collision trajectory (i.e., second row third column in Fig. 7), where the arm collides with the drawer rather than opening it, XIRL is able to provide it with a partial reward (i.e., for correctly moving towards the drawer) as opposed to the environment reward which remains zero. ",
+        "bbox": [
+            174,
+            845,
+            823,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/336f6e56fadde7992fbb34f9016b8184166d06e85e5dd38fc2086c18cc15eab3.jpg",
+        "image_caption": [
+            "Figure 5. Real-world-demo cross-embodiment setting: Comparison of XIRL with baselines using the simulated State Pusher environment from [6]. XIRL (real only) leverages real-world demonstration videos of humans (left, row 2) to teach a robot arm in sim (left, row 1), but unlike [6], we do not use human-labeled data of paired frame correspondences. $\\mathrm { R L V ^ { \\ast } }$ denotes results taken verbatim from [6] which uses a different implementation of SAC for RL policy learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            88,
+            748,
+            226
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            282,
+            826,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7dc35f5c98241570164e1208386c3d21140466f479c4540f2cf56d7b06bd8fa5.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            388,
+            692,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/af497430173dbd9d9ebdd0f01e8662f043721632071535ec3723b518aa43e7bc.jpg",
+        "image_caption": [
+            "Figure 6. X-MAGICAL demo cross-embodiment setting: Visualizing our learned reward function XIRL vs. the environment’s sparse reward on a successful and unsuccessful demonstration, for the short-stick agent on the X-MAGICAL sweeping task. The learned reward was trained on the three other agents. ",
+            "Figure 7. Real-world-demo cross-embodiment setting: Visualizing our learned XIRL reward function vs. the environment’s sparse reward on the State Pusher (top) and Drawer Opening (bottom) tasks from [6]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            515,
+            756,
+            674
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            726,
+            294,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This paper presents XIRL, a framework for learning vision-based reward functions from videos of expert demonstrators exhibiting different embodiments. XIRL uses TCC to self-supervise a deep visual encoder from videos, and uses this encoder to generate rewards via simple distances to goal observations in the embedding space. XIRL enables unseen agents with new embodiments to learn the demonstrated tasks via IRL. Reward functions from XIRL are fully self-supervised from videos, and we can successfully learn tasks without requiring manually paired video frames [6] between the demonstrator and learner. In this sense, our method presents favorable scalability to an arbitrary number of embodiments or experts with varying skill levels. Experiments show that policies learned via XIRL are more sample efficient than multiple baseline alternatives, including TCN [5], LIFS [16], and RLV [6]. While our experiments demonstrate promising results for learning policies in simulated environments using rewards learned from both simulated and real-world videos, we have yet to show policy learning on a real robot, which we look forward to trying post-COVID. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            321,
+            106
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Alex Nichol, Nick Hynes, Sean Kirmani, Brent Yi and Jimmy Wu for fruitful technical discussions, Sam Toyer for invaluable help with setting up the simulated benchmark, and Karl Schmeckpeper for discussions and help related to RLV. ",
+        "bbox": [
+            176,
+            114,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            166,
+            263,
+            181
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "[1] B. D. Argall, S. Chernova, M. Veloso, and B. Browning. A survey of robot learning from demonstration. Robotics and autonomous systems, 57(5), 2009. 1, 2, 11   \n[2] T. Zhang, Z. McCarthy, O. Jow, D. Lee, X. Chen, K. Goldberg, and P. Abbeel. Deep imitation learning for complex manipulation tasks from virtual reality teleoperation. In ICRA. IEEE, 2018. 1   \n[3] P. Florence, L. Manuelli, and R. Tedrake. Self-supervised correspondence in visuomotor policy learning. IEEE RAL, 5(2), 2019. 1   \n[4] P. Sermanet, K. Xu, and S. Levine. Unsupervised perceptual rewards for imitation learning. arXiv preprint arXiv:1612.06699, 2016. 1, 2, 11   \n[5] P. Sermanet, C. Lynch, Y. Chebotar, J. Hsu, E. Jang, S. Schaal, and S. Levine. Time-contrastive networks: Self-supervised learning from video. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pages 1134–1141. IEEE, 2018. 1, 2, 3, 5, 6, 8, 11, 16   \n[6] K. Schmeckpeper, O. Rybkin, K. Daniilidis, S. Levine, and C. Finn. Reinforcement learning with videos: Combining offline observations with interaction, 2020. 1, 2, 3, 4, 6, 7, 8, 11, 20   \n[7] D. Dwibedi, Y. Aytar, J. Tompson, P. Sermanet, and A. Zisserman. Temporal cycle-consistency learning. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019. 2, 3, 4, 12, 16   \n[8] C. Atkeson and S. Schaal. Robot learning from demonstration. In ICML, 1997. 2, 11   \n[9] T. Osa, J. Pajarinen, G. Neumann, J. Bagnell, P. Abbeel, and J. Peters. An algorithmic perspective on imitation learning. Found. Trends Robotics, 7:1–179, 2018. 2, 11   \n[10] F. Torabi, G. Warnell, and P. Stone. Behavioral cloning from observation. In IJCAI, 2018. 2, 11   \n[11] A. D. Edwards, H. Sahni, Y. Schroecker, and C. L. Isbell. Imitating latent policies from observation. arXiv preprint arXiv:1805.07914, 2018. 2, 11   \n[12] I. Radosavovic, X. Wang, L. Pinto, and J. Malik. State-only imitation learning for dexterous manipulation. arXiv preprint arXiv:2004.04650, 2020. 2, 11   \n[13] D. Pathak, P. Mahmoudieh, G. Luo, P. Agrawal, D. Chen, Y. Shentu, E. Shelhamer, J. Malik, A. A. Efros, and T. Darrell. Zero-shot visual imitation. In Proceedings of the IEEE conference on computer vision and pattern recognition workshops, pages 2050–2053, 2018. 2, 11   \n[14] Y. Aytar, T. Pfaff, D. Budden, T. Paine, Z. Wang, and N. de Freitas. Playing hard exploration games by watching youtube. In Advances in Neural Information Processing Systems, pages 2930–2941, 2018. 2, 3, 5, 11   \n[15] O. Mees, M. Merklinger, G. Kalweit, and W. Burgard. Adversarial skill networks: Unsupervised robot skill learning from video. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 4188–4194. IEEE, 2020. 2, 11   \n[16] A. Gupta, C. Devin, Y. Liu, P. Abbeel, and S. Levine. Learning invariant feature spaces to transfer skills with reinforcement learning, 2017. 3, 5, 6, 8, 11, 16   \n[17] A. Singh, L. Yang, K. Hartikainen, C. Finn, and S. Levine. End-to-end robotic reinforcement learning without reward engineering. arXiv preprint arXiv:1904.07854, 2019. 3, 11   \n[18] L. Smith, N. Dhawan, M. Zhang, P. Abbeel, and S. Levine. Avid: Learning multi-stage tasks via pixel-level translation of human videos. arXiv preprint arXiv:1912.04443, 2019. 3, 11   \n[19] Y. Liu, A. Gupta, P. Abbeel, and S. Levine. Imitation from observation: Learning to imitate behaviors from raw video via context translation. In ICRA. IEEE, 2018. 3, 11   \n[20] P. Sharma, D. Pathak, and A. Gupta. Third-person visual imitation learning via decoupled hierarchical controller. In Advances in Neural Information Processing Systems, pages 2597–2607, 2019. 3, 11   \n[21] D. Hejna, L. Pinto, and P. Abbeel. Hierarchically decoupled imitation for morphological transfer. In International Conference on Machine Learning, pages 4159–4171. PMLR, 2020. 3, 11   \n[22] J.-Y. Zhu, T. Park, P. Isola, and A. A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In ICCV, 2017. 3, 11   \n[23] P. Henderson, R. Islam, P. Bachman, J. Pineau, D. Precup, and D. Meger. Deep reinforcement learning that matters. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018. 5   \n[24] S. Toyer, R. Shah, A. Critch, and S. Russell. The magical benchmark for robust imitation. arXiv preprint arXiv:2011.00401, 2020. 5, 12   \n[25] V. Blomqvist. Pymunk: A easy-to-use pythonic rigid body 2d physics library (version 6.0.0), 2007. URL https://www.pymunk.org. 5   \n[26] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, et al. Human-level control through deep reinforcement learning. nature, 518(7540): 529–533, 2015. 6   \n[27] M. Vecerik, O. Sushkov, D. Barker, T. Rothorl, T. Hester, and J. Scholz. A practical approach to insertion with ¨ variable socket position using deep reinforcement learning. In 2019 International Conference on Robotics and Automation (ICRA), pages 754–760. IEEE, 2019. 6, 15, 16   \n[28] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2016. 6   \n[29] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint:1412.6980, 2014. 6   \n[30] T. Haarnoja, A. Zhou, P. Abbeel, and S. Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. arXiv preprint arXiv:1801.01290, 2018. 6, 7, 17   \n[31] T. Haarnoja, A. Zhou, K. Hartikainen, G. Tucker, S. Ha, J. Tan, V. Kumar, H. Zhu, A. Gupta, P. Abbeel, and S. Levine. Soft actor-critic algorithms and applications. arXiv preprint arXiv:1812.05905, 2018. 6   \n[32] C. Yang, X. Ma, W. Huang, F. Sun, H. Liu, J. Huang, and C. Gan. Imitation learning from observations by minimizing inverse dynamics disagreement. ArXiv, abs/1910.04417, 2019. 11   \n[33] L. Shao, T. Migimatsu, Q. Zhang, K. Yang, and J. Bohg. Concept2robot: Learning manipulation concepts from instructions and human demonstrations. Robotics: Science and Systems, 2020. 11   \n[34] G. Berseth and C. Pal. Visual imitation learning with recurrent siamese networks. ArXiv, abs/1901.07186, 2019. 11   \n[35] B. D. Ziebart, A. L. Maas, J. A. Bagnell, and A. K. Dey. Maximum entropy inverse reinforcement learning. In Aaai, volume 8, pages 1433–1438. Chicago, IL, USA, 2008. 11   \n[36] B. D. Ziebart, J. A. Bagnell, and A. K. Dey. Modeling interaction via the principle of maximum causal entropy. In ICML, 2010. 11   \n[37] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial networks. arXiv preprint arXiv:1406.2661, 2014. 11   \n[38] J. Ho and S. Ermon. Generative adversarial imitation learning. In NeurIPS, 2016. 11   \n[39] F. Torabi, G. Warnell, and P. Stone. Generative adversarial imitation from observation. arXiv preprint arXiv:1807.06158, 2018. 11   \n[40] B. C. Stadie, P. Abbeel, and I. Sutskever. Third-person imitation learning. arXiv:1703.01703, 2017. 11   \n[41] Y. Lu and J. Tompson. Adail: Adaptive adversarial imitation learning. NeurIPS Workshop on Learning Transferable Skills,, 2019. 11   \n[42] F. Liu, Z. Ling, T. Mu, and H. Su. State alignment-based imitation learning. arXiv preprint arXiv:1911.10947, 2019. 11   \n[43] W. Sun, A. Vemula, B. Boots, and J. Bagnell. Provably efficient imitation learning from observation alone. ArXiv, abs/1905.10948, 2019. 11   \n[44] K. Kim, Y. Gu, J. Song, S. Zhao, and S. Ermon. Domain adaptive imitation learning. arXiv, 2020. 11   \n[45] A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. Kopf, E. Yang, Z. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala. Pytorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems 32. Curran Associates, Inc., 2019. 14   \n[46] A. Buslaev, A. Parinov, E. Khvedchenya, V. Iglovikov, and A. A. Kalinin. Albumentations: fast and flexible image augmentations. arXiv e-prints, 2018. 16   \n[47] D. Yarats and I. Kostrikov. Soft actor-critic (sac) implementation in pytorch. https://github.com/ denisyarats/pytorch_sac, 2020. 17   \n[48] H. van Hasselt, A. Guez, and D. Silver. Deep reinforcement learning with double q-learning. arXiv e-prints, 2015. 17   \n[49] S. Fujimoto, H. van Hoof, and D. Meger. Addressing function approximation error in actor-critic methods. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018, 2018. 17   \n[50] A. M. Saxe, J. L. McClelland, and S. Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv e-prints, 2013. 17   \n[51] T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020. 17, 18 ",
+        "bbox": [
+            171,
+            191,
+            826,
+            907
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            826,
+            731
+        ],
+        "page_idx": 9
+    }
+]

parse/train/SkxSv6VFvS/SkxSv6VFvS.md

@@ -0,0 +1,343 @@
+# DEFORMABLE KERNELS: ADAPTING EFFECTIVE RECEPTIVE FIELDS FOR OBJECT DEFORMATION
+
+Hang $\mathbf { G a o ^ { 1 , 3 * } } ,$ Xizhou $\mathbf { Z } \mathbf { h } \mathbf { u } ^ { 2 , 3 * }$ , Steve $\mathbf { L i n ^ { 3 } }$ , Jifeng Dai3   
+1UC Berkeley 2University of Science and Technology of China 3Microsoft Research Asia   
+hangg@eecs.berkeley.edu, ezra0408@mail.ustc.edu.cn   
+{stevelin,jifdai}@microsoft.com   
+http://people.eecs.berkeley.edu/˜hangg/deformable-kernels/
+
+# ABSTRACT
+
+Convolutional networks are not aware of an object’s geometric variations, which leads to inefficient utilization of model and data capacity. To overcome this issue, recent works on deformation modeling seek to spatially reconfigure the data towards a common arrangement such that semantic recognition suffers less from deformation. This is typically done by augmenting static operators with learned free-form sampling grids in the image space, dynamically tuned to the data and task for adapting the receptive field. Yet adapting the receptive field does not quite reach the actual goal – what really matters to the network is the effective receptive field (ERF), which reflects how much each pixel contributes. It is thus natural to design other approaches to adapt the ERF directly during runtime.
+
+In this work, we instantiate one possible solution as Deformable Kernels (DKs), a family of novel and generic convolutional operators for handling object deformations by directly adapting the ERF while leaving the receptive field untouched. At the heart of our method is the ability to resample the original kernel space towards recovering the deformation of objects. This approach is justified with theoretical insights that the ERF is strictly determined by data sampling locations and kernel values. We implement DKs as generic drop-in replacements of rigid kernels and conduct a series of empirical studies whose results conform with our theories. Over several tasks and standard base models, our approach compares favorably against prior works that adapt during runtime. In addition, further experiments suggest a working mechanism orthogonal and complementary to previous works.
+
+# 1 INTRODUCTION
+
+The rich diversity of object appearance in images arises from variations in object semantics and deformation. Semantics describe the high-level abstraction of what we perceive, and deformation defines the geometric transformation tied to specific data (Gibson, 1950). Humans are remarkably adept at making abstractions of the world (Hudson & Manning, 2019); we see in raw visual signals, abstract semantics away from deformation, and form concepts.
+
+Interestingly, modern convolutional networks follow an analogous process by making abstractions through local connectivity and weight sharing (Zhang, 2019). However, such a mechanism is an inefficient one, as the emergent representations encode semantics and deformation together, instead of as disjoint notions. Though a convolution responds accordingly to each input, how it responds is primarily programmed by its rigid kernels, as in Figure 1(a, b). In effect, this consumes large model capacity and data modes (Shelhamer et al., 2019).
+
+We argue that the awareness of deformations emerges from adaptivity – the ability to adapt at runtime (Kanazawa et al., 2016; Jia et al., 2016; Li et al., 2019). Modeling of geometric transformations has been a constant pursuit for vision researchers over decades (Lowe et al., 1999; Lazebnik et al., 2006; Jaderberg et al., 2015; Dai et al., 2017). A basic idea is to spatially recompose data towards a common mode such that semantic recognition suffers less from deformation. A recent work that is representative of this direction is Deformable Convolution (Dai et al., 2017; Zhu et al., 2019). As shown in Figure 1(c), it augments the convolutions with free-form sampling grids in the data space. It is previously justified as adapting receptive field, or what we phrase as the “theoretical receptive field”, that defines which input pixels can contribute to the final output. However, theoretical receptive field does not measure how much impact an input pixel actually has. On the other hand, Luo et al. (2016) propose to measure the effective receptive field (ERF), i.e. the partial derivative of the output with respect to the input data, to quantify the exact contribution of each raw pixel to the convolution. Since adapting the theoretical receptive field is not the goal but a means to adapt the ERF, why not directly tune the ERF to specific data and tasks at runtime?
+
+![](images/a917c7f3a2bc01e2dd8b2cc933d94663ffbda1043f70c227f8d800fbf1704a7e.jpg)  
+Figure 1: Adaptation for deformation. We show how different $3 \times 3$ convolutions interact with deformations of two images. Kernel spaces are visualized as flat 2D Gaussians. Each “ $\cdot + \overrightarrow { \mathbf { \Gamma } }$ indicates a computation between a pixel and a kernel value sampled from the data and kernel space. Their colors represent corresponding kernel values. (a, b) Rigid kernels cannot adapt to specific deformations, thus consuming large model and data capacity. (c) Deformable Convolutions (Dai et al., 2017) reconfigure data towards common arrangement to counter the effects of geometric deformation. (d) Our Deformable Kernels (DKs) instead resample kernels and, in effect, adapt kernel spaces while leaving the data untouched. Note that (b) and (c) share kernel values but sample different data locations, while (b) and (d) share data locations but sample different kernel values.
+
+Toward this end, we introduce Deformable Kernels (DKs), a family of novel and generic convolutional operators for deformation modeling. We aim to augment rigid kernels with the expressiveness to directly interact with the ERF of the computation during inference. Illustrated in Figure 1(d), DKs learn free-form offsets on kernel coordinates to deform the original kernel space towards specific data modality, rather than recomposing data. This can directly adapt ERF while leaving receptive field untouched. The design of DKs that is agnostic to data coordinates naturally leads to two variants – the global DK and the local DK, which behave differently in practice as we later investigate. We justify our approach with theoretical results which show that ERF is strictly determined by data sampling locations and kernel values. Used as a generic drop-in replacement of rigid kernels, DKs achieve empirical results coherent with our developed theory. Concretely, we evaluate our operator with standard base models on image classification and object detection. DKs perform favorably against prior works that adapt during runtime. With both quantitative and qualitative analysis, we further show that DKs can work orthogonally and complementarily with previous techniques.
+
+# 2 RELATED WORKS
+
+We distinguish our work within the context of deformation modeling as our goal, and dynamic inference as our means.
+
+Deformation Modeling: We refer to deformation modeling as learning geometric transformations in 2D image space without regard to 3D. One angle to attack deformation modeling is to craft certain geometric invariances into networks. However, this usually requires designs specific to certain kinds of deformation, such as shift, rotation, reflection and scaling (Sifre & Mallat, 2013; Bruna & Mallat, 2013; Kanazawa et al., 2016; Cohen & Welling, 2016; Worrall et al., 2017; Esteves et al., 2018). Another line of work on this topic learns to recompose data by either semi-parameterized or completely free-form sampling in image space: Spatial Transformers (Jaderberg et al., 2015) learns 2D affine transformations, Deep Geometric Matchers (Rocco et al., 2017) learns thin-plate spline transformations, Deformable Convolutions (Dai et al., 2017; Zhu et al., 2019) learns free-form transformations.
+
+We interpret sampling data space as an effective approach to adapt effective receptive fields (ERF) by directly changing receptive field. At a high-level, our Deformable Kernels (DKs) share intuitions with this line of works for learning geometric transformations, yet are instantiated by learning to sample in kernel space which directly adapt ERF while leaving theoretical receptive fields untouched. While kernel space sampling is also studied in Deformable Filter (Xiong et al., 2019) and KPConv (Thomas et al., 2019), but in their contexts, sampling grids are computed from input point clouds rather than learned from data corpora.
+
+Dynamic Inference: Dynamic inference adapts the model or individual operators to the observed data. The computation of our approach differs from self-attention (Vaswani et al., 2017; Wang et al., 2018) in which linear or convolution modules are augmented with subsequent queries that extract from the same input. We consider our closest related works in terms of implementation as those approaches that adapt convolutional kernels at run time. It includes but is not limited to Dynamic Filters (Jia et al., 2016), Selective Kernels (Li et al., 2019) and Conditional Convolutions (Yang et al., 2019). All of these approaches can learn and infer customized kernel spaces with respect to the data, but are either less inefficient or are loosely formulated. Dynamic Filters generate new filters from scratch, while Conditional Convolutions extend this idea to linear combinations of a set of synthesized filters. Selective Kernels are, on the other hand, comparably lightweight, but aggregating activations from kernels of different size is not as compact as directly sampling the original kernel space. Another line of works contemporary to ours (Shelhamer et al., 2019; Wang et al., 2019) is to compose free-form filters with structured Gaussian filters, which essentially transforms kernel spaces by data. Our DKs also differ from these works with the emphasize of direct adaptation the ERF rather than the theoretical receptive field. As mentioned previously, the true goal should be to adapt the ERF, and to our knowledge, our work is the first to study dynamic inference of ERFs.
+
+# 3 APPROACH
+
+We start by covering preliminaries on convolutions, including the definition of effective receptive field (ERF). We then formulate a theoretical framework for analyzing ERFs, and thus motivate our Deformable Kernels (DKs). We finally elaborate different DK variants within such a framework. Our analysis suggests compatibility between DKs and the prior work.
+
+# 3.1 A DIVE INTO CONVOLUTIONS
+
+2D Convolution: Let us first consider an input image $\pmb { I } \in \mathbb { R } ^ { D \times D }$ . By convolving it with a kernel $\pmb { W } \in \mathbb { R } ^ { K \times K }$ of stride 1, we have an output image $o$ whose pixel values at each coordinate $j \in \mathbb R ^ { 2 }$ can be expressed as
+
+$$
+O _ { j } = \sum _ { k \in \mathcal { K } } I _ { j + k } W _ { k } ,
+$$
+
+by enumerating discrete kernel positions $\boldsymbol { k }$ within the support $\mathcal { K } = [ - K / 2 , K / 2 ] ^ { 2 } \cap \mathbb { Z }$ . This defines a rigid grid for sampling data and kernels.
+
+Theoretical Receptive Field: The same kernel $W$ can be stacked repeatedly to form a linear convolutional network with $n$ layers. The theoretical receptive field can then be imagined as the “accumulative coverage” of kernels at each given output unit on the input image by deconvolving back through the network. This property characterizes a set of input fields that could fire percepts onto corresponding output pixels. The size of a theoretical receptive field scales linearly with respect to the network depth $n$ and kernel size $K$ (He et al., 2016).
+
+Effective Receptive Field: Intuitively, not all pixels within a theoretical receptive field contribute equally. The influence of different fields varies from region to region thanks to the central emphasis of stacked convolutions and also to the non-linearity induced by activations. The notion of effective receptive field (ERF) (Luo et al., 2016) is thus introduced to measure the impact of each input pixel on the output at given locations. It is defined as a partial derivative field of the output with respect to the input data. With the numerical approximations in linear convolution networks, the ERF was previously identified as a Gaussian-like soft attention map over input images whose size grows fractionally with respect to the network depth $n$ and linearly to the kernel size $K$ . Empirical results validate this idea under more complex and realistic cases when networks exploit non-linearities, striding, padding, skip connections, and subsampling.
+
+# 3.2 ANALYSIS ON EFFECTIVE RECEPTIVE FIELDS
+
+We aim to revisit and complement the previous analysis on ERFs by Luo et al. (2016). While the previous analysis concentrates on studying the expectation of an ERF, i.e., when network depth $n$ approaches infinity or all kernels are randomly distributed without learning in general, our analysis focuses on how we can perturb the computation such that the change in ERF is predictable, given an input and a set of kernel spaces.
+
+We start our analysis by considering a linear convolutional network, without any unit activations, as defined in Section 3.1. For consistency, superscripts are introduced to image $\pmb { I }$ , kernel $W$ , and subscripts to kernel positions $\boldsymbol { k }$ to denote the index $s \in [ 1 , n ]$ of each layer. Formally, given an input image $\pmb { I } ^ { ( 0 ) }$ and a set of $K \times K$ kernels $\{ W ^ { ( s ) } \} _ { s = 1 } ^ { n }$ of stride 1, we can roll out the final output ${ \cal O } \equiv { \cal I } ^ { ( n ) }$ by unfolding Equation 1 as
+
+$$
+\begin{array} { l } { { { \cal I } _ { j } ^ { ( n ) } = \displaystyle \sum _ { k _ { n } \in { \cal K } } { \cal I } _ { j + k _ { n } } ^ { ( n - 1 ) } { \cal W } _ { k _ { n } } ^ { ( n ) } = \displaystyle \sum _ { ( k _ { n - 1 } , k _ { n } ) \in { \cal K } ^ { 2 } \atop { } } { \cal I } _ { j + k _ { n } + k _ { n - 1 } } ^ { ( n - 2 ) } { \cal W } _ { k _ { n } } ^ { ( n ) } { \cal W } _ { k _ { n - 1 } } ^ { ( n - 1 ) } = \cdots } } \\ { { = \displaystyle \sum _ { ( k _ { 1 } , k _ { 2 } , \ldots , k _ { n } ) \in { \cal K } ^ { n } } \left( { \cal I } _ { j + \sum _ { s = 1 } ^ { n } k _ { s } } ^ { ( 0 ) } \cdot \prod _ { s = 1 } ^ { n } { \cal W } _ { k _ { s } } ^ { ( s ) } \right) . } } \end{array}
+$$
+
+By definition1, the effective receptive field value $\mathcal { R } ^ { ( n ) } ( i ; j ) \equiv \partial I _ { j } ^ { ( n ) } / \partial I _ { i } ^ { ( 0 ) }$ of output coordinate $j$ that takes input coordinate $_ i$ can be computed by
+
+$$
+\mathcal { R } ^ { ( n ) } ( i ; j ) = \sum _ { ( k _ { 1 } , k _ { 2 } , \ldots , k _ { n } ) \in K ^ { n } } \left( \mathbb { 1 } \left[ j + \sum _ { s = 1 } ^ { n } k _ { s } = i \right] \cdot \prod _ { s = 1 } ^ { n } W _ { k _ { s } } ^ { ( s ) } \right) ,
+$$
+
+where $\mathbb { 1 } [ \cdot ]$ denotes the indicator function. This result indicates that ERF is related only to the data sampling location $j$ , kernel sampling location $\boldsymbol { k }$ , and kernel matrices $\{ W ^ { ( s ) } \}$ .
+
+If we replace the $m ^ { \mathrm { t h } }$ kernel $W ^ { ( m ) }$ with a $1 \times 1$ kernel of a single parameter $W _ { \tilde { \boldsymbol { k } } _ { m } } ^ { ( m ) }$ sampled from it, the value of ERF becomes to
+
+$$
+\mathcal { R } ^ { ( n ) } ( i ; j , \tilde { k } _ { m } ) = \sum _ { ( k _ { 1 } , \dots , k _ { m - 1 } , k _ { m + 1 } , \dots , k _ { n } ) \in K ^ { n - 1 } } \left( \mathbb { 1 } \left[ j + \sum _ { s \in \mathbb { S } } k _ { s } = i \right] \cdot \prod _ { s \in \mathbb { S } } W _ { k _ { s } } ^ { ( s ) } \cdot W _ { \tilde { k } _ { m } } ^ { ( m ) } \right) ,
+$$
+
+where $\mathbb { S } = [ 1 , n ] \backslash \{ m \}$ . Since a $K \times K$ kernel can be deemed as a composition of $K ^ { 2 } 1 \times 1$ kernels distributed on a square grid, Equation 3 can thus be reformulated as
+
+$$
+\mathcal { R } ^ { ( n ) } ( i ; j ) = \sum _ { k _ { m } \in \mathcal { K } } \mathcal { R } ^ { ( n ) } ( i ; j + k _ { m } , k _ { m } ) .
+$$
+
+For the case of complex non-linearities, where we here consider post $\mathrm { R e L U } ^ { 2 }$ activations in Equation 1,
+
+$$
+O _ { j } = \operatorname* { m a x } ( \sum _ { k \in \mathcal { K } } I _ { j + k } W _ { k } , 0 ) .
+$$
+
+We can follow a similar analysis and derive corresponding ERF as
+
+$$
+\begin{array} { r l } & { \mathcal { R } ^ { ' ( n ) } ( i ; j , \tilde { k } _ { m } ) = \displaystyle \sum _ { ( k _ { 1 } , \cdots , k _ { m - 1 } , k _ { m + 1 } , \cdots , k _ { n } ) \in K ^ { n - 1 } } \left( \mathcal { C } ^ { ( n ) } ( i ; j , k _ { 1 } , \cdots , k _ { n } , \tilde { k } _ { m } ) \cdot \prod _ { s \in \mathbb { S } } W _ { \tilde { k } _ { s } } ^ { ( s ) } \cdot W _ { \tilde { k } _ { m } } ^ { m } \right) } \\ & { \mathcal { C } ^ { ( n ) } ( i ; j , k _ { 1 } , \cdots , k _ { n } , \tilde { k } _ { m } ) = \mathbb { 1 } \big [ j + \displaystyle \sum _ { s \in \mathbb { S } } k _ { s } = i \big ] \prod _ { s \in \mathbb { S } } \mathbb { 1 } \big [ \displaystyle I _ { j } ^ { ( s - 1 ) } W _ { \tilde { k } _ { s } } ^ { ( s ) } > 0 \big ] \mathbb { 1 } \big [ I _ { j } ^ { ( m - 1 ) } W _ { \tilde { k } _ { m } } ^ { ( m ) } > 0 \big ] . } \end{array}
+$$
+
+Here we can see that the ERF becomes data-dependent due to the coefficient $\mathcal { C }$ , which is tied to input coordinates, kernel sampling locations, and input data $\pmb { I } ^ { ( 0 ) }$ . The more detailed analysis of this coefficient is beyond the scope of this paper. However, it should be noted that this coefficient only “gates” the contribution of the input pixels to the output. So in practice, ERF is “porous” – there are inactive (or gated) pixel units irregularly distributed around the ones that fire. This phenomenon also appeared in previous studies (such as in Luo et al. (2016), Figure 1). The maximal size of an ERF is still controlled by the data sampling location and kernel values as in the linear cases in Equation 5.
+
+A nice property of Equation 4 and Equation 5 is that all computations are linear, making it compatible with any linear sampling operators for querying kernel values of fractional coordinates. In other words, sampling kernels in effect samples the ERF on the data in the linear case, but also roughly generalizes to non-linear cases as well. This finding motivates our design of Deformable Kernels (DKs) in Section 3.3.
+
+# 3.3 DEFORMABLE KERNELS
+
+In the context of Equation 1, we resample the kernel $W$ with a group of learned kernel offsets denoted as $\{ \Delta k \}$ that correspond to each discrete kernel position $\boldsymbol { k }$ . This defines our DK as
+
+$$
+O _ { j } = \sum _ { k \in \mathcal K } I _ { j + k } W _ { k + \Delta k } ,
+$$
+
+and the value of ERF as
+
+$$
+\mathcal { R } _ { \mathrm { D K } } ^ { ( n ) } ( i ; j ) = \sum _ { k _ { m } \in { \mathcal { K } } } \mathcal { R } ^ { ( n ) } ( i ; j + k _ { m } , k _ { m } + \Delta k _ { m } ) .
+$$
+
+Note that this operation leads to sub-pixel sampling in the kernel space. In practice, we use bilinear sampling to interpolate within the discrete kernel grid.
+
+Intuitively, the size (resolution) of the original kernel space can affect sampling performance. Concretely, suppose we want to sample a $3 \times 3$ kernel. DKs do not have any constraint on the size of the original kernel space, which we call the “scope size” of DKs. That said, we can use a $W$ of any size $K ^ { \prime }$ even though the number of sampling locations is fixed as $K ^ { 2 }$ . We can thus exploit large kernels – the largest ones can reach $9 \times 9$ in our experiments with nearly no overhead in computation since bilinear interpolations are extremely lightweight compared to the cost of convolutions. This can also increase the number of learning parameters, which in practice might become intractable if not handled properly. In our implementation, we will exploit depthwise convolutions (Howard et al., 2017) such that increasing scope size induces a negligible amount of extra parameters.
+
+As previously discussed, sampling the kernel space in effect transforms into sampling the ERF. On the design of locality and spatial granularity of our learned offsets, DK naturally delivers two variants ��� the global DK and the local DKs, as illustrated in Figure 2. In both operators, we learn a kernel offset generator $\mathcal { G }$ that maps an input patch into a set of kernel offsets that are later applied to rigid kernels.
+
+In practice, we implement $\mathcal { G } _ { \mathrm { g l o b a l } }$ as a stack of one global average pooling layer, which reduces feature maps into a vector, and another fully-connected layer without non-linearities, which projects the reduced vector into an offset vector of $2 K ^ { 2 }$ dimensions. Then, we apply these offsets to all convolutions for the input image following Equation 7. For local DKs, we implement $\mathcal { G } _ { \mathrm { l o c a l } }$ as an extra convolution that has the same configuration as the target kernel, except that it only has $2 K ^ { 2 }$ output channels. This produces kernel sampling offsets $\{ \Delta k \}$ that are additionally indexed by output locations $j$ . It should be noted that similar designs were also discussed in Jia et al. (2016), in which filters are generated given either an image or individual patches from scratch rather than by resampling.
+
+![](images/2bb9668aaa37218849f82168db9cfaca57d102ffed1c046e386e2dacf5e7d991.jpg)  
+Figure 2: Instantiations. We show how DK variants works with an example image that contains a large and a small object. (a) The global DK learns one set of kernel sampling grid given an input image and apply it to all data positions. (b) The local DK adapts kernels for each input patches, and induces better locality for deformation modeling.
+
+Intuitively, we expect the global DK to adapt kernel space between different images but not within a single input. The local DK can further adpat to specific image patches: for smaller objects, it is better to have shaper kernels and thus denser ERF; for larger objects, flatter kernels can be more beneficial for accumulating a wider ERF. On a high level, local DKs can preserve better locality and have larger freedom to adapt kernel spaces comparing to its global counterpart. We later compare these operators in our experiments.
+
+# 3.4 LINK WITH DEFORMABLE CONVOLUTIONS
+
+The core idea of DKs is to learn adaptive offsets to sample the kernel space for modeling deformation, which makes them similar to Deformable Convolutions (Dai et al., 2017; Zhu et al., 2019), at both the conceptual and implementation levels. Here, we distinguish DKs from Deformable Convolutions and show how they can be unified.
+
+Deformable Convolutions can be reformulated in a general form as
+
+$$
+O _ { j } = \sum _ { k \in \mathcal { K } } I _ { j + k + \Delta j } W _ { k } ,
+$$
+
+where they aim to learn a group of data offsets $\{ \Delta j \}$ with respect to discrete data positions $j$ . For consistency for analysis, the value of effective receptive field becomes
+
+$$
+\mathcal { R } _ { \mathrm { D C } } ^ { ( n ) } ( i ; j ) = \sum _ { k _ { m } \in \mathcal { K } } \mathcal { R } ^ { ( n ) } ( i ; j + k _ { m } + \Delta j _ { m } , k _ { m } ) .
+$$
+
+This approach essentially recomposes the input image towards common modes such that semantic recognition suffers less from deformation. Moreover, according to our previous analysis in Equation 5, sampling data is another way of sampling the ERF. This, to a certain extent, also explains why Deformable Convolutions are well suited for learning deformation-agnostic representations.
+
+Moreover, we can learn both data and kernel offsets in one convolutional operator. Conceptually, this can be done by merging Equation 7 with Equation 9, which leads to
+
+$$
+\begin{array} { c } { { \displaystyle { \cal O } _ { j } = \displaystyle \sum _ { k \in { \cal K } } { \cal I } _ { j + k + \Delta j } W _ { k + \Delta k } , } } \\ { { \displaystyle \mathcal { R } _ { \mathrm { D C + D K } } ^ { ( n ) } ( i ; j ) = \displaystyle \sum _ { k _ { m } \in { \cal K } } { \cal R } ^ { ( n ) } ( i ; j + k _ { m } + \Delta j _ { m } , k _ { m } + \Delta k _ { m } ) . } } \end{array}
+$$
+
+We also investigate this operator in our experiments. Although the two techniques may be viewed as serving a similar purpose, we find the collaboration between Deformable Kernels and Deformable Convolutions to be powerful in practice, suggesting strong compatibility.
+
+# 4 EXPERIMENTS
+
+We evaluate our Deformable Kernels (DKs) on image classification using ILSVRC and object detection using the COCO benchmark. Necessary details are provided to reproduce our results, together with descriptions on base models and strong baselines for all experiments and ablations. For taskspecific considerations, we refer to each corresponding section.
+
+Implementation Details: We implement our operators in PyTorch and CUDA. We exploit depthwise convolutions when designing our operator for better computational efficiency3. We initialize kernel grids to be uniformly distributed within the scope size. For the kernel offset generator, we set its learning rate to be a fraction of that of the main network, which we cross-validate for each base model. We also find it important to clip sampling locations inside the original kernel space, such that $\pmb { k } + \Delta \pmb { k } \in \mathcal { K }$ in Equation 7.
+
+Base Models: We choose our base models to be ResNet-50 (He et al., 2016) and MobileNetV2 (Sandler et al., 2018), following the standard practice for most vision applications. As mentioned, we exploit depthwise convolution and thus make changes to the ResNet model. Concretely, we define our ResNet-50-DW base model by replacing all $3 \times 3$ convolutions by its depthwise counterpart while doubling the dimension of intermediate channels in all residual blocks. We find it to be a reasonable base model compared to the original ResNet-50, with comparable performance on both tasks. During training, we set the weight decay to be $4 \times 1 0 ^ { - 5 }$ rather than the common $1 0 ^ { - 4 }$ for both models since depthwise models usually underfit rather than overfit (Xie et al., 2017; Howard et al., 2017; Hu et al., 2018). We set the learning rate multiplier of DK operators as $1 0 ^ { - 2 }$ fo r ResNet-50-DW and $1 0 ^ { - 1 }$ for MobileNet-V2 in all of our experiments.
+
+Strong Baselines: We develop our comparison with two previous works: Conditional Convolutions (Yang et al., 2019) for dynamics inference, and Deformable Convolutions (Dai et al., 2017; Zhu et al., 2019) for deformation modeling. We choose Conditional Convolutions due to similar computation forms – sampling can be deemed as an elementewise “expert voting” mechanism. For fair comparisons, We reimplement and reproduce their results. We also combine our operator with these previous approach to show both quantitative evidence and qualitative insight that our working mechanisms are compatible.
+
+# 4.1 IMAGE CLASSIFICATION
+
+We first train our networks on the ImageNet 2012 training set (Deng et al., 2009). We adopt a common experiment protocol for fair comparisons as in Goyal et al. (2017); Loshchilov & Hutter (2017). For more details, please refer to our supplement.
+
+We first ablate the scope size of kernels for our DKs and study how it can affect model performance using ResNet-50-DW. As shown in Table 1, our DKs are sensitive to the choice of the scope size. We shown that when only applied to $3 \times 3$ convolutions inside residual bottlenecks, local DKs induce a $+ 0 . 7$ performance gain within the original scope. By further enlarging the scope size, performance increases yet quickly plateaus at scope $4 \times 4$ , yielding largest $+ 1 . 4$ gain for top-1 accuracy. Our speculation is that, although increasing scope size theoretically means better interpolation, it also makes the optimization space exponentially larger for each convolutional layer. And since number of entries for updating is fixed, this also leads to relatively sparse gradient flows. In principle, we set default scope size at $4 \times 4$ for our DKs.
+
+We next move on and ablate our designs by comparing the global DK with the local DK, shown in the table. Both operators helps while the local variants consistently performs better than their global counterparts, bringing a $+ 0 . 5$ gap on both base models. We also study the effect of using more DKs in the models – the $1 \times 1$ convolutions are replaced by global $\mathrm { D K } \dot { \mathrm { s } } ^ { 4 }$ with scope $2 \times 2$ . Note that all $1 \times 1$ convolutions are not depthwise, and therefore this operation induces nearly 4 times of parameters. We refer their results only for ablation and show that adding more DKs still helps – especially for MobileNet-V2 since it is under-parameterized. This finding also holds for previous models (Yang et al., 2019) as well.
+
+Table 1: Ablations of scope size and different instantiations of DK for image classification. Using proper scope size, and more DK layers boosts performance. Modeling individual offset kernel grid for each data entries is also beneficial.   
+
+<table><tr><td>Backbone</td><td>1×1Deformable Kernels</td><td>3×3Deformable Kernels</td><td>top1 (%)</td><td>#P (M)</td><td>GFLOPs</td></tr><tr><td>ResNet-50</td><td>w/o</td><td>w/o</td><td>76.7</td><td>25.6</td><td>3.86</td></tr><tr><td>ResNet-50-DW</td><td>w/o</td><td>w/o</td><td>76.3</td><td>23.7</td><td>3.82</td></tr><tr><td rowspan="4">ResNet-50-DW</td><td rowspan="4">w/o</td><td>local, scope size 3×3</td><td>77.4</td><td>24.9</td><td>4.32</td></tr><tr><td>local, scope size 4×4</td><td>78.1</td><td>25.0</td><td>4.32</td></tr><tr><td>local, scope size 5×5</td><td>77.8</td><td>25.0</td><td>4.32</td></tr><tr><td>local, scope size 9×9</td><td>77.4</td><td>25.4</td><td>4.32</td></tr><tr><td rowspan="4">ResNet-50-DW</td><td>w/o</td><td>global, scope size 4×4</td><td>77.6</td><td>23.9</td><td>3.82</td></tr><tr><td>global,scope size 2×2</td><td>global, scope size 4×4</td><td>77.9</td><td>80.1</td><td>4.09</td></tr><tr><td>w/o</td><td>local, scope size 4×4</td><td>78.1</td><td>25.0</td><td>4.32</td></tr><tr><td>global, scope size 2×2</td><td>local, scope size 4×4</td><td>78.5</td><td>81.2</td><td>4.60</td></tr><tr><td>MobileNet-V2</td><td>w/o</td><td>w/o</td><td>71.9</td><td>3.5</td><td>0.31</td></tr><tr><td rowspan="4">MobileNet-V2</td><td>w/o</td><td>global, scope size 4×4</td><td>73.6</td><td>3.7</td><td>0.31</td></tr><tr><td>global, scope size 2×2</td><td>global, scope size 4×4</td><td>74.5</td><td>10.1</td><td>0.34</td></tr><tr><td>w/o</td><td>local, scope size 4×4</td><td>74.1</td><td>4.7</td><td>0.73</td></tr><tr><td>global, scope size 2×2</td><td>local, scope size 4×4</td><td>74.8</td><td>11.1</td><td>0.76</td></tr></table>
+
+Table 2: Comparisons to strong baselines for image classification DKs perform comparably or superiorly to previous methods. Further combinations yield consistent gain, suggesting orthogonal and compatible working mechanisms.   
+
+<table><tr><td>Backbone</td><td>1×1Deformable Kernels</td><td>3×3DeformableKernels</td><td>top1 (%)</td><td>#P (M)</td><td>GFLOPs</td></tr><tr><td>ResNet-50-DW</td><td>w/o</td><td>local, scope size 4×4</td><td>78.1</td><td>25.0</td><td>4.32</td></tr><tr><td>ResNet-50-DW</td><td>w/o</td><td>w/o</td><td>77.6</td><td>42.5</td><td>7.13</td></tr><tr><td rowspan="2">with SCC ResNet-50-DW</td><td rowspan="2">w/0</td><td>local, scope size 4×4</td><td>78.9</td><td>43.7</td><td>7.61</td></tr><tr><td>w/o</td><td>78.0</td><td>24.8</td><td>4.10</td></tr><tr><td>with DCN</td><td></td><td>local, scope size 4×4</td><td>79.0</td><td>26.1</td><td>4.60</td></tr><tr><td>MobileNet-V2 MobileNet-V2</td><td>w/o</td><td>local, scope size 4×4</td><td>74.1</td><td>4.7</td><td>0.73</td></tr><tr><td rowspan="2">with SCC</td><td rowspan="2">w/o</td><td>w/o</td><td>74.3</td><td>19.0</td><td>2.19</td></tr><tr><td>local, scope size 4×4</td><td>75.5</td><td>19.7</td><td>2.48</td></tr><tr><td rowspan="2">MobileNet-V2 with DCN</td><td rowspan="2">w/0</td><td>w/o</td><td>73.2</td><td>4.6</td><td>0.52</td></tr><tr><td>local, scope size 4×4</td><td>74.4</td><td>5.8</td><td>0.93</td></tr></table>
+
+We further compare and combine DKs with Conditional Convolutions and Deformable Convolutions. Results are recorded in Table 2. We can see that DKs perform comparably on ResNet-V2 and compare favorably on MobileNet-V2 – improve $+ 0 . 9$ from Deformable Convolutions and achieve comparable results with less than a quarter number of parameters compared to Conditional Convolutions. Remarkably, we also show that if combined together, even larger performance gains are in reach. We see consistent boost in top-1 accuracy compared to strong baselines: $+ 1 . 3 / + 1 . 0$ on ResNet-50-DW, and $+ 1 . 2 / + 1 . 2$ on MobileNet-V2. These gaps are bigger than those from our own ablation, suggesting the working mechanisms across the operators to be orthogonal and compatible.
+
+# 4.2 OBJECT DETECTION
+
+We examine DKs on the COCO benchmark (Lin et al., 2014). For all experiments, we use Faster R-CNN (Ren et al., 2015) with FPN (Lin et al., 2017) as the base detector, plugging in the backbones we previously trained on ImageNet. For MobileNet-V2, we last feature maps of the each resolution for FPN post aggregation. Following the standard protocol, training and evaluation are performed on the $1 2 0 \mathrm { k }$ images in the train-val split and the 20k images in the test-dev split, respectively. For evaluation, we measure the standard mean average precision (mAP) and shattered scores for small, medium and large objects.
+
+Table 3 and Table 4 follow the same style of analysis as in image classification. While the baseline methods of ResNet achieve $3 6 . 6 \ \mathrm { m A P } ,$ indicating a strong baseline detector, applying local DKs brings a $+ 1 . 2 \mathrm { m A P }$ improvement when replacing 3x3 rigid kernels alone and a $+ 1 . 8$ mAP improvement when replacing both 1x1 and 3x3 rigid kernels. This trend magnifies on MobileNet-v2 models, where we see an improvement of $+ 1 . 6$ mAP and $+ 2 . 4 \ \mathrm { m A P } ,$ , respectively. Results also confirm the effectiveness of local DKs against global DKs, which is again in line with our expectation that local DKs can model locality better.
+
+Table 3: Ablations for object detection. Consistent results with image classification.   
+
+<table><tr><td>Backbone</td><td>1×1Deformable Kernels</td><td>3×3Deformable Kernels</td><td>mAP</td><td>mAPs</td><td>mAPM</td><td>mAPL</td></tr><tr><td>ResNet-50-DW</td><td>w/o</td><td>w/o</td><td>36.6</td><td>22.1</td><td>39.9</td><td>46.6</td></tr><tr><td rowspan="4">ResNet-50-DW</td><td>w/o</td><td>global, scope size 4×4</td><td>36.7</td><td>22.6</td><td>40.2</td><td>46.9</td></tr><tr><td>global,scope size 2×2</td><td>global, scope size 4×4</td><td>37.1</td><td>23.1</td><td>40.6</td><td>46.6</td></tr><tr><td>w/o</td><td>local, scope size 4×4</td><td>37.8</td><td>23.4</td><td>41.6</td><td>48.2</td></tr><tr><td>global, scope size 2×2</td><td>local, scope size 4×4</td><td>38.4</td><td>23.4</td><td>42.0</td><td>49.4</td></tr><tr><td>MobileNet-V2</td><td>w/o</td><td>w/o</td><td>31.3</td><td>18.6</td><td>33.7</td><td>40.4</td></tr><tr><td rowspan="4">MobileNet-V2</td><td>w/o</td><td>global, scope size 4×4</td><td>32.5</td><td>19.6</td><td>35.8</td><td>41.9</td></tr><tr><td>global,scope size 2×2</td><td>global, scope size 4×4</td><td>32.9</td><td>19.4</td><td>35.5</td><td>42.8</td></tr><tr><td>w/0</td><td>local, scope size 4×4</td><td>32.9</td><td>19.5</td><td>36.0</td><td>42.5</td></tr><tr><td>global, scope size 2×2</td><td>local, scope size 4×4</td><td>33.7</td><td>20.2</td><td>36.7</td><td>44.0</td></tr></table>
+
+Table 4: Comparisons to strong baselines for object detection DKs perform fall short to Deformable Convolution, but combination still improves performance.   
+
+<table><tr><td>Backbone</td><td>1×1Deformable Kernels</td><td>3×3DeformableKernels</td><td>mAP</td><td>mAPs</td><td>mAPM</td><td>mAPL</td></tr><tr><td>ResNet-50-DW</td><td>global, scope size 2×2</td><td>local, scope size 4×4</td><td>38.4</td><td>23.4</td><td>42.0</td><td>49.4</td></tr><tr><td>ResNet-50-DW</td><td>w/o</td><td>w/o</td><td>36.3</td><td>22.1</td><td>39.3</td><td>47.0</td></tr><tr><td rowspan="2">with SCC ResNet-50-DW</td><td rowspan="2">w/o</td><td>local, scope size 4×4</td><td>38.0</td><td>23.4</td><td>41.9</td><td>48.4</td></tr><tr><td>w/o</td><td>39.9</td><td>24.0</td><td>43.4</td><td>52.6</td></tr><tr><td>with DCN</td><td></td><td>local,scope size 4×4</td><td>40.6</td><td>24.6</td><td>43.9</td><td>53.3</td></tr><tr><td>MobileNet-V2 MobileNet-V2</td><td>global, scope size 2×2</td><td>local, scope size 4×4 w/o</td><td>33.7</td><td>20.2</td><td>36.7</td><td>44.0</td></tr><tr><td rowspan="2">with SCC</td><td rowspan="2">w/o</td><td>local, scope size 4×4</td><td>33.2</td><td>20.5</td><td>35.6</td><td>43.3</td></tr><tr><td></td><td>34.3</td><td>20.2</td><td>37.3</td><td>44.7</td></tr><tr><td>MobileNet-V2 with DCN</td><td>w/o</td><td>w/o local, scope size 4×4</td><td>34.4 35.6</td><td>20.5 20.6</td><td>37.0 38.5</td><td>44.7 47.3</td></tr></table>
+
+For the comparisons with strong baselines, an interesting phenomenon worth noting is that though DKs perform better than Deformable Convolutions on image classification, they fall noticeably short for object detection measured by mAP. We speculate that even though both techniques can adapt ERF in theory (as justified in Section 3.2), directly shifting sampling locations on data is easier to optimize. Yet after combining DKs with previous approaches, we can consistently boost performance for all the methods – $+ 0 . 7 / + 1 . 2$ for Deformable Convolutions on each base models, and $+ 1 . 7 / + 1 . 1$ for Conditional Convolutions. These findings align with the results from image classification. We next investigate what DKs learn and why they are compatible with previous methods in general.
+
+# 4.3 WHAT DO DEFORMABLE KERNELS LEARN?
+
+Awareness of Object Scale: Since deformation is hard to quantify, we use object scale as a rough proxy to understand what DKs learn. In Figure 3, we show the t-SNE (Maaten & Hinton, 2008) of learned model dynamics by the last convolutional layers in MobileNet-V2 using Conditional Convolution and our DKs. We validate the finding as claimed by Yang et al. (2019) that the experts of Conditional Convolutions have better correlation with object semantics than their scales (in reference to Figure 6 from their paper). Instead, our DKs learn kernel sampling offsets that strongly correlate to scales rather than semantics. This sheds light on why the two operators are complementary in our previous experiments.
+
+Adaptation of Effective Receptive Fields: To verify our claim that DK indeed adapts ERFs in practice, we show ERF visualizations on a set of images in which they display different degrees of deformations. We compare the results of rigid kernels, Deformable Convolutions, our DKs, and the combination of the two operators. For all examples, note that the theoretical receptive field covers every pixel in the image but ERFs contain only a central portion of it. Deformable Convolutions and DKs perform similarly in terms of adapting ERFs, but Deformable Convolutions tend to spread out and have sparse responses while DKs tend to concentrate and densely activate within an object region. Combining both operators yields more consistent ERFs that exploit both of their merits.
+
+![](images/03fe61b3a99a4b4fe54f5e472560a43e878aaca475f9aa9552dbcdad33a82abd.jpg)  
+Figure 3: Semantics vs. Scales. We show t-SNE results of learned model dynamics using 10 random classes of objects from the COCO test-dev split. Each point represents an object extracted by ground-truth bounding box, whose color either denotes its class label or bounding box scale. The color of an object scale is its normalized area rank discretized by every 10th percentile among all data. Numbers inside parentheses indicate the dimension of learned dynamics before t-SNE. (a) The dynamics of Conditional Convolutions are closer to semantics than to object scales. (b) On the contrary, our DKs learn dynamics that are significantly related to scales rather than semantics.
+
+![](images/711d1059d1b021301141e7743d64fe5288ae4ee7f13f4809906a3a3dbc32d974.jpg)  
+Figure 4: Learned Effective Receptive Fields. We show learned ERFs on three images with large, medium, and small objects from the COCO test-dev split. Given each ground-truth bounding box, we visualize the non-zero ERF values of its central point. Theoretical RFs cover the whole image for all three examples and we thus ignore them in our plots. (a) Rigid kernels have strong central effects and a Gaussian-like ERF that cannot deal with object deformation alone. (b) Deformable Convolutions and (c) Deformable Kernels both tune ERFs to data. (d) Combining both operators together enables better modeling of 2D geometric transformation of objects.
+
+# 5 CONCLUSION
+
+In this paper, we introduced Deformable Kernels (DKs) to adapt effective receptive fields (ERFs) of convolutional networks for object deformation. We proposed to sample kernel values from the original kernel space. This in effect samples the ERF in linear networks and also roughly generalizes to non-linear cases. We instantiated two variants of DKs and validate our designs, showing connections to previous works. Consistent improvements over them and compatibility with them were found, as illustrated in visualizations.
+
+# REFERENCES
+
+Joan Bruna and Stephane Mallat. Invariant scattering convolution networks. ´ TPAMI, 2013.
+
+Taco Cohen and Max Welling. Group equivariant convolutional networks. In ICML, 2016.
+
+Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei. Deformable convolutional networks. In CVPR, 2017.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009.
+
+Carlos Esteves, Christine Allen-Blanchette, Xiaowei Zhou, and Kostas Daniilidis. Polar transformer networks. In ICLR, 2018.
+
+James J Gibson. The perception of the visual world. Houghton Mifflin, 1950.
+
+Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An- ´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. In CVPR, 2017.
+
+Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In CVPR, 2018.
+
+Drew A Hudson and Christopher D Manning. Learning by abstraction: The neural state machine. arXiv preprint arXiv:1907.03950, 2019.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In NeurIPS, 2015.
+
+Xu Jia, Bert De Brabandere, Tinne Tuytelaars, and Luc V Gool. Dynamic filter networks. In NeurIPS, 2016.
+
+Angjoo Kanazawa, Abhishek Sharma, and David W. Jacobs. Locally scale-invariant convolutional neural networks. In NeurIPS Workshop, 2016.
+
+Svetlana Lazebnik, Cordelia Schmid, and Jean Ponce. Beyond bags of features: Spatial pyramid matching for recognizing natural scene categories. In CVPR, 2006.
+
+Xiang Li, Wenhai Wang, Xiaolin Hu, and Jian Yang. Selective kernel networks. In CVPR, 2019.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ ECCV, 2014.
+
+Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie. ´ Feature pyramid networks for object detection. In CVPR, 2017.
+
+Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. In ICLR, 2017.
+
+David G Lowe et al. Object recognition from local scale-invariant features. In ICCV, 1999.
+
+Wenjie Luo, Yujia Li, Raquel Urtasun, and Richard Zemel. Understanding the effective receptive field in deep convolutional neural networks. In NeurIPS, 2016.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 2008.
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In NeurIPS, 2015.
+
+Ignacio Rocco, Relja Arandjelovic, and Josef Sivic. Convolutional neural network architecture for geometric matching. In CVPR, 2017.
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In CVPR, 2018.
+
+Evan Shelhamer, Dequan Wang, and Trevor Darrell. Blurring the line between structure and learning to optimize and adapt receptive fields. arXiv preprint arXiv:1904.11487, 2019.
+
+Laurent Sifre and Stephane Mallat. Rotation, scaling and deformation invariant scattering for texture ´ discrimination. In CVPR, 2013.
+
+Hugues Thomas, Charles R Qi, Jean-Emmanuel Deschaud, Beatriz Marcotegui, Franc¸ois Goulette, and Leonidas J Guibas. Kpconv: Flexible and deformable convolution for point clouds. In ICCV, 2019.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017.
+
+Dequan Wang, Evan Shelhamer, Bruno Olshausen, and Trevor Darrell. Dynamic scale inference by entropy optimization. arXiv preprint arXiv:1908.03182, 2019.
+
+Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In CVPR, 2018.
+
+Daniel E Worrall, Stephan J Garbin, Daniyar Turmukhambetov, and Gabriel J Brostow. Harmonic networks: Deep translation and rotation equivariance. In CVPR, 2017.
+
+Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, and Kaiming He. Aggregated residual trans-´ formations for deep neural networks. In CVPR, 2017.
+
+Yuwen Xiong, Mengye Ren, Renjie Liao, Kelvin Wong, and Raquel Urtasun. Deformable filter convolution for point cloud reasoning. arXiv preprint arXiv:1907.13079, 2019.
+
+Brandon Yang, Gabriel Bender, Quoc V Le, and Jiquan Ngiam. Soft conditional computation. arXiv preprint arXiv:1904.04971, 2019.
+
+Richard Zhang. Making convolutional networks shift-invariant again. In ICML, 2019.
+
+Xizhou Zhu, Han Hu, Stephen Lin, and Jifeng Dai. Deformable convnets v2: More deformable, better results. In CVPR, 2019.
+
+![](images/5abbb82c034f8a61878e301501e3654d6912395090b816e2237653329513f497.jpg)  
+Figure 5: Illustration of feed-forwarding through a $\mathbf { 3 \times 3 }$ local Deformable Kernel from a $4 \times 4$ scope. For each input patch, local DK first generates a group of kernel offsets $\{ \Delta k \}$ from input feature patch using the light-weight generator $\mathcal { G }$ (a $3 \times 3$ convolution of rigid kernel). Given the original kernel weights $W$ and the offset group $\{ \Delta k \}$ , DK samples a new set of kernel $W ^ { \prime }$ using a bilinear sampler $\boldsymbol { B }$ . Finally, DK convolves the input feature map and the sampled kernels to complete the whole computation.
+
+# A COMPUTATION FLOW OF DEFORMABLE KERNELS
+
+We now cover more details on implementing DKs by elaborating the computation flow of their forward and backward passes. We will focus on the local DK given its superior performance in practice. The extension to global DK implementation is straight-forward.
+
+# A.1 FORWARD PASS
+
+In Section 3.3, we introduce a kernel offset generator $\mathcal { G }$ and a bilinear sampler $\boldsymbol { B }$ . Figure 5 illustrates an example of the forward pass.
+
+Concretely, given a kernel $W$ and a learned group of kernel offsets $\{ \Delta k \}$ on top of a regular 2D grid $\{ k \}$ , we can resample a new kernel $W ^ { \prime }$ by a bilinear operator $\boldsymbol { B }$ as
+
+$$
+\begin{array} { c } { W ^ { \prime } \equiv W _ { k + \Delta k } = \displaystyle \sum _ { k ^ { \prime } \in K } | \beta ( k + \Delta k , k ^ { \prime } ) W _ { k ^ { \prime } } , } \\ { \displaystyle \mathcal { B } ( k + \Delta k , k ^ { \prime } ) = \operatorname* { m a x } ( 0 , 1 - | k _ { x } + \Delta k _ { x } - k _ { x } ^ { \prime } | ) \cdot \operatorname* { m a x } ( 0 , 1 - | k _ { y } + \Delta k _ { y } - k _ { y } ^ { \prime } | ) . } \end{array}
+$$
+
+Given this resampled kernel, DK convolves it with the input image just as in normal convolutions using rigid kernels, characterized by Equation 1.
+
+# A.2 BACKWARD PASS
+
+The backward pass of local DK consists of three types of gradients: (1) the gradient to the data of the previous layer, (2) the gradient to the full scope kernel of the current layer and (3) the additional gradient to the kernel offset generator of the current layer. The first two types of gradients share same forms of the computation comparing to the normal convolutions. We now cover the computation for the third flow of gradient that directs where to sample kernel values.
+
+In the context of Equation 7, the partial derivative of a output item $O _ { j }$ w.r.t. $x$ component of a given kernel offset $\Delta k _ { x }$ (similar for its $y$ component $\Delta k _ { y }$ ) can be computed as
+
+$$
+\frac { \partial O _ { j } } { \partial \Delta k _ { x } } = \sum _ { k } I _ { j + k } \bigg ( \sum _ { k ^ { \prime } } W _ { k ^ { \prime } } \frac { \partial \mathcal { B } ( k + \Delta k , k ^ { \prime } ) } { \partial \Delta k _ { x } } \bigg ) ,
+$$
+
+$$
+\frac { \partial \mathcal { B } ( k + \Delta k , k ^ { \prime } ) } { \partial \Delta k _ { x } } = \operatorname* { m a x } ( 0 , 1 - | k _ { y } + \Delta k _ { y } - k _ { y } ^ { \prime } | ) \cdot \left\{ \begin{array} { l l } { 0 } & { | k _ { x } + \Delta k _ { x } - k _ { x } ^ { \prime } | \ge 1 } \\ { 1 } & { k _ { x } + \Delta k _ { x } < k _ { x } ^ { \prime } } \\ { - 1 } & { k _ { x } + \Delta k _ { x } \ge k _ { x } ^ { \prime } } \end{array} \right. .
+$$
+
+Table 5: Network architecture of our ResNet-50-DW comparing to the original ResNet-50 Inside the brackets are the general shape of a residual block, including filter sizes and feature dimensionalities. The number of stacked blocks on each stage is presented outside the brackets. $G = 1 2 8 ^ { \prime \prime }$ suggests the depthwise convolution with 128 input channels. Two models have similar numbers of parameters and FLOPs. At the same time, depthwise convolutions facilitate the computation efficiency of our Deformable Kernels.   
+
+<table><tr><td rowspan=1 colspan=1>Output</td><td rowspan=1 colspan=3>ResNet-50</td><td rowspan=1 colspan=4>ResNet-50-DW</td></tr><tr><td rowspan=1 colspan=1>112 × 112</td><td rowspan=1 colspan=7>7 × 7,64,stride 2</td></tr><tr><td rowspan=1 colspan=1>56×56</td><td rowspan=1 colspan=7>3 × 3 max pool, stride 2</td></tr><tr><td rowspan=1 colspan=1>56×56</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,643 ×3,641 × 1,256</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>1 ×1,1283 × 3,128,G = 1281 × 1,256</td><td rowspan=1 colspan=1>×3</td></tr><tr><td rowspan=1 colspan=1>28×28</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,1283 ×3,1281 × 1,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>1 ×1,2563 × 3,256,G = 2561 ×1,512</td><td rowspan=1 colspan=1>×4</td></tr><tr><td rowspan=1 colspan=1>14 ×14</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1 ×1,2563 ×3,2561 × 1,1024</td><td rowspan=1 colspan=1>×6</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>1 ×1,5123 × 3,512,G = 5121 × 1,1024</td><td rowspan=1 colspan=1>×6</td></tr><tr><td rowspan=1 colspan=1>7×7</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1 ×1,5123 ×3,5121 × 1,2048</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>1 ×1,10243 × 3,1024,G =10241 × 1,2048</td><td rowspan=1 colspan=1>×3</td></tr><tr><td rowspan=1 colspan=1>1×1</td><td rowspan=1 colspan=7>7 × 7 global average pool,1000-d fc, softmax</td></tr><tr><td rowspan=1 colspan=1>#P (M)</td><td rowspan=1 colspan=3>25.6</td><td rowspan=1 colspan=4>23.7</td></tr><tr><td rowspan=1 colspan=1>GFLOPs</td><td rowspan=1 colspan=3>3.86</td><td rowspan=1 colspan=4>3.82</td></tr></table>
+
+# B NETWORK ARCHITECTURES
+
+Table 5 shows the comparison between the original ResNet-50 (He et al., 2016) and our modified ResNet-50-DW. The motivation of introducing depthwise convolutions to ResNet is to accelerate the computation of local DKs based on our current implementations. The ResNet-50-DW model has similar model capacity/complexity and performance (see Table 1) compared to its non-depthwise counterpart, making it an ideal base architecture for our experiments.
+
+On the other hand, in all of our experiments, MobileNet-V2 (Sandler et al., 2018) base model is left untouched.
+
+# C ADDITIONAL COMPARISON OF EFFECTIVE RECEPTIVE FIELDS
+
+We here show additional comparison of ERFs when objects have different kinds of deformations in Figure 6. Comparing to baseline, our method can adapt ERFs to be more persistent to object’s semantic rather than its geometric configuration.
+
+# D ADDITIONAL EXPERIMENT DETAILS
+
+Image Classification: Similar to Goyal et al. (2017); Loshchilov & Hutter (2017), training is performed by SGD for 90 epochs with momentum 0.9 and batch size 256. We set our learning rate of $1 0 ^ { - 1 }$ so that it linearly warms up from zero within first 5 epochs. A cosine training schedule is applied over the training epochs. We use scale and aspect ratio augmentation with color perturbation as standard data augmentations. We evaluate the performance of trained models on the ImageNet 2012 validation set. The images are resized so that the shorter side is of 256 pixels. We then centrally crop $2 2 4 \times 2 2 4$ windows from the images as input to measure recognition accuracy.
+
+![](images/fe8c4b789257333e32ac79b42776e417679053ca788bfbae0a2167b18b100042.jpg)  
+Figure 6: Effective Receptive Field Comparison between rigid kernels and DKs under different kinds of Object Deformation. At each row and from left to right, we show the original image $( 1 3 0 0 \times 8 0 0 )$ , the image rotated by -90 degrees and the image scaled by 1.5 times. Images are cropped and resized for the typesetting purpose.

parse/train/SkxSv6VFvS/SkxSv6VFvS_content_list.json

@@ -0,0 +1,1752 @@
+[
+    {
+        "type": "text",
+        "text": "DEFORMABLE KERNELS: ADAPTING EFFECTIVE RECEPTIVE FIELDS FOR OBJECT DEFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hang $\\mathbf { G a o ^ { 1 , 3 * } } ,$ Xizhou $\\mathbf { Z } \\mathbf { h } \\mathbf { u } ^ { 2 , 3 * }$ , Steve $\\mathbf { L i n ^ { 3 } }$ , Jifeng Dai3   \n1UC Berkeley 2University of Science and Technology of China 3Microsoft Research Asia   \nhangg@eecs.berkeley.edu, ezra0408@mail.ustc.edu.cn   \n{stevelin,jifdai}@microsoft.com   \nhttp://people.eecs.berkeley.edu/˜hangg/deformable-kernels/ ",
+        "bbox": [
+            184,
+            167,
+            774,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            277,
+            544,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional networks are not aware of an object’s geometric variations, which leads to inefficient utilization of model and data capacity. To overcome this issue, recent works on deformation modeling seek to spatially reconfigure the data towards a common arrangement such that semantic recognition suffers less from deformation. This is typically done by augmenting static operators with learned free-form sampling grids in the image space, dynamically tuned to the data and task for adapting the receptive field. Yet adapting the receptive field does not quite reach the actual goal – what really matters to the network is the effective receptive field (ERF), which reflects how much each pixel contributes. It is thus natural to design other approaches to adapt the ERF directly during runtime. ",
+        "bbox": [
+            233,
+            309,
+            764,
+            448
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we instantiate one possible solution as Deformable Kernels (DKs), a family of novel and generic convolutional operators for handling object deformations by directly adapting the ERF while leaving the receptive field untouched. At the heart of our method is the ability to resample the original kernel space towards recovering the deformation of objects. This approach is justified with theoretical insights that the ERF is strictly determined by data sampling locations and kernel values. We implement DKs as generic drop-in replacements of rigid kernels and conduct a series of empirical studies whose results conform with our theories. Over several tasks and standard base models, our approach compares favorably against prior works that adapt during runtime. In addition, further experiments suggest a working mechanism orthogonal and complementary to previous works. ",
+        "bbox": [
+            233,
+            450,
+            764,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            631,
+            336,
+            647
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The rich diversity of object appearance in images arises from variations in object semantics and deformation. Semantics describe the high-level abstraction of what we perceive, and deformation defines the geometric transformation tied to specific data (Gibson, 1950). Humans are remarkably adept at making abstractions of the world (Hudson & Manning, 2019); we see in raw visual signals, abstract semantics away from deformation, and form concepts. ",
+        "bbox": [
+            174,
+            662,
+            823,
+            732
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, modern convolutional networks follow an analogous process by making abstractions through local connectivity and weight sharing (Zhang, 2019). However, such a mechanism is an inefficient one, as the emergent representations encode semantics and deformation together, instead of as disjoint notions. Though a convolution responds accordingly to each input, how it responds is primarily programmed by its rigid kernels, as in Figure 1(a, b). In effect, this consumes large model capacity and data modes (Shelhamer et al., 2019). ",
+        "bbox": [
+            174,
+            739,
+            823,
+            823
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We argue that the awareness of deformations emerges from adaptivity – the ability to adapt at runtime (Kanazawa et al., 2016; Jia et al., 2016; Li et al., 2019). Modeling of geometric transformations has been a constant pursuit for vision researchers over decades (Lowe et al., 1999; Lazebnik et al., 2006; Jaderberg et al., 2015; Dai et al., 2017). A basic idea is to spatially recompose data towards a common mode such that semantic recognition suffers less from deformation. A recent work that is representative of this direction is Deformable Convolution (Dai et al., 2017; Zhu et al., 2019). As shown in Figure 1(c), it augments the convolutions with free-form sampling grids in the data space. It is previously justified as adapting receptive field, or what we phrase as the “theoretical receptive field”, that defines which input pixels can contribute to the final output. However, theoretical receptive field does not measure how much impact an input pixel actually has. On the other hand, Luo et al. (2016) propose to measure the effective receptive field (ERF), i.e. the partial derivative of the output with respect to the input data, to quantify the exact contribution of each raw pixel to the convolution. Since adapting the theoretical receptive field is not the goal but a means to adapt the ERF, why not directly tune the ERF to specific data and tasks at runtime? ",
+        "bbox": [
+            174,
+            830,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a917c7f3a2bc01e2dd8b2cc933d94663ffbda1043f70c227f8d800fbf1704a7e.jpg",
+        "image_caption": [
+            "Figure 1: Adaptation for deformation. We show how different $3 \\times 3$ convolutions interact with deformations of two images. Kernel spaces are visualized as flat 2D Gaussians. Each “ $\\cdot + \\overrightarrow { \\mathbf { \\Gamma } }$ indicates a computation between a pixel and a kernel value sampled from the data and kernel space. Their colors represent corresponding kernel values. (a, b) Rigid kernels cannot adapt to specific deformations, thus consuming large model and data capacity. (c) Deformable Convolutions (Dai et al., 2017) reconfigure data towards common arrangement to counter the effects of geometric deformation. (d) Our Deformable Kernels (DKs) instead resample kernels and, in effect, adapt kernel spaces while leaving the data untouched. Note that (b) and (c) share kernel values but sample different data locations, while (b) and (d) share data locations but sample different kernel values. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            102,
+            808,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            512,
+            825,
+            638
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Toward this end, we introduce Deformable Kernels (DKs), a family of novel and generic convolutional operators for deformation modeling. We aim to augment rigid kernels with the expressiveness to directly interact with the ERF of the computation during inference. Illustrated in Figure 1(d), DKs learn free-form offsets on kernel coordinates to deform the original kernel space towards specific data modality, rather than recomposing data. This can directly adapt ERF while leaving receptive field untouched. The design of DKs that is agnostic to data coordinates naturally leads to two variants – the global DK and the local DK, which behave differently in practice as we later investigate. We justify our approach with theoretical results which show that ERF is strictly determined by data sampling locations and kernel values. Used as a generic drop-in replacement of rigid kernels, DKs achieve empirical results coherent with our developed theory. Concretely, we evaluate our operator with standard base models on image classification and object detection. DKs perform favorably against prior works that adapt during runtime. With both quantitative and qualitative analysis, we further show that DKs can work orthogonally and complementarily with previous techniques. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            857,
+            354,
+            873
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We distinguish our work within the context of deformation modeling as our goal, and dynamic inference as our means. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deformation Modeling: We refer to deformation modeling as learning geometric transformations in 2D image space without regard to 3D. One angle to attack deformation modeling is to craft certain geometric invariances into networks. However, this usually requires designs specific to certain kinds of deformation, such as shift, rotation, reflection and scaling (Sifre & Mallat, 2013; Bruna & Mallat, 2013; Kanazawa et al., 2016; Cohen & Welling, 2016; Worrall et al., 2017; Esteves et al., 2018). Another line of work on this topic learns to recompose data by either semi-parameterized or completely free-form sampling in image space: Spatial Transformers (Jaderberg et al., 2015) learns 2D affine transformations, Deep Geometric Matchers (Rocco et al., 2017) learns thin-plate spline transformations, Deformable Convolutions (Dai et al., 2017; Zhu et al., 2019) learns free-form transformations. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We interpret sampling data space as an effective approach to adapt effective receptive fields (ERF) by directly changing receptive field. At a high-level, our Deformable Kernels (DKs) share intuitions with this line of works for learning geometric transformations, yet are instantiated by learning to sample in kernel space which directly adapt ERF while leaving theoretical receptive fields untouched. While kernel space sampling is also studied in Deformable Filter (Xiong et al., 2019) and KPConv (Thomas et al., 2019), but in their contexts, sampling grids are computed from input point clouds rather than learned from data corpora. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dynamic Inference: Dynamic inference adapts the model or individual operators to the observed data. The computation of our approach differs from self-attention (Vaswani et al., 2017; Wang et al., 2018) in which linear or convolution modules are augmented with subsequent queries that extract from the same input. We consider our closest related works in terms of implementation as those approaches that adapt convolutional kernels at run time. It includes but is not limited to Dynamic Filters (Jia et al., 2016), Selective Kernels (Li et al., 2019) and Conditional Convolutions (Yang et al., 2019). All of these approaches can learn and infer customized kernel spaces with respect to the data, but are either less inefficient or are loosely formulated. Dynamic Filters generate new filters from scratch, while Conditional Convolutions extend this idea to linear combinations of a set of synthesized filters. Selective Kernels are, on the other hand, comparably lightweight, but aggregating activations from kernels of different size is not as compact as directly sampling the original kernel space. Another line of works contemporary to ours (Shelhamer et al., 2019; Wang et al., 2019) is to compose free-form filters with structured Gaussian filters, which essentially transforms kernel spaces by data. Our DKs also differ from these works with the emphasize of direct adaptation the ERF rather than the theoretical receptive field. As mentioned previously, the true goal should be to adapt the ERF, and to our knowledge, our work is the first to study dynamic inference of ERFs. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            297,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We start by covering preliminaries on convolutions, including the definition of effective receptive field (ERF). We then formulate a theoretical framework for analyzing ERFs, and thus motivate our Deformable Kernels (DKs). We finally elaborate different DK variants within such a framework. Our analysis suggests compatibility between DKs and the prior work. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 A DIVE INTO CONVOLUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            702,
+            423,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2D Convolution: Let us first consider an input image $\\pmb { I } \\in \\mathbb { R } ^ { D \\times D }$ . By convolving it with a kernel $\\pmb { W } \\in \\mathbb { R } ^ { K \\times K }$ of stride 1, we have an output image $o$ whose pixel values at each coordinate $j \\in \\mathbb R ^ { 2 }$ can be expressed as ",
+        "bbox": [
+            173,
+            727,
+            825,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/785106a0ed31fb4225fadcd0ab4bb64dbc2b62be4ec704e70c987b4c0793f814.jpg",
+        "text": "$$\nO _ { j } = \\sum _ { k \\in \\mathcal { K } } I _ { j + k } W _ { k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            768,
+            563,
+            800
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "by enumerating discrete kernel positions $\\boldsymbol { k }$ within the support $\\mathcal { K } = [ - K / 2 , K / 2 ] ^ { 2 } \\cap \\mathbb { Z }$ . This defines a rigid grid for sampling data and kernels. ",
+        "bbox": [
+            173,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theoretical Receptive Field: The same kernel $W$ can be stacked repeatedly to form a linear convolutional network with $n$ layers. The theoretical receptive field can then be imagined as the “accumulative coverage” of kernels at each given output unit on the input image by deconvolving back through the network. This property characterizes a set of input fields that could fire percepts onto corresponding output pixels. The size of a theoretical receptive field scales linearly with respect to the network depth $n$ and kernel size $K$ (He et al., 2016). ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Effective Receptive Field: Intuitively, not all pixels within a theoretical receptive field contribute equally. The influence of different fields varies from region to region thanks to the central emphasis of stacked convolutions and also to the non-linearity induced by activations. The notion of effective receptive field (ERF) (Luo et al., 2016) is thus introduced to measure the impact of each input pixel on the output at given locations. It is defined as a partial derivative field of the output with respect to the input data. With the numerical approximations in linear convolution networks, the ERF was previously identified as a Gaussian-like soft attention map over input images whose size grows fractionally with respect to the network depth $n$ and linearly to the kernel size $K$ . Empirical results validate this idea under more complex and realistic cases when networks exploit non-linearities, striding, padding, skip connections, and subsampling. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 ANALYSIS ON EFFECTIVE RECEPTIVE FIELDS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            258,
+            531,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We aim to revisit and complement the previous analysis on ERFs by Luo et al. (2016). While the previous analysis concentrates on studying the expectation of an ERF, i.e., when network depth $n$ approaches infinity or all kernels are randomly distributed without learning in general, our analysis focuses on how we can perturb the computation such that the change in ERF is predictable, given an input and a set of kernel spaces. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We start our analysis by considering a linear convolutional network, without any unit activations, as defined in Section 3.1. For consistency, superscripts are introduced to image $\\pmb { I }$ , kernel $W$ , and subscripts to kernel positions $\\boldsymbol { k }$ to denote the index $s \\in [ 1 , n ]$ of each layer. Formally, given an input image $\\pmb { I } ^ { ( 0 ) }$ and a set of $K \\times K$ kernels $\\{ W ^ { ( s ) } \\} _ { s = 1 } ^ { n }$ of stride 1, we can roll out the final output ${ \\cal O } \\equiv { \\cal I } ^ { ( n ) }$ by unfolding Equation 1 as ",
+        "bbox": [
+            176,
+            361,
+            823,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4d0f6925d3ec949e4c211ec9d9a44a37fd7e28b11787c611b96446eb3b2375cd.jpg",
+        "text": "$$\n\\begin{array} { l } { { { \\cal I } _ { j } ^ { ( n ) } = \\displaystyle \\sum _ { k _ { n } \\in { \\cal K } } { \\cal I } _ { j + k _ { n } } ^ { ( n - 1 ) } { \\cal W } _ { k _ { n } } ^ { ( n ) } = \\displaystyle \\sum _ { ( k _ { n - 1 } , k _ { n } ) \\in { \\cal K } ^ { 2 } \\atop { } } { \\cal I } _ { j + k _ { n } + k _ { n - 1 } } ^ { ( n - 2 ) } { \\cal W } _ { k _ { n } } ^ { ( n ) } { \\cal W } _ { k _ { n - 1 } } ^ { ( n - 1 ) } = \\cdots } } \\\\ { { = \\displaystyle \\sum _ { ( k _ { 1 } , k _ { 2 } , \\ldots , k _ { n } ) \\in { \\cal K } ^ { n } } \\left( { \\cal I } _ { j + \\sum _ { s = 1 } ^ { n } k _ { s } } ^ { ( 0 ) } \\cdot \\prod _ { s = 1 } ^ { n } { \\cal W } _ { k _ { s } } ^ { ( s ) } \\right) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            438,
+            735,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By definition1, the effective receptive field value $\\mathcal { R } ^ { ( n ) } ( i ; j ) \\equiv \\partial I _ { j } ^ { ( n ) } / \\partial I _ { i } ^ { ( 0 ) }$ of output coordinate $j$ that takes input coordinate $_ i$ can be computed by ",
+        "bbox": [
+            173,
+            523,
+            823,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec2d0d9d897f7d295a2405647b593cf7b72e33ca535ed390b0fef2039da745c3.jpg",
+        "text": "$$\n\\mathcal { R } ^ { ( n ) } ( i ; j ) = \\sum _ { ( k _ { 1 } , k _ { 2 } , \\ldots , k _ { n } ) \\in K ^ { n } } \\left( \\mathbb { 1 } \\left[ j + \\sum _ { s = 1 } ^ { n } k _ { s } = i \\right] \\cdot \\prod _ { s = 1 } ^ { n } W _ { k _ { s } } ^ { ( s ) } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            560,
+            700,
+            606
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { 1 } [ \\cdot ]$ denotes the indicator function. This result indicates that ERF is related only to the data sampling location $j$ , kernel sampling location $\\boldsymbol { k }$ , and kernel matrices $\\{ W ^ { ( s ) } \\}$ . ",
+        "bbox": [
+            173,
+            609,
+            823,
+            641
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If we replace the $m ^ { \\mathrm { t h } }$ kernel $W ^ { ( m ) }$ with a $1 \\times 1$ kernel of a single parameter $W _ { \\tilde { \\boldsymbol { k } } _ { m } } ^ { ( m ) }$ sampled from it, the value of ERF becomes to ",
+        "bbox": [
+            171,
+            648,
+            823,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66c20b6fedf15073b1f4ca65c88e193746eefcc42b4c08648ed593835186f268.jpg",
+        "text": "$$\n\\mathcal { R } ^ { ( n ) } ( i ; j , \\tilde { k } _ { m } ) = \\sum _ { ( k _ { 1 } , \\dots , k _ { m - 1 } , k _ { m + 1 } , \\dots , k _ { n } ) \\in K ^ { n - 1 } } \\left( \\mathbb { 1 } \\left[ j + \\sum _ { s \\in \\mathbb { S } } k _ { s } = i \\right] \\cdot \\prod _ { s \\in \\mathbb { S } } W _ { k _ { s } } ^ { ( s ) } \\cdot W _ { \\tilde { k } _ { m } } ^ { ( m ) } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            684,
+            784,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { S } = [ 1 , n ] \\backslash \\{ m \\}$ . Since a $K \\times K$ kernel can be deemed as a composition of $K ^ { 2 } 1 \\times 1$ kernels distributed on a square grid, Equation 3 can thus be reformulated as ",
+        "bbox": [
+            173,
+            736,
+            825,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43a24a6a8f988ab4faf961b6a24ca6e2147206fc9cdc64011e67bf2ebce57d98.jpg",
+        "text": "$$\n\\mathcal { R } ^ { ( n ) } ( i ; j ) = \\sum _ { k _ { m } \\in \\mathcal { K } } \\mathcal { R } ^ { ( n ) } ( i ; j + k _ { m } , k _ { m } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            768,
+            629,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the case of complex non-linearities, where we here consider post $\\mathrm { R e L U } ^ { 2 }$ activations in Equation 1, ",
+        "bbox": [
+            174,
+            806,
+            823,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d447143cee3fafd22e3729f18038dc74d9d5120ef20da1e1bad0d9d8716dadaf.jpg",
+        "text": "$$\nO _ { j } = \\operatorname* { m a x } ( \\sum _ { k \\in \\mathcal { K } } I _ { j + k } W _ { k } , 0 ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            830,
+            591,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can follow a similar analysis and derive corresponding ERF as ",
+        "bbox": [
+            173,
+            103,
+            609,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd88a68380a532b2d2e5f0806b3d9d35dcad7145d9c4cd642d2e87175b43456d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { R } ^ { ' ( n ) } ( i ; j , \\tilde { k } _ { m } ) = \\displaystyle \\sum _ { ( k _ { 1 } , \\cdots , k _ { m - 1 } , k _ { m + 1 } , \\cdots , k _ { n } ) \\in K ^ { n - 1 } } \\left( \\mathcal { C } ^ { ( n ) } ( i ; j , k _ { 1 } , \\cdots , k _ { n } , \\tilde { k } _ { m } ) \\cdot \\prod _ { s \\in \\mathbb { S } } W _ { \\tilde { k } _ { s } } ^ { ( s ) } \\cdot W _ { \\tilde { k } _ { m } } ^ { m } \\right) } \\\\ & { \\mathcal { C } ^ { ( n ) } ( i ; j , k _ { 1 } , \\cdots , k _ { n } , \\tilde { k } _ { m } ) = \\mathbb { 1 } \\big [ j + \\displaystyle \\sum _ { s \\in \\mathbb { S } } k _ { s } = i \\big ] \\prod _ { s \\in \\mathbb { S } } \\mathbb { 1 } \\big [ \\displaystyle I _ { j } ^ { ( s - 1 ) } W _ { \\tilde { k } _ { s } } ^ { ( s ) } > 0 \\big ] \\mathbb { 1 } \\big [ I _ { j } ^ { ( m - 1 ) } W _ { \\tilde { k } _ { m } } ^ { ( m ) } > 0 \\big ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            125,
+            828,
+            200
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here we can see that the ERF becomes data-dependent due to the coefficient $\\mathcal { C }$ , which is tied to input coordinates, kernel sampling locations, and input data $\\pmb { I } ^ { ( 0 ) }$ . The more detailed analysis of this coefficient is beyond the scope of this paper. However, it should be noted that this coefficient only “gates” the contribution of the input pixels to the output. So in practice, ERF is “porous” – there are inactive (or gated) pixel units irregularly distributed around the ones that fire. This phenomenon also appeared in previous studies (such as in Luo et al. (2016), Figure 1). The maximal size of an ERF is still controlled by the data sampling location and kernel values as in the linear cases in Equation 5. ",
+        "bbox": [
+            173,
+            205,
+            825,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A nice property of Equation 4 and Equation 5 is that all computations are linear, making it compatible with any linear sampling operators for querying kernel values of fractional coordinates. In other words, sampling kernels in effect samples the ERF on the data in the linear case, but also roughly generalizes to non-linear cases as well. This finding motivates our design of Deformable Kernels (DKs) in Section 3.3. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 DEFORMABLE KERNELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            398,
+            383,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the context of Equation 1, we resample the kernel $W$ with a group of learned kernel offsets denoted as $\\{ \\Delta k \\}$ that correspond to each discrete kernel position $\\boldsymbol { k }$ . This defines our DK as ",
+        "bbox": [
+            173,
+            424,
+            825,
+            453
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3a071f9861f1e7be515522dff815c71dcaeddb8819e4f0c10a0dc277de76b66f.jpg",
+        "text": "$$\nO _ { j } = \\sum _ { k \\in \\mathcal K } I _ { j + k } W _ { k + \\Delta k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            460,
+            576,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and the value of ERF as ",
+        "bbox": [
+            174,
+            498,
+            333,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f56f6e5ab1490d7e415b55fc4a12313b41979597ac64d47ec5fa095c7b81272d.jpg",
+        "text": "$$\n\\mathcal { R } _ { \\mathrm { D K } } ^ { ( n ) } ( i ; j ) = \\sum _ { k _ { m } \\in { \\mathcal { K } } } \\mathcal { R } ^ { ( n ) } ( i ; j + k _ { m } , k _ { m } + \\Delta k _ { m } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            516,
+            655,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that this operation leads to sub-pixel sampling in the kernel space. In practice, we use bilinear sampling to interpolate within the discrete kernel grid. ",
+        "bbox": [
+            173,
+            554,
+            823,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the size (resolution) of the original kernel space can affect sampling performance. Concretely, suppose we want to sample a $3 \\times 3$ kernel. DKs do not have any constraint on the size of the original kernel space, which we call the “scope size” of DKs. That said, we can use a $W$ of any size $K ^ { \\prime }$ even though the number of sampling locations is fixed as $K ^ { 2 }$ . We can thus exploit large kernels – the largest ones can reach $9 \\times 9$ in our experiments with nearly no overhead in computation since bilinear interpolations are extremely lightweight compared to the cost of convolutions. This can also increase the number of learning parameters, which in practice might become intractable if not handled properly. In our implementation, we will exploit depthwise convolutions (Howard et al., 2017) such that increasing scope size induces a negligible amount of extra parameters. ",
+        "bbox": [
+            173,
+            588,
+            825,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As previously discussed, sampling the kernel space in effect transforms into sampling the ERF. On the design of locality and spatial granularity of our learned offsets, DK naturally delivers two variants – the global DK and the local DKs, as illustrated in Figure 2. In both operators, we learn a kernel offset generator $\\mathcal { G }$ that maps an input patch into a set of kernel offsets that are later applied to rigid kernels. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In practice, we implement $\\mathcal { G } _ { \\mathrm { g l o b a l } }$ as a stack of one global average pooling layer, which reduces feature maps into a vector, and another fully-connected layer without non-linearities, which projects the reduced vector into an offset vector of $2 K ^ { 2 }$ dimensions. Then, we apply these offsets to all convolutions for the input image following Equation 7. For local DKs, we implement $\\mathcal { G } _ { \\mathrm { l o c a l } }$ as an extra convolution that has the same configuration as the target kernel, except that it only has $2 K ^ { 2 }$ output channels. This produces kernel sampling offsets $\\{ \\Delta k \\}$ that are additionally indexed by output locations $j$ . It should be noted that similar designs were also discussed in Jia et al. (2016), in which filters are generated given either an image or individual patches from scratch rather than by resampling. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2bb9668aaa37218849f82168db9cfaca57d102ffed1c046e386e2dacf5e7d991.jpg",
+        "image_caption": [
+            "Figure 2: Instantiations. We show how DK variants works with an example image that contains a large and a small object. (a) The global DK learns one set of kernel sampling grid given an input image and apply it to all data positions. (b) The local DK adapts kernels for each input patches, and induces better locality for deformation modeling. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            102,
+            808,
+            328
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, we expect the global DK to adapt kernel space between different images but not within a single input. The local DK can further adpat to specific image patches: for smaller objects, it is better to have shaper kernels and thus denser ERF; for larger objects, flatter kernels can be more beneficial for accumulating a wider ERF. On a high level, local DKs can preserve better locality and have larger freedom to adapt kernel spaces comparing to its global counterpart. We later compare these operators in our experiments. ",
+        "bbox": [
+            173,
+            415,
+            825,
+            500
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 LINK WITH DEFORMABLE CONVOLUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            515,
+            514,
+            530
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The core idea of DKs is to learn adaptive offsets to sample the kernel space for modeling deformation, which makes them similar to Deformable Convolutions (Dai et al., 2017; Zhu et al., 2019), at both the conceptual and implementation levels. Here, we distinguish DKs from Deformable Convolutions and show how they can be unified. ",
+        "bbox": [
+            173,
+            541,
+            825,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Deformable Convolutions can be reformulated in a general form as ",
+        "bbox": [
+            179,
+            604,
+            611,
+            618
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/efaef5c86c9f740a90478babf1316252a167b47cdfdcaa5be7194b813e6d9bff.jpg",
+        "text": "$$\nO _ { j } = \\sum _ { k \\in \\mathcal { K } } I _ { j + k + \\Delta j } W _ { k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            621,
+            576,
+            652
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where they aim to learn a group of data offsets $\\{ \\Delta j \\}$ with respect to discrete data positions $j$ . For consistency for analysis, the value of effective receptive field becomes ",
+        "bbox": [
+            176,
+            655,
+            823,
+            684
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7c245ee76fcf8f76a73be5d04308fd0b312e6965271bcc1a3fb5805d4dbe3ebe.jpg",
+        "text": "$$\n\\mathcal { R } _ { \\mathrm { D C } } ^ { ( n ) } ( i ; j ) = \\sum _ { k _ { m } \\in \\mathcal { K } } \\mathcal { R } ^ { ( n ) } ( i ; j + k _ { m } + \\Delta j _ { m } , k _ { m } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            686,
+            653,
+            719
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This approach essentially recomposes the input image towards common modes such that semantic recognition suffers less from deformation. Moreover, according to our previous analysis in Equation 5, sampling data is another way of sampling the ERF. This, to a certain extent, also explains why Deformable Convolutions are well suited for learning deformation-agnostic representations. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            777
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we can learn both data and kernel offsets in one convolutional operator. Conceptually, this can be done by merging Equation 7 with Equation 9, which leads to ",
+        "bbox": [
+            174,
+            784,
+            821,
+            813
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/959a93bfb29f3ef6ec6a295944b46034218c0d6a06f2e29aa1487d882023ad74.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\displaystyle { \\cal O } _ { j } = \\displaystyle \\sum _ { k \\in { \\cal K } } { \\cal I } _ { j + k + \\Delta j } W _ { k + \\Delta k } , } } \\\\ { { \\displaystyle \\mathcal { R } _ { \\mathrm { D C + D K } } ^ { ( n ) } ( i ; j ) = \\displaystyle \\sum _ { k _ { m } \\in { \\cal K } } { \\cal R } ^ { ( n ) } ( i ; j + k _ { m } + \\Delta j _ { m } , k _ { m } + \\Delta k _ { m } ) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            815,
+            687,
+            880
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also investigate this operator in our experiments. Although the two techniques may be viewed as serving a similar purpose, we find the collaboration between Deformable Kernels and Deformable Convolutions to be powerful in practice, suggesting strong compatibility. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            326,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our Deformable Kernels (DKs) on image classification using ILSVRC and object detection using the COCO benchmark. Necessary details are provided to reproduce our results, together with descriptions on base models and strong baselines for all experiments and ablations. For taskspecific considerations, we refer to each corresponding section. ",
+        "bbox": [
+            174,
+            135,
+            823,
+            190
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details: We implement our operators in PyTorch and CUDA. We exploit depthwise convolutions when designing our operator for better computational efficiency3. We initialize kernel grids to be uniformly distributed within the scope size. For the kernel offset generator, we set its learning rate to be a fraction of that of the main network, which we cross-validate for each base model. We also find it important to clip sampling locations inside the original kernel space, such that $\\pmb { k } + \\Delta \\pmb { k } \\in \\mathcal { K }$ in Equation 7. ",
+        "bbox": [
+            174,
+            198,
+            825,
+            281
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Base Models: We choose our base models to be ResNet-50 (He et al., 2016) and MobileNetV2 (Sandler et al., 2018), following the standard practice for most vision applications. As mentioned, we exploit depthwise convolution and thus make changes to the ResNet model. Concretely, we define our ResNet-50-DW base model by replacing all $3 \\times 3$ convolutions by its depthwise counterpart while doubling the dimension of intermediate channels in all residual blocks. We find it to be a reasonable base model compared to the original ResNet-50, with comparable performance on both tasks. During training, we set the weight decay to be $4 \\times 1 0 ^ { - 5 }$ rather than the common $1 0 ^ { - 4 }$ for both models since depthwise models usually underfit rather than overfit (Xie et al., 2017; Howard et al., 2017; Hu et al., 2018). We set the learning rate multiplier of DK operators as $1 0 ^ { - 2 }$ fo r ResNet-50-DW and $1 0 ^ { - 1 }$ for MobileNet-V2 in all of our experiments. ",
+        "bbox": [
+            173,
+            287,
+            825,
+            426
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Strong Baselines: We develop our comparison with two previous works: Conditional Convolutions (Yang et al., 2019) for dynamics inference, and Deformable Convolutions (Dai et al., 2017; Zhu et al., 2019) for deformation modeling. We choose Conditional Convolutions due to similar computation forms – sampling can be deemed as an elementewise “expert voting” mechanism. For fair comparisons, We reimplement and reproduce their results. We also combine our operator with these previous approach to show both quantitative evidence and qualitative insight that our working mechanisms are compatible. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            531
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 IMAGE CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            551,
+            383,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first train our networks on the ImageNet 2012 training set (Deng et al., 2009). We adopt a common experiment protocol for fair comparisons as in Goyal et al. (2017); Loshchilov & Hutter (2017). For more details, please refer to our supplement. ",
+        "bbox": [
+            176,
+            577,
+            823,
+            619
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first ablate the scope size of kernels for our DKs and study how it can affect model performance using ResNet-50-DW. As shown in Table 1, our DKs are sensitive to the choice of the scope size. We shown that when only applied to $3 \\times 3$ convolutions inside residual bottlenecks, local DKs induce a $+ 0 . 7$ performance gain within the original scope. By further enlarging the scope size, performance increases yet quickly plateaus at scope $4 \\times 4$ , yielding largest $+ 1 . 4$ gain for top-1 accuracy. Our speculation is that, although increasing scope size theoretically means better interpolation, it also makes the optimization space exponentially larger for each convolutional layer. And since number of entries for updating is fixed, this also leads to relatively sparse gradient flows. In principle, we set default scope size at $4 \\times 4$ for our DKs. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            751
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We next move on and ablate our designs by comparing the global DK with the local DK, shown in the table. Both operators helps while the local variants consistently performs better than their global counterparts, bringing a $+ 0 . 5$ gap on both base models. We also study the effect of using more DKs in the models – the $1 \\times 1$ convolutions are replaced by global $\\mathrm { D K } \\dot { \\mathrm { s } } ^ { 4 }$ with scope $2 \\times 2$ . Note that all $1 \\times 1$ convolutions are not depthwise, and therefore this operation induces nearly 4 times of parameters. We refer their results only for ablation and show that adding more DKs still helps – especially for MobileNet-V2 since it is under-parameterized. This finding also holds for previous models (Yang et al., 2019) as well. ",
+        "bbox": [
+            174,
+            758,
+            823,
+            869
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/652f1d996a9554cdf5fff81dbfd3812d83676c7a832f4e383c6c9aa73bd64b9c.jpg",
+        "table_caption": [
+            "Table 1: Ablations of scope size and different instantiations of DK for image classification. Using proper scope size, and more DK layers boosts performance. Modeling individual offset kernel grid for each data entries is also beneficial. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Backbone</td><td>1×1Deformable Kernels</td><td>3×3Deformable Kernels</td><td>top1 (%)</td><td>#P (M)</td><td>GFLOPs</td></tr><tr><td>ResNet-50</td><td>w/o</td><td>w/o</td><td>76.7</td><td>25.6</td><td>3.86</td></tr><tr><td>ResNet-50-DW</td><td>w/o</td><td>w/o</td><td>76.3</td><td>23.7</td><td>3.82</td></tr><tr><td rowspan=\"4\">ResNet-50-DW</td><td rowspan=\"4\">w/o</td><td>local, scope size 3×3</td><td>77.4</td><td>24.9</td><td>4.32</td></tr><tr><td>local, scope size 4×4</td><td>78.1</td><td>25.0</td><td>4.32</td></tr><tr><td>local, scope size 5×5</td><td>77.8</td><td>25.0</td><td>4.32</td></tr><tr><td>local, scope size 9×9</td><td>77.4</td><td>25.4</td><td>4.32</td></tr><tr><td rowspan=\"4\">ResNet-50-DW</td><td>w/o</td><td>global, scope size 4×4</td><td>77.6</td><td>23.9</td><td>3.82</td></tr><tr><td>global,scope size 2×2</td><td>global, scope size 4×4</td><td>77.9</td><td>80.1</td><td>4.09</td></tr><tr><td>w/o</td><td>local, scope size 4×4</td><td>78.1</td><td>25.0</td><td>4.32</td></tr><tr><td>global, scope size 2×2</td><td>local, scope size 4×4</td><td>78.5</td><td>81.2</td><td>4.60</td></tr><tr><td>MobileNet-V2</td><td>w/o</td><td>w/o</td><td>71.9</td><td>3.5</td><td>0.31</td></tr><tr><td rowspan=\"4\">MobileNet-V2</td><td>w/o</td><td>global, scope size 4×4</td><td>73.6</td><td>3.7</td><td>0.31</td></tr><tr><td>global, scope size 2×2</td><td>global, scope size 4×4</td><td>74.5</td><td>10.1</td><td>0.34</td></tr><tr><td>w/o</td><td>local, scope size 4×4</td><td>74.1</td><td>4.7</td><td>0.73</td></tr><tr><td>global, scope size 2×2</td><td>local, scope size 4×4</td><td>74.8</td><td>11.1</td><td>0.76</td></tr></table>",
+        "bbox": [
+            192,
+            101,
+            805,
+            329
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/891e2d62bba2b5ccc495a0c79ec8157d0f1351b5ca0501564dc64aad1c1b79f7.jpg",
+        "table_caption": [
+            "Table 2: Comparisons to strong baselines for image classification DKs perform comparably or superiorly to previous methods. Further combinations yield consistent gain, suggesting orthogonal and compatible working mechanisms. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Backbone</td><td>1×1Deformable Kernels</td><td>3×3DeformableKernels</td><td>top1 (%)</td><td>#P (M)</td><td>GFLOPs</td></tr><tr><td>ResNet-50-DW</td><td>w/o</td><td>local, scope size 4×4</td><td>78.1</td><td>25.0</td><td>4.32</td></tr><tr><td>ResNet-50-DW</td><td>w/o</td><td>w/o</td><td>77.6</td><td>42.5</td><td>7.13</td></tr><tr><td rowspan=\"2\">with SCC ResNet-50-DW</td><td rowspan=\"2\">w/0</td><td>local, scope size 4×4</td><td>78.9</td><td>43.7</td><td>7.61</td></tr><tr><td>w/o</td><td>78.0</td><td>24.8</td><td>4.10</td></tr><tr><td>with DCN</td><td></td><td>local, scope size 4×4</td><td>79.0</td><td>26.1</td><td>4.60</td></tr><tr><td>MobileNet-V2 MobileNet-V2</td><td>w/o</td><td>local, scope size 4×4</td><td>74.1</td><td>4.7</td><td>0.73</td></tr><tr><td rowspan=\"2\">with SCC</td><td rowspan=\"2\">w/o</td><td>w/o</td><td>74.3</td><td>19.0</td><td>2.19</td></tr><tr><td>local, scope size 4×4</td><td>75.5</td><td>19.7</td><td>2.48</td></tr><tr><td rowspan=\"2\">MobileNet-V2 with DCN</td><td rowspan=\"2\">w/0</td><td>w/o</td><td>73.2</td><td>4.6</td><td>0.52</td></tr><tr><td>local, scope size 4×4</td><td>74.4</td><td>5.8</td><td>0.93</td></tr></table>",
+        "bbox": [
+            192,
+            390,
+            805,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We further compare and combine DKs with Conditional Convolutions and Deformable Convolutions. Results are recorded in Table 2. We can see that DKs perform comparably on ResNet-V2 and compare favorably on MobileNet-V2 – improve $+ 0 . 9$ from Deformable Convolutions and achieve comparable results with less than a quarter number of parameters compared to Conditional Convolutions. Remarkably, we also show that if combined together, even larger performance gains are in reach. We see consistent boost in top-1 accuracy compared to strong baselines: $+ 1 . 3 / + 1 . 0$ on ResNet-50-DW, and $+ 1 . 2 / + 1 . 2$ on MobileNet-V2. These gaps are bigger than those from our own ablation, suggesting the working mechanisms across the operators to be orthogonal and compatible. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            734
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 OBJECT DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            751,
+            356,
+            765
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We examine DKs on the COCO benchmark (Lin et al., 2014). For all experiments, we use Faster R-CNN (Ren et al., 2015) with FPN (Lin et al., 2017) as the base detector, plugging in the backbones we previously trained on ImageNet. For MobileNet-V2, we last feature maps of the each resolution for FPN post aggregation. Following the standard protocol, training and evaluation are performed on the $1 2 0 \\mathrm { k }$ images in the train-val split and the 20k images in the test-dev split, respectively. For evaluation, we measure the standard mean average precision (mAP) and shattered scores for small, medium and large objects. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3 and Table 4 follow the same style of analysis as in image classification. While the baseline methods of ResNet achieve $3 6 . 6 \\ \\mathrm { m A P } ,$ indicating a strong baseline detector, applying local DKs brings a $+ 1 . 2 \\mathrm { m A P }$ improvement when replacing 3x3 rigid kernels alone and a $+ 1 . 8$ mAP improvement when replacing both 1x1 and 3x3 rigid kernels. This trend magnifies on MobileNet-v2 models, where we see an improvement of $+ 1 . 6$ mAP and $+ 2 . 4 \\ \\mathrm { m A P } ,$ , respectively. Results also confirm the effectiveness of local DKs against global DKs, which is again in line with our expectation that local DKs can model locality better. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7350cae2e29b0a46813a9481577bb38913d33309325ba0ce2e1adc93f7c63273.jpg",
+        "table_caption": [
+            "Table 3: Ablations for object detection. Consistent results with image classification. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Backbone</td><td>1×1Deformable Kernels</td><td>3×3Deformable Kernels</td><td>mAP</td><td>mAPs</td><td>mAPM</td><td>mAPL</td></tr><tr><td>ResNet-50-DW</td><td>w/o</td><td>w/o</td><td>36.6</td><td>22.1</td><td>39.9</td><td>46.6</td></tr><tr><td rowspan=\"4\">ResNet-50-DW</td><td>w/o</td><td>global, scope size 4×4</td><td>36.7</td><td>22.6</td><td>40.2</td><td>46.9</td></tr><tr><td>global,scope size 2×2</td><td>global, scope size 4×4</td><td>37.1</td><td>23.1</td><td>40.6</td><td>46.6</td></tr><tr><td>w/o</td><td>local, scope size 4×4</td><td>37.8</td><td>23.4</td><td>41.6</td><td>48.2</td></tr><tr><td>global, scope size 2×2</td><td>local, scope size 4×4</td><td>38.4</td><td>23.4</td><td>42.0</td><td>49.4</td></tr><tr><td>MobileNet-V2</td><td>w/o</td><td>w/o</td><td>31.3</td><td>18.6</td><td>33.7</td><td>40.4</td></tr><tr><td rowspan=\"4\">MobileNet-V2</td><td>w/o</td><td>global, scope size 4×4</td><td>32.5</td><td>19.6</td><td>35.8</td><td>41.9</td></tr><tr><td>global,scope size 2×2</td><td>global, scope size 4×4</td><td>32.9</td><td>19.4</td><td>35.5</td><td>42.8</td></tr><tr><td>w/0</td><td>local, scope size 4×4</td><td>32.9</td><td>19.5</td><td>36.0</td><td>42.5</td></tr><tr><td>global, scope size 2×2</td><td>local, scope size 4×4</td><td>33.7</td><td>20.2</td><td>36.7</td><td>44.0</td></tr></table>",
+        "bbox": [
+            192,
+            101,
+            805,
+            256
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/84f243c0470669e39536a5c1102527d64f8ccb616ae14ac691530cfd41891dfe.jpg",
+        "table_caption": [
+            "Table 4: Comparisons to strong baselines for object detection DKs perform fall short to Deformable Convolution, but combination still improves performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Backbone</td><td>1×1Deformable Kernels</td><td>3×3DeformableKernels</td><td>mAP</td><td>mAPs</td><td>mAPM</td><td>mAPL</td></tr><tr><td>ResNet-50-DW</td><td>global, scope size 2×2</td><td>local, scope size 4×4</td><td>38.4</td><td>23.4</td><td>42.0</td><td>49.4</td></tr><tr><td>ResNet-50-DW</td><td>w/o</td><td>w/o</td><td>36.3</td><td>22.1</td><td>39.3</td><td>47.0</td></tr><tr><td rowspan=\"2\">with SCC ResNet-50-DW</td><td rowspan=\"2\">w/o</td><td>local, scope size 4×4</td><td>38.0</td><td>23.4</td><td>41.9</td><td>48.4</td></tr><tr><td>w/o</td><td>39.9</td><td>24.0</td><td>43.4</td><td>52.6</td></tr><tr><td>with DCN</td><td></td><td>local,scope size 4×4</td><td>40.6</td><td>24.6</td><td>43.9</td><td>53.3</td></tr><tr><td>MobileNet-V2 MobileNet-V2</td><td>global, scope size 2×2</td><td>local, scope size 4×4 w/o</td><td>33.7</td><td>20.2</td><td>36.7</td><td>44.0</td></tr><tr><td rowspan=\"2\">with SCC</td><td rowspan=\"2\">w/o</td><td>local, scope size 4×4</td><td>33.2</td><td>20.5</td><td>35.6</td><td>43.3</td></tr><tr><td></td><td>34.3</td><td>20.2</td><td>37.3</td><td>44.7</td></tr><tr><td>MobileNet-V2 with DCN</td><td>w/o</td><td>w/o local, scope size 4×4</td><td>34.4 35.6</td><td>20.5 20.6</td><td>37.0 38.5</td><td>44.7 47.3</td></tr></table>",
+        "bbox": [
+            192,
+            289,
+            805,
+            444
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            503,
+            825,
+            560
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the comparisons with strong baselines, an interesting phenomenon worth noting is that though DKs perform better than Deformable Convolutions on image classification, they fall noticeably short for object detection measured by mAP. We speculate that even though both techniques can adapt ERF in theory (as justified in Section 3.2), directly shifting sampling locations on data is easier to optimize. Yet after combining DKs with previous approaches, we can consistently boost performance for all the methods – $+ 0 . 7 / + 1 . 2$ for Deformable Convolutions on each base models, and $+ 1 . 7 / + 1 . 1$ for Conditional Convolutions. These findings align with the results from image classification. We next investigate what DKs learn and why they are compatible with previous methods in general. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 WHAT DO DEFORMABLE KERNELS LEARN? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            709,
+            516,
+            723
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Awareness of Object Scale: Since deformation is hard to quantify, we use object scale as a rough proxy to understand what DKs learn. In Figure 3, we show the t-SNE (Maaten & Hinton, 2008) of learned model dynamics by the last convolutional layers in MobileNet-V2 using Conditional Convolution and our DKs. We validate the finding as claimed by Yang et al. (2019) that the experts of Conditional Convolutions have better correlation with object semantics than their scales (in reference to Figure 6 from their paper). Instead, our DKs learn kernel sampling offsets that strongly correlate to scales rather than semantics. This sheds light on why the two operators are complementary in our previous experiments. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adaptation of Effective Receptive Fields: To verify our claim that DK indeed adapts ERFs in practice, we show ERF visualizations on a set of images in which they display different degrees of deformations. We compare the results of rigid kernels, Deformable Convolutions, our DKs, and the combination of the two operators. For all examples, note that the theoretical receptive field covers every pixel in the image but ERFs contain only a central portion of it. Deformable Convolutions and DKs perform similarly in terms of adapting ERFs, but Deformable Convolutions tend to spread out and have sparse responses while DKs tend to concentrate and densely activate within an object region. Combining both operators yields more consistent ERFs that exploit both of their merits. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/03fe61b3a99a4b4fe54f5e472560a43e878aaca475f9aa9552dbcdad33a82abd.jpg",
+        "image_caption": [
+            "Figure 3: Semantics vs. Scales. We show t-SNE results of learned model dynamics using 10 random classes of objects from the COCO test-dev split. Each point represents an object extracted by ground-truth bounding box, whose color either denotes its class label or bounding box scale. The color of an object scale is its normalized area rank discretized by every 10th percentile among all data. Numbers inside parentheses indicate the dimension of learned dynamics before t-SNE. (a) The dynamics of Conditional Convolutions are closer to semantics than to object scales. (b) On the contrary, our DKs learn dynamics that are significantly related to scales rather than semantics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            99,
+            807,
+            227
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/711d1059d1b021301141e7743d64fe5288ae4ee7f13f4809906a3a3dbc32d974.jpg",
+        "image_caption": [
+            "Figure 4: Learned Effective Receptive Fields. We show learned ERFs on three images with large, medium, and small objects from the COCO test-dev split. Given each ground-truth bounding box, we visualize the non-zero ERF values of its central point. Theoretical RFs cover the whole image for all three examples and we thus ignore them in our plots. (a) Rigid kernels have strong central effects and a Gaussian-like ERF that cannot deal with object deformation alone. (b) Deformable Convolutions and (c) Deformable Kernels both tune ERFs to data. (d) Combining both operators together enables better modeling of 2D geometric transformation of objects. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            353,
+            807,
+            593
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            731,
+            825,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            803,
+            318,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduced Deformable Kernels (DKs) to adapt effective receptive fields (ERFs) of convolutional networks for object deformation. We proposed to sample kernel values from the original kernel space. This in effect samples the ERF in linear networks and also roughly generalizes to non-linear cases. We instantiated two variants of DKs and validate our designs, showing connections to previous works. Consistent improvements over them and compatibility with them were found, as illustrated in visualizations. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna and Stephane Mallat. Invariant scattering convolution networks. ´ TPAMI, 2013. ",
+        "bbox": [
+            168,
+            126,
+            769,
+            141
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Taco Cohen and Max Welling. Group equivariant convolutional networks. In ICML, 2016. ",
+        "bbox": [
+            168,
+            148,
+            769,
+            165
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei. Deformable convolutional networks. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            172,
+            825,
+            202
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009. ",
+        "bbox": [
+            173,
+            209,
+            823,
+            239
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Carlos Esteves, Christine Allen-Blanchette, Xiaowei Zhou, and Kostas Daniilidis. Polar transformer networks. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            247,
+            823,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James J Gibson. The perception of the visual world. Houghton Mifflin, 1950. ",
+        "bbox": [
+            171,
+            285,
+            679,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An- ´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017. ",
+        "bbox": [
+            173,
+            309,
+            826,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            359,
+            823,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In CVPR, 2018. ",
+        "bbox": [
+            171,
+            449,
+            717,
+            465
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Drew A Hudson and Christopher D Manning. Learning by abstraction: The neural state machine. arXiv preprint arXiv:1907.03950, 2019. ",
+        "bbox": [
+            173,
+            472,
+            823,
+            502
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In NeurIPS, 2015. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            540
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xu Jia, Bert De Brabandere, Tinne Tuytelaars, and Luc V Gool. Dynamic filter networks. In NeurIPS, 2016. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            577
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Angjoo Kanazawa, Abhishek Sharma, and David W. Jacobs. Locally scale-invariant convolutional neural networks. In NeurIPS Workshop, 2016. ",
+        "bbox": [
+            173,
+            584,
+            825,
+            614
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Svetlana Lazebnik, Cordelia Schmid, and Jean Ponce. Beyond bags of features: Spatial pyramid matching for recognizing natural scene categories. In CVPR, 2006. ",
+        "bbox": [
+            173,
+            622,
+            821,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiang Li, Wenhai Wang, Xiaolin Hu, and Jian Yang. Selective kernel networks. In CVPR, 2019. ",
+        "bbox": [
+            176,
+            660,
+            805,
+            675
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ ECCV, 2014. ",
+        "bbox": [
+            176,
+            683,
+            823,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie. ´ Feature pyramid networks for object detection. In CVPR, 2017. ",
+        "bbox": [
+            176,
+            720,
+            821,
+            751
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            787
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David G Lowe et al. Object recognition from local scale-invariant features. In ICCV, 1999. ",
+        "bbox": [
+            171,
+            796,
+            772,
+            813
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenjie Luo, Yujia Li, Raquel Urtasun, and Richard Zemel. Understanding the effective receptive field in deep convolutional neural networks. In NeurIPS, 2016. ",
+        "bbox": [
+            173,
+            820,
+            821,
+            849
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 2008. ",
+        "bbox": [
+            174,
+            857,
+            823,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In NeurIPS, 2015. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ignacio Rocco, Relja Arandjelovic, and Josef Sivic. Convolutional neural network architecture for geometric matching. In CVPR, 2017. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In CVPR, 2018. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Evan Shelhamer, Dequan Wang, and Trevor Darrell. Blurring the line between structure and learning to optimize and adapt receptive fields. arXiv preprint arXiv:1904.11487, 2019. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Laurent Sifre and Stephane Mallat. Rotation, scaling and deformation invariant scattering for texture ´ discrimination. In CVPR, 2013. ",
+        "bbox": [
+            171,
+            215,
+            825,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hugues Thomas, Charles R Qi, Jean-Emmanuel Deschaud, Beatriz Marcotegui, Franc¸ois Goulette, and Leonidas J Guibas. Kpconv: Flexible and deformable convolution for point clouds. In ICCV, 2019. ",
+        "bbox": [
+            174,
+            253,
+            823,
+            296
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017. ",
+        "bbox": [
+            173,
+            305,
+            823,
+            335
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dequan Wang, Evan Shelhamer, Bruno Olshausen, and Trevor Darrell. Dynamic scale inference by entropy optimization. arXiv preprint arXiv:1908.03182, 2019. ",
+        "bbox": [
+            173,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In CVPR, 2018. ",
+        "bbox": [
+            176,
+            381,
+            821,
+            410
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel E Worrall, Stephan J Garbin, Daniyar Turmukhambetov, and Gabriel J Brostow. Harmonic networks: Deep translation and rotation equivariance. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            419,
+            823,
+            448
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, and Kaiming He. Aggregated residual trans-´ formations for deep neural networks. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            457,
+            821,
+            486
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuwen Xiong, Mengye Ren, Renjie Liao, Kelvin Wong, and Raquel Urtasun. Deformable filter convolution for point cloud reasoning. arXiv preprint arXiv:1907.13079, 2019. ",
+        "bbox": [
+            174,
+            494,
+            820,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brandon Yang, Gabriel Bender, Quoc V Le, and Jiquan Ngiam. Soft conditional computation. arXiv preprint arXiv:1904.04971, 2019. ",
+        "bbox": [
+            174,
+            531,
+            821,
+            561
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard Zhang. Making convolutional networks shift-invariant again. In ICML, 2019. ",
+        "bbox": [
+            173,
+            570,
+            738,
+            585
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xizhou Zhu, Han Hu, Stephen Lin, and Jifeng Dai. Deformable convnets v2: More deformable, better results. In CVPR, 2019. ",
+        "bbox": [
+            173,
+            593,
+            821,
+            623
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/5abbb82c034f8a61878e301501e3654d6912395090b816e2237653329513f497.jpg",
+        "image_caption": [
+            "Figure 5: Illustration of feed-forwarding through a $\\mathbf { 3 \\times 3 }$ local Deformable Kernel from a $4 \\times 4$ scope. For each input patch, local DK first generates a group of kernel offsets $\\{ \\Delta k \\}$ from input feature patch using the light-weight generator $\\mathcal { G }$ (a $3 \\times 3$ convolution of rigid kernel). Given the original kernel weights $W$ and the offset group $\\{ \\Delta k \\}$ , DK samples a new set of kernel $W ^ { \\prime }$ using a bilinear sampler $\\boldsymbol { B }$ . Finally, DK convolves the input feature map and the sampled kernels to complete the whole computation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            102,
+            758,
+            297
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A COMPUTATION FLOW OF DEFORMABLE KERNELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            409,
+            625,
+            426
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We now cover more details on implementing DKs by elaborating the computation flow of their forward and backward passes. We will focus on the local DK given its superior performance in practice. The extension to global DK implementation is straight-forward. ",
+        "bbox": [
+            174,
+            439,
+            823,
+            483
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 FORWARD PASS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            328,
+            513
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Section 3.3, we introduce a kernel offset generator $\\mathcal { G }$ and a bilinear sampler $\\boldsymbol { B }$ . Figure 5 illustrates an example of the forward pass. ",
+        "bbox": [
+            174,
+            525,
+            821,
+            554
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Concretely, given a kernel $W$ and a learned group of kernel offsets $\\{ \\Delta k \\}$ on top of a regular 2D grid $\\{ k \\}$ , we can resample a new kernel $W ^ { \\prime }$ by a bilinear operator $\\boldsymbol { B }$ as ",
+        "bbox": [
+            174,
+            560,
+            821,
+            589
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a608a84c320e9f9db047d8137e472273804898794dfbeeeb983cc56c63cc8680.jpg",
+        "text": "$$\n\\begin{array} { c } { W ^ { \\prime } \\equiv W _ { k + \\Delta k } = \\displaystyle \\sum _ { k ^ { \\prime } \\in K } | \\beta ( k + \\Delta k , k ^ { \\prime } ) W _ { k ^ { \\prime } } , } \\\\ { \\displaystyle \\mathcal { B } ( k + \\Delta k , k ^ { \\prime } ) = \\operatorname* { m a x } ( 0 , 1 - | k _ { x } + \\Delta k _ { x } - k _ { x } ^ { \\prime } | ) \\cdot \\operatorname* { m a x } ( 0 , 1 - | k _ { y } + \\Delta k _ { y } - k _ { y } ^ { \\prime } | ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            593,
+            789,
+            650
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Given this resampled kernel, DK convolves it with the input image just as in normal convolutions using rigid kernels, characterized by Equation 1. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            681
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 BACKWARD PASS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            696,
+            339,
+            712
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The backward pass of local DK consists of three types of gradients: (1) the gradient to the data of the previous layer, (2) the gradient to the full scope kernel of the current layer and (3) the additional gradient to the kernel offset generator of the current layer. The first two types of gradients share same forms of the computation comparing to the normal convolutions. We now cover the computation for the third flow of gradient that directs where to sample kernel values. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            794
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In the context of Equation 7, the partial derivative of a output item $O _ { j }$ w.r.t. $x$ component of a given kernel offset $\\Delta k _ { x }$ (similar for its $y$ component $\\Delta k _ { y }$ ) can be computed as ",
+        "bbox": [
+            174,
+            800,
+            821,
+            829
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc0a8c703b7b502bedc043ba2fe0f1337abf699f80982d0d75b9a5b6be8431d4.jpg",
+        "text": "$$\n\\frac { \\partial O _ { j } } { \\partial \\Delta k _ { x } } = \\sum _ { k } I _ { j + k } \\bigg ( \\sum _ { k ^ { \\prime } } W _ { k ^ { \\prime } } \\frac { \\partial \\mathcal { B } ( k + \\Delta k , k ^ { \\prime } ) } { \\partial \\Delta k _ { x } } \\bigg ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            834,
+            643,
+            872
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3c53ed1a230cc95c857ea460abdc9afc9a2b467ba33c1a90d363151ea5d0218.jpg",
+        "text": "$$\n\\frac { \\partial \\mathcal { B } ( k + \\Delta k , k ^ { \\prime } ) } { \\partial \\Delta k _ { x } } = \\operatorname* { m a x } ( 0 , 1 - | k _ { y } + \\Delta k _ { y } - k _ { y } ^ { \\prime } | ) \\cdot \\left\\{ \\begin{array} { l l } { 0 } & { | k _ { x } + \\Delta k _ { x } - k _ { x } ^ { \\prime } | \\ge 1 } \\\\ { 1 } & { k _ { x } + \\Delta k _ { x } < k _ { x } ^ { \\prime } } \\\\ { - 1 } & { k _ { x } + \\Delta k _ { x } \\ge k _ { x } ^ { \\prime } } \\end{array} \\right. .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            877,
+            794,
+            926
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/a5bfd5471dec38e95309e5d40b5738522899bfb52ad9f1e2443e02b8e16a022a.jpg",
+        "table_caption": [
+            "Table 5: Network architecture of our ResNet-50-DW comparing to the original ResNet-50 Inside the brackets are the general shape of a residual block, including filter sizes and feature dimensionalities. The number of stacked blocks on each stage is presented outside the brackets. $G = 1 2 8 ^ { \\prime \\prime }$ suggests the depthwise convolution with 128 input channels. Two models have similar numbers of parameters and FLOPs. At the same time, depthwise convolutions facilitate the computation efficiency of our Deformable Kernels. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Output</td><td rowspan=1 colspan=3>ResNet-50</td><td rowspan=1 colspan=4>ResNet-50-DW</td></tr><tr><td rowspan=1 colspan=1>112 × 112</td><td rowspan=1 colspan=7>7 × 7,64,stride 2</td></tr><tr><td rowspan=1 colspan=1>56×56</td><td rowspan=1 colspan=7>3 × 3 max pool, stride 2</td></tr><tr><td rowspan=1 colspan=1>56×56</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,643 ×3,641 × 1,256</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>1 ×1,1283 × 3,128,G = 1281 × 1,256</td><td rowspan=1 colspan=1>×3</td></tr><tr><td rowspan=1 colspan=1>28×28</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,1283 ×3,1281 × 1,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>1 ×1,2563 × 3,256,G = 2561 ×1,512</td><td rowspan=1 colspan=1>×4</td></tr><tr><td rowspan=1 colspan=1>14 ×14</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1 ×1,2563 ×3,2561 × 1,1024</td><td rowspan=1 colspan=1>×6</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>1 ×1,5123 × 3,512,G = 5121 × 1,1024</td><td rowspan=1 colspan=1>×6</td></tr><tr><td rowspan=1 colspan=1>7×7</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1 ×1,5123 ×3,5121 × 1,2048</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>1 ×1,10243 × 3,1024,G =10241 × 1,2048</td><td rowspan=1 colspan=1>×3</td></tr><tr><td rowspan=1 colspan=1>1×1</td><td rowspan=1 colspan=7>7 × 7 global average pool,1000-d fc, softmax</td></tr><tr><td rowspan=1 colspan=1>#P (M)</td><td rowspan=1 colspan=3>25.6</td><td rowspan=1 colspan=4>23.7</td></tr><tr><td rowspan=1 colspan=1>GFLOPs</td><td rowspan=1 colspan=3>3.86</td><td rowspan=1 colspan=4>3.82</td></tr></table>",
+        "bbox": [
+            256,
+            101,
+            740,
+            385
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            507,
+            444,
+            523
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 5 shows the comparison between the original ResNet-50 (He et al., 2016) and our modified ResNet-50-DW. The motivation of introducing depthwise convolutions to ResNet is to accelerate the computation of local DKs based on our current implementations. The ResNet-50-DW model has similar model capacity/complexity and performance (see Table 1) compared to its non-depthwise counterpart, making it an ideal base architecture for our experiments. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            608
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, in all of our experiments, MobileNet-V2 (Sandler et al., 2018) base model is left untouched. ",
+        "bbox": [
+            173,
+            614,
+            823,
+            643
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C ADDITIONAL COMPARISON OF EFFECTIVE RECEPTIVE FIELDS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            664,
+            727,
+            680
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We here show additional comparison of ERFs when objects have different kinds of deformations in Figure 6. Comparing to baseline, our method can adapt ERFs to be more persistent to object’s semantic rather than its geometric configuration. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            738
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D ADDITIONAL EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            758,
+            514,
+            773
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Image Classification: Similar to Goyal et al. (2017); Loshchilov & Hutter (2017), training is performed by SGD for 90 epochs with momentum 0.9 and batch size 256. We set our learning rate of $1 0 ^ { - 1 }$ so that it linearly warms up from zero within first 5 epochs. A cosine training schedule is applied over the training epochs. We use scale and aspect ratio augmentation with color perturbation as standard data augmentations. We evaluate the performance of trained models on the ImageNet 2012 validation set. The images are resized so that the shorter side is of 256 pixels. We then centrally crop $2 2 4 \\times 2 2 4$ windows from the images as input to measure recognition accuracy. ",
+        "bbox": [
+            173,
+            789,
+            825,
+            887
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe8c4b789257333e32ac79b42776e417679053ca788bfbae0a2167b18b100042.jpg",
+        "image_caption": [
+            "Figure 6: Effective Receptive Field Comparison between rigid kernels and DKs under different kinds of Object Deformation. At each row and from left to right, we show the original image $( 1 3 0 0 \\times 8 0 0 )$ , the image rotated by -90 degrees and the image scaled by 1.5 times. Images are cropped and resized for the typesetting purpose. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            310,
+            758,
+            652
+        ],
+        "page_idx": 14
+    }
+]