Add files using upload-large-folder tool

parse/train/HJPmdP9le/HJPmdP9le.md

@@ -0,0 +1,299 @@
+# EFFICIENT SUMMARIZATION WITH READ-AGAIN AND COPY MECHANISM
+
+Wenyuan Zeng†, Wenjie $\mathbf { L u o } ^ { \ddagger }$ , Sanja Fidler‡, Raquel Urtasun‡
+
+†Tsinghua University, ‡University of Toronto cengwy13@mails.tsinghua.edu.cn {wenjie, fidler, urtasun}@cs.toronto.edu
+
+# ABSTRACT
+
+Encoder-decoder models have been widely used to solve sequence to sequence prediction tasks. However current approaches suffer from two shortcomings. First, the encoders compute a representation of each word taking into account only the history of the words it has read so far, yielding suboptimal representations. Second, current models utilize large vocabularies in order to minimize the problem of unknown words, resulting in slow decoding times and large storage costs. In this paper we address both shortcomings. Towards this goal, we first introduce a simple mechanism that first reads the input sequence before committing to a representation of each word. Furthermore, we propose a simple copy mechanism that is able to exploit very small vocabularies and handle out-of-vocabulary words. We demonstrate the effectiveness of our approach on the Gigaword dataset and DUC competition outperforming the state-of-the-art.
+
+# 1 INTRODUCTION
+
+Encoder-decoder models have been widely used in sequence to sequence tasks such as machine translation (Cho et al. (2014); Sutskever et al. (2014)). They consist of an encoder which represents the whole input sequence with a single feature vector. The decoder then takes this representation and generates the desired output sequence. The most successful models are LSTM and GRU as they are much easier to train than vanilla RNNs.
+
+In this paper we are interested in summarization where the input sequence is a sentence/paragraph and the output is a summary of the text. Several encoding-decoding approaches have been proposed (Rush et al. (2015); Hu et al. (2015); Chopra et al. (2016)). Despite their success, it is commonly believed that the intermediate feature vectors are limited as they are created by only looking at previous words. This is particularly detrimental when dealing with large input sequences. Bi-directorial RNNs (Schuster & Paliwal (1997); Bahdanau et al. (2014)) try to address this problem by computing two different representations resulting of reading the input sequence left-to-right and right-to-left. The final vectors are computed by concatenating the two representations. However, the word representations are computed with limited scope.
+
+The decoder employed in all these methods outputs at each time step a distribution over a fixed vocabulary. In practice, this introduces problems with rare words (e.g., proper nouns) which are out of vocabulary. To alleviate this problem, one could potentially increase the size of the decoder vocabulary, but decoding becomes computationally much harder, as one has to compute the soft-max over all possible words. Gulcehre et al. (2016), Nallapati et al. (2016) and Gu et al. (2016) proposed to use a copy mechanism that dynamically copy the words from the input sequence while decoding. However, they lack the ability to extract proper embeddings of out-of-vocabulary words from the input context. Bahdanau et al. (2014) proposed to use an attention mechanism to emphasize specific parts of the input sentence when generating each word. However the encoder problem still remains in this approach.
+
+In this work, we propose two simple mechanisms to deal with both encoder and decoder problems. We borrowed intuition from human readers which read the text multiple times before generating summaries. We thus propose a ‘Read-Again’ model that first reads the input sequence before committing to a representation of each word. The first read representation then biases the second read representation and thus allows the intermediate hidden vectors to capture the meaning appropriate for the input text. We show that this idea can be applied to both LSTM and GRU models. Our second contribution is a copy mechanism which allows us to use much smaller vocabulary sizes resulting in much faster decoding and much smaller storage space. Our copy mechanism also allows us to construct a better representation of out-of-vocabulary words. We demonstrate the effectiveness of our approach in the challenging Gigaword dataset and DUC competition showing state-of-the-art performance.
+
+# 2 RELATED WORK
+
+# 2.1 SUMMARIZATION
+
+In the past few years, there has been a lot of work on extractive summarization, where a summary is created by composing words or sentences from the source text. Notable examples are Neto et al. (2002), Erkan & Radev (2004), Wong et al. (2008), Filippova & Altun (2013) and Colmenares et al. (2015). As a consequence of their extractive nature the summary is restricted to words (sentences) in the source text.
+
+Abstractive summarization, on the contrary, aims at generating consistent summaries based on understanding the input text. Although there has been much less work on abstractive methods, they can in principle produce much richer summaries. Abstractive summarization is standardized by the DUC2003 and DUC2004 competitions (Over et al. (2007)). Some of the prominent approaches on this task includes Banko et al. (2000), Zajic et al. (2004), Cohn & Lapata (2008) and Woodsend et al. (2010). Among them, the TOPIARY system (Zajic et al. (2004)) performs the best in the competitions amongst non neural net based methods.
+
+Very recently, the success of deep neural networks in many natural language processing tasks (Collobert et al. (2011)) has inspired new work in abstractive summarization . Rush et al. (2015) propose a neural attention model with a convolutional encoder to solve this task. Hu et al. (2015) build a large dataset for Chinese text summarization and propose to feed all hidden states from the encoder into the decoder. More recently, Chopra et al. (2016) extended Rush et al. (2015)’s work with an RNN decoder, and Nallapati et al. (2016) proposed an RNN encoder-decoder architecture for summarization. Both techniques are currently the state-of-the-art on the DUC competition. However, the encoders exploited in these methods lack the ability to encode each word condition on the whole text, as an RNN encodes a word into a hidden vector by taking into account only the words up to that time step.
+
+In contrast, in this work we propose a ‘Read-Again’ encoder-decoder architecture, which enables the encoder to understand each input word after reading the whole sentence. Our encoder first reads the text, and the results from the first read help represent the text in the second pass over the source text. Our second contribution is a simple copy mechanism that allows us to significantly reduce the decoder vocabulary size resulting in much faster inference times. Furthermore our copy mechanism allows us to handle out-of-vocabulary words in a principled manner. Finally our experiments show state-of-the-art performance on the DUC competition.
+
+# 2.2 NEURAL MACHINE TRANSLATION
+
+Our work is also closely related to recent work on neural machine translation, where neural encoderdecoder models have shown promising results (Kalchbrenner & Blunsom (2013); Cho et al. (2014); Sutskever et al. (2014)). Bahdanau et al. (2014) further developed an attention mechanism in the decoder in order to pay attention to a specific part of the input at every generating time-step. Our approach also exploits an attention mechanism during decoding.
+
+# 2.3 OUT-OF-VOCABULARY AND COPY MECHANISM
+
+Dealing with Out-Of-Vocabulary words (OOVs) is an important issue in sequence to sequence approaches as we cannot enumerate all possible words and learn their embeddings since they might not be part of our training set. Luong et al. (2014) address this issue by annotating words on the source, and aligning OOVs in the target with those source words. Recently, Vinyals et al. (2015)
+
+![](images/653fea17ac317937d4d03ec1901f36f8de6b5af657201f58b2b1b20b091388a4.jpg)  
+Figure 1: Read-Again Summarization Model
+
+propose Pointer Networks, which calculate a probability distribution over the input sequence instead of predicting a token from a pre-defined dictionary. Cheng & Lapata (2016) develop a neural-based extractive summarization model, which predicts the targets from the input sequences. Gulcehre et al. (2016); Nallapati et al. (2016) use explicit gating to decide adaptively wether to generate a target word from the fixed-size dictionary or from the input sequence. Gu et al. (2016) use a implicit implicit gating operation instead of the explicit gating. This is similar to our decoder. However, our decoder can also extract different OOVs’ embedding accordingly from the input text instead of using a single ${ \bf \mathrm { < U N K > } }$ embedding to represent all OOVs. This further enhances the model’s ability to handle OOVs.
+
+# 3 THE READ AGAIN MODEL
+
+Text summarization can be formulated as a sequence to sequence prediction task, where the input is a longer text and the output is a summary of that text. In this paper we develop an encoder-decoder approach to summarization. The encoder is used to represent the input text with a set of continuous vectors, and the decoder is used to generate a summary word by word.
+
+In the following, we first introduce our ‘Read-Again’ model for encoding sentences. The idea behind our approach is very intuitive and is inspired by how humans do this task. When we create summaries, we first read the text and then we do a second read where we pay special attention to the words that are relevant to generate the summary. Our ‘Read-Again’ model implements this idea by reading the input text twice and using the information acquired from the first read to bias the second read. This idea can be seamlessly plugged into LSTM and GRU models. Our second contribution is a copy mechanism used in the decoder. It allows us to reduce the decoder vocabulary size dramatically and can be used to extract a better embedding for OOVs. Fig. 1(a) gives an overview of our model.
+
+# 3.1 ENCODER
+
+We first review the typical encoder used in machine translation (e.g., Sutskever et al. (2014); Bahdanau et al. (2014)). Let $x = \{ x _ { 1 } , x _ { 2 } , \cdot \cdot \cdot , x _ { n } \}$ be the input sequence of words. An encoder sequentially reads each word and creates the hidden representation $h _ { i }$ by exploting a recurrent neural network (RNN)
+
+$$
+h _ { i } = \mathrm { R N N } ( \mathbf { x _ { i } } , h _ { i - 1 } ) ,
+$$
+
+where $\mathbf { x _ { i } }$ is the word embedding of $x _ { i }$ . The hidden vectors $h = \{ h _ { 1 } , h _ { 2 } , \cdots , h _ { n } \}$ are then treated as the feature representations for the whole input sentence and can be used by another RNN to decode and generate a target sentence. Although RNNs have been shown to be useful in modeling sequences, one of the major drawback is that $h _ { i }$ depends only on past information i.e., $\{ x _ { 1 } , \cdots , x _ { i } \}$ . However, it is hard (even for humans) to have a proper representation of a word without reading the whole input sentence.
+
+Following this intuition, we propose our ‘Read-Again’ model where the encoder reads the input sentence twice. In particular, the first read is used to bias the second more attentive read. We apply this idea to two popular RNN architectures, i.e. GRU and LSTM, resulting in better encodings of the input text. Note that although other alternatives, such as bidirectional RNN exist, the hidden states from the forward RNN lack direct interactions with the backward RNN, and thus forward/backward hidden states still cannot utilize the whole sequence. Besides, although we only use our model in a uni-directional manner, it can also be easily adapted to the bidirectional case. We now describe the two variants of our model.
+
+![](images/7583a902ba579cd1e646597ef8cc176db700cc72ce413c7267649ce33a2c585e.jpg)  
+Figure 2: Read-Again Model
+
+# 3.1.1 GRU READ-AGAIN
+
+We read the input sentence $\{ x _ { 1 } , x _ { 2 } , \cdots , x _ { n } \}$ for the first-time using a standard GRU
+
+$$
+h _ { i } ^ { 1 } = \mathrm { G R U } ^ { 1 } ( \mathbf { x _ { i } } , h _ { i - 1 } ^ { 1 } ) ,
+$$
+
+where the function $G R U ^ { 1 }$ is defined as,
+
+$$
+\begin{array} { r l } & { z _ { i } = \sigma ( W _ { z } [ \mathbf { x _ { i } } , h _ { i - 1 } ^ { 1 } ] ) } \\ & { r _ { i } = \sigma ( W _ { r } [ \mathbf { x _ { i } } , h _ { i - 1 } ^ { 1 } ] ) } \\ & { \widetilde { h } _ { i } ^ { 1 } = t a n h ( W _ { h } [ \mathbf { x _ { i } } , r _ { i } \odot h _ { i - 1 } ^ { 1 } ] ) } \\ & { h _ { i } ^ { 1 } = ( 1 - z _ { i } ) \odot h _ { i - 1 } ^ { 1 } + z _ { i } \odot \widetilde { h } _ { i } ^ { 1 } } \end{array}
+$$
+
+It consists of two gatings $z _ { i } , r _ { i }$ , controlling whether the current hidden state $h _ { i } ^ { 1 }$ should be directly copied from $h _ { i - 1 } ^ { 1 }$ or should pass through a more complex path $\widetilde { h } _ { i } ^ { 1 }$ .
+
+Given the sentence feature vector $h _ { n } ^ { 1 }$ , we then compute an importance weight vector $\alpha _ { i }$ of each word for the second reading. We put the importance weight $\alpha _ { i }$ on the skip-connections as shown in Fig. 2(a) to bias the two information flows: If the current word $x _ { i }$ has a very small weight $\alpha _ { i }$ , then the second read hidden state $h _ { i } ^ { 2 }$ will mostly take the information directly from the previous state $h _ { i - 1 } ^ { 2 }$ , ignoring the influence of the current word. If $\alpha _ { i }$ is close to 1 then it will be similar to a standard GRU, which is only influenced from the current word. Thus the second reading has the following update rule
+
+$$
+h _ { i } ^ { 2 } = ( 1 - \alpha _ { i } ) \odot h _ { i - 1 } ^ { 2 } + \alpha _ { i } \odot \mathrm { G R U } ^ { 2 } ( \mathbf { x _ { i } } , h _ { i - 1 } ^ { 2 } ) ,
+$$
+
+where $\odot$ means element-wise product. We compute the importance weights by attending $h _ { i } ^ { 1 }$ with $h _ { n } ^ { 1 }$ as follows
+
+$$
+\alpha _ { i } = t a n h ( W _ { e } h _ { i } ^ { 1 } + U _ { e } h _ { n } ^ { 1 } + V _ { e } \mathbf { x _ { i } } ) ,
+$$
+
+where $W _ { e }$ , $U _ { e }$ , $V _ { e }$ are learnable parameters. Note that $\alpha _ { i }$ is a vector representing the importance of each dimension in the word embedding. Empirically, we find that using a vector is better than a scalar gating. We hypothesize that this is because different dimensions represent different semantic meanings, and a scalar gating mechanism lacks the ability to capture the variances among these dimensions.
+
+![](images/60a53f9808b57076e7e777d401e2e7704cf3b6e00e61e896a2bbfa86eaee9eec.jpg)  
+Figure 3: Hierachical Read-Again
+
+Combining this with the standard GRU update rule
+
+$$
+\mathrm { G R U } ^ { 2 } ( \mathbf { x _ { i } } , h _ { i - 1 } ^ { 2 } ) = ( 1 - z _ { i } ) \odot h _ { i - 1 } ^ { 2 } + z _ { i } \odot \widetilde { h } _ { i } ^ { 2 } ,
+$$
+
+we can simplify the updating rule Eq. (4) to get
+
+$$
+h _ { i } ^ { 2 } = ( 1 - \alpha _ { i } \odot z _ { i } ) \odot h _ { i - 1 } ^ { 2 } + ( \alpha _ { i } \odot z _ { i } ) \odot \widetilde { h } _ { i } ^ { 2 }
+$$
+
+This equations shows that our ‘read-again’ model on GRU is equivalent to replace the GRU cell with a more general gating mechanism that also depends on the feature representation of the whole sentence computed from the first reading pass. We argue that adding this global information could help direct the information flow for the forward pass resulting in a better encoder.
+
+# 3.1.2 LSTM READ-AGAIN
+
+We now apply the ‘Read-Again’ idea to the LSTM architecture as shown in Fig. 2(b). Our first reading is performed by an $\bar { L } S T M ^ { 1 }$ defined as
+
+$$
+\begin{array} { l } { f _ { i } = \sigma ( W _ { f } [ { \bf x _ { i } } , h _ { i - 1 } ] ) } \\ { ~ i _ { i } = \sigma ( W _ { i } [ { \bf x _ { i } } , h _ { i - 1 } ] ) } \\ { o _ { i } = \sigma ( W _ { o } [ { \bf x _ { i } } , h _ { i - 1 } ] ) } \\ { ~ \widetilde C _ { i } = t a n h ( W _ { C } [ { \bf x _ { i } } , h _ { i - 1 } ] ) } \\ { ~ C _ { i } = f _ { t } \odot C _ { i - 1 } + i _ { i } \odot \widetilde C _ { i } } \\ { h _ { i } = o _ { i } \odot t a n h ( C _ { i } ) } \end{array}
+$$
+
+Different from the GRU architecture, LSTM calculates the hidden state by applying a non-linear activation function to the cell state $C _ { i }$ , instead of a linear combination of two paths used in the GRU. Thus for our second read, instead of using skip-connections, we make the gating functions explicitly depend on the whole sentence vector computed from the first reading pass. We argue that this helps the encoding of the second reading $L S T M ^ { 2 }$ , as all gating and updating increments are also conditioned on the whole sequence feature vector $\left( h _ { i } ^ { 1 } , h _ { n } ^ { 1 } \right)$ . Thus
+
+$$
+h _ { i } ^ { 2 } = \mathrm { L S T M } ^ { 2 } ( [ \mathbf { x _ { i } } , h _ { i } ^ { 1 } , h _ { n } ^ { 1 } ] , h _ { i - 1 } ^ { 2 } ) ,
+$$
+
+# 3.1.3 READING MULTIPLE SENTENCES
+
+In this section we extend our ‘Read-Again’ model to the case where the input sequence has more than one sentence. Towards this goal, we propose to use a hierarchical representation, where each sentence has its own feature vector from the first reading pass. We then combine them into a single vector to bias the second reading pass. We illustrate this in the context of two input sentences, but it is easy to generalize to more sentences. Let $\{ x _ { 1 } , x _ { 2 } , \cdots , x _ { n } \}$ and $\{ x _ { 1 } ^ { \prime } , \cdots , x _ { m } ^ { \bar { \prime } } \}$ be the two input sentences. The first RNN reads these two sentences independently to get two sentence feature vectors $h _ { n } ^ { 1 }$ and $h _ { m } ^ { \prime 1 }$ respectively.
+
+Here we investigate two different ways to handle multiple sentences. Our first option is to simply concatenate the two feature vectors to bias our second reading pass:
+
+$$
+h _ { i } ^ { 2 } = \mathbf { R N N ^ { 2 } } ( [ \mathbf { x _ { i } } , h _ { i } ^ { 1 } , h _ { n } ^ { 1 } , h _ { m } ^ { \prime 1 } ] , h _ { i - 1 } ^ { 2 } )
+$$
+
+$$
+h _ { i } ^ { \prime 2 } = \mathrm { R N N } ^ { 2 } ( [ \mathbf { x } _ { \mathbf { i } } ^ { \prime } , h _ { i } ^ { \prime 1 } , h _ { n } ^ { 1 } , h _ { m } ^ { \prime 1 } ] , h _ { i - 1 } ^ { \prime 2 } )
+$$
+
+where $h _ { 0 } ^ { 2 }$ and $h _ { 0 } ^ { \prime 2 }$ are initialized as zero vectors. Feeding $h _ { n } ^ { 1 } , h _ { m } ^ { \prime 1 }$ into the second RNN provides more global information explicitly and helps acquire long term dependencies.
+
+The second option we explored is shown in Fig. 3. In particular, we use a non-linear transformation to get a single feature vector $h _ { g l o b a l }$ from both sentence feature vectors:
+
+$$
+h _ { g l o b a l } = t a n h ( W _ { r } h _ { n } ^ { 1 } + U _ { r } h _ { m } ^ { \prime 1 } + v _ { r } )
+$$
+
+The second reading pass is then
+
+$$
+\begin{array} { r l } & { \widetilde { h _ { i } ^ { 2 } } = \mathrm { R N N } ^ { 2 } ( [ \mathbf { x _ { i } } , h _ { i } ^ { 1 } , h _ { n } ^ { 1 } , h _ { g l o b a l } ] , h _ { i - 1 } ^ { 2 } ) } \\ & { \widetilde { h _ { i } ^ { \prime 2 } } = \mathrm { R N N } ^ { 2 } ( [ \mathbf { x _ { i } ^ { \prime } } , h _ { i } ^ { \prime 1 } , h _ { m } ^ { \prime 1 } , h _ { g l o b a l } ] , h _ { i - 1 } ^ { \prime 2 } ) } \end{array}
+$$
+
+Note that this is more easily scalable to more sentences. In our experiments both approaches perform similarly.
+
+# 3.2 DECODER WITH COPY MECHANISM
+
+In this paper we argue that only a small number of common words are needed for generating a summary in addition to the words that are present in the source text. We can consider this as a hybrid approach which combines extractive and abstractive summarization. This has two benefits: first it allow us to use a very small vocabulary size, speeding up inference. Furthermore, we can create summaries which contain OOVs if they are present in the source text.
+
+Our decoder reads the vector representations of the input text using an attention mechanism, and generates the target summary word by word. We use an LSTM as our decoder, with a fixed-size vocabulary dictionary $Y$ and learnable word embeddings $\mathbf { Y } \in \mathbf { R } ^ { | Y | \times d i m }$ . At time-step $t$ the LSTM generates a summary word $y _ { t }$ by first computing the current hidden state $s _ { t }$ from the previous hidden state $s _ { t - 1 }$ , previous summary word $y _ { t - 1 }$ and current context vector $c _ { t }$
+
+$$
+s _ { t } = L S T M ( [ \mathbf { y _ { t - 1 } } , c _ { t } ] , s _ { t - 1 } ) ,
+$$
+
+where the context vector $c _ { t }$ is computed with an attention mechanism on the encoder hidden states:
+
+$$
+c _ { t } = \sum _ { i = 1 } ^ { n } \beta _ { i t } h _ { i } ^ { 2 } .
+$$
+
+The attention score $\beta _ { i t }$ at time-step $t$ on the $i$ -th word is computed via a soft-max over $o _ { i t }$ , where
+
+$$
+o _ { i t } = a t t ( s _ { t - 1 } , h _ { i } ^ { 2 } ) = v _ { a } ^ { T } t a n h ( W _ { a } s _ { t - 1 } + U _ { a } h _ { i } ^ { 2 } ) ,
+$$
+
+with $v _ { a }$ , $W _ { a }$ , $U _ { a }$ learnable parameters.
+
+A typical way to treat OOVs is to encode them with a single shared embedding. However, different OOVs can have very different meanings, and thus using a single embedding for all OOVs will confuse the model. This is particularly detrimental when using small vocabulary sizes. Here we address this issue by deriving the representations of OOVs from their corresponding context in the input text. Towards this goal, we change the update rule of $\mathbf { y _ { t - 1 } }$ . In particular, if $y _ { t - 1 }$ belongs to a word that is in our decoder vocabulary we take its representation from the word embedding, otherwise if it appears in the input sentence as $x _ { i }$ we use
+
+$$
+\mathbf { y _ { t - 1 } } = \mathbf { p _ { i } } = t a n h ( W _ { c } h _ { i } ^ { 2 } + b _ { c } )
+$$
+
+where $W _ { c }$ and $b _ { c }$ are learnable parameters. Since $h _ { i } ^ { 2 }$ encodes useful context information of the source word $x _ { i }$ , $p _ { i }$ can be interpreted as the semantics of this word extracted from the input sentence. Furthermore, if $y _ { t - 1 }$ does not appear in the input text, nor in $Y$ , then we represent $\mathbf { y _ { t - 1 } }$ using the ${ \bf \mathrm { < U N K > } }$ embedding.
+
+Given the current decoder’s hidden state $s _ { t }$ , we can generate the target summary word $y _ { t }$ . As shown in Fig. 1(b), at each time step during decoding, the decoder outputs a distribution over generating words from $Y$ , as well as over copying a specific word $x _ { i }$ from the source sentence.
+
+# 3.3 LEARNING
+
+We jointly learn our encoder and decoder by maximizing the likelihood of decoding the correct word at each time step. We refer the reader to the experimental evaluation for more details.
+
+# 4 EXPERIMENTAL EVALALUATION
+
+In this section, we show results of abstractive summarization on Gigaword (Graff & Cieri (2003); Napoles et al. (2012)) and DUC2004 (Over et al. (2007)) datasets. Our model can learn a meaningful re-reading weight distribution for each word in the input text, putting more emphasis on important verb and nous, while ignoring common words such as prepositions. As for the decoder, we demonstrate that our copy mechanism can successfully reduce the typical vocabulary size by a factor 5 while achieving much better performance than the state-of-the-art, and by a factor of 30 while maintaining the same level of performance. In addition, we provide an analysis and examples of which words are copied during decoding.
+
+Dataset and Evaluation Metric: We use the Gigaword corpus to train and evaluate our models. Gigaword is a news corpus where the title is employed as a proxy for the summary of the article. We follow the same pre-processing steps of Rush et al. (2015), which include filtering, PTB tokenization, lower-casing, replacing digit characters with #, replacing low-frequency words with UNK and extracting the first sentence in each article. This results in a training set of $3 . 8 \mathbf { M }$ articles, a validation set and a test set each containing 400K articles. The average sentence length is 31.3 words for the source, and 8.3 words for the summaries. Following the standard protocol we evaluate ROUGE score on 2000 random samples from the test set. As for evaluation metric, we use full-length F1 score on Rouge-1, Rouge-2 and Rouge-L, following Chopra et al. (2016) and Nallapati et al. (2016), since these metrics are less bias to the outputs’ length than full-length recall scores.
+
+Implemetation Details: We implement our model in Tensorflow and conduct all experiments on a NVIDIA Titan X GPU. Our models converged after 2-3 days of training, depending on model size. Our RNN cells in all models have 1 layer, 512-dimensional hidden states, and 512-dimensional word embeddings. We use dropout rate of 0.2 in all activation layers. All parameters, except the biases are initialized uniformly with a range of $\sqrt { 3 / d }$ , where $d$ is the dimension of the hidden state (Sussillo & Abbott (2014)). The biases are initialized to 0.1. We use plain SGD to train the model with gradient clipped at 10. We start with an initial learning rate of 2, and halve it every epoch after first 5 epochs. Our max epoch for training is 10. We use a mini-batch size of 64, which is shuffled during training.
+
+# 4.1 QUANTITATIVE EVALUATION
+
+Table 1: Different Read-Again Model. Ours denotes Read-Again models. C denotes copy mechanism. Ours-Opt-1 and Ours-Opt-2 are the models described in section 3.1.3. Size denotes the size of decoder vocabulary in a model.   
+
+<table><tr><td>#Input</td><td>Model</td><td>Size</td><td>Rouge-1</td><td>Rouge-2</td><td>Rouge-L</td></tr><tr><td rowspan="7">1 sent</td><td>ABS (baseline)</td><td>69K</td><td>24.12</td><td>10.24</td><td>22.61</td></tr><tr><td>GRU (baseline)</td><td>69K</td><td>26.79</td><td>12.03</td><td>25.14</td></tr><tr><td>Ours-GRU</td><td>69K</td><td>27.26</td><td>12.28</td><td>25.48</td></tr><tr><td>Ours-LSTM</td><td>69K</td><td>27.82</td><td>12.74</td><td>26.01</td></tr><tr><td>GRU (baseline)</td><td>15K</td><td>24.67</td><td>11.30</td><td>23.28</td></tr><tr><td>Ours-GRU</td><td>15K</td><td>25.04</td><td>11.40</td><td>23.47</td></tr><tr><td>Ours-LSTM</td><td>15K</td><td>25.30</td><td>11.76</td><td>23.71</td></tr><tr><td>Ours-GRU (C)</td><td>15K</td><td>27.41</td><td>12.58</td><td>25.74</td></tr><tr><td rowspan="2">2 sent</td><td>Ours-LSTM (C) Ours-Opt-1 (C)</td><td>15K 15K</td><td>27.37 27.95</td><td>12.64</td><td>25.69</td></tr><tr><td></td><td></td><td></td><td>12.65</td><td>26.10</td></tr><tr><td></td><td>Ours-Opt-2 (C)</td><td>15K</td><td>27.96</td><td>12.65</td><td>26.18</td></tr></table>
+
+Results on Gigaword: We compare the performances of different architectures and report ROUGE scores in Table 1. Our baselines include the ABS model of Rush et al. (2015) with its proposed vocabulary size as well as an attention encoder-decoder model with uni-directional GRU encoder. We allow the decoder to generate variable length summaries. As shown in Table 1 our Read-Again models outperform the baselines on all ROUGE scores, when using both 15K and 69K sized vocabularies. We also observe that adding the copy mechanism further helps to improve performance: Even though the decoder vocabulary size of our approach with copy (15K) is much smaller than ABS (69K) and GRU (69K), it achieves a higher ROUGE score. Besides, our Multiple-Sentences model achieves the best performance.
+
+Table 2: Rouge-N limited-length recall on DUC2004. Size denotes the size of decoder vocabulary in a model.   
+
+<table><tr><td>Models</td><td>Size</td><td>Rouge-1</td><td>Rouge-2</td><td>Rouge-L</td></tr><tr><td>ZOPIARY (Zajic et al. (2004))</td><td>-</td><td>25.12</td><td>6.46</td><td>20.12</td></tr><tr><td>ABS (Rush et al. (2015))</td><td>69K</td><td>26.55</td><td>7.06</td><td>23.49</td></tr><tr><td>ABS+ (Rush et al. (2015))</td><td>69K</td><td>28.18</td><td>8.49</td><td>23.81</td></tr><tr><td>RAS-LSTM (Chopra et al. (2016))</td><td>69K</td><td>27.41</td><td>7.69</td><td>23.06</td></tr><tr><td>RAS-Elman (Chopra et al. (2016))</td><td>69K</td><td>28.97</td><td>8.26</td><td>24.06</td></tr><tr><td>big-words-lvt2k-1sent (Nallapati et al. (2016))</td><td>69K</td><td>28.35</td><td>9.46</td><td>24.59</td></tr><tr><td>big-words-lvt5k-1sent (Nallapati et al. (2016))</td><td>200K</td><td>28.61</td><td>9.42</td><td>25.24</td></tr><tr><td>Ours-GRU (C)</td><td>15K</td><td>29.08</td><td>9.20</td><td>25.25</td></tr><tr><td>Ours-LSTM (C)</td><td>15K</td><td>29.89</td><td>9.37</td><td>25.93</td></tr><tr><td>Ours-Opt-2 (C)</td><td>15K</td><td>29.74</td><td>9.44</td><td>25.94</td></tr></table>
+
+Evaluation on DUC2004: DUC 2004 (Over et al. (2007)) is a commonly used benchmark on summarization task consisting of 500 news articles. Each article is paired with 4 different humangenerated reference summaries, capped at 75 characters. This dataset is evaluation-only. Similar to Rush et al. (2015), we train our neural model on the Gigaword training set, and show the models’ performances on DUC2004. Following the convention, we also use ROUGE limited-length recall as our evaluation metric, and set the capping length to 75 characters. We generate summaries with 15 words using beam-size of 10. As shown in Table 2, our method outperforms all previous methods on Rouge-1 and Rouge-L, and is comparable on Rouge-2. Furthermore, our model only uses $1 5 \mathrm { k }$ decoder vocabulary, while previous methods use $6 9 \mathrm { k }$ or 200k.
+
+Importance Weight Visualization: As we described in the section before, $\alpha _ { i }$ is a high-dimension vector representing the importance of each word $x _ { i }$ . While the importance of a word is different over each dimension, by averaging we can still look at general trends of which word is more relevant.indonesia has moved #.# million people and resettl Fig. 4 depicts sample sentences with the importance weight #,### village $\alpha _ { i }$ over input words. Words such asn a national transmigration scheme the, a, ${ \bf \Phi } _ { s }$ , have small $\alpha _ { i }$ , while words such as aeronautics, resettled, impediments, which carry morepast ## years , president suharto said here mo information have higher values. This shows that our read-again technique indeed extracts usefultariffs and other barriers remain serious impediments to information from the first reading to help bias the second reading results.onesia 's state-owned domestic carrier merpati nusantara and business in the asia-p
+
+![](images/539b0be6900581910a2f2c98f2c6c4cb02dad3c5523881834fbd893b85b67305.jpg)  
+Figure 4: Weight Visualization. Black indicates high weight
+
+# 4.2 EVALUATION OF COPY MECHANISM
+
+Table 3 shows the effect on our model of decreasing the decoder vocabulary size. We can see that when using the copy mechanism, we are able to reduce the decoder vocabulary size from 69K to 2K, with only 2-3 points drop on ROUGE score. This contrasts the models that do not use the copy mechanism. Equipped with a copy mechanism, our model is able to generate OOVs as summary words, and thus maintains its expressive ability even with a small decoder vocabulary size. We also observe from Table 4 that the copy mechanism help us to decrease the encoder vocabulary size as well. The model without copy suffers from severe OOV problem when encoder size is small, since a single shared ${ \bf \mathrm { < U N K > } }$ embedding cannot depict many different OOVs. This makes it difficult for the encoder to understand the input text. Meanwhile, our copy model can extract an OOV’s meaning accordingly from its context in the input text, and thus it is sufficient to learn and store only the high-frequency words embeddings using our model, which in turn save the storage. We also notice that shrinking the encoder vocabulary to $1 5 \mathrm { k }$ achieves better result. One possible reason is that long tail words can not learn efficient embeddings during training, and representing them with extracted embedding from our model performs better.
+
+Table 3: ROUGE Evaluation for Models with Different Decoder Size and 110k Encoder Size. Ours denotes Read-Again. C denotes copy mechanism.   
+
+<table><tr><td></td><td colspan="2">Rouge-1</td><td colspan="2">Rouge-2</td><td colspan="2">Rouge-L</td></tr><tr><td>Size</td><td>Ours-LSTM</td><td>Ours-LSTM (C)</td><td>Ours-LSTM</td><td>Ours-LSTM (C)</td><td>Ours-LSTM</td><td>Ours-LSTM(C)</td></tr><tr><td>2K</td><td>14.39</td><td>24.21</td><td>6.46</td><td>11.27</td><td>13.74</td><td>23.09</td></tr><tr><td>5K</td><td>20.61</td><td>26.83</td><td>9.67</td><td>12.66</td><td>19.58</td><td>25.31</td></tr><tr><td>15K</td><td>25.30</td><td>27.37</td><td>11.76</td><td>12.64</td><td>23.74</td><td>25.69</td></tr><tr><td>30K</td><td>26.86</td><td>27.49</td><td>11.93</td><td>12.75</td><td>25.16</td><td>25.77</td></tr><tr><td>69K</td><td>27.82</td><td>27.89</td><td>12.73</td><td>12.69</td><td>26.01</td><td>26.03</td></tr></table>
+
+Table 4: ROUGE Evaluation for Models with Different Encoder Size and 15k Decoder Size. Ours denotes Read-Again. C denotes copy mechanism.   
+
+<table><tr><td colspan="3"></td><td colspan="2">Rouge-2</td><td colspan="2">Rouge-L</td></tr><tr><td>Size</td><td>Ours-LSTM</td><td>Ours-LSTM (C)</td><td>Ours-LSTM</td><td>Ours-LSTM(C)</td><td>Ours-LSTM</td><td>Ours-LSTM(C)</td></tr><tr><td>5K</td><td>21.82</td><td>26.57</td><td>9.80</td><td>11.98</td><td>20.60</td><td>25.00</td></tr><tr><td>15K</td><td>23.84</td><td>27.79</td><td>10.69</td><td>12.54</td><td>22.50</td><td>25.96</td></tr><tr><td>30K</td><td>23.78</td><td>27.48</td><td>10.68</td><td>12.56</td><td>22.28</td><td>25.94</td></tr><tr><td>110K</td><td>25.30</td><td>27.37</td><td>11.76</td><td>12.64</td><td>23.74</td><td>25.69</td></tr></table>
+
+Table 5 shows the decoding time as a function of vocabulary size. As computing the soft-max is usually the bottleneck for decoding, reducing vocabulary size dramatically reduces the decoding time from 0.38 second per sentence to 0.08 second.
+
+Table 5: Decoding Time (s) per Sentence of Models with Different Decoder Size   
+
+<table><tr><td>Decoder-Size</td><td>2k</td><td>5k</td><td>15k</td><td>30k</td><td>69k</td></tr><tr><td>Ours-LSTM</td><td>0.076</td><td>0.081</td><td>0.111</td><td>0.161</td><td>0.356</td></tr><tr><td>Ours-LSTM(C)</td><td>0.084</td><td>0.090</td><td>0.123</td><td>0.171</td><td>0.376</td></tr></table>
+
+Table 6 provides some examples of visualization of the copy mechanism. Note that we are able to copy key words from source sentences to improve the summary. From these examples we can see that our model is able to copy different types of rare words, such as special entities’ names in case 1 and 2, rare nouns in case 3 and 4, adjectives in case 5 and 6, and even rare verbs in the last example. Note that in the third example, when the copy model’s decoder uses the embedding of headmaster as its first input, which is extracted from the source sentence, it generates the same following sentence as the no-copy model. This probably means that the extracted embedding of headmaster is closely related to the learned embedding of teacher.
+
+Table 6: Visualization of Copy Mechanism   
+
+<table><tr><td>Input: Golden: No Copy: </td><td>air new zealand said friday it had reached agreement to buya ## percent interest inaustralia&#x27;s ansett holdings limited for ### million australian -lrb-### million us dollars -rrb-. urgent air new zealand buys ## percent of australia &#x27;s ansett airlines air nz to buy ## percent stake in australia&#x27;s &lt;unk&gt; air nz to buy ## percent stake in ansett</td></tr><tr><td>Copy: Input: Golden: No Copy: Copy:</td><td>yemen &#x27;s ruling party was expected wednesday to nominate president ali abdullah saleh as its candidate for september &#x27;s presidential election ,although saleh insisted he is not bluffing about bowing out. the #### gmt news advisory yemen &#x27;s ruling party expected to nominate president as presidential candidate yemen &#x27;s ruling party expected to nominate saleh as presidential candidate</td></tr><tr><td>Input: Golden: No Copy: Copy:</td><td>a ##-year-old headmaster who taught children in care homes for more than ## years was jailed for ## years on friday after being convicted of ## sexual assaults against his pupils. britain :headmaster jailed for ## years for paedophilia teacher jailed for ## years for sexuallyabusing childre headmaster jailed for ## years for sexually abusing children</td></tr><tr><td>Input: Golden: No Copy: Copy:</td><td>singapore ’s rapidly ageing population poses the major challenge to fiscal policy in the ##st century, finance minister richard hu said,and warned against european-style state &lt;unk&gt;. ageing population to pose major fiscal challenge to singapore finance minister warns against &lt;unk&gt; state s pore &#x27;s ageing population poses challenge to fiscal policy</td></tr><tr><td>Input: Golden: No Copy:</td><td>angola is planning to refit its ageing soviet-era fleet of military jets in russan factories,a media report said on tuesday. angola to refit jet fighters in russia :report angola to &lt;unk&gt; soviet-era soviet-era fleet</td></tr></table>
+
+# 5 CONCLUSION
+
+In this paper we have proposed two simple mechanisms to alleviate the problems of current encoderdecoder models. Our first contribution is a ‘Read-Again’ model which does not form a representation of the input word until the whole sentence is read. Our second contribution is a copy mechanism that can handle out-of-vocabulary words in a principled manner allowing us to reduce the decoder vocabulary size and significantly speed up inference. We have demonstrated the effectiveness of our approach in the context of summarization and shown state-of-the-art performance. In the future, we plan to tackle summarization problems with large input text. We also plan to exploit our findings in other tasks such as machine translation.
+
+# REFERENCES
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
+
+Michele Banko, Vibhu O Mittal, and Michael J Witbrock. Headline generation based on statistical translation. In Proceedings of the 38th Annual Meeting on Association for Computational Linguistics, pp. 318–325. Association for Computational Linguistics, 2000.
+
+Jianpeng Cheng and Mirella Lapata. Neural summarization by extracting sentences and words. arXiv preprint arXiv:1603.07252, 2016.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.
+
+Sumit Chopra, Michael Auli, Alexander M Rush, and SEAS Harvard. Abstractive sentence summarization with attentive recurrent neural networks. arXiv preprint arXiv:1602.06023, 2016.
+
+Trevor Cohn and Mirella Lapata. Sentence compression beyond word deletion. In Proceedings of the 22nd International Conference on Computational Linguistics-Volume 1, pp. 137–144. Association for Computational Linguistics, 2008.
+
+Ronan Collobert, Jason Weston, Leon Bottou, Michael Karlen, Koray Kavukcuoglu, and Pavel ´ Kuksa. Natural language processing (almost) from scratch. Journal of Machine Learning Research, 12(Aug):2493–2537, 2011.
+
+Carlos A Colmenares, Marina Litvak, Amin Mantrach, and Fabrizio Silvestri. Heads: Headline generation as sequence prediction using an abstract feature-rich space. 2015.
+
+Gunes Erkan and Dragomir R Radev. Lexrank: Graph-based lexical centrality as salience in text ¨ summarization. Journal of Artificial Intelligence Research, 22:457–479, 2004.
+
+Katja Filippova and Yasemin Altun. Overcoming the lack of parallel data in sentence compression. In EMNLP, pp. 1481–1491. Citeseer, 2013.
+
+David Graff and Christopher Cieri. English giga-word, 2003. Linguistic Data Consortium, Philadeplhia, 2003.
+
+Jiatao Gu, Zhengdong Lu, Hang Li, and Victor OK Li. Incorporating copying mechanism in sequence-to-sequence learning. arXiv preprint arXiv:1603.06393, 2016.
+
+Caglar Gulcehre, Sungjin Ahn, Ramesh Nallapati, Bowen Zhou, and Yoshua Bengio. Pointing the unknown words. arXiv preprint arXiv:1603.08148, 2016.
+
+Baotian Hu, Qingcai Chen, and Fangze Zhu. Lcsts: A large scale chinese short text summarization dataset. arXiv preprint arXiv:1506.05865, 2015.
+
+Nal Kalchbrenner and Phil Blunsom. Recurrent continuous translation models. In EMNLP, volume 3, pp. 413, 2013.
+
+Minh-Thang Luong, Ilya Sutskever, Quoc V Le, Oriol Vinyals, and Wojciech Zaremba. Addressing the rare word problem in neural machine translation. arXiv preprint arXiv:1410.8206, 2014.
+
+Ramesh Nallapati, Bowen Zhou, C¸ a glar Gulc¸ehre, and Bing Xiang. Abstractive text summarization using sequence-to-sequence rnns and beyond. 2016.
+
+Courtney Napoles, Matthew Gormley, and Benjamin Van Durme. Annotated gigaword. In Proceedings of the Joint Workshop on Automatic Knowledge Base Construction and Web-scale Knowledge Extraction, pp. 95–100. Association for Computational Linguistics, 2012.
+
+Joel Larocca Neto, Alex A Freitas, and Celso AA Kaestner. Automatic text summarization using a machine learning approach. In Brazilian Symposium on Artificial Intelligence, pp. 205–215. Springer, 2002.
+
+Paul Over, Hoa Dang, and Donna Harman. Duc in context. Information Processing & Management, 43(6):1506–1520, 2007.   
+Alexander M Rush, Sumit Chopra, and Jason Weston. A neural attention model for abstractive sentence summarization. arXiv preprint arXiv:1509.00685, 2015.   
+Mike Schuster and Kuldip K Paliwal. Bidirectional recurrent neural networks. IEEE Transactions on Signal Processing, 45(11):2673–2681, 1997.   
+David Sussillo and LF Abbott. Random walk initialization for training very deep feedforward networks. arXiv preprint arXiv:1412.6558, 2014.   
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.   
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015.   
+Kam-Fai Wong, Mingli Wu, and Wenjie Li. Extractive summarization using supervised and semisupervised learning. In Proceedings of the 22nd International Conference on Computational Linguistics-Volume 1, pp. 985–992. Association for Computational Linguistics, 2008.   
+Kristian Woodsend, Yansong Feng, and Mirella Lapata. Generation with quasi-synchronous grammar. In Proceedings of the 2010 conference on empirical methods in natural language processing, pp. 513–523. Association for Computational Linguistics, 2010.   
+David Zajic, Bonnie Dorr, and Richard Schwartz. Bbn/umd at duc-2004: Topiary. In Proceedings of the HLT-NAACL 2004 Document Understanding Workshop, Boston, pp. 112–119, 2004.

parse/train/HJPmdP9le/HJPmdP9le_content_list.json

@@ -0,0 +1,1487 @@
+[
+    {
+        "type": "text",
+        "text": "EFFICIENT SUMMARIZATION WITH READ-AGAIN AND COPY MECHANISM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            820,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wenyuan Zeng†, Wenjie $\\mathbf { L u o } ^ { \\ddagger }$ , Sanja Fidler‡, Raquel Urtasun‡ ",
+        "bbox": [
+            184,
+            169,
+            619,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "†Tsinghua University, ‡University of Toronto cengwy13@mails.tsinghua.edu.cn {wenjie, fidler, urtasun}@cs.toronto.edu ",
+        "bbox": [
+            184,
+            185,
+            573,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            263,
+            544,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Encoder-decoder models have been widely used to solve sequence to sequence prediction tasks. However current approaches suffer from two shortcomings. First, the encoders compute a representation of each word taking into account only the history of the words it has read so far, yielding suboptimal representations. Second, current models utilize large vocabularies in order to minimize the problem of unknown words, resulting in slow decoding times and large storage costs. In this paper we address both shortcomings. Towards this goal, we first introduce a simple mechanism that first reads the input sequence before committing to a representation of each word. Furthermore, we propose a simple copy mechanism that is able to exploit very small vocabularies and handle out-of-vocabulary words. We demonstrate the effectiveness of our approach on the Gigaword dataset and DUC competition outperforming the state-of-the-art. ",
+        "bbox": [
+            233,
+            292,
+            764,
+            458
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            482,
+            336,
+            498
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Encoder-decoder models have been widely used in sequence to sequence tasks such as machine translation (Cho et al. (2014); Sutskever et al. (2014)). They consist of an encoder which represents the whole input sequence with a single feature vector. The decoder then takes this representation and generates the desired output sequence. The most successful models are LSTM and GRU as they are much easier to train than vanilla RNNs. ",
+        "bbox": [
+            174,
+            513,
+            823,
+            582
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we are interested in summarization where the input sequence is a sentence/paragraph and the output is a summary of the text. Several encoding-decoding approaches have been proposed (Rush et al. (2015); Hu et al. (2015); Chopra et al. (2016)). Despite their success, it is commonly believed that the intermediate feature vectors are limited as they are created by only looking at previous words. This is particularly detrimental when dealing with large input sequences. Bi-directorial RNNs (Schuster & Paliwal (1997); Bahdanau et al. (2014)) try to address this problem by computing two different representations resulting of reading the input sequence left-to-right and right-to-left. The final vectors are computed by concatenating the two representations. However, the word representations are computed with limited scope. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The decoder employed in all these methods outputs at each time step a distribution over a fixed vocabulary. In practice, this introduces problems with rare words (e.g., proper nouns) which are out of vocabulary. To alleviate this problem, one could potentially increase the size of the decoder vocabulary, but decoding becomes computationally much harder, as one has to compute the soft-max over all possible words. Gulcehre et al. (2016), Nallapati et al. (2016) and Gu et al. (2016) proposed to use a copy mechanism that dynamically copy the words from the input sequence while decoding. However, they lack the ability to extract proper embeddings of out-of-vocabulary words from the input context. Bahdanau et al. (2014) proposed to use an attention mechanism to emphasize specific parts of the input sentence when generating each word. However the encoder problem still remains in this approach. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose two simple mechanisms to deal with both encoder and decoder problems. We borrowed intuition from human readers which read the text multiple times before generating summaries. We thus propose a ‘Read-Again’ model that first reads the input sequence before committing to a representation of each word. The first read representation then biases the second read representation and thus allows the intermediate hidden vectors to capture the meaning appropriate for the input text. We show that this idea can be applied to both LSTM and GRU models. Our second contribution is a copy mechanism which allows us to use much smaller vocabulary sizes resulting in much faster decoding and much smaller storage space. Our copy mechanism also allows us to construct a better representation of out-of-vocabulary words. We demonstrate the effectiveness of our approach in the challenging Gigaword dataset and DUC competition showing state-of-the-art performance. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            223,
+            338,
+            239
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 SUMMARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            256,
+            336,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the past few years, there has been a lot of work on extractive summarization, where a summary is created by composing words or sentences from the source text. Notable examples are Neto et al. (2002), Erkan & Radev (2004), Wong et al. (2008), Filippova & Altun (2013) and Colmenares et al. (2015). As a consequence of their extractive nature the summary is restricted to words (sentences) in the source text. ",
+        "bbox": [
+            174,
+            282,
+            823,
+            352
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Abstractive summarization, on the contrary, aims at generating consistent summaries based on understanding the input text. Although there has been much less work on abstractive methods, they can in principle produce much richer summaries. Abstractive summarization is standardized by the DUC2003 and DUC2004 competitions (Over et al. (2007)). Some of the prominent approaches on this task includes Banko et al. (2000), Zajic et al. (2004), Cohn & Lapata (2008) and Woodsend et al. (2010). Among them, the TOPIARY system (Zajic et al. (2004)) performs the best in the competitions amongst non neural net based methods. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Very recently, the success of deep neural networks in many natural language processing tasks (Collobert et al. (2011)) has inspired new work in abstractive summarization . Rush et al. (2015) propose a neural attention model with a convolutional encoder to solve this task. Hu et al. (2015) build a large dataset for Chinese text summarization and propose to feed all hidden states from the encoder into the decoder. More recently, Chopra et al. (2016) extended Rush et al. (2015)’s work with an RNN decoder, and Nallapati et al. (2016) proposed an RNN encoder-decoder architecture for summarization. Both techniques are currently the state-of-the-art on the DUC competition. However, the encoders exploited in these methods lack the ability to encode each word condition on the whole text, as an RNN encodes a word into a hidden vector by taking into account only the words up to that time step. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            603
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In contrast, in this work we propose a ‘Read-Again’ encoder-decoder architecture, which enables the encoder to understand each input word after reading the whole sentence. Our encoder first reads the text, and the results from the first read help represent the text in the second pass over the source text. Our second contribution is a simple copy mechanism that allows us to significantly reduce the decoder vocabulary size resulting in much faster inference times. Furthermore our copy mechanism allows us to handle out-of-vocabulary words in a principled manner. Finally our experiments show state-of-the-art performance on the DUC competition. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            707
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 NEURAL MACHINE TRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            726,
+            452,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work is also closely related to recent work on neural machine translation, where neural encoderdecoder models have shown promising results (Kalchbrenner & Blunsom (2013); Cho et al. (2014); Sutskever et al. (2014)). Bahdanau et al. (2014) further developed an attention mechanism in the decoder in order to pay attention to a specific part of the input at every generating time-step. Our approach also exploits an attention mechanism during decoding. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.3 OUT-OF-VOCABULARY AND COPY MECHANISM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            840,
+            549,
+            856
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Dealing with Out-Of-Vocabulary words (OOVs) is an important issue in sequence to sequence approaches as we cannot enumerate all possible words and learn their embeddings since they might not be part of our training set. Luong et al. (2014) address this issue by annotating words on the source, and aligning OOVs in the target with those source words. Recently, Vinyals et al. (2015) ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/653fea17ac317937d4d03ec1901f36f8de6b5af657201f58b2b1b20b091388a4.jpg",
+        "image_caption": [
+            "Figure 1: Read-Again Summarization Model "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            108,
+            764,
+            261
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "propose Pointer Networks, which calculate a probability distribution over the input sequence instead of predicting a token from a pre-defined dictionary. Cheng & Lapata (2016) develop a neural-based extractive summarization model, which predicts the targets from the input sequences. Gulcehre et al. (2016); Nallapati et al. (2016) use explicit gating to decide adaptively wether to generate a target word from the fixed-size dictionary or from the input sequence. Gu et al. (2016) use a implicit implicit gating operation instead of the explicit gating. This is similar to our decoder. However, our decoder can also extract different OOVs’ embedding accordingly from the input text instead of using a single ${ \\bf \\mathrm { < U N K > } }$ embedding to represent all OOVs. This further enhances the model’s ability to handle OOVs. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            443
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE READ AGAIN MODEL ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            465,
+            416,
+            481
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Text summarization can be formulated as a sequence to sequence prediction task, where the input is a longer text and the output is a summary of that text. In this paper we develop an encoder-decoder approach to summarization. The encoder is used to represent the input text with a set of continuous vectors, and the decoder is used to generate a summary word by word. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            553
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the following, we first introduce our ‘Read-Again’ model for encoding sentences. The idea behind our approach is very intuitive and is inspired by how humans do this task. When we create summaries, we first read the text and then we do a second read where we pay special attention to the words that are relevant to generate the summary. Our ‘Read-Again’ model implements this idea by reading the input text twice and using the information acquired from the first read to bias the second read. This idea can be seamlessly plugged into LSTM and GRU models. Our second contribution is a copy mechanism used in the decoder. It allows us to reduce the decoder vocabulary size dramatically and can be used to extract a better embedding for OOVs. Fig. 1(a) gives an overview of our model. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            702,
+            284,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first review the typical encoder used in machine translation (e.g., Sutskever et al. (2014); Bahdanau et al. (2014)). Let $x = \\{ x _ { 1 } , x _ { 2 } , \\cdot \\cdot \\cdot , x _ { n } \\}$ be the input sequence of words. An encoder sequentially reads each word and creates the hidden representation $h _ { i }$ by exploting a recurrent neural network (RNN) ",
+        "bbox": [
+            174,
+            728,
+            823,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff11a58db74d96f4e53fe48ad8f65f65d6eb9717652e8ca0dae336139c2b2427.jpg",
+        "text": "$$\nh _ { i } = \\mathrm { R N N } ( \\mathbf { x _ { i } } , h _ { i - 1 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            784,
+            570,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { x _ { i } }$ is the word embedding of $x _ { i }$ . The hidden vectors $h = \\{ h _ { 1 } , h _ { 2 } , \\cdots , h _ { n } \\}$ are then treated as the feature representations for the whole input sentence and can be used by another RNN to decode and generate a target sentence. Although RNNs have been shown to be useful in modeling sequences, one of the major drawback is that $h _ { i }$ depends only on past information i.e., $\\{ x _ { 1 } , \\cdots , x _ { i } \\}$ . However, it is hard (even for humans) to have a proper representation of a word without reading the whole input sentence. ",
+        "bbox": [
+            174,
+            804,
+            823,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Following this intuition, we propose our ‘Read-Again’ model where the encoder reads the input sentence twice. In particular, the first read is used to bias the second more attentive read. We apply this idea to two popular RNN architectures, i.e. GRU and LSTM, resulting in better encodings of the input text. Note that although other alternatives, such as bidirectional RNN exist, the hidden states from the forward RNN lack direct interactions with the backward RNN, and thus forward/backward hidden states still cannot utilize the whole sequence. Besides, although we only use our model in a uni-directional manner, it can also be easily adapted to the bidirectional case. We now describe the two variants of our model. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7583a902ba579cd1e646597ef8cc176db700cc72ce413c7267649ce33a2c585e.jpg",
+        "image_caption": [
+            "Figure 2: Read-Again Model "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            104,
+            794,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            339,
+            826,
+            424
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 GRU READ-AGAIN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            439,
+            364,
+            454
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We read the input sentence $\\{ x _ { 1 } , x _ { 2 } , \\cdots , x _ { n } \\}$ for the first-time using a standard GRU ",
+        "bbox": [
+            173,
+            464,
+            727,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6d81cc191c2eb76c1529a389872bf3dce47584be0e612b684c3de4d128aacf14.jpg",
+        "text": "$$\nh _ { i } ^ { 1 } = \\mathrm { G R U } ^ { 1 } ( \\mathbf { x _ { i } } , h _ { i - 1 } ^ { 1 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            487,
+            575,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the function $G R U ^ { 1 }$ is defined as, ",
+        "bbox": [
+            174,
+            515,
+            436,
+            530
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc92f19bee7d9259e6f6918e3c3053af7446edd7c27df3220869faaf3820f25a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { z _ { i } = \\sigma ( W _ { z } [ \\mathbf { x _ { i } } , h _ { i - 1 } ^ { 1 } ] ) } \\\\ & { r _ { i } = \\sigma ( W _ { r } [ \\mathbf { x _ { i } } , h _ { i - 1 } ^ { 1 } ] ) } \\\\ & { \\widetilde { h } _ { i } ^ { 1 } = t a n h ( W _ { h } [ \\mathbf { x _ { i } } , r _ { i } \\odot h _ { i - 1 } ^ { 1 } ] ) } \\\\ & { h _ { i } ^ { 1 } = ( 1 - z _ { i } ) \\odot h _ { i - 1 } ^ { 1 } + z _ { i } \\odot \\widetilde { h } _ { i } ^ { 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            536,
+            607,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It consists of two gatings $z _ { i } , r _ { i }$ , controlling whether the current hidden state $h _ { i } ^ { 1 }$ should be directly copied from $h _ { i - 1 } ^ { 1 }$ or should pass through a more complex path $\\widetilde { h } _ { i } ^ { 1 }$ . ",
+        "bbox": [
+            171,
+            628,
+            821,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the sentence feature vector $h _ { n } ^ { 1 }$ , we then compute an importance weight vector $\\alpha _ { i }$ of each word for the second reading. We put the importance weight $\\alpha _ { i }$ on the skip-connections as shown in Fig. 2(a) to bias the two information flows: If the current word $x _ { i }$ has a very small weight $\\alpha _ { i }$ , then the second read hidden state $h _ { i } ^ { 2 }$ will mostly take the information directly from the previous state $h _ { i - 1 } ^ { 2 }$ , ignoring the influence of the current word. If $\\alpha _ { i }$ is close to 1 then it will be similar to a standard GRU, which is only influenced from the current word. Thus the second reading has the following update rule ",
+        "bbox": [
+            173,
+            667,
+            825,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ef224dfd5b9b5fbc5f119ca8fff08e6de90b34cc61a414caa1ff0f8d65b6dfb.jpg",
+        "text": "$$\nh _ { i } ^ { 2 } = ( 1 - \\alpha _ { i } ) \\odot h _ { i - 1 } ^ { 2 } + \\alpha _ { i } \\odot \\mathrm { G R U } ^ { 2 } ( \\mathbf { x _ { i } } , h _ { i - 1 } ^ { 2 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            773,
+            656,
+            794
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ means element-wise product. We compute the importance weights by attending $h _ { i } ^ { 1 }$ with $h _ { n } ^ { 1 }$ as follows ",
+        "bbox": [
+            173,
+            803,
+            823,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b5baf412e248bb0a569ff0cf10176bb20731c9c34abd447e17dbaf0938d7568.jpg",
+        "text": "$$\n\\alpha _ { i } = t a n h ( W _ { e } h _ { i } ^ { 1 } + U _ { e } h _ { n } ^ { 1 } + V _ { e } \\mathbf { x _ { i } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            830,
+            617,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { e }$ , $U _ { e }$ , $V _ { e }$ are learnable parameters. Note that $\\alpha _ { i }$ is a vector representing the importance of each dimension in the word embedding. Empirically, we find that using a vector is better than a scalar gating. We hypothesize that this is because different dimensions represent different semantic meanings, and a scalar gating mechanism lacks the ability to capture the variances among these dimensions. ",
+        "bbox": [
+            173,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/60a53f9808b57076e7e777d401e2e7704cf3b6e00e61e896a2bbfa86eaee9eec.jpg",
+        "image_caption": [
+            "Figure 3: Hierachical Read-Again "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            99,
+            756,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Combining this with the standard GRU update rule ",
+        "bbox": [
+            173,
+            334,
+            509,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9190225c2a0ffa35522005c9159a6af4046731ddff973f1661a90ad50c50051b.jpg",
+        "text": "$$\n\\mathrm { G R U } ^ { 2 } ( \\mathbf { x _ { i } } , h _ { i - 1 } ^ { 2 } ) = ( 1 - z _ { i } ) \\odot h _ { i - 1 } ^ { 2 } + z _ { i } \\odot \\widetilde { h } _ { i } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            357,
+            653,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "we can simplify the updating rule Eq. (4) to get ",
+        "bbox": [
+            174,
+            382,
+            486,
+            398
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad5a8c6eaa40366f201b03bfec14fe2c6d70fb83933a57ac0e91f1837cf469b6.jpg",
+        "text": "$$\nh _ { i } ^ { 2 } = ( 1 - \\alpha _ { i } \\odot z _ { i } ) \\odot h _ { i - 1 } ^ { 2 } + ( \\alpha _ { i } \\odot z _ { i } ) \\odot \\widetilde { h } _ { i } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            404,
+            650,
+            425
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This equations shows that our ‘read-again’ model on GRU is equivalent to replace the GRU cell with a more general gating mechanism that also depends on the feature representation of the whole sentence computed from the first reading pass. We argue that adding this global information could help direct the information flow for the forward pass resulting in a better encoder. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            494
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 LSTM READ-AGAIN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            510,
+            375,
+            523
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now apply the ‘Read-Again’ idea to the LSTM architecture as shown in Fig. 2(b). Our first reading is performed by an $\\bar { L } S T M ^ { 1 }$ defined as ",
+        "bbox": [
+            173,
+            534,
+            823,
+            563
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3c53588ecd36ebc823858e3f88edd18ac8d19595b5da1985b1b8a7bb36dff3ff.jpg",
+        "text": "$$\n\\begin{array} { l } { f _ { i } = \\sigma ( W _ { f } [ { \\bf x _ { i } } , h _ { i - 1 } ] ) } \\\\ { ~ i _ { i } = \\sigma ( W _ { i } [ { \\bf x _ { i } } , h _ { i - 1 } ] ) } \\\\ { o _ { i } = \\sigma ( W _ { o } [ { \\bf x _ { i } } , h _ { i - 1 } ] ) } \\\\ { ~ \\widetilde C _ { i } = t a n h ( W _ { C } [ { \\bf x _ { i } } , h _ { i - 1 } ] ) } \\\\ { ~ C _ { i } = f _ { t } \\odot C _ { i - 1 } + i _ { i } \\odot \\widetilde C _ { i } } \\\\ { h _ { i } = o _ { i } \\odot t a n h ( C _ { i } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            569,
+            589,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Different from the GRU architecture, LSTM calculates the hidden state by applying a non-linear activation function to the cell state $C _ { i }$ , instead of a linear combination of two paths used in the GRU. Thus for our second read, instead of using skip-connections, we make the gating functions explicitly depend on the whole sentence vector computed from the first reading pass. We argue that this helps the encoding of the second reading $L S T M ^ { 2 }$ , as all gating and updating increments are also conditioned on the whole sequence feature vector $\\left( h _ { i } ^ { 1 } , h _ { n } ^ { 1 } \\right)$ . Thus ",
+        "bbox": [
+            173,
+            696,
+            825,
+            781
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ad3501d8035f5a75d84ba28ae465d272d1e3e7b5ebc4040b4a2041d65e614d9.jpg",
+        "text": "$$\nh _ { i } ^ { 2 } = \\mathrm { L S T M } ^ { 2 } ( [ \\mathbf { x _ { i } } , h _ { i } ^ { 1 } , h _ { n } ^ { 1 } ] , h _ { i - 1 } ^ { 2 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            787,
+            609,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 READING MULTIPLE SENTENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            829,
+            460,
+            844
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section we extend our ‘Read-Again’ model to the case where the input sequence has more than one sentence. Towards this goal, we propose to use a hierarchical representation, where each sentence has its own feature vector from the first reading pass. We then combine them into a single vector to bias the second reading pass. We illustrate this in the context of two input sentences, but it is easy to generalize to more sentences. Let $\\{ x _ { 1 } , x _ { 2 } , \\cdots , x _ { n } \\}$ and $\\{ x _ { 1 } ^ { \\prime } , \\cdots , x _ { m } ^ { \\bar { \\prime } } \\}$ be the two input sentences. The first RNN reads these two sentences independently to get two sentence feature vectors $h _ { n } ^ { 1 }$ and $h _ { m } ^ { \\prime 1 }$ respectively. ",
+        "bbox": [
+            173,
+            853,
+            825,
+            925
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here we investigate two different ways to handle multiple sentences. Our first option is to simply concatenate the two feature vectors to bias our second reading pass: ",
+        "bbox": [
+            173,
+            138,
+            820,
+            166
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/80e5656c0ac2084d01bc32cc2297a4488f454ae9bd3d75ca5bf0434021344939.jpg",
+        "text": "$$\nh _ { i } ^ { 2 } = \\mathbf { R N N ^ { 2 } } ( [ \\mathbf { x _ { i } } , h _ { i } ^ { 1 } , h _ { n } ^ { 1 } , h _ { m } ^ { \\prime 1 } ] , h _ { i - 1 } ^ { 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            167,
+            622,
+            185
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/25f01db72e30ce7553d5c81c77caf5159acd3f6df773566541faa329367770ac.jpg",
+        "text": "$$\nh _ { i } ^ { \\prime 2 } = \\mathrm { R N N } ^ { 2 } ( [ \\mathbf { x } _ { \\mathbf { i } } ^ { \\prime } , h _ { i } ^ { \\prime 1 } , h _ { n } ^ { 1 } , h _ { m } ^ { \\prime 1 } ] , h _ { i - 1 } ^ { \\prime 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            188,
+            622,
+            205
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $h _ { 0 } ^ { 2 }$ and $h _ { 0 } ^ { \\prime 2 }$ are initialized as zero vectors. Feeding $h _ { n } ^ { 1 } , h _ { m } ^ { \\prime 1 }$ into the second RNN provides more global information explicitly and helps acquire long term dependencies. ",
+        "bbox": [
+            173,
+            208,
+            821,
+            236
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The second option we explored is shown in Fig. 3. In particular, we use a non-linear transformation to get a single feature vector $h _ { g l o b a l }$ from both sentence feature vectors: ",
+        "bbox": [
+            171,
+            242,
+            821,
+            271
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d0f3ece7896af1407a69f7a9cccdfaf96b5e5a21a41eb39e79896565702883f.jpg",
+        "text": "$$\nh _ { g l o b a l } = t a n h ( W _ { r } h _ { n } ^ { 1 } + U _ { r } h _ { m } ^ { \\prime 1 } + v _ { r } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            272,
+            625,
+            291
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The second reading pass is then ",
+        "bbox": [
+            174,
+            292,
+            383,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93235c0b3bb6c7b85018dde446fde1ea2418a61e5ceb44d7866a3fb2ee154cbb.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\widetilde { h _ { i } ^ { 2 } } = \\mathrm { R N N } ^ { 2 } ( [ \\mathbf { x _ { i } } , h _ { i } ^ { 1 } , h _ { n } ^ { 1 } , h _ { g l o b a l } ] , h _ { i - 1 } ^ { 2 } ) } \\\\ & { \\widetilde { h _ { i } ^ { \\prime 2 } } = \\mathrm { R N N } ^ { 2 } ( [ \\mathbf { x _ { i } ^ { \\prime } } , h _ { i } ^ { \\prime 1 } , h _ { m } ^ { \\prime 1 } , h _ { g l o b a l } ] , h _ { i - 1 } ^ { \\prime 2 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            306,
+            633,
+            353
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that this is more easily scalable to more sentences. In our experiments both approaches perform similarly. ",
+        "bbox": [
+            178,
+            353,
+            823,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 DECODER WITH COPY MECHANISM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            396,
+            459,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this paper we argue that only a small number of common words are needed for generating a summary in addition to the words that are present in the source text. We can consider this as a hybrid approach which combines extractive and abstractive summarization. This has two benefits: first it allow us to use a very small vocabulary size, speeding up inference. Furthermore, we can create summaries which contain OOVs if they are present in the source text. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            492
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our decoder reads the vector representations of the input text using an attention mechanism, and generates the target summary word by word. We use an LSTM as our decoder, with a fixed-size vocabulary dictionary $Y$ and learnable word embeddings $\\mathbf { Y } \\in \\mathbf { R } ^ { | Y | \\times d i m }$ . At time-step $t$ the LSTM generates a summary word $y _ { t }$ by first computing the current hidden state $s _ { t }$ from the previous hidden state $s _ { t - 1 }$ , previous summary word $y _ { t - 1 }$ and current context vector $c _ { t }$ ",
+        "bbox": [
+            173,
+            498,
+            825,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8a5350d6951ee8912adad67559173ec7667eb15dc3bbb24aa581c483d934ac26.jpg",
+        "text": "$$\ns _ { t } = L S T M ( [ \\mathbf { y _ { t - 1 } } , c _ { t } ] , s _ { t - 1 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            571,
+            599,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where the context vector $c _ { t }$ is computed with an attention mechanism on the encoder hidden states: ",
+        "bbox": [
+            176,
+            588,
+            818,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/25997be0d934b2bf2700bd172305c324e33b33d7006fe3e8d1fa33219ebb0bb6.jpg",
+        "text": "$$\nc _ { t } = \\sum _ { i = 1 } ^ { n } \\beta _ { i t } h _ { i } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            604,
+            552,
+            645
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The attention score $\\beta _ { i t }$ at time-step $t$ on the $i$ -th word is computed via a soft-max over $o _ { i t }$ , where ",
+        "bbox": [
+            186,
+            645,
+            803,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca07c8acdbbbf348aafb83b32f04aaf88040c416734e04760f39648cd41767b8.jpg",
+        "text": "$$\no _ { i t } = a t t ( s _ { t - 1 } , h _ { i } ^ { 2 } ) = v _ { a } ^ { T } t a n h ( W _ { a } s _ { t - 1 } + U _ { a } h _ { i } ^ { 2 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            660,
+            663,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "with $v _ { a }$ , $W _ { a }$ , $U _ { a }$ learnable parameters. ",
+        "bbox": [
+            176,
+            679,
+            426,
+            694
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A typical way to treat OOVs is to encode them with a single shared embedding. However, different OOVs can have very different meanings, and thus using a single embedding for all OOVs will confuse the model. This is particularly detrimental when using small vocabulary sizes. Here we address this issue by deriving the representations of OOVs from their corresponding context in the input text. Towards this goal, we change the update rule of $\\mathbf { y _ { t - 1 } }$ . In particular, if $y _ { t - 1 }$ belongs to a word that is in our decoder vocabulary we take its representation from the word embedding, otherwise if it appears in the input sentence as $x _ { i }$ we use ",
+        "bbox": [
+            173,
+            700,
+            825,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fc59b0916a35659ba299153ec002978450af638c8003229f61a774eee041ae9b.jpg",
+        "text": "$$\n\\mathbf { y _ { t - 1 } } = \\mathbf { p _ { i } } = t a n h ( W _ { c } h _ { i } ^ { 2 } + b _ { c } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            797,
+            606,
+            816
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { c }$ and $b _ { c }$ are learnable parameters. Since $h _ { i } ^ { 2 }$ encodes useful context information of the source word $x _ { i }$ , $p _ { i }$ can be interpreted as the semantics of this word extracted from the input sentence. Furthermore, if $y _ { t - 1 }$ does not appear in the input text, nor in $Y$ , then we represent $\\mathbf { y _ { t - 1 } }$ using the ${ \\bf \\mathrm { < U N K > } }$ embedding. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given the current decoder’s hidden state $s _ { t }$ , we can generate the target summary word $y _ { t }$ . As shown in Fig. 1(b), at each time step during decoding, the decoder outputs a distribution over generating words from $Y$ , as well as over copying a specific word $x _ { i }$ from the source sentence. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            290,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We jointly learn our encoder and decoder by maximizing the likelihood of decoding the correct word at each time step. We refer the reader to the experimental evaluation for more details. ",
+        "bbox": [
+            174,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL EVALALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            178,
+            475,
+            194
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we show results of abstractive summarization on Gigaword (Graff & Cieri (2003); Napoles et al. (2012)) and DUC2004 (Over et al. (2007)) datasets. Our model can learn a meaningful re-reading weight distribution for each word in the input text, putting more emphasis on important verb and nous, while ignoring common words such as prepositions. As for the decoder, we demonstrate that our copy mechanism can successfully reduce the typical vocabulary size by a factor 5 while achieving much better performance than the state-of-the-art, and by a factor of 30 while maintaining the same level of performance. In addition, we provide an analysis and examples of which words are copied during decoding. ",
+        "bbox": [
+            174,
+            209,
+            825,
+            321
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dataset and Evaluation Metric: We use the Gigaword corpus to train and evaluate our models. Gigaword is a news corpus where the title is employed as a proxy for the summary of the article. We follow the same pre-processing steps of Rush et al. (2015), which include filtering, PTB tokenization, lower-casing, replacing digit characters with #, replacing low-frequency words with UNK and extracting the first sentence in each article. This results in a training set of $3 . 8 \\mathbf { M }$ articles, a validation set and a test set each containing 400K articles. The average sentence length is 31.3 words for the source, and 8.3 words for the summaries. Following the standard protocol we evaluate ROUGE score on 2000 random samples from the test set. As for evaluation metric, we use full-length F1 score on Rouge-1, Rouge-2 and Rouge-L, following Chopra et al. (2016) and Nallapati et al. (2016), since these metrics are less bias to the outputs’ length than full-length recall scores. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            476
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Implemetation Details: We implement our model in Tensorflow and conduct all experiments on a NVIDIA Titan X GPU. Our models converged after 2-3 days of training, depending on model size. Our RNN cells in all models have 1 layer, 512-dimensional hidden states, and 512-dimensional word embeddings. We use dropout rate of 0.2 in all activation layers. All parameters, except the biases are initialized uniformly with a range of $\\sqrt { 3 / d }$ , where $d$ is the dimension of the hidden state (Sussillo & Abbott (2014)). The biases are initialized to 0.1. We use plain SGD to train the model with gradient clipped at 10. We start with an initial learning rate of 2, and halve it every epoch after first 5 epochs. Our max epoch for training is 10. We use a mini-batch size of 64, which is shuffled during training. ",
+        "bbox": [
+            173,
+            491,
+            825,
+            606
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 QUANTITATIVE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            622,
+            415,
+            637
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5c4283b5847a060daebdbee7c3454d35a28401cabc9acfe1462dadd91b75ef3.jpg",
+        "table_caption": [
+            "Table 1: Different Read-Again Model. Ours denotes Read-Again models. C denotes copy mechanism. Ours-Opt-1 and Ours-Opt-2 are the models described in section 3.1.3. Size denotes the size of decoder vocabulary in a model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>#Input</td><td>Model</td><td>Size</td><td>Rouge-1</td><td>Rouge-2</td><td>Rouge-L</td></tr><tr><td rowspan=\"7\">1 sent</td><td>ABS (baseline)</td><td>69K</td><td>24.12</td><td>10.24</td><td>22.61</td></tr><tr><td>GRU (baseline)</td><td>69K</td><td>26.79</td><td>12.03</td><td>25.14</td></tr><tr><td>Ours-GRU</td><td>69K</td><td>27.26</td><td>12.28</td><td>25.48</td></tr><tr><td>Ours-LSTM</td><td>69K</td><td>27.82</td><td>12.74</td><td>26.01</td></tr><tr><td>GRU (baseline)</td><td>15K</td><td>24.67</td><td>11.30</td><td>23.28</td></tr><tr><td>Ours-GRU</td><td>15K</td><td>25.04</td><td>11.40</td><td>23.47</td></tr><tr><td>Ours-LSTM</td><td>15K</td><td>25.30</td><td>11.76</td><td>23.71</td></tr><tr><td>Ours-GRU (C)</td><td>15K</td><td>27.41</td><td>12.58</td><td>25.74</td></tr><tr><td rowspan=\"2\">2 sent</td><td>Ours-LSTM (C) Ours-Opt-1 (C)</td><td>15K 15K</td><td>27.37 27.95</td><td>12.64</td><td>25.69</td></tr><tr><td></td><td></td><td></td><td>12.65</td><td>26.10</td></tr><tr><td></td><td>Ours-Opt-2 (C)</td><td>15K</td><td>27.96</td><td>12.65</td><td>26.18</td></tr></table>",
+        "bbox": [
+            264,
+            654,
+            732,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results on Gigaword: We compare the performances of different architectures and report ROUGE scores in Table 1. Our baselines include the ABS model of Rush et al. (2015) with its proposed vocabulary size as well as an attention encoder-decoder model with uni-directional GRU encoder. We allow the decoder to generate variable length summaries. As shown in Table 1 our Read-Again models outperform the baselines on all ROUGE scores, when using both 15K and 69K sized vocabularies. We also observe that adding the copy mechanism further helps to improve performance: Even though the decoder vocabulary size of our approach with copy (15K) is much smaller than ABS (69K) and GRU (69K), it achieves a higher ROUGE score. Besides, our Multiple-Sentences model achieves the best performance. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/500f58ba06360628745e083952880138404f1567034bba8f53fed41901562bdb.jpg",
+        "table_caption": [
+            "Table 2: Rouge-N limited-length recall on DUC2004. Size denotes the size of decoder vocabulary in a model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Size</td><td>Rouge-1</td><td>Rouge-2</td><td>Rouge-L</td></tr><tr><td>ZOPIARY (Zajic et al. (2004))</td><td>-</td><td>25.12</td><td>6.46</td><td>20.12</td></tr><tr><td>ABS (Rush et al. (2015))</td><td>69K</td><td>26.55</td><td>7.06</td><td>23.49</td></tr><tr><td>ABS+ (Rush et al. (2015))</td><td>69K</td><td>28.18</td><td>8.49</td><td>23.81</td></tr><tr><td>RAS-LSTM (Chopra et al. (2016))</td><td>69K</td><td>27.41</td><td>7.69</td><td>23.06</td></tr><tr><td>RAS-Elman (Chopra et al. (2016))</td><td>69K</td><td>28.97</td><td>8.26</td><td>24.06</td></tr><tr><td>big-words-lvt2k-1sent (Nallapati et al. (2016))</td><td>69K</td><td>28.35</td><td>9.46</td><td>24.59</td></tr><tr><td>big-words-lvt5k-1sent (Nallapati et al. (2016))</td><td>200K</td><td>28.61</td><td>9.42</td><td>25.24</td></tr><tr><td>Ours-GRU (C)</td><td>15K</td><td>29.08</td><td>9.20</td><td>25.25</td></tr><tr><td>Ours-LSTM (C)</td><td>15K</td><td>29.89</td><td>9.37</td><td>25.93</td></tr><tr><td>Ours-Opt-2 (C)</td><td>15K</td><td>29.74</td><td>9.44</td><td>25.94</td></tr></table>",
+        "bbox": [
+            192,
+            214,
+            805,
+            372
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on DUC2004: DUC 2004 (Over et al. (2007)) is a commonly used benchmark on summarization task consisting of 500 news articles. Each article is paired with 4 different humangenerated reference summaries, capped at 75 characters. This dataset is evaluation-only. Similar to Rush et al. (2015), we train our neural model on the Gigaword training set, and show the models’ performances on DUC2004. Following the convention, we also use ROUGE limited-length recall as our evaluation metric, and set the capping length to 75 characters. We generate summaries with 15 words using beam-size of 10. As shown in Table 2, our method outperforms all previous methods on Rouge-1 and Rouge-L, and is comparable on Rouge-2. Furthermore, our model only uses $1 5 \\mathrm { k }$ decoder vocabulary, while previous methods use $6 9 \\mathrm { k }$ or 200k. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            551
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Importance Weight Visualization: As we described in the section before, $\\alpha _ { i }$ is a high-dimension vector representing the importance of each word $x _ { i }$ . While the importance of a word is different over each dimension, by averaging we can still look at general trends of which word is more relevant.indonesia has moved #.# million people and resettl Fig. 4 depicts sample sentences with the importance weight #,### village $\\alpha _ { i }$ over input words. Words such asn a national transmigration scheme the, a, ${ \\bf \\Phi } _ { s }$ , have small $\\alpha _ { i }$ , while words such as aeronautics, resettled, impediments, which carry morepast ## years , president suharto said here mo information have higher values. This shows that our read-again technique indeed extracts usefultariffs and other barriers remain serious impediments to information from the first reading to help bias the second reading results.onesia 's state-owned domestic carrier merpati nusantara and business in the asia-p ",
+        "bbox": [
+            173,
+            559,
+            825,
+            656
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/539b0be6900581910a2f2c98f2c6c4cb02dad3c5523881834fbd893b85b67305.jpg",
+        "image_caption": [
+            "Figure 4: Weight Visualization. Black indicates high weight "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            675,
+            833,
+            780
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 EVALUATION OF COPY MECHANISM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            465,
+            856
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows the effect on our model of decreasing the decoder vocabulary size. We can see that when using the copy mechanism, we are able to reduce the decoder vocabulary size from 69K to 2K, with only 2-3 points drop on ROUGE score. This contrasts the models that do not use the copy mechanism. Equipped with a copy mechanism, our model is able to generate OOVs as summary words, and thus maintains its expressive ability even with a small decoder vocabulary size. We also observe from Table 4 that the copy mechanism help us to decrease the encoder vocabulary size as well. The model without copy suffers from severe OOV problem when encoder size is small, since a single shared ${ \\bf \\mathrm { < U N K > } }$ embedding cannot depict many different OOVs. This makes it difficult for the encoder to understand the input text. Meanwhile, our copy model can extract an OOV’s meaning accordingly from its context in the input text, and thus it is sufficient to learn and store only the high-frequency words embeddings using our model, which in turn save the storage. We also notice that shrinking the encoder vocabulary to $1 5 \\mathrm { k }$ achieves better result. One possible reason is that long tail words can not learn efficient embeddings during training, and representing them with extracted embedding from our model performs better. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/8adf0480c31aea2eb98b954fae915bed63bb8cc7b2b6be553b96ad4deab79b84.jpg",
+        "table_caption": [
+            "Table 3: ROUGE Evaluation for Models with Different Decoder Size and 110k Encoder Size. Ours denotes Read-Again. C denotes copy mechanism. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Rouge-1</td><td colspan=\"2\">Rouge-2</td><td colspan=\"2\">Rouge-L</td></tr><tr><td>Size</td><td>Ours-LSTM</td><td>Ours-LSTM (C)</td><td>Ours-LSTM</td><td>Ours-LSTM (C)</td><td>Ours-LSTM</td><td>Ours-LSTM(C)</td></tr><tr><td>2K</td><td>14.39</td><td>24.21</td><td>6.46</td><td>11.27</td><td>13.74</td><td>23.09</td></tr><tr><td>5K</td><td>20.61</td><td>26.83</td><td>9.67</td><td>12.66</td><td>19.58</td><td>25.31</td></tr><tr><td>15K</td><td>25.30</td><td>27.37</td><td>11.76</td><td>12.64</td><td>23.74</td><td>25.69</td></tr><tr><td>30K</td><td>26.86</td><td>27.49</td><td>11.93</td><td>12.75</td><td>25.16</td><td>25.77</td></tr><tr><td>69K</td><td>27.82</td><td>27.89</td><td>12.73</td><td>12.69</td><td>26.01</td><td>26.03</td></tr></table>",
+        "bbox": [
+            174,
+            101,
+            843,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/80dbcd2894825d1641006fc1de41630581a9988b52b73ca47721d23e5aee97fb.jpg",
+        "table_caption": [
+            "Table 4: ROUGE Evaluation for Models with Different Encoder Size and 15k Decoder Size. Ours denotes Read-Again. C denotes copy mechanism. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\"></td><td colspan=\"2\">Rouge-2</td><td colspan=\"2\">Rouge-L</td></tr><tr><td>Size</td><td>Ours-LSTM</td><td>Ours-LSTM (C)</td><td>Ours-LSTM</td><td>Ours-LSTM(C)</td><td>Ours-LSTM</td><td>Ours-LSTM(C)</td></tr><tr><td>5K</td><td>21.82</td><td>26.57</td><td>9.80</td><td>11.98</td><td>20.60</td><td>25.00</td></tr><tr><td>15K</td><td>23.84</td><td>27.79</td><td>10.69</td><td>12.54</td><td>22.50</td><td>25.96</td></tr><tr><td>30K</td><td>23.78</td><td>27.48</td><td>10.68</td><td>12.56</td><td>22.28</td><td>25.94</td></tr><tr><td>110K</td><td>25.30</td><td>27.37</td><td>11.76</td><td>12.64</td><td>23.74</td><td>25.69</td></tr></table>",
+        "bbox": [
+            173,
+            243,
+            848,
+            323
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            386,
+            825,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 5 shows the decoding time as a function of vocabulary size. As computing the soft-max is usually the bottleneck for decoding, reducing vocabulary size dramatically reduces the decoding time from 0.38 second per sentence to 0.08 second. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/f3ce386aebcd050a0706188907170707b1598c480f2b3f762c7e3b64d7f4422c.jpg",
+        "table_caption": [
+            "Table 5: Decoding Time (s) per Sentence of Models with Different Decoder Size "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Decoder-Size</td><td>2k</td><td>5k</td><td>15k</td><td>30k</td><td>69k</td></tr><tr><td>Ours-LSTM</td><td>0.076</td><td>0.081</td><td>0.111</td><td>0.161</td><td>0.356</td></tr><tr><td>Ours-LSTM(C)</td><td>0.084</td><td>0.090</td><td>0.123</td><td>0.171</td><td>0.376</td></tr></table>",
+        "bbox": [
+            307,
+            587,
+            691,
+            630
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 6 provides some examples of visualization of the copy mechanism. Note that we are able to copy key words from source sentences to improve the summary. From these examples we can see that our model is able to copy different types of rare words, such as special entities’ names in case 1 and 2, rare nouns in case 3 and 4, adjectives in case 5 and 6, and even rare verbs in the last example. Note that in the third example, when the copy model’s decoder uses the embedding of headmaster as its first input, which is extracted from the source sentence, it generates the same following sentence as the no-copy model. This probably means that the extracted embedding of headmaster is closely related to the learned embedding of teacher. ",
+        "bbox": [
+            173,
+            681,
+            825,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/66d3df6ff002d61f9b2ff3593450662cdeaa12d66006f5e8c543016a155f27e7.jpg",
+        "table_caption": [
+            "Table 6: Visualization of Copy Mechanism "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input: Golden: No Copy: </td><td>air new zealand said friday it had reached agreement to buya ## percent interest inaustralia&#x27;s ansett holdings limited for ### million australian -lrb-### million us dollars -rrb-. urgent air new zealand buys ## percent of australia &#x27;s ansett airlines air nz to buy ## percent stake in australia&#x27;s &lt;unk&gt; air nz to buy ## percent stake in ansett</td></tr><tr><td>Copy: Input: Golden: No Copy: Copy:</td><td>yemen &#x27;s ruling party was expected wednesday to nominate president ali abdullah saleh as its candidate for september &#x27;s presidential election ,although saleh insisted he is not bluffing about bowing out. the #### gmt news advisory yemen &#x27;s ruling party expected to nominate president as presidential candidate yemen &#x27;s ruling party expected to nominate saleh as presidential candidate</td></tr><tr><td>Input: Golden: No Copy: Copy:</td><td>a ##-year-old headmaster who taught children in care homes for more than ## years was jailed for ## years on friday after being convicted of ## sexual assaults against his pupils. britain :headmaster jailed for ## years for paedophilia teacher jailed for ## years for sexuallyabusing childre headmaster jailed for ## years for sexually abusing children</td></tr><tr><td>Input: Golden: No Copy: Copy:</td><td>singapore ’s rapidly ageing population poses the major challenge to fiscal policy in the ##st century, finance minister richard hu said,and warned against european-style state &lt;unk&gt;. ageing population to pose major fiscal challenge to singapore finance minister warns against &lt;unk&gt; state s pore &#x27;s ageing population poses challenge to fiscal policy</td></tr><tr><td>Input: Golden: No Copy:</td><td>angola is planning to refit its ageing soviet-era fleet of military jets in russan factories,a media report said on tuesday. angola to refit jet fighters in russia :report angola to &lt;unk&gt; soviet-era soviet-era fleet</td></tr></table>",
+        "bbox": [
+            173,
+            103,
+            874,
+            422
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            477,
+            320,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper we have proposed two simple mechanisms to alleviate the problems of current encoderdecoder models. Our first contribution is a ‘Read-Again’ model which does not form a representation of the input word until the whole sentence is read. Our second contribution is a copy mechanism that can handle out-of-vocabulary words in a principled manner allowing us to reduce the decoder vocabulary size and significantly speed up inference. We have demonstrated the effectiveness of our approach in the context of summarization and shown state-of-the-art performance. In the future, we plan to tackle summarization problems with large input text. We also plan to exploit our findings in other tasks such as machine translation. ",
+        "bbox": [
+            173,
+            510,
+            825,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014. ",
+        "bbox": [
+            171,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michele Banko, Vibhu O Mittal, and Michael J Witbrock. Headline generation based on statistical translation. In Proceedings of the 38th Annual Meeting on Association for Computational Linguistics, pp. 318–325. Association for Computational Linguistics, 2000. ",
+        "bbox": [
+            176,
+            162,
+            821,
+            207
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jianpeng Cheng and Mirella Lapata. Neural summarization by extracting sentences and words. arXiv preprint arXiv:1603.07252, 2016. ",
+        "bbox": [
+            168,
+            215,
+            821,
+            244
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014. ",
+        "bbox": [
+            174,
+            253,
+            823,
+            296
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sumit Chopra, Michael Auli, Alexander M Rush, and SEAS Harvard. Abstractive sentence summarization with attentive recurrent neural networks. arXiv preprint arXiv:1602.06023, 2016. ",
+        "bbox": [
+            171,
+            305,
+            821,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Trevor Cohn and Mirella Lapata. Sentence compression beyond word deletion. In Proceedings of the 22nd International Conference on Computational Linguistics-Volume 1, pp. 137–144. Association for Computational Linguistics, 2008. ",
+        "bbox": [
+            174,
+            344,
+            823,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ronan Collobert, Jason Weston, Leon Bottou, Michael Karlen, Koray Kavukcuoglu, and Pavel ´ Kuksa. Natural language processing (almost) from scratch. Journal of Machine Learning Research, 12(Aug):2493–2537, 2011. ",
+        "bbox": [
+            173,
+            395,
+            825,
+            439
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Carlos A Colmenares, Marina Litvak, Amin Mantrach, and Fabrizio Silvestri. Heads: Headline generation as sequence prediction using an abstract feature-rich space. 2015. ",
+        "bbox": [
+            173,
+            448,
+            821,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gunes Erkan and Dragomir R Radev. Lexrank: Graph-based lexical centrality as salience in text ¨ summarization. Journal of Artificial Intelligence Research, 22:457–479, 2004. ",
+        "bbox": [
+            173,
+            486,
+            820,
+            515
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Katja Filippova and Yasemin Altun. Overcoming the lack of parallel data in sentence compression. In EMNLP, pp. 1481–1491. Citeseer, 2013. ",
+        "bbox": [
+            176,
+            523,
+            821,
+            554
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Graff and Christopher Cieri. English giga-word, 2003. Linguistic Data Consortium, Philadeplhia, 2003. ",
+        "bbox": [
+            174,
+            561,
+            823,
+            590
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiatao Gu, Zhengdong Lu, Hang Li, and Victor OK Li. Incorporating copying mechanism in sequence-to-sequence learning. arXiv preprint arXiv:1603.06393, 2016. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            630
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Caglar Gulcehre, Sungjin Ahn, Ramesh Nallapati, Bowen Zhou, and Yoshua Bengio. Pointing the unknown words. arXiv preprint arXiv:1603.08148, 2016. ",
+        "bbox": [
+            173,
+            638,
+            823,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baotian Hu, Qingcai Chen, and Fangze Zhu. Lcsts: A large scale chinese short text summarization dataset. arXiv preprint arXiv:1506.05865, 2015. ",
+        "bbox": [
+            174,
+            676,
+            823,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nal Kalchbrenner and Phil Blunsom. Recurrent continuous translation models. In EMNLP, volume 3, pp. 413, 2013. ",
+        "bbox": [
+            174,
+            715,
+            823,
+            744
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong, Ilya Sutskever, Quoc V Le, Oriol Vinyals, and Wojciech Zaremba. Addressing the rare word problem in neural machine translation. arXiv preprint arXiv:1410.8206, 2014. ",
+        "bbox": [
+            173,
+            752,
+            823,
+            782
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ramesh Nallapati, Bowen Zhou, C¸ a glar Gulc¸ehre, and Bing Xiang. Abstractive text summarization using sequence-to-sequence rnns and beyond. 2016. ",
+        "bbox": [
+            171,
+            790,
+            823,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Courtney Napoles, Matthew Gormley, and Benjamin Van Durme. Annotated gigaword. In Proceedings of the Joint Workshop on Automatic Knowledge Base Construction and Web-scale Knowledge Extraction, pp. 95–100. Association for Computational Linguistics, 2012. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joel Larocca Neto, Alex A Freitas, and Celso AA Kaestner. Automatic text summarization using a machine learning approach. In Brazilian Symposium on Artificial Intelligence, pp. 205–215. Springer, 2002. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Paul Over, Hoa Dang, and Donna Harman. Duc in context. Information Processing & Management, 43(6):1506–1520, 2007.   \nAlexander M Rush, Sumit Chopra, and Jason Weston. A neural attention model for abstractive sentence summarization. arXiv preprint arXiv:1509.00685, 2015.   \nMike Schuster and Kuldip K Paliwal. Bidirectional recurrent neural networks. IEEE Transactions on Signal Processing, 45(11):2673–2681, 1997.   \nDavid Sussillo and LF Abbott. Random walk initialization for training very deep feedforward networks. arXiv preprint arXiv:1412.6558, 2014.   \nIlya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.   \nOriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015.   \nKam-Fai Wong, Mingli Wu, and Wenjie Li. Extractive summarization using supervised and semisupervised learning. In Proceedings of the 22nd International Conference on Computational Linguistics-Volume 1, pp. 985–992. Association for Computational Linguistics, 2008.   \nKristian Woodsend, Yansong Feng, and Mirella Lapata. Generation with quasi-synchronous grammar. In Proceedings of the 2010 conference on empirical methods in natural language processing, pp. 513–523. Association for Computational Linguistics, 2010.   \nDavid Zajic, Bonnie Dorr, and Richard Schwartz. Bbn/umd at duc-2004: Topiary. In Proceedings of the HLT-NAACL 2004 Document Understanding Workshop, Boston, pp. 112–119, 2004. ",
+        "bbox": [
+            171,
+            103,
+            826,
+            464
+        ],
+        "page_idx": 11
+    }
+]

parse/train/NzTU59SYbNq/NzTU59SYbNq.md

@@ -0,0 +1,282 @@
+# EIGENGAME: PCA AS A NASH EQUILIBRIUM
+
+Ian Gemp, Brian McWilliams, Claire Vernade & Thore Graepel DeepMind {imgemp,bmcw,vernade,thore}@google.com
+
+# ABSTRACT
+
+We present a novel view on principal component analysis (PCA) as a competitive game in which each approximate eigenvector is controlled by a player whose goal is to maximize their own utility function. We analyze the properties of this PCA game and the behavior of its gradient based updates. The resulting algorithm—which combines elements from Oja’s rule with a generalized GramSchmidt orthogonalization—is naturally decentralized and hence parallelizable through message passing. We demonstrate the scalability of the algorithm with experiments on large image datasets and neural network activations. We discuss how this new view of PCA as a differentiable game can lead to further algorithmic developments and insights.
+
+# 1 INTRODUCTION
+
+The principal components of data are the vectors that align with the directions of maximum variance. These have two main purposes: a) as interpretable features and b) for data compression. Recent methods for principal component analysis (PCA) focus on the latter, explicitly stating objectives to find the $k$ -dimensional subspace that captures maximum variance (e.g., (Tang, 2019)), and leaving the problem of rotating within this subspace to, for example, a more efficient downstream singular value (SVD) decomposition step1. This point is subtle, yet critical. For example, any pair of twodimensional, orthogonal vectors spans all of $\mathbb { R } ^ { 2 }$ and, therefore, captures maximum variance of any two-dimensional dataset. However, for these vectors to be principal components, they must, in addition, align with the directions of maximum variance which depends on the covariance of the data. By learning the optimal subspace, rather than the principal components themselves, objectives focused on subspace error ignore the first purpose of PCA. In contrast, modern nonlinear representation learning techniques focus on learning features that are both disentangled (uncorrelated) and low dimensional (Chen et al., 2016; Mathieu et al., 2018; Locatello et al., 2019; Sarhan et al., 2019).
+
+It is well known that the PCA solution of the $d$ -dimensional dataset $\ b { X } \in \mathbb { R } ^ { n \times d }$ is given by the eigenvectors of $X ^ { \top } X$ or equivalently, the right singular vectors of $X$ . Impractically, the cost of computing the full SVD scales with $\bar { \mathcal { O } } ( \operatorname* { m i n } \{ n \bar { d } ^ { 2 } , n ^ { 2 } \bar { d } \} )$ -time and $\mathcal { O } ( n d )$ -space (Shamir, 2015; Tang, 2019). For moderately sized data, randomized methods can be used (Halko et al., 2011). Beyond this, stochastic—or online—methods based on Oja’s rule (Oja, 1982) or power iterations (Rutishauser, 1971) are common. Another option is to use streaming $k$ -PCA algorithms such as Frequent Directions (FD) (Ghashami et al., 2016) or Oja’s algorithm2 (Allen-Zhu and Li, 2017) with storage complexity $\mathcal { O } ( k d )$ . Sampling or sketching methods also scale well, but again, focus on the top- $k$ subspace (Sarlos, 2006; Cohen et al., 2017; Feldman et al., 2020).
+
+In contrast to these approaches, we view each principal component (equivalently eigenvector) as a player in a game whose objective is to maximize their own local utility function in controlled competition with other vectors. The proposed utility gradients are interpretable as a combination of Oja’s rule and a generalized Gram-Schmidt process. We make the following contributions:
+
+• A novel formulation of PCA as finding the Nash equilibrium of a suitable game, • A sequential, globally convergent algorithm for approximating the Nash on full-batch data, • A decentralized algorithm with experiments demonstrating the approach as competitive with modern streaming $k$ -PCA algorithms on synthetic and real data, In demonstration of the scaling of the approach, we compute the top-32 principal components of the matrix of RESNET-200 activations on the IMAGENET dataset $\cdot n \approx 1 0 ^ { \hat { 6 } }$ , $d \approx \dot { 2 0 } \cdot 1 0 ^ { 6 }$ ).
+
+Each of these contributions is important. Novel formulations often lead to deeper understanding of problems, thereby, opening doors to improved techniques. In particular, $k$ -player games are in general complex and hard to analyze. In contrast, PCA has been well-studied. By combining the two fields we hope to develop useful analytical tools. Our specific formulation is important because it obviates the need for any centralized orthonormalization step and lends itself naturally to decentralization. And lastly, theory and experiments support the viability of this approach for continued research.
+
+# 2 PCA AS AN EIGEN-GAME
+
+We adhere to the following notation. Vectors and matrices meant to approximate principal components (equivalently eigenvectors) are designated with hats, $\hat { v }$ and $\hat { V }$ respectively, whereas true principal components are $v$ and $V$ . Subscripts indicate which eigenvalue a vector is associated with. For example, $v _ { i }$ is the ith largest eigenvector. In this work, we will assume each eigenvalue is distinct. By an abuse of notation, $v _ { j < i }$ refers to the set of vectors $\{ v _ { j } | j \in \{ 1 , \ldots , i - 1 \} \bar  \}$ and are also referred to as the parents of $v _ { i }$ $\mathbf { \chi } _ { v _ { i } }$ is their child). Sums over indices should be clear from context, e.g., $\textstyle \sum _ { j < i } = \sum _ { j = 1 } ^ { i - 1 }$ . The Euclidean inner product is written $\langle u , v \rangle = u ^ { \top } v$ . We denote the unit sphere by $S ^ { d - 1 }$ and simplex by $\Delta ^ { d - 1 }$ in $d$ -dimensional ambient space.
+
+Outline of derivation As argued in the introduction, the PCA problem is often mis-interpreted as learning a projection of the data into a subspace that captures maximum variance (equiv. maximizing the trace of a suitable matrix $R$ introduced below). This is in contrast to the original goal of learning the principal components. We first develop the intuition for deriving our utility functions by (i) showing that only maximizing the trace of $R$ is not sufficient for recovering all principal components (equiv. eigenvectors), and (ii) showing that minimizing off-diagonal terms in $R$ is a complementary objective to maximizing the trace and can recover all components. We then consider learning only the top- $k$ and construct utilities that are consistent with findings in (i) and (ii), equal the true eigenvalues at the Nash of the game we construct, and result in a game that is amenable to analysis.
+
+Derivation of player utilities. The eigenvalue problem for a symmetric matrix $X ^ { \top } X = M \in$ $\mathbb { R } ^ { d \times d }$ is to find a matrix of $d$ orthonormal column vectors $V$ (implies $V$ is full-rank) such that $M V = V \Lambda$ with $\Lambda$ diagonal. Given a solution to this problem, the columns of $V$ are known as eigenvectors and corresponding entries in $\Lambda$ are eigenvalues. By left-multiplying by $V ^ { \top }$ and recalling $V ^ { \top } V = V V ^ { \top } = I$ by orthonormality (i.e., $V$ is unitary), we can rewrite the equality as
+
+$$
+V ^ { \top } M V = V ^ { \top } V \Lambda \stackrel { \mathrm { u n i t a r y } } { = } \Lambda .
+$$
+
+Let $\hat { V }$ denote a guess or estimate of the true eigenvectors $V$ and define $R ( { \hat { V } } ) { \stackrel { \mathrm { d e f } } { = } } { \hat { V } } ^ { \top } M { \hat { V } }$ . The PCA problem is often posed as maximizing the trace of $R$ (equiv. minimizing reconstruction error):
+
+$$
+\operatorname* { m a x } _ { \hat { V } ^ { \top } \hat { V } = I } \bigg \{ \qquad = \mathrm { T r } ( R ) = \mathrm { T r } ( \hat { V } ^ { \top } M \hat { V } ) = \mathrm { T r } ( \hat { V } \hat { V } ^ { \top } M ) \qquad \Big \} .
+$$
+
+Surprisingly, the objective in (2) is independent of $\hat { V }$ , so it cannot be used to recover all (i.e., $k = d$ ) the eigenvectors of $M$ —(i). Alternatively, Equation (1) implies the eigenvalue problem can be phrased as ensuring all off-diagonal terms of $R$ are zero, thereby ensuring $R$ is diagonal—(ii):
+
+$$
+\operatorname* { m i n } _ { \hat { V } ^ { \top } \hat { V } = I } \sum _ { i \neq j } R _ { i j } ^ { 2 } .
+$$
+
+It is worth further examining the entries of $R$ in detail. Diagonal entries $R _ { i i } = \langle \hat { v } _ { i } , M \hat { v } _ { i } \rangle$ are recognized as Rayleigh quotients because $| | \hat { v } _ { i } | | = 1$ by the constraints. Off-diagonal entries $R _ { i j } =$ $\langle \hat { v } _ { i } , M \hat { v } _ { j } \rangle$ measure alignment between $\hat { v } _ { i }$ and $\hat { v } _ { j }$ under a generalized inner product $\langle \cdot , \cdot \rangle _ { M }$ .
+
+![](images/5a2012c084c16f131e17053fea30fade5eefb797947af202891999acf57cfe59.jpg)  
+Figure 1: Each player $i$ ’s utility function depends on its parents represented here by a directed acyclic graph. Each parent must broadcast its vector, “location”, down the hierarchy in a fixed order.
+
+So far, we have considered learning all the eigenvectors. If we repeat the logic for the top- $k$ eigenvectors with $k \ < \ d$ , then by Equation (1), $R$ must still be diagonal. $V$ is not square, so $V \mathbf { } ^ { \top } \neq I$ , but assuming $V$ is orthonormal as before, we have $V V ^ { \top } = P$ is a projection matrix. Left-multiplying Equation (1) by $V$ now reads $( P M ) V = V \Lambda$ so we are solving an eigenvalue problem for a subspace of $M$ .
+
+If we only desire the top- $k$ eigenvectors, maximizing the trace encourages learning a subspace spanned by the top- $k$ eigenvectors, but does not recover the eigenvectors themselves. On the other hand, Equation (3) places no preference on recovering large over small eigenvectors, but does enforce the columns of $\hat { V }$ to actually be eigenvectors. The preceding exercise is intended to introduce minimizing the off-diagonal terms of $R$ as a possible complementary objective for solving top- $k$ PCA. Next, we will use these two objectives to construct utility functions for each eigenvector $\hat { v } _ { i }$ .
+
+We want to combine the objectives to take advantage of both their strengths. A valid proposal is
+
+$$
+\operatorname* { m a x } _ { \hat { V } ^ { \top } \hat { V } = I } \sum _ { i } R _ { i i } - \sum _ { i \neq j } R _ { i j } ^ { 2 } .
+$$
+
+However, this objective ignores the natural hierarchy of the top- $k$ eigenvectors. For example, $\hat { v } _ { 1 }$ is penalized for aligning with $\hat { v } _ { k }$ and vice versa, but $\hat { v } _ { 1 }$ , being the estimate of the largest eigenvector, should be free to search for the direction that captures the most variance independent of the locations of the other vectors. Instead, first consider solving for the top-1 eigenvector, $v _ { 1 }$ , in which case $R = [ \langle \hat { v } _ { 1 } , M \hat { v } _ { 1 } \rangle ]$ is a $1 \times 1$ matrix. In this setting, Equation (3) is not applicable because there are no off-diagonal elements, so $\mathrm { m a x } _ { \hat { v } _ { 1 } ^ { \top } \hat { v } _ { 1 } = 1 } \langle \hat { v } _ { 1 } , M \hat { v } _ { 1 } \rangle$ is a sensible utility function for $\hat { v } _ { 1 }$ .
+
+If considering the top-2 eigenvectors, $\hat { v } _ { 1 }$ ’s utility remains as before, and we introduce a new utility for $\hat { v } _ { 2 }$ . Equation (3) is now applicable, so $\hat { v } _ { 2 }$ ’s utility is
+
+$$
+\operatorname* { m a x } _ { \hat { v } _ { 2 } ^ { \top } \hat { v } _ { 2 } = 1 , \hat { v } _ { 1 } ^ { \top } \hat { v } _ { 2 } = 0 } \langle \hat { v } _ { 2 } , M \hat { v } _ { 2 } \rangle - \frac { \langle \hat { v } _ { 2 } , M \hat { v } _ { 1 } \rangle ^ { 2 } } { \langle \hat { v } _ { 1 } , M \hat { v } _ { 1 } \rangle }
+$$
+
+where we have divided the off-diagonal penalty by $\langle v _ { 1 } , M v _ { 1 } \rangle$ so a) the two terms in Equation (5) are on a similar scale and b) for reasons that ease analysis. Additionally note that the constraint $\hat { v } _ { 1 } ^ { \top } \hat { v } _ { 2 } = 0$ may be redundant at the optimum $\hat { v } _ { 1 } ^ { * } = v _ { 1 } , \hat { v } _ { 2 } ^ { * } = v _ { 2 } ,$ ) because the second term, $\langle \hat { v } _ { 2 } ^ { * } , M \hat { v } _ { 1 } ^ { * } \rangle ^ { 2 } =$ $\langle v _ { 2 } , M v _ { 1 } \rangle ^ { 2 } = \Lambda _ { 1 1 } ^ { 2 } \langle v _ { 2 } , v _ { 1 } \rangle ^ { 2 }$ , already penalizes such deviations $\Lambda _ { i i }$ is the $i$ th largest eigenvector). These reasons motivate the following set of objectives (utilities), one for each vector $i \in \{ 1 , \ldots , k \}$ :
+
+$$
+\operatorname* { m a x } _ { \hat { v } _ { i } ^ { \top } \hat { v } _ { i } = 1 } \left\{ u _ { i } ( \hat { v } _ { i } | \hat { v } _ { j < i } ) = \hat { v } _ { i } ^ { \top } M \hat { v } _ { i } - \sum _ { j < i } \frac { ( \hat { v } _ { i } ^ { \top } M \hat { v } _ { j } ) ^ { 2 } } { \hat { v } _ { j } ^ { \top } M \hat { v } _ { j } } = | | X \hat { v } _ { i } | | ^ { 2 } - \sum _ { j < i } \frac { \langle X \hat { v } _ { i } , X \hat { v } _ { j } \rangle ^ { 2 } } { \langle X \hat { v } _ { j } , X \hat { v } _ { j } \rangle } \right\}
+$$
+
+where the notation $u _ { i } ( a _ { i } | b )$ emphasizes that player $i$ adjusts $a _ { i }$ to maximize a utility conditioned on $b$
+
+It is interesting to note that by incorporating knowledge of the natural hierarchy (see Figure 1), we are immediately led to constructing asymmetric utilities, and thereby, inspired to formulate the PCA problem as a game, rather than a direct optimization problem as in Equation (4).
+
+A key concept in games is a Nash equilibrium. A Nash equilibrium specifies a variable for each player from which no player can unilaterally deviate and improve their outcome. In this case, $\hat { V }$ is a (strict-)Nash equilibrium if and only if for all $i$ , $u _ { i } ( \hat { v } _ { i } | \hat { v } _ { j < i } ) > u _ { i } ( z _ { i } | \hat { v } _ { j < i } )$ for all $z _ { i } \in \mathcal { S } ^ { d - 1 }$ .
+
+Theorem 2.1 (PCA Solution is the Unique strict-Nash Equilibrium). Assume that the top- $k$ eigenvalues of $X ^ { \top } X$ are positive and distinct. Then the top- $k$ eigenvectors form the unique strictNash equilibrium of the proposed game in Equation (6).3 The proof is deferred to Appendix L.
+
+Solving for the Nash of a game is difficult in general. Specifically, it belongs to the class of PPADcomplete problems (Gilboa and Zemel, 1989; Daskalakis et al., 2009). However, because the game
+
+is hierarchical and each player’s utility only depends on its parents, it is possible to construct a sequential algorithm that is convergent by solving each player’s optimization problem in sequence.
+
+# 3 METHOD
+
+Utility gradient. In Section 2, we mentioned that normalizing the penalty term from Equation (5) had a motivation beyond scaling. Dividing by $\langle \hat { v } _ { j } , M \hat { v } _ { j } \rangle$ results in the following gradient for player $i$ :
+
+$$
+\nabla _ { \hat { v } _ { i } } u _ { i } \big ( \hat { v } _ { i } | \hat { v } _ { j < i } \big ) = 2 M \Big [ \hat { v } _ { i } - \sum _ { j < i } \frac { \hat { v } _ { i } ^ { \top } M \hat { v } _ { j } } { \hat { v } _ { j } ^ { \top } M \hat { v } _ { j } } \hat { v } _ { j } \Big ] = 2 X ^ { \top } \Big [ X \hat { v } _ { i } - \sum _ { j < i } \frac { \langle X \hat { v } _ { i } , X \hat { v } _ { j } \rangle } { \langle X \hat { v } _ { j } , X \hat { v } _ { j } \rangle } X \hat { v } _ { j } \Big ] .
+$$
+
+The resulting gradient with normalized penalty term has an intuitive meaning. It consists of a single generalized Gram-Schmidt step followed by the standard matrix product found in power iteration and Oja’s rule. Also, notice that applying the gradient as a fixed point operator in sequence $\hat { v } _ { i } \gets$ $\begin{array} { r } { \frac { 1 } { 2 } \nabla _ { \hat { v } _ { i } } \bar { u } _ { i } \big ( \hat { v } _ { i } | \hat { v } _ { j < i } \big ) \big ) } \end{array}$ on $M = I$ recovers the standard Gram-Schmidt procedure for orthogonalization.
+
+A sequential algorithm. Each eigenvector can be learned by maximizing its utility. The vectors are constrained to the unit sphere, a non-convex Riemannian manifold, so we use Riemmanian gradient ascent with gradients given by Equation (7). In this case, Riemannian optimization theory simply requires an intermediate step where the gradient, $\nabla _ { \hat { v } _ { i } }$ , is projected onto the tangent space of the sphere to compute the Riemannian gradient, $\nabla _ { \hat { v } _ { i } } ^ { \tilde { R } }$ . A more detailed illustration can be found in Appendix J. Recall that each $u _ { i }$ depends on $\hat { v } _ { j < i }$ . If any of $\hat { v } _ { j < i }$ are being learned concurrently, then $\hat { v } _ { i }$ is maximizing a non-stationary objective which makes a convergence proof difficult. Instead, for completeness, we prove convergence assuming each $\hat { v } _ { i }$ is learned in sequence. Algorithm 1 learns $\hat { v } _ { i }$ given fixed parents $\hat { v } _ { j < i }$ ; we present the convergence guarantee in Section 4 and details on setting $\rho _ { i }$ and $\alpha$ in Appendix O.
+
+![](images/39c8426c3f737061f92367d5bc997c4b7a2e0ec6f926bd67ed13d247f37932a5.jpg)  
+Figure 2: EigenGame guides each $\hat { v } _ { i }$ along the unit-sphere from $\uparrow$ to in parallel; $M = \bar { \mathrm { d i } } \mathsf { a g } ( [ 3 , 2 , 1 ] )$ .
+
+<table><tr><td>Algorithm1 EigenGameR-Sequential</td><td>Algorithm 2 EigenGameR (EigenGame-update Given: matrix X ∈ Rnxd maximum err with Voi instead of V)</td></tr><tr><td>tolerance ρi, initial vector  ∈ Sd-1, learned approximate parents Uj&lt;i, and step size α.</td><td>Given: stream, Xt ∈ Rmxd, total iterations T, initial vector O ∈ Sd-1, and step size α.</td></tr><tr><td>v← ti =「 min(|/Vouil/2, pi)-²]</td><td>← fort=1: Tdo</td></tr><tr><td>fort=1:tdo</td><td>rewards ←Xti {XtO，Xtj）</td></tr><tr><td>rewards ←Xi penalties←∑j&lt;iXo,xo) (Xui,X0j） Xuj</td><td>penalties←∑j&lt;iXtoxXt XtUj</td></tr><tr><td>Vo ← 2XT[rewards -penalties]</td><td>Vo←2XT rewards-penalties</td></tr><tr><td>B←Vo-{Vo,Ui）Ui 0←0+aV</td><td>V←Vo-{VoUi）i 0←0+aV</td></tr></table>
+
+A decentralized algorithm. While Algorithm 1 enjoys a convergence guarantee, learning every parent $\hat { v } _ { j < i }$ before learning $\hat { v } _ { i }$ may be unnecessarily restrictive. Intuitively, as parents approach their respective optima, they become quasi-stationary, so we do not expect maximizing utilities in parallel to be problematic in practice. To this end, we propose Algorithm 2 visualized in Figure 2.
+
+![](images/b113e234d2341807b50a55bc76b6f8c8dcef8cf9a74140dfb4443aff798aa468.jpg)  
+Figure 3: (a) The longest streak of consecutive vectors with angular error less than $\frac { \pi } { 8 }$ radians is plotted versus algorithm iterations for a matrix $M \in \mathbb { R } ^ { 5 0 \times 5 0 }$ with a spectrum decaying from 1000 to 1 linearly and exponentially. Average runtimes are reported in milliseconds next to the method names5. We omit Krasulina’s as it is only designed to find the top- $k$ subspace. Both EigenGame variants and GHA achieve similar asymptotes on the linear spectrum. (b) Longest streak and subspace distance on MNIST with average runtimes reported in seconds. (a,b) Learning rates were chosen from $\{ 1 0 ^ { - 3 } , \dotsc , 1 0 ^ { - 6 } \}$ on 10 held out runs. Solid lines denote results with the best performing learning rate. Dotted and dashed lines denote results using the best learning rate $\times 1 0$ and 0.1. All plots show means over 10 trials. Shading highlights $\pm$ standard error of the mean for the best learning rates.
+
+In practice we can assign each eigenvector update to its own device (e.g. a GPU or TPU). Systems with fast interconnects may facilitate tens, hundreds or thousands of accelerators to be used. In such settings, the overhead of broadcast $( \hat { v } _ { i } )$ is minimal. We can also specify that the data stream is co-located with the update so $\hat { v } _ { i }$ updates with respect to its own $X _ { i , t }$ . This is a standard paradigm for e.g. data-parallel distributed neural network training. We provide further details in Section 6.
+
+Message Passing on a DAG. Our proposed utilities enforce a strict hierarchy on the eigenvectors. This is a simplification that both eases analysis (see Appendix M) and improves convergence4, however, it is not optimal. We assume vectors are initialized randomly on the sphere and, for instance, $\hat { v } _ { k }$ may be initialized closer to $v _ { 1 }$ than even $\hat { v } _ { 1 }$ and vice versa. The hierarchy shown in Figure 1 enforces a strict graph structure for broadcasting information of parents to the childrens’ utilities.
+
+To our knowledge, our utility formulation in Equation (6) is novel. One disadvantage is that stochastic gradients of Equation (7) are biased. This is mitigated with large batch sizes (further discussion in Appendix I).
+
+# 4 CONVERGENCE OF EIGENGAME
+
+Here, we first show that Equation (6) has a simple form such that any local maximum of $u _ { i }$ is also a global maximum. Player $i$ ’s utility depends on its parents, so we next explain how error in the parents propagates to children through mis-specification of player $i$ ’s utility. Using the first result and accounting for this error, we are then able to give global, finite-sample convergence guarantees in the full-batch setting by leveraging recent non-convex Riemannian optimization theory.
+
+The utility landscape and parent-to-child error propagation. Equation (6) is abstruse, but we prove that the shape of player $i$ ’s utility is simply sinusoidal in the angular deviation of $\hat { v } _ { i }$ from the optimum. The amplitude of the sinusoid varies with the direction of the angular deviation along the unit-sphere and is dependent on the accuracy of players $j < i$ . In the special case where players $j < i$ have learned the top- $( i - 1 )$ eigenvectors exactly, player $i$ ’s utility simplifies (see Lemma N.1) to
+
+$$
+u _ { i } \big ( \hat { v } _ { i } , \big \{ v _ { j < i } \big \} \big ) = \Lambda _ { i i } - \sin ^ { 2 } ( \theta _ { i } ) \Big ( \Lambda _ { i i } - \sum _ { l > i } z _ { l } \Lambda _ { l l } \Big )
+$$
+
+where $\theta _ { i }$ is the angular deviation and $z \in \Delta ^ { d - 1 }$ parameterizes the deviation direction. Note that $\sin ^ { 2 }$ has period $\pi$ instead of $2 \pi$ , which simply reflects the fact that $v _ { i }$ and $- v _ { i }$ are both eigenvectors.
+
+An error propagation analysis reveals that it is critical to learn the parents to a given degree of accuracy. The angular distance between $v _ { i }$ and the maximizer of player $i$ ’s utility with approximate parents has $\tan ^ { - 1 }$ dependence (i.e., a soft step-function; see Lemma N.5 and Figure 13 in Appendix N).
+
+Theorem 4.1 (Global convergence). Algorithm 1 achieves finite sample convergence to within $\theta _ { t o l }$ angular error of the top- $k$ principal components, independent of initialization. Furthermore, if each $\hat { v } _ { i }$ is initialized to within $\frac { \pi } { 4 }$ of $v _ { i }$ , Algorithm $^ { l }$ returns the components with angular error less than $\theta _ { t o l }$ in $\begin{array} { r } { T = \left\lceil \mathcal { O } \Big ( k \Big [ \frac { ( k - 1 ) ! } { \theta _ { t o l } } \prod _ { i = 1 } ^ { k } \big ( \frac { 1 6 \Lambda _ { 1 1 } } { g _ { i } } \big ) \Big ] ^ { 2 } \Big ) \right\rceil } \end{array}$ iterations. Proofs are deferred to Appendices O.4 and O.5.
+
+Angular error is defined as the angle between $\hat { v } _ { i }$ and $v _ { i }$ : $\theta _ { i } = \mathrm { s i n } ^ { - 1 } ( \sqrt { 1 - \langle v _ { i } , \hat { v } _ { i } \rangle ^ { 2 } } )$ . The first $k$ in the formula for $T$ appears from a naive summing of worst case bounds on the number of iterations required to learn each $\hat { v } _ { j < k }$ individually. The constant 16 arises from the error propagation analysis; parent vectors, $\hat { v } _ { j < i }$ , must be learned to under 1/16th of a canonical error threshold, $\frac { g _ { i } } { ( i - 1 ) \Lambda _ { 1 1 } }$ , for the child $\hat { v } _ { i }$ where $g _ { i } = \Lambda _ { i i } - \Lambda _ { i + 1 , i + 1 }$ . The Riemannian optimization theory we leverage dictates that $\textstyle { \frac { 1 } { \rho ^ { 2 } } }$ iterations are required to meet a $\mathcal { O } ( \rho )$ error threshold. This is why the squared inverse of the error threshold appears here. Breaking down the error threshold itself, the ratio $\Lambda _ { 1 1 } / g _ { i }$ says that more iterations are required to distinguish eigenvectors when the difference between them (summarized by the gap $g _ { i }$ ) is small relative to the scale of the spectrum, $\Lambda _ { 1 1 }$ . The $( k - 1 ) !$ ! term appears because learning smaller eigenvectors requires learning a much more accurate $\hat { v } _ { 1 }$ higher up the DAG.
+
+Lastly, the utility function for each $\hat { v } _ { i }$ is sinusoidal, and it is possible that we initialize $\hat { v } _ { i }$ with initial utility arbitrarily close to the trough (bottom) of the function where gradients are arbitrarily small. This is why the global convergence rate depends on the initialization in general. Note that Algorithm 1 effectively detects the trough by measuring the norm of the initial gradient $( \nabla _ { \widehat { v } _ { i } ^ { 0 } } u _ { i } )$ and scales the number of required iterations appropriately. A complete theorem that considers the probability of initializing $\hat { v } _ { i }$ within $\frac { \pi } { 4 }$ of $v _ { i }$ is in Appendix O, but this possibility shrinks to zero in high dimensions.
+
+We would also like to highlight that these theoretical findings are strong relative to some other claims. For example, the exponential convergence guarantee for Matrix Krasulina requires the initial guess at the eigenvectors capture the top- $\left( k - 1 \right)$ subspace (Tang, 2019), unlikely when $d \gg k$ . A similar condition is required in (Shamir, 2016b). These guarantees are given for the mini-batch setting while ours is for the full-batch, however, we provide global convergence without restrictions on initialization.
+
+# 5 RELATED WORK
+
+PCA is a century-old problem and a massive literature exists (Jolliffe, 2002; Golub and Van Loan, 2012). The standard solution to this problem is to compute the SVD, possibly combined with randomized algorithms, to recover the top- $k$ components as in (Halko et al., 2011) or with Frequent Directions (Ghashami et al., 2016) which combines sketching with SVD.
+
+In neuroscience, Hebb’s rule (Hebb, 2005) refers to a connectionist rule that solves for the top eigenvector of a matrix $M$ using additive updates of a vector $v$ as $v  v + \eta M v$ . Likewise, Oja’s rule (Oja, 1982; Shamir, 2015) refers to a similar update $v  v + \eta ( I - v v ^ { \top } ) M v$ . In machine learning, using a normalization step of $v  v / | | v | |$ with Hebb’s rule is somewhat confusingly referred to as Oja’s algorithm (Shamir, 2015), the reason being that the subtractive term in Oja’s rule can be viewed as a regularization term for implicitly enforcing the normalization. In the limit of infinite step size, $\eta  \infty$ , Oja’s algorithm effectively becomes the well known Power method. If a normalization step is added to Oja’s rule, this is referred to as Krasulina’s algorithm (Krasulina, 1969). In the language of Riemannian manifolds, $v / | | v | |$ can be recognized as a retraction and $( I - v v ^ { \top } )$ as projecting the gradient $M v$ onto the tangent space of the sphere (Absil et al., 2009).
+
+Many of the methods above have been generalized to the top- $k$ components. Most generalizations involve adding an orthonormalization step after each update, typically accomplished with a QR factorization plus some minor sign accounting (e.g., see Algorithm 3 in Appendix A.1). An extension of Krasulina’s algorithm to the top- $k$ setting, termed Matrix Krasulina (Tang, 2019), was recently proposed in the machine learning literature. This algorithm can be recognized as projecting the gradient onto the Stiefel manifold (the space of orthonormal matrices) followed by a QR step to maintain orthonormality, which is a well known retraction.
+
+Maintaining orthonormality via QR is computationally expensive. Amid and Warmuth (2019) propose an alternative Krasulina method which does not require re-orthonormalization but instead requires inverting a $k \times k$ matrix; in a streaming setting restricted to minibatches of size 1 $( X _ { t } \in \mathbb { R } ^ { d }$ ), Sherman-Morrison (Golub and Van Loan, 2012) can be used to efficiently replace the inversion step. Raja and Bajwa (2020) develop a data-parallel distributed algorithm for the top eigenvector. Alternatively, the Jacobi eigenvalue algorithm explicitly represents the matrix of eigenvectors as a Givens rotation matrix using sin’s and cos’s and rotates $M$ until it is diagonal (Golub and Van der Vorst, 2000).
+
+In contrast, other methods extract the top components in sequence by solving for the ith component using an algorithm such as power iteration or Oja’s, and then enforcing orthogonality by removing the learned subspace from the matrix, a process known as deflation. Alternatively, the deflation process may be intertwined with the learning of the top components. The generalized Hebbian algorithm (Sanger, 1989) (GHA) works this way as do Lagrangian inspired formulations (Ghojogh et al., 2019) as well as our own approach. We make the connection between GHA and our algorithm concrete in Prop. K.1. Note, however, that the GHA update is not the gradient of any utility (Prop. K.2) and therefore, lacks a clear game interpretation.
+
+Of these, Oja’s algorithm has arguably been the most extensively studied (Shamir, 2016a; Allen-Zhu and Li, $2 0 1 \bar { 7 } ) ^ { 6 }$ Note that Oja’s algorithm converges to the actual principal components (Allen-Zhu and Li, 2017) and Matrix Krasulina (Tang, 2019) converges to the top- $k$ subspace. However, neither can be obviously decentralized. GHA (Sanger, 1989) converges to the principal components asymptotically and can be decentralized (Gang et al., 2019). Each of these is applicable in the streaming $k$ -PCA setting.
+
+# 6 EXPERIMENTS
+
+We compare our approach against GHA, Matrix Krasulina, and Oja’s algorithm7. We present both EigenGame and EigenGameR which projects the gradient onto the tangent space of the sphere each step. We measure performance of methods in terms of principal component accuracy and subspace distance. We measure principal component accuracy by the number of consecutive components, or longest streak, that are estimated within an angle of $\frac { \pi } { 8 }$ from ground truth. For example, if the angular errors of the $\hat { v } _ { i }$ ’s returned by a method are, in order, $\begin{array} { r } { [ \theta _ { 1 } , \bar { \theta } _ { 2 } , \theta _ { 3 } , . . . ] = [ \frac { \pi } { 1 6 } , \frac { \pi } { 4 } , \frac { \pi } { 1 0 } , . . . ] , } \end{array}$ [ π16 , π4 , π10 , . . . ] , th en the method is credited with a streak of only 1 regardless of the errors $\theta _ { i > 2 }$ . For Matrix Krasulina, we first compute the optimal matching from $\hat { v } _ { i }$ to ground truth before measuring angular error. We present the longest streak as opposed to $^ { 6 6 } \#$ of eigenvectors found” because, in practice, no ground truth is available and we think the user should be able to place higher confidence in the larger eigenvectors being correct. If an algorithm returns $k$ vectors, $\frac { k } { 2 }$ of which are accurate components but does not indicate which, this is less helpful. We measure normalized subspace distance using $\textstyle 1 - { \frac { 1 } { k } } \cdot \operatorname { T r } ( U ^ { * } P ) \in [ 0 , 1 ]$ where $U ^ { * } = V V ^ { \dagger }$ and $P = \hat { V } \hat { V } ^ { \dag }$ similarly to Tang (2019).
+
+Synthetic data. Experiments on synthetic data demonstrate the viability of our approach (Figure 3a). Oja’s algorithm performs best on synthetic experiments because strictly enforcing orthogonalization with an expensive QR step greatly helps when solving for all eigenvectors. EigenGame is able to effectively parallelize this over $k$ machines and the advantage of QR diminishes in Figure 3b. The remaining algorithms perform similarly on a linearly decaying spectrum, however, EigenGame performs better on an exponentially decaying spectrum due possibly to instability of Riemannian gradients near the equilibrium (see Appendix J for further discussion). GHA and EigenGameR are equivalent under specific conditions (see Proposition K.1).
+
+Figure 4a shows EigenGame solves for the eigenvectors up to a high degree of accuracy $\frac { \pi } { 3 2 }$ , i.e. the convergence results in Figure 3a are not the result of using a loose tolerance of $\frac { \pi } { 8 }$ . With the lower tolerance, all algorithms take slightly more iterations to learn the eigenvectors of the linear spectrum; it is difficult to see any performance change for the exponential spectrum. Although Theorem 4.1 assumes distinct eigenvalues, Figure 4b supports the claim that EigenGame does not require distinct eigenvalues for convergence. We leave proving convergence in this setting to future work.
+
+![](images/6669788ae7fec1a85e64041d26b0412233317a21e23fcff30771f113df148876.jpg)  
+Figure 4: (a) Repeats analysis of Figure 3a but for a lower angular tolerance of $\frac { \pi } { 3 2 }$ . (b) Repeats analysis of Figure 3a with an angular tolerance of $\frac { \pi } { 8 }$ as before, but with eigenvalues $\mathrm { \bar { 1 0 } - 1 9 }$ of the ordered spectrum overwritten with $\lambda _ { 1 0 }$ of the original spectrum. We compute angular error for the eigenvectors on either side of this “bubble" to show that EigenGame finds these eigenvectors despite repeated eigenvalues in the spectrum; note $4 0 / 5 0$ is optimal in this experiment.
+
+![](images/fb90b017833142d5eb56cb041919940760489f3a8b2cea66b0a552456fc4c292.jpg)  
+Figure 5: (a) Top-8 principal components of the activations of a RESNET-200 on IMAGENET ordered block-wise by network topology (dimension of each block on the right $y$ -axis). Block 1 is closest to input and Block 5 is the output of the network. Color coding is based on relative variance between blocks across the top-8 PCs from blue (low) to red (high). (b) Block 1 mean activation maps of the top-32 principal components of RESNET-200 on IMAGENET computed with EigenGame.
+
+MNIST handwritten digits. We compare EigenGame against GHA, Matrix Krasulina, and Oja’s algorithm on the MNIST dataset (Figure 3b). We flatten each image in the training set to obtain a $6 0 , 0 0 0 \times 7 8 4$ dimensional matrix. EigenGame is competitive with Oja’s in a high batch size regime (1024 samples per mini-batch). The performance gap between EigenGame and the other methods shrinks as the mini-batch size is reduced (see Appendix I), expectedly due to biased gradients.
+
+The principal components of RESNET-200 activations on IMAGENET are edge filters. A primary goal of PCA is to obtain interpretable low-dimensional representations. To this end we present an example of using EigenGame to compute the top-32 principal components of the activations of a pretrained RESNET-200 on the IMAGENET dataset. We concatenate the flattened activations from the output of each residual block resulting in a $d \approx 2 0 \mathbf { M }$ dimensional vector representation for each of the roughly 1.2M input images. It is not possible to store the entire 195TB matrix in memory, nor incrementally compute the Gram/covariance matrix.
+
+We implemented a data-and-model parallel version of EigenGame in JAX (Bradbury et al., 2018) where each $\hat { v } _ { i }$ is assigned to it’s own TPU (Jouppi et al., 2017). Each device keeps a local copy of the RESNET parameters and the IMAGENET datastream. Sampling a mini-batch (of size 128), computing the network activations and updating $\hat { v } _ { i }$ are all performed locally. The broadcast $( \hat { v } _ { i } )$ ) step is handled by the pmap and lax.all_gather functions. Computing the top-32 principal components takes approximately nine hours on 32 TPUv3s.
+
+Figure 5a shows the top principal components of the activations of the trained network organized by network topology (consisting of five residual blocks). Note that EigenGame is not applied block-wise, but on all 20M dimensions. We do not assume independence between blocks and the eigenvector has unit norm across all blocks. We observe that Block 1 (closest to input) of PC 1 has very small magnitude activations relative to the other PCs. This is because PC 1 should capture the variance which discriminates most between the classes in the dataset. Since Block 1 is mainly concerned with learning low-level image filters, it stands to reason that although these are important for good performance, they do not necessarily extract abstract representations which are useful for classification. Conversely, we see that PC 1 has larger relative activations in the later blocks.
+
+We visualize the average principal activation in Block $1 ^ { 8 }$ in Figure 5b. The higher PCs learn distinct filters (Gabor filters, Laplacian-of-Gaussian filters c.f. (Bell and Sejnowski, 1997)).
+
+# 7 CONCLUSION
+
+It seems easier to train a bi-directional LSTM with attention than to compute the SVD of a large matrix. –Chris Re
+
+NeurIPS 2017 Test-of-Time Award, Rahimi and Recht (Rahimi and Recht, 2017).
+
+In this work we motivated PCA from the perspective of a multi-player game. This inspired a decentralized algorithm which enables large-scale principal components estimation. To demonstrate this we used EigenGame to analyze a large neural network through the lens of PCA. To our knowledge this is the first academic analysis of its type and scale (for reference, (Tang, 2019) compute the top-6 PCs of the $d = 2 3 0 0$ outputs of VGG). EigenGame also opens a variety of research directions.
+
+Scale. In experiments, we broadcast across all edges in Figure 1 every iteration. Introducing lag or broadcasting with dropout may improve efficiency. Can we further reduce our memory footprint by storing only scalars of the losses and avoiding congestion through online bandit or reinforcement learning techniques? Our decentralized algorithm may have implications for federated and privacy preserving learning as well (Heinze et al., 2016; Heinze-Deml et al., 2018; Bonawitz et al., 2019).
+
+Games. EigenGame has a unique Nash equilibrium due to the fixed DAG structure, but vectors are initialized randomly so $\hat { v } _ { k }$ may start closer to $v _ { 1 }$ than $\hat { v } _ { 1 }$ does. Adapting the DAG could make sense, but might also introduce spurious fixed points or suboptimal Nash. Might replacing vectors with populations accelerate extraction of the top principal components?
+
+Core ML. EigenGame could be useful as a diagnostic or for accelerating training (Desjardins et al., 2015; Krummenacher et al., 2016); similarly, spectral normalization has shown to be a valuable tool for stabilizing GAN training (Miyato et al., 2018).
+
+Lastly, GANs (Goodfellow et al., 2014) recently reformulated learning a generative model as a two-player zero-sum game. Here, we show how another fundamental unsupervised learning task can be formulated as a $k$ -player game. While two-player, zero-sum games are well understood, research on $k$ -player, general-sum games lies at the forefront in machine learning. We hope that marrying a fundamental, well-understood task in PCA with the relatively less understood domain of many player games will help advance techniques on both ends.
+
+# ACKNOWLEDGEMENTS
+
+We are grateful to Trevor Cai for his help scaling the JAX implementation of EigenGame to handle the large IMAGENET experiment and to Daniele Calandriello for sharing his expert knowledge of related work and advice on revising parts of the manuscript.
+
+# REFERENCES
+
+P-A. Absil, Robert Mahony, and Rodolphe Sepulchre. Optimization Algorithms on Matrix Manifolds. Princeton University Press, 2009.
+
+Zeyuan Allen-Zhu and Yuanzhi Li. First efficient convergence for streaming k-PCA: a global, gap-free, and near-optimal rate. In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), pages 487–492. IEEE, 2017.
+
+Ehsan Amid and Manfred K Warmuth. An implicit form of Krasulina’s k-PCA update without the orthonormality constraint. arXiv preprint arXiv:1909.04803, 2019.
+
+Anthony J Bell and Terrence J Sejnowski. The “independent components” of natural scenes are edge filters. Vision Research, 37(23):3327–3338, 1997.
+
+Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloe Kiddon, Jakub Konecny, Stefano Mazzocchi, H Brendan McMahan, et al. Towards federated learning at scale: system design. arXiv preprint arXiv:1902.01046, 2019.
+
+Nicolas Boumal, Pierre-Antoine Absil, and Coralia Cartis. Global rates of convergence for nonconvex optimization on manifolds. IMA Journal of Numerical Analysis, 39(1):1–33, 2019.
+
+James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, and Skye Wanderman-Milne. JAX: composable transformations of Python+NumPy programs, 2018. URL http://github.com/google/jax.
+
+Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: interpretable representation learning by information maximizing generative adversarial nets. In Advances in Neural Information Processing Systems, pages 2172–2180, 2016.
+
+Michael B Cohen, Cameron Musco, and Christopher Musco. Input sparsity time low-rank approximation via ridge leverage score sampling. In Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1758–1777. SIAM, 2017.
+
+Constantinos Daskalakis, Paul W Goldberg, and Christos H Papadimitriou. The complexity of computing a Nash equilibrium. SIAM Journal on Computing, 39(1):195–259, 2009.
+
+Guillaume Desjardins, Karen Simonyan, Razvan Pascanu, et al. Natural neural networks. In Advances in Neural Information Processing Systems, pages 2071–2079, 2015.
+
+Dan Feldman, Melanie Schmidt, and Christian Sohler. Turning big data into tiny data: Constant-size coresets for k-means, PCA, and projective clustering. SIAM Journal on Computing, 49(3):601–657, 2020.
+
+Arpita Gang, Haroon Raja, and Waheed U Bajwa. Fast and communication-efficient distributed pca. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 7450–7454. IEEE, 2019.
+
+Mina Ghashami, Edo Liberty, Jeff M Phillips, and David P Woodruff. Frequent directions: simple and deterministic matrix sketching. SIAM Journal on Computing, 45(5):1762–1792, 2016.
+
+Benyamin Ghojogh, Fakhri Karray, and Mark Crowley. Eigenvalue and generalized eigenvalue problems: Tutorial. arXiv preprint arXiv:1903.11240, 2019.
+
+Itzhak Gilboa and Eitan Zemel. Nash and correlated equilibria: some complexity considerations. Games and Economic Behavior, 1(1):80–93, 1989.
+
+Gene H Golub and Henk A Van der Vorst. Eigenvalue computation in the 20th century. Journal of Computational and Applied Mathematics, 123(1-2):35–65, 2000.
+
+Gene H Golub and Charles F Van Loan. Matrix Computations, volume 3. JHU press, 2012.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, pages 2672–2680, 2014.
+
+Nathan Halko, Per-Gunnar Martinsson, and Joel A Tropp. Finding structure with randomness: probabilistic algorithms for constructing approximate matrix decompositions. SIAM review, 53(2):217–288, 2011.
+
+Donald Olding Hebb. The Organization of Behavior: A Neuropsychological Theory. Psychology Press, 2005.
+
+Christina Heinze, Brian McWilliams, and Nicolai Meinshausen. Dual-loco: distributing statistical estimation using random projections. In Artificial Intelligence and Statistics, pages 875–883, 2016.
+
+Christina Heinze-Deml, Brian McWilliams, and Nicolai Meinshausen. Preserving privacy between features in distributed estimation. Stat, 7(1):e189, 2018.
+
+Roger A Horn and Charles R Johnson. Matrix Analysis. Cambridge University Press, 2012.
+
+Ian T Jolliffe. Principal components in regression analysis. In Principal Component Analysis. Springer, 2002.
+
+Norman P Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, et al. In-datacenter performance analysis of a tensor processing unit. In Proceedings of the 44th Annual International Symposium on Computer Architecture, pages 1–12, 2017.
+
+TP Krasulina. The method of stochastic approximation for the determination of the least eigenvalue of a symmetrical matrix. USSR Computational Mathematics and Mathematical Physics, 9(6):189–195, 1969.
+
+Gabriel Krummenacher, Brian McWilliams, Yannic Kilcher, Joachim M Buhmann, and Nicolai Meinshausen. Scalable adaptive stochastic optimization using random projections. In Advances in Neural Information Processing Systems, pages 1750–1758, 2016.
+
+Shengqiao Li. Concise formulas for the area and volume of a hyperspherical cap. Asian Journal of Mathematics and Statistics, 4(1):66–70, 2011.
+
+Francesco Locatello, Stefan Bauer, Mario Lucic, Gunnar Raetsch, Sylvain Gelly, Bernhard Schölkopf, and Olivier Bachem. Challenging common assumptions in the unsupervised learning of disentangled representations. In Proceedings of the International Conference on Machine Learning, pages 4114–4124, 2019.
+
+Emile Mathieu, Tom Rainforth, N Siddharth, and Yee Whye Teh. Disentangling disentanglement in variational autoencoders. arXiv preprint arXiv:1812.02833, 2018.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. arXiv preprint arXiv:1802.05957, 2018.
+
+Erkki Oja. Simplified neuron model as a principal component analyzer. Journal of Mathematical Biology, 15(3): 267–273, 1982.
+
+Ali Rahimi and Benjamin Recht. Reflections on random kitchen sinks, 2017. URL http://www.argmin. net/2017/12/05/kitchen-sinks/.
+
+Haroon Raja and Waheed U Bajwa. Distributed stochastic algorithms for high-rate streaming principal component analysis. arXiv preprint arXiv:2001.01017, 2020.
+
+H Rutishauser. Simultaneous iteration method for symmetric matrices. In Handbook for Automatic Computation, pages 284–302. Springer, 1971.
+
+Terence D Sanger. Optimal unsupervised learning in a single-layer linear feedforward neural network. Neural Networks, 2(6):459–473, 1989.
+
+Mhd Hasan Sarhan, Abouzar Eslami, Nassir Navab, and Shadi Albarqouni. Learning interpretable disentangled representations using adversarial VAEs. In Domain Adaptation and Representation Transfer and Medical Image Learning with Less Labels and Imperfect Data, pages 37–44. Springer, 2019.
+
+Tamas Sarlos. Improved approximation algorithms for large matrices via random projections. In 2006 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS’06), pages 143–152. IEEE, 2006.
+
+Ohad Shamir. A stochastic PCA and SVD algorithm with an exponential convergence rate. In Proceedings of the International Conference on Machine Learning, pages 144–152, 2015.
+
+Ohad Shamir. Convergence of stochastic gradient descent for PCA. In Proceedings of the International Conference on Machine Learning, pages 257–265, 2016a.
+
+Ohad Shamir. Fast stochastic algorithms for SVD and PCA: Convergence properties and convexity. In Proceedings of the International Conference on Machine Learning, pages 248–256, 2016b.
+
+Cheng Tang. Exponentially convergent stochastic $\mathbf { k }$ -PCA without variance reduction. In Advances in Neural Information Processing Systems, pages 12393–12404, 2019.
+
+Aladin Virmaux and Kevin Scaman. Lipschitz regularity of deep neural networks: analysis and efficient estimation. In Advances in Neural Information Processing Systems, pages 3835–3844, 2018.

parse/train/NzTU59SYbNq/NzTU59SYbNq_content_list.json

@@ -0,0 +1,1526 @@
+[
+    {
+        "type": "text",
+        "text": "EIGENGAME: PCA AS A NASH EQUILIBRIUM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            720,
+            122
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ian Gemp, Brian McWilliams, Claire Vernade & Thore Graepel DeepMind {imgemp,bmcw,vernade,thore}@google.com ",
+        "bbox": [
+            183,
+            147,
+            632,
+            190
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            227,
+            544,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present a novel view on principal component analysis (PCA) as a competitive game in which each approximate eigenvector is controlled by a player whose goal is to maximize their own utility function. We analyze the properties of this PCA game and the behavior of its gradient based updates. The resulting algorithm—which combines elements from Oja’s rule with a generalized GramSchmidt orthogonalization—is naturally decentralized and hence parallelizable through message passing. We demonstrate the scalability of the algorithm with experiments on large image datasets and neural network activations. We discuss how this new view of PCA as a differentiable game can lead to further algorithmic developments and insights. ",
+        "bbox": [
+            233,
+            258,
+            764,
+            398
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            428,
+            336,
+            443
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The principal components of data are the vectors that align with the directions of maximum variance. These have two main purposes: a) as interpretable features and b) for data compression. Recent methods for principal component analysis (PCA) focus on the latter, explicitly stating objectives to find the $k$ -dimensional subspace that captures maximum variance (e.g., (Tang, 2019)), and leaving the problem of rotating within this subspace to, for example, a more efficient downstream singular value (SVD) decomposition step1. This point is subtle, yet critical. For example, any pair of twodimensional, orthogonal vectors spans all of $\\mathbb { R } ^ { 2 }$ and, therefore, captures maximum variance of any two-dimensional dataset. However, for these vectors to be principal components, they must, in addition, align with the directions of maximum variance which depends on the covariance of the data. By learning the optimal subspace, rather than the principal components themselves, objectives focused on subspace error ignore the first purpose of PCA. In contrast, modern nonlinear representation learning techniques focus on learning features that are both disentangled (uncorrelated) and low dimensional (Chen et al., 2016; Mathieu et al., 2018; Locatello et al., 2019; Sarhan et al., 2019). ",
+        "bbox": [
+            174,
+            460,
+            825,
+            640
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It is well known that the PCA solution of the $d$ -dimensional dataset $\\ b { X } \\in \\mathbb { R } ^ { n \\times d }$ is given by the eigenvectors of $X ^ { \\top } X$ or equivalently, the right singular vectors of $X$ . Impractically, the cost of computing the full SVD scales with $\\bar { \\mathcal { O } } ( \\operatorname* { m i n } \\{ n \\bar { d } ^ { 2 } , n ^ { 2 } \\bar { d } \\} )$ -time and $\\mathcal { O } ( n d )$ -space (Shamir, 2015; Tang, 2019). For moderately sized data, randomized methods can be used (Halko et al., 2011). Beyond this, stochastic—or online—methods based on Oja’s rule (Oja, 1982) or power iterations (Rutishauser, 1971) are common. Another option is to use streaming $k$ -PCA algorithms such as Frequent Directions (FD) (Ghashami et al., 2016) or Oja’s algorithm2 (Allen-Zhu and Li, 2017) with storage complexity $\\mathcal { O } ( k d )$ . Sampling or sketching methods also scale well, but again, focus on the top- $k$ subspace (Sarlos, 2006; Cohen et al., 2017; Feldman et al., 2020). ",
+        "bbox": [
+            174,
+            647,
+            825,
+            772
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In contrast to these approaches, we view each principal component (equivalently eigenvector) as a player in a game whose objective is to maximize their own local utility function in controlled competition with other vectors. The proposed utility gradients are interpretable as a combination of Oja’s rule and a generalized Gram-Schmidt process. We make the following contributions: ",
+        "bbox": [
+            176,
+            780,
+            825,
+            835
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• A novel formulation of PCA as finding the Nash equilibrium of a suitable game, • A sequential, globally convergent algorithm for approximating the Nash on full-batch data, • A decentralized algorithm with experiments demonstrating the approach as competitive with modern streaming $k$ -PCA algorithms on synthetic and real data, In demonstration of the scaling of the approach, we compute the top-32 principal components of the matrix of RESNET-200 activations on the IMAGENET dataset $\\cdot n \\approx 1 0 ^ { \\hat { 6 } }$ , $d \\approx \\dot { 2 0 } \\cdot 1 0 ^ { 6 }$ ). ",
+        "bbox": [
+            205,
+            848,
+            826,
+            883
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            212,
+            103,
+            825,
+            165
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Each of these contributions is important. Novel formulations often lead to deeper understanding of problems, thereby, opening doors to improved techniques. In particular, $k$ -player games are in general complex and hard to analyze. In contrast, PCA has been well-studied. By combining the two fields we hope to develop useful analytical tools. Our specific formulation is important because it obviates the need for any centralized orthonormalization step and lends itself naturally to decentralization. And lastly, theory and experiments support the viability of this approach for continued research. ",
+        "bbox": [
+            174,
+            176,
+            826,
+            261
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PCA AS AN EIGEN-GAME ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            280,
+            421,
+            296
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We adhere to the following notation. Vectors and matrices meant to approximate principal components (equivalently eigenvectors) are designated with hats, $\\hat { v }$ and $\\hat { V }$ respectively, whereas true principal components are $v$ and $V$ . Subscripts indicate which eigenvalue a vector is associated with. For example, $v _ { i }$ is the ith largest eigenvector. In this work, we will assume each eigenvalue is distinct. By an abuse of notation, $v _ { j < i }$ refers to the set of vectors $\\{ v _ { j } | j \\in \\{ 1 , \\ldots , i - 1 \\} \\bar  \\}$ and are also referred to as the parents of $v _ { i }$ $\\mathbf { \\chi } _ { v _ { i } }$ is their child). Sums over indices should be clear from context, e.g., $\\textstyle \\sum _ { j < i } = \\sum _ { j = 1 } ^ { i - 1 }$ . The Euclidean inner product is written $\\langle u , v \\rangle = u ^ { \\top } v$ . We denote the unit sphere by $S ^ { d - 1 }$ and simplex by $\\Delta ^ { d - 1 }$ in $d$ -dimensional ambient space. ",
+        "bbox": [
+            173,
+            310,
+            826,
+            433
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Outline of derivation As argued in the introduction, the PCA problem is often mis-interpreted as learning a projection of the data into a subspace that captures maximum variance (equiv. maximizing the trace of a suitable matrix $R$ introduced below). This is in contrast to the original goal of learning the principal components. We first develop the intuition for deriving our utility functions by (i) showing that only maximizing the trace of $R$ is not sufficient for recovering all principal components (equiv. eigenvectors), and (ii) showing that minimizing off-diagonal terms in $R$ is a complementary objective to maximizing the trace and can recover all components. We then consider learning only the top- $k$ and construct utilities that are consistent with findings in (i) and (ii), equal the true eigenvalues at the Nash of the game we construct, and result in a game that is amenable to analysis. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            571
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Derivation of player utilities. The eigenvalue problem for a symmetric matrix $X ^ { \\top } X = M \\in$ $\\mathbb { R } ^ { d \\times d }$ is to find a matrix of $d$ orthonormal column vectors $V$ (implies $V$ is full-rank) such that $M V = V \\Lambda$ with $\\Lambda$ diagonal. Given a solution to this problem, the columns of $V$ are known as eigenvectors and corresponding entries in $\\Lambda$ are eigenvalues. By left-multiplying by $V ^ { \\top }$ and recalling $V ^ { \\top } V = V V ^ { \\top } = I$ by orthonormality (i.e., $V$ is unitary), we can rewrite the equality as ",
+        "bbox": [
+            173,
+            585,
+            825,
+            657
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/19aaa083889f9e6ea7f0d12f2d03a21603ea968f7e5242cc17f3f91c10afbe73.jpg",
+        "text": "$$\nV ^ { \\top } M V = V ^ { \\top } V \\Lambda \\stackrel { \\mathrm { u n i t a r y } } { = } \\Lambda .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            664,
+            593,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\hat { V }$ denote a guess or estimate of the true eigenvectors $V$ and define $R ( { \\hat { V } } ) { \\stackrel { \\mathrm { d e f } } { = } } { \\hat { V } } ^ { \\top } M { \\hat { V } }$ . The PCA problem is often posed as maximizing the trace of $R$ (equiv. minimizing reconstruction error): ",
+        "bbox": [
+            171,
+            703,
+            825,
+            734
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/976986917b4b5159b4c9ddb61e8acb73866593ebf67e557c76c86b7c2fc07808.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\hat { V } ^ { \\top } \\hat { V } = I } \\bigg \\{ \\qquad = \\mathrm { T r } ( R ) = \\mathrm { T r } ( \\hat { V } ^ { \\top } M \\hat { V } ) = \\mathrm { T r } ( \\hat { V } \\hat { V } ^ { \\top } M ) \\qquad \\Big \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            739,
+            735,
+            775
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Surprisingly, the objective in (2) is independent of $\\hat { V }$ , so it cannot be used to recover all (i.e., $k = d$ ) the eigenvectors of $M$ —(i). Alternatively, Equation (1) implies the eigenvalue problem can be phrased as ensuring all off-diagonal terms of $R$ are zero, thereby ensuring $R$ is diagonal—(ii): ",
+        "bbox": [
+            174,
+            782,
+            825,
+            827
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b57e7d3caad74ded837c1303fa952ac1a788566d739505bb77236e11c5e2b94.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\hat { V } ^ { \\top } \\hat { V } = I } \\sum _ { i \\neq j } R _ { i j } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            832,
+            553,
+            867
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It is worth further examining the entries of $R$ in detail. Diagonal entries $R _ { i i } = \\langle \\hat { v } _ { i } , M \\hat { v } _ { i } \\rangle$ are recognized as Rayleigh quotients because $| | \\hat { v } _ { i } | | = 1$ by the constraints. Off-diagonal entries $R _ { i j } =$ $\\langle \\hat { v } _ { i } , M \\hat { v } _ { j } \\rangle$ measure alignment between $\\hat { v } _ { i }$ and $\\hat { v } _ { j }$ under a generalized inner product $\\langle \\cdot , \\cdot \\rangle _ { M }$ . ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a2012c084c16f131e17053fea30fade5eefb797947af202891999acf57cfe59.jpg",
+        "image_caption": [
+            "Figure 1: Each player $i$ ’s utility function depends on its parents represented here by a directed acyclic graph. Each parent must broadcast its vector, “location”, down the hierarchy in a fixed order. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            393,
+            102,
+            601,
+            150
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "So far, we have considered learning all the eigenvectors. If we repeat the logic for the top- $k$ eigenvectors with $k \\ < \\ d$ , then by Equation (1), $R$ must still be diagonal. $V$ is not square, so $V \\mathbf { } ^ { \\top } \\neq I$ , but assuming $V$ is orthonormal as before, we have $V V ^ { \\top } = P$ is a projection matrix. Left-multiplying Equation (1) by $V$ now reads $( P M ) V = V \\Lambda$ so we are solving an eigenvalue problem for a subspace of $M$ . ",
+        "bbox": [
+            173,
+            210,
+            825,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If we only desire the top- $k$ eigenvectors, maximizing the trace encourages learning a subspace spanned by the top- $k$ eigenvectors, but does not recover the eigenvectors themselves. On the other hand, Equation (3) places no preference on recovering large over small eigenvectors, but does enforce the columns of $\\hat { V }$ to actually be eigenvectors. The preceding exercise is intended to introduce minimizing the off-diagonal terms of $R$ as a possible complementary objective for solving top- $k$ PCA. Next, we will use these two objectives to construct utility functions for each eigenvector $\\hat { v } _ { i }$ . ",
+        "bbox": [
+            173,
+            286,
+            825,
+            373
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We want to combine the objectives to take advantage of both their strengths. A valid proposal is ",
+        "bbox": [
+            171,
+            380,
+            802,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2413a81de4622bce681a10439e7c4b90a787e9c6dbacd46c651b14288c7f3f39.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\hat { V } ^ { \\top } \\hat { V } = I } \\sum _ { i } R _ { i i } - \\sum _ { i \\neq j } R _ { i j } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            398,
+            588,
+            434
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, this objective ignores the natural hierarchy of the top- $k$ eigenvectors. For example, $\\hat { v } _ { 1 }$ is penalized for aligning with $\\hat { v } _ { k }$ and vice versa, but $\\hat { v } _ { 1 }$ , being the estimate of the largest eigenvector, should be free to search for the direction that captures the most variance independent of the locations of the other vectors. Instead, first consider solving for the top-1 eigenvector, $v _ { 1 }$ , in which case $R = [ \\langle \\hat { v } _ { 1 } , M \\hat { v } _ { 1 } \\rangle ]$ is a $1 \\times 1$ matrix. In this setting, Equation (3) is not applicable because there are no off-diagonal elements, so $\\mathrm { m a x } _ { \\hat { v } _ { 1 } ^ { \\top } \\hat { v } _ { 1 } = 1 } \\langle \\hat { v } _ { 1 } , M \\hat { v } _ { 1 } \\rangle$ is a sensible utility function for $\\hat { v } _ { 1 }$ . ",
+        "bbox": [
+            173,
+            438,
+            825,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If considering the top-2 eigenvectors, $\\hat { v } _ { 1 }$ ’s utility remains as before, and we introduce a new utility for $\\hat { v } _ { 2 }$ . Equation (3) is now applicable, so $\\hat { v } _ { 2 }$ ’s utility is ",
+        "bbox": [
+            173,
+            530,
+            821,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/11a0b775b2689a4f8c17ba10e90ec085bcb4b904b1d76a0c13d8218b207807ec.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\hat { v } _ { 2 } ^ { \\top } \\hat { v } _ { 2 } = 1 , \\hat { v } _ { 1 } ^ { \\top } \\hat { v } _ { 2 } = 0 } \\langle \\hat { v } _ { 2 } , M \\hat { v } _ { 2 } \\rangle - \\frac { \\langle \\hat { v } _ { 2 } , M \\hat { v } _ { 1 } \\rangle ^ { 2 } } { \\langle \\hat { v } _ { 1 } , M \\hat { v } _ { 1 } \\rangle }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            563,
+            633,
+            599
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where we have divided the off-diagonal penalty by $\\langle v _ { 1 } , M v _ { 1 } \\rangle$ so a) the two terms in Equation (5) are on a similar scale and b) for reasons that ease analysis. Additionally note that the constraint $\\hat { v } _ { 1 } ^ { \\top } \\hat { v } _ { 2 } = 0$ may be redundant at the optimum $\\hat { v } _ { 1 } ^ { * } = v _ { 1 } , \\hat { v } _ { 2 } ^ { * } = v _ { 2 } ,$ ) because the second term, $\\langle \\hat { v } _ { 2 } ^ { * } , M \\hat { v } _ { 1 } ^ { * } \\rangle ^ { 2 } =$ $\\langle v _ { 2 } , M v _ { 1 } \\rangle ^ { 2 } = \\Lambda _ { 1 1 } ^ { 2 } \\langle v _ { 2 } , v _ { 1 } \\rangle ^ { 2 }$ , already penalizes such deviations $\\Lambda _ { i i }$ is the $i$ th largest eigenvector). These reasons motivate the following set of objectives (utilities), one for each vector $i \\in \\{ 1 , \\ldots , k \\}$ : ",
+        "bbox": [
+            173,
+            603,
+            826,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1e6df6834c885112e900561a1effe40e11c3a8f3c01e2606849bc4a365d40bf8.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\hat { v } _ { i } ^ { \\top } \\hat { v } _ { i } = 1 } \\left\\{ u _ { i } ( \\hat { v } _ { i } | \\hat { v } _ { j < i } ) = \\hat { v } _ { i } ^ { \\top } M \\hat { v } _ { i } - \\sum _ { j < i } \\frac { ( \\hat { v } _ { i } ^ { \\top } M \\hat { v } _ { j } ) ^ { 2 } } { \\hat { v } _ { j } ^ { \\top } M \\hat { v } _ { j } } = | | X \\hat { v } _ { i } | | ^ { 2 } - \\sum _ { j < i } \\frac { \\langle X \\hat { v } _ { i } , X \\hat { v } _ { j } \\rangle ^ { 2 } } { \\langle X \\hat { v } _ { j } , X \\hat { v } _ { j } \\rangle } \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            679,
+            776,
+            719
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the notation $u _ { i } ( a _ { i } | b )$ emphasizes that player $i$ adjusts $a _ { i }$ to maximize a utility conditioned on $b$ ",
+        "bbox": [
+            171,
+            724,
+            825,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is interesting to note that by incorporating knowledge of the natural hierarchy (see Figure 1), we are immediately led to constructing asymmetric utilities, and thereby, inspired to formulate the PCA problem as a game, rather than a direct optimization problem as in Equation (4). ",
+        "bbox": [
+            174,
+            744,
+            825,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A key concept in games is a Nash equilibrium. A Nash equilibrium specifies a variable for each player from which no player can unilaterally deviate and improve their outcome. In this case, $\\hat { V }$ is a (strict-)Nash equilibrium if and only if for all $i$ , $u _ { i } ( \\hat { v } _ { i } | \\hat { v } _ { j < i } ) > u _ { i } ( z _ { i } | \\hat { v } _ { j < i } )$ for all $z _ { i } \\in \\mathcal { S } ^ { d - 1 }$ . ",
+        "bbox": [
+            173,
+            794,
+            825,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2.1 (PCA Solution is the Unique strict-Nash Equilibrium). Assume that the top- $k$ eigenvalues of $X ^ { \\top } X$ are positive and distinct. Then the top- $k$ eigenvectors form the unique strictNash equilibrium of the proposed game in Equation (6).3 The proof is deferred to Appendix L. ",
+        "bbox": [
+            173,
+            842,
+            825,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Solving for the Nash of a game is difficult in general. Specifically, it belongs to the class of PPADcomplete problems (Gilboa and Zemel, 1989; Daskalakis et al., 2009). However, because the game ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "is hierarchical and each player’s utility only depends on its parents, it is possible to construct a sequential algorithm that is convergent by solving each player’s optimization problem in sequence. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            282,
+            167
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Utility gradient. In Section 2, we mentioned that normalizing the penalty term from Equation (5) had a motivation beyond scaling. Dividing by $\\langle \\hat { v } _ { j } , M \\hat { v } _ { j } \\rangle$ results in the following gradient for player $i$ : ",
+        "bbox": [
+            171,
+            183,
+            825,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43950e5ef4691d1960dabfd5588abaccdb819d62252adb6ae6c2a53570fd548c.jpg",
+        "text": "$$\n\\nabla _ { \\hat { v } _ { i } } u _ { i } \\big ( \\hat { v } _ { i } | \\hat { v } _ { j < i } \\big ) = 2 M \\Big [ \\hat { v } _ { i } - \\sum _ { j < i } \\frac { \\hat { v } _ { i } ^ { \\top } M \\hat { v } _ { j } } { \\hat { v } _ { j } ^ { \\top } M \\hat { v } _ { j } } \\hat { v } _ { j } \\Big ] = 2 X ^ { \\top } \\Big [ X \\hat { v } _ { i } - \\sum _ { j < i } \\frac { \\langle X \\hat { v } _ { i } , X \\hat { v } _ { j } \\rangle } { \\langle X \\hat { v } _ { j } , X \\hat { v } _ { j } \\rangle } X \\hat { v } _ { j } \\Big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            218,
+            781,
+            258
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The resulting gradient with normalized penalty term has an intuitive meaning. It consists of a single generalized Gram-Schmidt step followed by the standard matrix product found in power iteration and Oja’s rule. Also, notice that applying the gradient as a fixed point operator in sequence $\\hat { v } _ { i } \\gets$ $\\begin{array} { r } { \\frac { 1 } { 2 } \\nabla _ { \\hat { v } _ { i } } \\bar { u } _ { i } \\big ( \\hat { v } _ { i } | \\hat { v } _ { j < i } \\big ) \\big ) } \\end{array}$ on $M = I$ recovers the standard Gram-Schmidt procedure for orthogonalization. ",
+        "bbox": [
+            176,
+            285,
+            823,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A sequential algorithm. Each eigenvector can be learned by maximizing its utility. The vectors are constrained to the unit sphere, a non-convex Riemannian manifold, so we use Riemmanian gradient ascent with gradients given by Equation (7). In this case, Riemannian optimization theory simply requires an intermediate step where the gradient, $\\nabla _ { \\hat { v } _ { i } }$ , is projected onto the tangent space of the sphere to compute the Riemannian gradient, $\\nabla _ { \\hat { v } _ { i } } ^ { \\tilde { R } }$ . A more detailed illustration can be found in Appendix J. Recall that each $u _ { i }$ depends on $\\hat { v } _ { j < i }$ . If any of $\\hat { v } _ { j < i }$ are being learned concurrently, then $\\hat { v } _ { i }$ is maximizing a non-stationary objective which makes a convergence proof difficult. Instead, for completeness, we prove convergence assuming each $\\hat { v } _ { i }$ is learned in sequence. Algorithm 1 learns $\\hat { v } _ { i }$ given fixed parents $\\hat { v } _ { j < i }$ ; we present the convergence guarantee in Section 4 and details on setting $\\rho _ { i }$ and $\\alpha$ in Appendix O. ",
+        "bbox": [
+            174,
+            356,
+            583,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/39c8426c3f737061f92367d5bc997c4b7a2e0ec6f926bd67ed13d247f37932a5.jpg",
+        "image_caption": [
+            "Figure 2: EigenGame guides each $\\hat { v } _ { i }$ along the unit-sphere from $\\uparrow$ to in parallel; $M = \\bar { \\mathrm { d i } } \\mathsf { a g } ( [ 3 , 2 , 1 ] )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            596,
+            349,
+            820,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            523,
+            823,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/37975be32bebc4929a0d11376774301463168862dbfda31041039b8cd74ecf05.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm1 EigenGameR-Sequential</td><td>Algorithm 2 EigenGameR (EigenGame-update Given: matrix X ∈ Rnxd maximum err with Voi instead of V)</td></tr><tr><td>tolerance ρi, initial vector  ∈ Sd-1, learned approximate parents Uj&lt;i, and step size α.</td><td>Given: stream, Xt ∈ Rmxd, total iterations T, initial vector O ∈ Sd-1, and step size α.</td></tr><tr><td>v← ti =「 min(|/Vouil/2, pi)-²]</td><td>← fort=1: Tdo</td></tr><tr><td>fort=1:tdo</td><td>rewards ←Xti {XtO，Xtj）</td></tr><tr><td>rewards ←Xi penalties←∑j&lt;iXo,xo) (Xui,X0j） Xuj</td><td>penalties←∑j&lt;iXtoxXt XtUj</td></tr><tr><td>Vo ← 2XT[rewards -penalties]</td><td>Vo←2XT rewards-penalties</td></tr><tr><td>B←Vo-{Vo,Ui）Ui 0←0+aV</td><td>V←Vo-{VoUi）i 0←0+aV</td></tr></table>",
+        "bbox": [
+            171,
+            574,
+            818,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A decentralized algorithm. While Algorithm 1 enjoys a convergence guarantee, learning every parent $\\hat { v } _ { j < i }$ before learning $\\hat { v } _ { i }$ may be unnecessarily restrictive. Intuitively, as parents approach their respective optima, they become quasi-stationary, so we do not expect maximizing utilities in parallel to be problematic in practice. To this end, we propose Algorithm 2 visualized in Figure 2. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b113e234d2341807b50a55bc76b6f8c8dcef8cf9a74140dfb4443aff798aa468.jpg",
+        "image_caption": [
+            "Figure 3: (a) The longest streak of consecutive vectors with angular error less than $\\frac { \\pi } { 8 }$ radians is plotted versus algorithm iterations for a matrix $M \\in \\mathbb { R } ^ { 5 0 \\times 5 0 }$ with a spectrum decaying from 1000 to 1 linearly and exponentially. Average runtimes are reported in milliseconds next to the method names5. We omit Krasulina’s as it is only designed to find the top- $k$ subspace. Both EigenGame variants and GHA achieve similar asymptotes on the linear spectrum. (b) Longest streak and subspace distance on MNIST with average runtimes reported in seconds. (a,b) Learning rates were chosen from $\\{ 1 0 ^ { - 3 } , \\dotsc , 1 0 ^ { - 6 } \\}$ on 10 held out runs. Solid lines denote results with the best performing learning rate. Dotted and dashed lines denote results using the best learning rate $\\times 1 0$ and 0.1. All plots show means over 10 trials. Shading highlights $\\pm$ standard error of the mean for the best learning rates. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            102,
+            813,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In practice we can assign each eigenvector update to its own device (e.g. a GPU or TPU). Systems with fast interconnects may facilitate tens, hundreds or thousands of accelerators to be used. In such settings, the overhead of broadcast $( \\hat { v } _ { i } )$ is minimal. We can also specify that the data stream is co-located with the update so $\\hat { v } _ { i }$ updates with respect to its own $X _ { i , t }$ . This is a standard paradigm for e.g. data-parallel distributed neural network training. We provide further details in Section 6. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            434
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Message Passing on a DAG. Our proposed utilities enforce a strict hierarchy on the eigenvectors. This is a simplification that both eases analysis (see Appendix M) and improves convergence4, however, it is not optimal. We assume vectors are initialized randomly on the sphere and, for instance, $\\hat { v } _ { k }$ may be initialized closer to $v _ { 1 }$ than even $\\hat { v } _ { 1 }$ and vice versa. The hierarchy shown in Figure 1 enforces a strict graph structure for broadcasting information of parents to the childrens’ utilities. ",
+        "bbox": [
+            173,
+            450,
+            826,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To our knowledge, our utility formulation in Equation (6) is novel. One disadvantage is that stochastic gradients of Equation (7) are biased. This is mitigated with large batch sizes (further discussion in Appendix I). ",
+        "bbox": [
+            176,
+            529,
+            821,
+            570
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 CONVERGENCE OF EIGENGAME ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            473,
+            609
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, we first show that Equation (6) has a simple form such that any local maximum of $u _ { i }$ is also a global maximum. Player $i$ ’s utility depends on its parents, so we next explain how error in the parents propagates to children through mis-specification of player $i$ ’s utility. Using the first result and accounting for this error, we are then able to give global, finite-sample convergence guarantees in the full-batch setting by leveraging recent non-convex Riemannian optimization theory. ",
+        "bbox": [
+            173,
+            626,
+            825,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The utility landscape and parent-to-child error propagation. Equation (6) is abstruse, but we prove that the shape of player $i$ ’s utility is simply sinusoidal in the angular deviation of $\\hat { v } _ { i }$ from the optimum. The amplitude of the sinusoid varies with the direction of the angular deviation along the unit-sphere and is dependent on the accuracy of players $j < i$ . In the special case where players $j < i$ have learned the top- $( i - 1 )$ eigenvectors exactly, player $i$ ’s utility simplifies (see Lemma N.1) to ",
+        "bbox": [
+            173,
+            714,
+            825,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c91ca6924ee4dcf5335122f4429d3ce356c975c33cc8c982e570755ded7d0a5a.jpg",
+        "text": "$$\nu _ { i } \\big ( \\hat { v } _ { i } , \\big \\{ v _ { j < i } \\big \\} \\big ) = \\Lambda _ { i i } - \\sin ^ { 2 } ( \\theta _ { i } ) \\Big ( \\Lambda _ { i i } - \\sum _ { l > i } z _ { l } \\Lambda _ { l l } \\Big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            792,
+            666,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta _ { i }$ is the angular deviation and $z \\in \\Delta ^ { d - 1 }$ parameterizes the deviation direction. Note that $\\sin ^ { 2 }$ has period $\\pi$ instead of $2 \\pi$ , which simply reflects the fact that $v _ { i }$ and $- v _ { i }$ are both eigenvectors. ",
+        "bbox": [
+            173,
+            839,
+            823,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An error propagation analysis reveals that it is critical to learn the parents to a given degree of accuracy. The angular distance between $v _ { i }$ and the maximizer of player $i$ ’s utility with approximate parents has $\\tan ^ { - 1 }$ dependence (i.e., a soft step-function; see Lemma N.5 and Figure 13 in Appendix N). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.1 (Global convergence). Algorithm 1 achieves finite sample convergence to within $\\theta _ { t o l }$ angular error of the top- $k$ principal components, independent of initialization. Furthermore, if each $\\hat { v } _ { i }$ is initialized to within $\\frac { \\pi } { 4 }$ of $v _ { i }$ , Algorithm $^ { l }$ returns the components with angular error less than $\\theta _ { t o l }$ in $\\begin{array} { r } { T = \\left\\lceil \\mathcal { O } \\Big ( k \\Big [ \\frac { ( k - 1 ) ! } { \\theta _ { t o l } } \\prod _ { i = 1 } ^ { k } \\big ( \\frac { 1 6 \\Lambda _ { 1 1 } } { g _ { i } } \\big ) \\Big ] ^ { 2 } \\Big ) \\right\\rceil } \\end{array}$ iterations. Proofs are deferred to Appendices O.4 and O.5. ",
+        "bbox": [
+            173,
+            148,
+            825,
+            226
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Angular error is defined as the angle between $\\hat { v } _ { i }$ and $v _ { i }$ : $\\theta _ { i } = \\mathrm { s i n } ^ { - 1 } ( \\sqrt { 1 - \\langle v _ { i } , \\hat { v } _ { i } \\rangle ^ { 2 } } )$ . The first $k$ in the formula for $T$ appears from a naive summing of worst case bounds on the number of iterations required to learn each $\\hat { v } _ { j < k }$ individually. The constant 16 arises from the error propagation analysis; parent vectors, $\\hat { v } _ { j < i }$ , must be learned to under 1/16th of a canonical error threshold, $\\frac { g _ { i } } { ( i - 1 ) \\Lambda _ { 1 1 } }$ , for the child $\\hat { v } _ { i }$ where $g _ { i } = \\Lambda _ { i i } - \\Lambda _ { i + 1 , i + 1 }$ . The Riemannian optimization theory we leverage dictates that $\\textstyle { \\frac { 1 } { \\rho ^ { 2 } } }$ iterations are required to meet a $\\mathcal { O } ( \\rho )$ error threshold. This is why the squared inverse of the error threshold appears here. Breaking down the error threshold itself, the ratio $\\Lambda _ { 1 1 } / g _ { i }$ says that more iterations are required to distinguish eigenvectors when the difference between them (summarized by the gap $g _ { i }$ ) is small relative to the scale of the spectrum, $\\Lambda _ { 1 1 }$ . The $( k - 1 ) !$ ! term appears because learning smaller eigenvectors requires learning a much more accurate $\\hat { v } _ { 1 }$ higher up the DAG. ",
+        "bbox": [
+            173,
+            236,
+            825,
+            383
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lastly, the utility function for each $\\hat { v } _ { i }$ is sinusoidal, and it is possible that we initialize $\\hat { v } _ { i }$ with initial utility arbitrarily close to the trough (bottom) of the function where gradients are arbitrarily small. This is why the global convergence rate depends on the initialization in general. Note that Algorithm 1 effectively detects the trough by measuring the norm of the initial gradient $( \\nabla _ { \\widehat { v } _ { i } ^ { 0 } } u _ { i } )$ and scales the number of required iterations appropriately. A complete theorem that considers the probability of initializing $\\hat { v } _ { i }$ within $\\frac { \\pi } { 4 }$ of $v _ { i }$ is in Appendix O, but this possibility shrinks to zero in high dimensions. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We would also like to highlight that these theoretical findings are strong relative to some other claims. For example, the exponential convergence guarantee for Matrix Krasulina requires the initial guess at the eigenvectors capture the top- $\\left( k - 1 \\right)$ subspace (Tang, 2019), unlikely when $d \\gg k$ . A similar condition is required in (Shamir, 2016b). These guarantees are given for the mini-batch setting while ours is for the full-batch, however, we provide global convergence without restrictions on initialization. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            566
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            587,
+            341,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "PCA is a century-old problem and a massive literature exists (Jolliffe, 2002; Golub and Van Loan, 2012). The standard solution to this problem is to compute the SVD, possibly combined with randomized algorithms, to recover the top- $k$ components as in (Halko et al., 2011) or with Frequent Directions (Ghashami et al., 2016) which combines sketching with SVD. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            672
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In neuroscience, Hebb’s rule (Hebb, 2005) refers to a connectionist rule that solves for the top eigenvector of a matrix $M$ using additive updates of a vector $v$ as $v  v + \\eta M v$ . Likewise, Oja’s rule (Oja, 1982; Shamir, 2015) refers to a similar update $v  v + \\eta ( I - v v ^ { \\top } ) M v$ . In machine learning, using a normalization step of $v  v / | | v | |$ with Hebb’s rule is somewhat confusingly referred to as Oja’s algorithm (Shamir, 2015), the reason being that the subtractive term in Oja’s rule can be viewed as a regularization term for implicitly enforcing the normalization. In the limit of infinite step size, $\\eta  \\infty$ , Oja’s algorithm effectively becomes the well known Power method. If a normalization step is added to Oja’s rule, this is referred to as Krasulina’s algorithm (Krasulina, 1969). In the language of Riemannian manifolds, $v / | | v | |$ can be recognized as a retraction and $( I - v v ^ { \\top } )$ as projecting the gradient $M v$ onto the tangent space of the sphere (Absil et al., 2009). ",
+        "bbox": [
+            173,
+            680,
+            825,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Many of the methods above have been generalized to the top- $k$ components. Most generalizations involve adding an orthonormalization step after each update, typically accomplished with a QR factorization plus some minor sign accounting (e.g., see Algorithm 3 in Appendix A.1). An extension of Krasulina’s algorithm to the top- $k$ setting, termed Matrix Krasulina (Tang, 2019), was recently proposed in the machine learning literature. This algorithm can be recognized as projecting the gradient onto the Stiefel manifold (the space of orthonormal matrices) followed by a QR step to maintain orthonormality, which is a well known retraction. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Maintaining orthonormality via QR is computationally expensive. Amid and Warmuth (2019) propose an alternative Krasulina method which does not require re-orthonormalization but instead requires inverting a $k \\times k$ matrix; in a streaming setting restricted to minibatches of size 1 $( X _ { t } \\in \\mathbb { R } ^ { d }$ ), Sherman-Morrison (Golub and Van Loan, 2012) can be used to efficiently replace the inversion step. Raja and Bajwa (2020) develop a data-parallel distributed algorithm for the top eigenvector. Alternatively, the Jacobi eigenvalue algorithm explicitly represents the matrix of eigenvectors as a Givens rotation matrix using sin’s and cos’s and rotates $M$ until it is diagonal (Golub and Van der Vorst, 2000). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In contrast, other methods extract the top components in sequence by solving for the ith component using an algorithm such as power iteration or Oja’s, and then enforcing orthogonality by removing the learned subspace from the matrix, a process known as deflation. Alternatively, the deflation process may be intertwined with the learning of the top components. The generalized Hebbian algorithm (Sanger, 1989) (GHA) works this way as do Lagrangian inspired formulations (Ghojogh et al., 2019) as well as our own approach. We make the connection between GHA and our algorithm concrete in Prop. K.1. Note, however, that the GHA update is not the gradient of any utility (Prop. K.2) and therefore, lacks a clear game interpretation. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            333
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Of these, Oja’s algorithm has arguably been the most extensively studied (Shamir, 2016a; Allen-Zhu and Li, $2 0 1 \\bar { 7 } ) ^ { 6 }$ Note that Oja’s algorithm converges to the actual principal components (Allen-Zhu and Li, 2017) and Matrix Krasulina (Tang, 2019) converges to the top- $k$ subspace. However, neither can be obviously decentralized. GHA (Sanger, 1989) converges to the principal components asymptotically and can be decentralized (Gang et al., 2019). Each of these is applicable in the streaming $k$ -PCA setting. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            424
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            446,
+            326,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare our approach against GHA, Matrix Krasulina, and Oja’s algorithm7. We present both EigenGame and EigenGameR which projects the gradient onto the tangent space of the sphere each step. We measure performance of methods in terms of principal component accuracy and subspace distance. We measure principal component accuracy by the number of consecutive components, or longest streak, that are estimated within an angle of $\\frac { \\pi } { 8 }$ from ground truth. For example, if the angular errors of the $\\hat { v } _ { i }$ ’s returned by a method are, in order, $\\begin{array} { r } { [ \\theta _ { 1 } , \\bar { \\theta } _ { 2 } , \\theta _ { 3 } , . . . ] = [ \\frac { \\pi } { 1 6 } , \\frac { \\pi } { 4 } , \\frac { \\pi } { 1 0 } , . . . ] , } \\end{array}$ [ π16 , π4 , π10 , . . . ] , th en the method is credited with a streak of only 1 regardless of the errors $\\theta _ { i > 2 }$ . For Matrix Krasulina, we first compute the optimal matching from $\\hat { v } _ { i }$ to ground truth before measuring angular error. We present the longest streak as opposed to $^ { 6 6 } \\#$ of eigenvectors found” because, in practice, no ground truth is available and we think the user should be able to place higher confidence in the larger eigenvectors being correct. If an algorithm returns $k$ vectors, $\\frac { k } { 2 }$ of which are accurate components but does not indicate which, this is less helpful. We measure normalized subspace distance using $\\textstyle 1 - { \\frac { 1 } { k } } \\cdot \\operatorname { T r } ( U ^ { * } P ) \\in [ 0 , 1 ]$ where $U ^ { * } = V V ^ { \\dagger }$ and $P = \\hat { V } \\hat { V } ^ { \\dag }$ similarly to Tang (2019). ",
+        "bbox": [
+            173,
+            479,
+            825,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Synthetic data. Experiments on synthetic data demonstrate the viability of our approach (Figure 3a). Oja’s algorithm performs best on synthetic experiments because strictly enforcing orthogonalization with an expensive QR step greatly helps when solving for all eigenvectors. EigenGame is able to effectively parallelize this over $k$ machines and the advantage of QR diminishes in Figure 3b. The remaining algorithms perform similarly on a linearly decaying spectrum, however, EigenGame performs better on an exponentially decaying spectrum due possibly to instability of Riemannian gradients near the equilibrium (see Appendix J for further discussion). GHA and EigenGameR are equivalent under specific conditions (see Proposition K.1). ",
+        "bbox": [
+            173,
+            680,
+            825,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 4a shows EigenGame solves for the eigenvectors up to a high degree of accuracy $\\frac { \\pi } { 3 2 }$ , i.e. the convergence results in Figure 3a are not the result of using a loose tolerance of $\\frac { \\pi } { 8 }$ . With the lower tolerance, all algorithms take slightly more iterations to learn the eigenvectors of the linear spectrum; it is difficult to see any performance change for the exponential spectrum. Although Theorem 4.1 assumes distinct eigenvalues, Figure 4b supports the claim that EigenGame does not require distinct eigenvalues for convergence. We leave proving convergence in this setting to future work. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            882
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6669788ae7fec1a85e64041d26b0412233317a21e23fcff30771f113df148876.jpg",
+        "image_caption": [
+            "Figure 4: (a) Repeats analysis of Figure 3a but for a lower angular tolerance of $\\frac { \\pi } { 3 2 }$ . (b) Repeats analysis of Figure 3a with an angular tolerance of $\\frac { \\pi } { 8 }$ as before, but with eigenvalues $\\mathrm { \\bar { 1 0 } - 1 9 }$ of the ordered spectrum overwritten with $\\lambda _ { 1 0 }$ of the original spectrum. We compute angular error for the eigenvectors on either side of this “bubble\" to show that EigenGame finds these eigenvectors despite repeated eigenvalues in the spectrum; note $4 0 / 5 0$ is optimal in this experiment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            101,
+            813,
+            202
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb90b017833142d5eb56cb041919940760489f3a8b2cea66b0a552456fc4c292.jpg",
+        "image_caption": [
+            "Figure 5: (a) Top-8 principal components of the activations of a RESNET-200 on IMAGENET ordered block-wise by network topology (dimension of each block on the right $y$ -axis). Block 1 is closest to input and Block 5 is the output of the network. Color coding is based on relative variance between blocks across the top-8 PCs from blue (low) to red (high). (b) Block 1 mean activation maps of the top-32 principal components of RESNET-200 on IMAGENET computed with EigenGame. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            294,
+            820,
+            446
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "MNIST handwritten digits. We compare EigenGame against GHA, Matrix Krasulina, and Oja’s algorithm on the MNIST dataset (Figure 3b). We flatten each image in the training set to obtain a $6 0 , 0 0 0 \\times 7 8 4$ dimensional matrix. EigenGame is competitive with Oja’s in a high batch size regime (1024 samples per mini-batch). The performance gap between EigenGame and the other methods shrinks as the mini-batch size is reduced (see Appendix I), expectedly due to biased gradients. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            628
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The principal components of RESNET-200 activations on IMAGENET are edge filters. A primary goal of PCA is to obtain interpretable low-dimensional representations. To this end we present an example of using EigenGame to compute the top-32 principal components of the activations of a pretrained RESNET-200 on the IMAGENET dataset. We concatenate the flattened activations from the output of each residual block resulting in a $d \\approx 2 0 \\mathbf { M }$ dimensional vector representation for each of the roughly 1.2M input images. It is not possible to store the entire 195TB matrix in memory, nor incrementally compute the Gram/covariance matrix. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We implemented a data-and-model parallel version of EigenGame in JAX (Bradbury et al., 2018) where each $\\hat { v } _ { i }$ is assigned to it’s own TPU (Jouppi et al., 2017). Each device keeps a local copy of the RESNET parameters and the IMAGENET datastream. Sampling a mini-batch (of size 128), computing the network activations and updating $\\hat { v } _ { i }$ are all performed locally. The broadcast $( \\hat { v } _ { i } )$ ) step is handled by the pmap and lax.all_gather functions. Computing the top-32 principal components takes approximately nine hours on 32 TPUv3s. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 5a shows the top principal components of the activations of the trained network organized by network topology (consisting of five residual blocks). Note that EigenGame is not applied block-wise, but on all 20M dimensions. We do not assume independence between blocks and the eigenvector has unit norm across all blocks. We observe that Block 1 (closest to input) of PC 1 has very small magnitude activations relative to the other PCs. This is because PC 1 should capture the variance which discriminates most between the classes in the dataset. Since Block 1 is mainly concerned with learning low-level image filters, it stands to reason that although these are important for good performance, they do not necessarily extract abstract representations which are useful for classification. Conversely, we see that PC 1 has larger relative activations in the later blocks. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We visualize the average principal activation in Block $1 ^ { 8 }$ in Figure 5b. The higher PCs learn distinct filters (Gabor filters, Laplacian-of-Gaussian filters c.f. (Bell and Sejnowski, 1997)). ",
+        "bbox": [
+            173,
+            151,
+            821,
+            181
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            200,
+            318,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It seems easier to train a bi-directional LSTM with attention than to compute the SVD of a large matrix. –Chris Re ",
+        "bbox": [
+            467,
+            208,
+            823,
+            234
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "NeurIPS 2017 Test-of-Time Award, Rahimi and Recht (Rahimi and Recht, 2017). ",
+        "bbox": [
+            503,
+            237,
+            825,
+            262
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work we motivated PCA from the perspective of a multi-player game. This inspired a decentralized algorithm which enables large-scale principal components estimation. To demonstrate this we used EigenGame to analyze a large neural network through the lens of PCA. To our knowledge this is the first academic analysis of its type and scale (for reference, (Tang, 2019) compute the top-6 PCs of the $d = 2 3 0 0$ outputs of VGG). EigenGame also opens a variety of research directions. ",
+        "bbox": [
+            174,
+            266,
+            825,
+            335
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Scale. In experiments, we broadcast across all edges in Figure 1 every iteration. Introducing lag or broadcasting with dropout may improve efficiency. Can we further reduce our memory footprint by storing only scalars of the losses and avoiding congestion through online bandit or reinforcement learning techniques? Our decentralized algorithm may have implications for federated and privacy preserving learning as well (Heinze et al., 2016; Heinze-Deml et al., 2018; Bonawitz et al., 2019). ",
+        "bbox": [
+            174,
+            343,
+            825,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Games. EigenGame has a unique Nash equilibrium due to the fixed DAG structure, but vectors are initialized randomly so $\\hat { v } _ { k }$ may start closer to $v _ { 1 }$ than $\\hat { v } _ { 1 }$ does. Adapting the DAG could make sense, but might also introduce spurious fixed points or suboptimal Nash. Might replacing vectors with populations accelerate extraction of the top principal components? ",
+        "bbox": [
+            174,
+            420,
+            825,
+            476
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Core ML. EigenGame could be useful as a diagnostic or for accelerating training (Desjardins et al., 2015; Krummenacher et al., 2016); similarly, spectral normalization has shown to be a valuable tool for stabilizing GAN training (Miyato et al., 2018). ",
+        "bbox": [
+            174,
+            482,
+            825,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lastly, GANs (Goodfellow et al., 2014) recently reformulated learning a generative model as a two-player zero-sum game. Here, we show how another fundamental unsupervised learning task can be formulated as a $k$ -player game. While two-player, zero-sum games are well understood, research on $k$ -player, general-sum games lies at the forefront in machine learning. We hope that marrying a fundamental, well-understood task in PCA with the relatively less understood domain of many player games will help advance techniques on both ends. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            614
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            636,
+            367,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We are grateful to Trevor Cai for his help scaling the JAX implementation of EigenGame to handle the large IMAGENET experiment and to Daniele Calandriello for sharing his expert knowledge of related work and advice on revising parts of the manuscript. ",
+        "bbox": [
+            174,
+            665,
+            823,
+            708
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            728,
+            285,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "P-A. Absil, Robert Mahony, and Rodolphe Sepulchre. Optimization Algorithms on Matrix Manifolds. Princeton University Press, 2009. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            775
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zeyuan Allen-Zhu and Yuanzhi Li. First efficient convergence for streaming k-PCA: a global, gap-free, and near-optimal rate. In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), pages 487–492. IEEE, 2017. ",
+        "bbox": [
+            174,
+            781,
+            823,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ehsan Amid and Manfred K Warmuth. An implicit form of Krasulina’s k-PCA update without the orthonormality constraint. arXiv preprint arXiv:1909.04803, 2019. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            854
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anthony J Bell and Terrence J Sejnowski. The “independent components” of natural scenes are edge filters. Vision Research, 37(23):3327–3338, 1997. ",
+        "bbox": [
+            178,
+            863,
+            821,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloe Kiddon, Jakub Konecny, Stefano Mazzocchi, H Brendan McMahan, et al. Towards federated learning at scale: system design. arXiv preprint arXiv:1902.01046, 2019. ",
+        "bbox": [
+            176,
+            104,
+            823,
+            143
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Boumal, Pierre-Antoine Absil, and Coralia Cartis. Global rates of convergence for nonconvex optimization on manifolds. IMA Journal of Numerical Analysis, 39(1):1–33, 2019. ",
+        "bbox": [
+            171,
+            152,
+            823,
+            180
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, and Skye Wanderman-Milne. JAX: composable transformations of Python+NumPy programs, 2018. URL http://github.com/google/jax. ",
+        "bbox": [
+            174,
+            189,
+            823,
+            228
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: interpretable representation learning by information maximizing generative adversarial nets. In Advances in Neural Information Processing Systems, pages 2172–2180, 2016. ",
+        "bbox": [
+            173,
+            237,
+            823,
+            276
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael B Cohen, Cameron Musco, and Christopher Musco. Input sparsity time low-rank approximation via ridge leverage score sampling. In Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1758–1777. SIAM, 2017. ",
+        "bbox": [
+            173,
+            286,
+            823,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Constantinos Daskalakis, Paul W Goldberg, and Christos H Papadimitriou. The complexity of computing a Nash equilibrium. SIAM Journal on Computing, 39(1):195–259, 2009. ",
+        "bbox": [
+            173,
+            333,
+            821,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Desjardins, Karen Simonyan, Razvan Pascanu, et al. Natural neural networks. In Advances in Neural Information Processing Systems, pages 2071–2079, 2015. ",
+        "bbox": [
+            174,
+            371,
+            823,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Feldman, Melanie Schmidt, and Christian Sohler. Turning big data into tiny data: Constant-size coresets for k-means, PCA, and projective clustering. SIAM Journal on Computing, 49(3):601–657, 2020. ",
+        "bbox": [
+            173,
+            406,
+            823,
+            433
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arpita Gang, Haroon Raja, and Waheed U Bajwa. Fast and communication-efficient distributed pca. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 7450–7454. IEEE, 2019. ",
+        "bbox": [
+            173,
+            441,
+            823,
+            481
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mina Ghashami, Edo Liberty, Jeff M Phillips, and David P Woodruff. Frequent directions: simple and deterministic matrix sketching. SIAM Journal on Computing, 45(5):1762–1792, 2016. ",
+        "bbox": [
+            169,
+            491,
+            823,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Benyamin Ghojogh, Fakhri Karray, and Mark Crowley. Eigenvalue and generalized eigenvalue problems: Tutorial. arXiv preprint arXiv:1903.11240, 2019. ",
+        "bbox": [
+            171,
+            526,
+            823,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Itzhak Gilboa and Eitan Zemel. Nash and correlated equilibria: some complexity considerations. Games and Economic Behavior, 1(1):80–93, 1989. ",
+        "bbox": [
+            174,
+            563,
+            823,
+            589
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gene H Golub and Henk A Van der Vorst. Eigenvalue computation in the 20th century. Journal of Computational and Applied Mathematics, 123(1-2):35–65, 2000. ",
+        "bbox": [
+            173,
+            598,
+            823,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gene H Golub and Charles F Van Loan. Matrix Computations, volume 3. JHU press, 2012. ",
+        "bbox": [
+            173,
+            633,
+            715,
+            648
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, pages 2672–2680, 2014. ",
+        "bbox": [
+            178,
+            657,
+            825,
+            696
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nathan Halko, Per-Gunnar Martinsson, and Joel A Tropp. Finding structure with randomness: probabilistic algorithms for constructing approximate matrix decompositions. SIAM review, 53(2):217–288, 2011. ",
+        "bbox": [
+            174,
+            705,
+            823,
+            733
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Donald Olding Hebb. The Organization of Behavior: A Neuropsychological Theory. Psychology Press, 2005. ",
+        "bbox": [
+            171,
+            742,
+            821,
+            757
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christina Heinze, Brian McWilliams, and Nicolai Meinshausen. Dual-loco: distributing statistical estimation using random projections. In Artificial Intelligence and Statistics, pages 875–883, 2016. ",
+        "bbox": [
+            173,
+            765,
+            821,
+            792
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christina Heinze-Deml, Brian McWilliams, and Nicolai Meinshausen. Preserving privacy between features in distributed estimation. Stat, 7(1):e189, 2018. ",
+        "bbox": [
+            174,
+            801,
+            823,
+            829
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Roger A Horn and Charles R Johnson. Matrix Analysis. Cambridge University Press, 2012. ",
+        "bbox": [
+            174,
+            837,
+            718,
+            852
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian T Jolliffe. Principal components in regression analysis. In Principal Component Analysis. Springer, 2002. ",
+        "bbox": [
+            171,
+            861,
+            818,
+            876
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Norman P Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, et al. In-datacenter performance analysis of a tensor processing unit. In Proceedings of the 44th Annual International Symposium on Computer Architecture, pages 1–12, 2017. ",
+        "bbox": [
+            174,
+            885,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "TP Krasulina. The method of stochastic approximation for the determination of the least eigenvalue of a symmetrical matrix. USSR Computational Mathematics and Mathematical Physics, 9(6):189–195, 1969. ",
+        "bbox": [
+            173,
+            104,
+            823,
+            131
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Krummenacher, Brian McWilliams, Yannic Kilcher, Joachim M Buhmann, and Nicolai Meinshausen. Scalable adaptive stochastic optimization using random projections. In Advances in Neural Information Processing Systems, pages 1750–1758, 2016. ",
+        "bbox": [
+            176,
+            140,
+            823,
+            179
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shengqiao Li. Concise formulas for the area and volume of a hyperspherical cap. Asian Journal of Mathematics and Statistics, 4(1):66–70, 2011. ",
+        "bbox": [
+            173,
+            188,
+            823,
+            214
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francesco Locatello, Stefan Bauer, Mario Lucic, Gunnar Raetsch, Sylvain Gelly, Bernhard Schölkopf, and Olivier Bachem. Challenging common assumptions in the unsupervised learning of disentangled representations. In Proceedings of the International Conference on Machine Learning, pages 4114–4124, 2019. ",
+        "bbox": [
+            173,
+            222,
+            823,
+            262
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emile Mathieu, Tom Rainforth, N Siddharth, and Yee Whye Teh. Disentangling disentanglement in variational autoencoders. arXiv preprint arXiv:1812.02833, 2018. ",
+        "bbox": [
+            171,
+            270,
+            825,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. arXiv preprint arXiv:1802.05957, 2018. ",
+        "bbox": [
+            173,
+            305,
+            823,
+            333
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Erkki Oja. Simplified neuron model as a principal component analyzer. Journal of Mathematical Biology, 15(3): 267–273, 1982. ",
+        "bbox": [
+            173,
+            340,
+            823,
+            367
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ali Rahimi and Benjamin Recht. Reflections on random kitchen sinks, 2017. URL http://www.argmin. net/2017/12/05/kitchen-sinks/. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            404
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haroon Raja and Waheed U Bajwa. Distributed stochastic algorithms for high-rate streaming principal component analysis. arXiv preprint arXiv:2001.01017, 2020. ",
+        "bbox": [
+            174,
+            410,
+            823,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "H Rutishauser. Simultaneous iteration method for symmetric matrices. In Handbook for Automatic Computation, pages 284–302. Springer, 1971. ",
+        "bbox": [
+            174,
+            445,
+            823,
+            473
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Terence D Sanger. Optimal unsupervised learning in a single-layer linear feedforward neural network. Neural Networks, 2(6):459–473, 1989. ",
+        "bbox": [
+            173,
+            481,
+            823,
+            508
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mhd Hasan Sarhan, Abouzar Eslami, Nassir Navab, and Shadi Albarqouni. Learning interpretable disentangled representations using adversarial VAEs. In Domain Adaptation and Representation Transfer and Medical Image Learning with Less Labels and Imperfect Data, pages 37–44. Springer, 2019. ",
+        "bbox": [
+            173,
+            516,
+            823,
+            556
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tamas Sarlos. Improved approximation algorithms for large matrices via random projections. In 2006 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS’06), pages 143–152. IEEE, 2006. ",
+        "bbox": [
+            173,
+            564,
+            823,
+            592
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ohad Shamir. A stochastic PCA and SVD algorithm with an exponential convergence rate. In Proceedings of the International Conference on Machine Learning, pages 144–152, 2015. ",
+        "bbox": [
+            176,
+            599,
+            823,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ohad Shamir. Convergence of stochastic gradient descent for PCA. In Proceedings of the International Conference on Machine Learning, pages 257–265, 2016a. ",
+        "bbox": [
+            176,
+            635,
+            823,
+            662
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ohad Shamir. Fast stochastic algorithms for SVD and PCA: Convergence properties and convexity. In Proceedings of the International Conference on Machine Learning, pages 248–256, 2016b. ",
+        "bbox": [
+            174,
+            670,
+            823,
+            696
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cheng Tang. Exponentially convergent stochastic $\\mathbf { k }$ -PCA without variance reduction. In Advances in Neural Information Processing Systems, pages 12393–12404, 2019. ",
+        "bbox": [
+            173,
+            705,
+            823,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aladin Virmaux and Kevin Scaman. Lipschitz regularity of deep neural networks: analysis and efficient estimation. In Advances in Neural Information Processing Systems, pages 3835–3844, 2018. ",
+        "bbox": [
+            171,
+            741,
+            823,
+            768
+        ],
+        "page_idx": 10
+    }
+]

parse/train/SyZipzbCb/SyZipzbCb.md

@@ -0,0 +1,351 @@
+# DISTRIBUTED DISTRIBUTIONAL DETERMINISTIC POLICY GRADIENTS
+
+Gabriel Barth-Maron˚, Matthew W. Hoffman˚, David Budden, Will Dabney, Dan Horgan, Dhruva TB, Alistair Muldal, Nicolas Heess, Timothy Lillicrap DeepMind   
+London, UK   
+{gabrielbm, mwhoffman, budden, wdabney, horgan, dhruvat, alimuldal, heess, countzero}@google.com
+
+# ABSTRACT
+
+This work adopts the very successful distributional perspective on reinforcement learning and adapts it to the continuous control setting. We combine this within a distributed framework for off-policy learning in order to develop what we call the Distributed Distributional Deep Deterministic Policy Gradient algorithm, D4PG. We also combine this technique with a number of additional, simple improvements such as the use of $N$ -step returns and prioritized experience replay. Experimentally we examine the contribution of each of these individual components, and show how they interact, as well as their combined contributions. Our results show that across a wide variety of simple control tasks, difficult manipulation tasks, and a set of hard obstacle-based locomotion tasks the D4PG algorithm achieves state of the art performance.
+
+# 1 INTRODUCTION
+
+The ability to solve complex control tasks with high-dimensional input and action spaces is a key milestone in developing real-world artificial intelligence. The use of reinforcement learning to solve these types of tasks has exploded following the work of the Deep Q Network (DQN) algorithm (Mnih et al., 2015), capable of human-level performance on many Atari games. Similarly, ground breaking achievements have been made in classical games such as Go (Silver et al., 2016). However, these algorithms are restricted to problems with a finite number of discrete actions.
+
+In control tasks, commonly seen in the robotics domain, continuous action spaces are the norm. For algorithms such as DQN the policy is only implicitly defined in terms of its value function, with actions selected by maximizing this function. In the continuous control domain this would require either a costly optimization step or discretization of the action space. While discretization is perhaps the most straightforward solution, this can prove a particularly poor approximation in highdimensional settings or those that require finer grained control. Instead, a more principled approach is to parameterize the policy explicitly and directly optimize the long term value of following this policy.
+
+In this work we consider a number of modifications to the Deep Deterministic Policy Gradient (DDPG) algorithm (Lillicrap et al., 2015). This algorithm has several properties that make it ideal for the enhancements we consider, which is at its core an off-policy actor-critic method. In particular, the policy gradient used to update the actor network depends only on a learned critic. This means that any improvements to the critic learning procedure will directly improve the quality of the actor updates. In this work we utilize a distributional (Bellemare et al., 2017) version of the critic update which provides a better, more stable learning signal. Such distributions model the randomness due to intrinsic factors, among these is the inherent uncertainty imposed by function approximation in a continuous environment. We will see that using this distributional update directly results in better gradients and hence improves the performance of the learning algorithm.
+
+Due to the fact that DDPG is capable of learning off-policy it is also possible to modify the way in which experience is gathered. In this work we utilize this fact to run many actors in parallel, all feeding into a single replay table. This allows us to seamlessly distribute the task of gathering experience, which we implement using the ApeX framework (Horgan et al., 2018). This results in significant savings in terms of wall-clock time for difficult control tasks. We will also introduce a number of small improvements to the DDPG algorithm, and in our experiments will show the individual contributions of each component. Finally, this algorithm, which we call the Distributed Distributional DDPG algorithm (D4PG), obtains state-of-the-art performance across a wide variety of control tasks, including hard manipulation and locomotion tasks.
+
+# 1.1 RELATED WORK
+
+Historically, estimation of the policy gradient has relied on the likelihood ratio trick (see e.g. Glynn, 1990), more commonly known as REINFORCE (Williams, 1992) in the reinforcement learning community. Modern variants of these so-called “vanilla” policy gradient methods include the work of (Mnih et al., 2016). Alternatively, one can consider second-order or “natural” variants of this objective, a set of techniques that include e.g. the Natural Actor-Critic (Peters & Schaal, 2008) and Trust Region Policy Optimization (TRPO) (Schulman et al., 2015) algorithms. More recently Proximal Policy Optimization (PPO) (Schulman et al., 2017), which can be seen as an approximation of TRPO, has proven very effective in large-scale distributed settings. Often, however, algorithms of this form are restricted to learning on-policy, which can limit both the amount of data-reuse as well as restrict the types of policies that are used for exploration.
+
+The Deterministic Policy Gradient (DPG) algorithm (Silver et al., 2014) upon which this work is based starts from a different set of ideas, namely the policy gradient theorem of (Sutton et al., 2000). The deterministic policy gradient theorem builds upon this earlier approach, but replaces the stochastic policy with one that includes no randomness. This approach is particularly important because it had previously been believed that the deterministic policy gradient did not exist in a model-free setting. The form of this gradient is also interesting in that it does not require one to integrate over the action space, and hence may require less samples to learn. DPG was later built upon by Lillicrap et al. (2015) who extended this algorithm and made use of a deep neural network as the function approximator, primarily as a mechanism for extending these results to work with vision-based inputs. Further, this entire endeavor lends itself very readily to an off-policy actorcritic architecture such that the actor’s gradients depend only on derivatives through the learned critic. This means that by improving estimation of the critic one is directly able to improve the actor gradients. Most interestingly, there have also been recent attempts to distribute updates for the DDPG algorithm, (e.g. Popov et al., 2017) and more generally in this work we build on work of (Horgan et al., 2018) for implementing distributed actors.
+
+Recently, Bellemare et al. (2017) showed that the distribution over returns, whose expectation is the value function, obeys a distributional Bellman equation. Although the idea of estimating a distribution over returns has been revisited before (Sobel, 1982; Morimura et al., 2010), Bellemare et al. demonstrated that this estimation alone was enough to achieve state-of-the-art results on the Atari 2600 benchmarks. Crucially, this technique achieves these gains by directly improving updates for the critic.
+
+# 2 BACKGROUND
+
+In this work we consider a standard reinforcement learning setting wherein an agent interacts with an environment in discrete time. At each timestep $t$ the agent makes observations $\bar { \mathbf { x } } _ { t } \in \mathcal { X }$ , takes actions ${ \bf a } _ { t } \in \mathcal A$ , and receives rewards $r ( \mathbf { x } _ { t } , \mathbf { a } _ { t } ) \in \mathbb { R }$ . Although we will in general make no assumptions about the inputs $\mathcal { X }$ , we will assume that the environments considered in this work have real-valued actions $\ b { A } = \mathbb { R } ^ { d }$ .
+
+In this standard setup, the agent’s behavior is controlled by a policy $\pi : \mathcal { X }  \mathcal { A }$ which maps each observation to an action. The state-action value function, which describes the expected return conditioned on first taking action $\mathbf { a } \in { \mathcal { A } }$ from state $\mathbf { x } \in \mathcal { X }$ and subsequently acting according to $\pi$ , is defined as
+
+$$
+\begin{array} { r } { \begin{array} { r } { Q _ { \pi } ( \mathbf { x } , \mathbf { a } ) = \mathbb { E } \Big [ \displaystyle \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r ( \mathbf { x } _ { t } , \mathbf { a } _ { t } ) \Big ] \quad \mathrm { w h e r e } \quad \mathbf { x } _ { 0 } = \mathbf { x } , \mathbf { a } _ { 0 } = \mathbf { a } , } \\ { \quad \mathbf { x } _ { t } \sim p ( \cdot | \mathbf { x } _ { t - 1 } , \mathbf { a } _ { t - 1 } ) , } \\ { \quad \mathbf { a } _ { t } = \pi ( \mathbf { x } _ { t } ) , } \end{array} } \end{array}
+$$
+
+and is commonly used to evaluate the quality of a policy. While it is possible to derive an updated policy directly from $Q _ { \pi }$ , such an approach typically requires maximizing this function with respect to a and is made complicated by the continuous action space. Instead we will consider a parameterized policy $\pi _ { \theta }$ and maximize the expected value of this policy by optimizing $J ( \theta ) \ = \ \mathbb { E } [ Q _ { \pi _ { \theta } } ( \mathbf { x } , \pi _ { \theta } ( \mathbf { \bar { x } } ) ) ]$ . By making use of the deterministic policy gradient theorem (Silver et al., 2014) one can write the gradient of this objective as”
+
+$$
+\begin{array} { r } { \nabla _ { \theta } J ( \theta ) \approx \mathbb { E } _ { \rho } \Big [ \nabla _ { \theta } \pi _ { \theta } ( \mathbf { x } ) \nabla _ { \mathbf { a } } Q _ { \pi _ { \theta } } ( \mathbf { x } , \mathbf { a } ) \big | _ { \mathbf { a } = \pi _ { \theta } ( \mathbf { x } ) } \Big ] , } \end{array}
+$$
+
+where $\rho$ is the state-visitation distribution associated with some behavior policy. Note that by letting the behavior policy differ from $\pi$ we are able to empirically evaluate this gradient using data gathered off-policy.
+
+While the exact gradient given by (2) assumes access to the true value function of the current policy, we can instead approximate this quantity with a parameterized critic $Q _ { w } ( \mathbf { x } , \mathbf { a } )$ . By introducing the Bellman operator
+
+$$
+( \mathcal { T } _ { \pi } Q ) ( \mathbf { x } , \mathbf { a } ) = r ( \mathbf { x } , \mathbf { a } ) + \gamma \mathbb { E } \big [ Q ( \mathbf { x } ^ { \prime } , \pi ( \mathbf { x } ^ { \prime } ) ) \big | \mathbf { x } , \mathbf { a } \big ] ,
+$$
+
+whose expectation is taken with respect to the next state $\mathbf { x } ^ { \prime }$ , we can minimize the temporal difference (TD) error, i.e. the difference between the value function before and after applying the Bellman update. Typically the TD error will be evaluated under separate target policy and value networks, i.e. networks with separate parameters $( \theta ^ { \prime } , w ^ { \prime } )$ , in order to stabilize learning. By taking the twonorm of this error we can write the resulting loss as
+
+$$
+L ( w ) = \mathbb { E } _ { \rho } \Big [ ( Q _ { w } ( \mathbf { x } , \mathbf { a } ) - ( \mathcal { T } _ { \pi _ { \theta ^ { \prime } } } Q _ { w ^ { \prime } } ) ( \mathbf { x } , \mathbf { a } ) ) ^ { 2 } \Big ] .
+$$
+
+In practice we will periodically replace the target networks with copies of the current network weights. Finally, by training a neural network policy using the deterministic policy gradient in (2) and training a deep neural to minimize the TD error in (4) we obtain the Deep Deterministic Policy Gradient (DDPG) algorithm (Lillicrap et al., 2016). Here a sample-based approximation to these gradients is employed by using data gathered in some replay table.
+
+# 3 DISTRIBUTED DISTRIBUTIONAL DDPG
+
+The approach taken in this work starts from the DDPG algorithm and includes a number of enhancements. These extensions, which we will detail in this section, include a distributional critic update, the use of distributed parallel actors, $N$ -step returns, and prioritization of the experience replay.
+
+First, and perhaps most crucially, we consider the inclusion of a distributional critic as introduced in Bellemare et al. (2017). In order to introduce the distributional update we first revisit (1) in terms of the return as a random variable $Z _ { \pi }$ , such that $Q _ { \pi } ( \mathbf { x } , \mathbf { a } ) = \mathbb { E } Z _ { \pi } ( \mathbf { x } , \mathbf { a } )$ . The distributional Bellman operator can be defined as
+
+$$
+( \mathcal { T } _ { \pi } Z ) ( \mathbf { x } , \mathbf { a } ) = r ( \mathbf { x } , \mathbf { a } ) + \gamma \mathbb { E } \big [ Z ( \mathbf { x } ^ { \prime } , \pi ( \mathbf { x } ^ { \prime } ) ) \big | \mathbf { x } , \mathbf { a } \big ] ,
+$$
+
+where equality is with respect to the probability law of the random variables; note that this expectation is taken with respect to distribution of $Z$ as well as the transition dynamics.
+
+While the definition of this operator looks very similar to the canonical Bellman operator defined in (3), it differs in the types of functions it acts on. The distributional variant takes functions which map from state-action pairs to distributions, and returns a function of the same form. In order to use this function within the context of the actor-critic architecture introduced above, we must parameterize this distribution and define a loss similar to that of Equation 4. We will write the loss as
+
+$$
+L ( w ) = \mathbb { E } _ { \rho } \Big [ d ( { \mathcal { T } } _ { \pi _ { \theta ^ { \prime } } } Z _ { w ^ { \prime } } ( \mathbf { x } , \mathbf { a } ) , Z _ { w } ( \mathbf { x } , \mathbf { a } ) ) \Big ]
+$$
+
+for some metric $d$ that measures the distance between two distributions. Two components that can have a significant impact on the performance of this algorithm are the specific parameterization used for $\bar { Z } _ { w }$ and the metric $d$ used to measure the distributional TD error. In both cases we will give further details in Appendix A; in the experiments that follow we will use the Categorical distribution detailed in that section.
+
+We can complete this distributional policy gradient algorithm by including the action-value distribution inside the actor update from Equation 2. This is done by taking the expectation with respect to the action-value distribution, i.e.
+
+$$
+\begin{array} { r l } & { \nabla _ { \boldsymbol { \theta } } J ( \boldsymbol { \theta } ) \approx \mathbb { E } _ { \boldsymbol { \rho } } \Big [ \nabla _ { \boldsymbol { \theta } } \pi _ { \boldsymbol { \theta } } ( \mathbf { x } ) \nabla _ { \mathbf { a } } Q _ { w } ( \mathbf { x } , \mathbf { a } ) \big | _ { \mathbf { a } = \pi _ { \boldsymbol { \theta } } ( \mathbf { x } ) } \Big ] , } \\ & { \qquad = \mathbb { E } _ { \boldsymbol { \rho } } \Big [ \nabla _ { \boldsymbol { \theta } } \pi _ { \boldsymbol { \theta } } ( \mathbf { x } ) \mathbb { E } \big [ \nabla _ { \mathbf { a } } Z _ { w } ( \mathbf { x } , \mathbf { a } ) \big ] \big | _ { \mathbf { a } = \pi _ { \boldsymbol { \theta } } ( \mathbf { x } ) } \Big ] . } \end{array}
+$$
+
+# Algorithm 1 D4PG
+
+Input: batch size $M$ , trajectory length $N$ , number of actors $K$ , replay size $R$ , exploration constant , initial learning rates $\alpha _ { 0 }$ and $\beta _ { 0 }$
+
+6: Construct the target distributions “ N´1n“0 γnri\`n \` γN Zw1 pxi\`N , πθ1 pxi\`N qq   
+7: Compute the actor and critic updates
+
+$$
+\begin{array} { l } { \displaystyle \delta _ { w } = \frac { 1 } { M } \sum _ { i } \nabla _ { w } ( R p _ { i } ) ^ { - 1 } \boldsymbol { d } ( Y _ { i } , Z _ { w } ( \mathbf { x } _ { i } , \mathbf { a } _ { i } ) ) } \\ { \displaystyle \delta _ { \theta } = \frac { 1 } { M } \sum _ { i } \nabla _ { \theta } \pi _ { \theta } ( \mathbf { x } _ { i } ) \left. \mathbb { E } [ \nabla _ { \mathbf { a } } Z _ { w } ( \mathbf { x } _ { i } , \mathbf { a } ) ] \right. _ { \mathbf { a } = \pi _ { \theta } ( \mathbf { x } _ { i } ) } } \\ { \displaystyle \quad \left. \cfrac { \mathrm { ~ \rho ~ } } { \mathrm { ~ \rho ~ } } \right. } \end{array}
+$$
+
+: Update network parameters $\theta \gets \theta + \alpha _ { t } \delta _ { \theta }$ , $w \gets w + \beta _ { t } \delta _ { w }$
+
+9: If $t = 0$ mod $t _ { \mathrm { t a r g e t } }$ , update the target networks $( \theta ^ { \prime } , w ^ { \prime } )  ( \theta , w )$
+
+0: If $t = 0$ mod $t _ { \mathrm { a c t o r s } }$ , replicate network weights to the actors
+
+11: end for   
+12: return policy parameters $\theta$
+
+# Actor
+
+1: repeat   
+2: Sample action $\mathbf { a } = \pi _ { \boldsymbol { \theta } } ( \mathbf { x } ) + \epsilon \mathcal { N } ( 0 , 1 )$   
+3: Execute action a, observe reward $r$ and state $\mathbf { x } ^ { \prime }$   
+4: Store $( { \bf x } , { \bf a } , r , { \bf x } ^ { \prime } )$ in replay   
+5: until learner finishes
+
+As before, this update can be empirically evaluated by replacing the outer expectation with a samplebased approximation.
+
+Next, we consider a modification to the DDPG update which utilizes $N$ -step returns when estimating the TD error. This can be seen as replacing the Bellman operator with an $N$ -step variant
+
+$$
+( \mathcal T _ { \pi } ^ { N } Q ) ( { \bf x } _ { 0 } , { \bf a } _ { 0 } ) = r ( { \bf x } _ { 0 } , { \bf a } _ { 0 } ) + \mathbb E \big [ \sum _ { n = 1 } ^ { N - 1 } \gamma ^ { n } r ( { \bf x } _ { n } , { \bf a } _ { n } ) + \gamma ^ { N } Q ( { \bf x } _ { N } , \pi ( { \bf x } _ { N } ) ) \big | { \bf x } _ { 0 } , { \bf a } _ { 0 } \big ]
+$$
+
+where the expectation is with respect to the $N$ -step transition dynamics. Although not used by Lillicrap et al. (2016), $N$ -step returns are widely used in the context of many policy gradient algorithms (e.g. Mnih et al., 2016) as well as Q-learning variants (Hessel et al., 2017). This modification can be applied analogously to the distributional Bellman operator in order to make use of it when updating the distributional critic.
+
+Finally, we also modify the standard training procedure in order to distribute the process of gathering experience. Note from Equations (2,4) that the actor and critic updates rely entirely on sampling from some state-visitation distribution $\rho$ . We can parallelize this process by using $K$ independent actors, each writing to the same replay table. A learner process can then sample from some replay table of size $R$ and perform the necessary network updates using this data. Additionally sampling can be implemented using non-uniform priorities $p _ { i }$ as in Schaul et al. (2016). Note that this requires the use of importance sampling, implemented by weighting the critic update by a factor of $1 { \bar { / } } R p _ { i }$ . We implement this procedure using the ApeX framework (Horgan et al., 2018) and refer the reader there for more details.
+
+Algorithm pseudocode for the D4PG algorithm which includes all the above-mentioned modifications can be found in Algorithm 1. Here the actor and critic parameters are updated using stochastic gradient descent with learning rates, $\alpha _ { t }$ and $\beta _ { t }$ respectively, which are adjusted online using ADAM (Kingma & Ba, 2015). While this pseudocode focuses on the learning process, also shown is pseudocode for actor processes which in parallel fill the replay table with data.
+
+![](images/cad84abe7c40d3060704f8949c7b9a752da8327f6de12c18aba43592d48ab6aa.jpg)  
+Figure 1: Architectural variants used for each domain. The left-most set illustrates the actor network and critic torso used for the standard control and manipulation domains. The full critic architecture is completed by feeding the output of the critic torso into a relevant distribution, e.g. the categorical distribution, as defined in Section A. The right half of the figure similarly illustrates the architecture used by the parkour domains.
+
+# 4 RESULTS
+
+In this section we describe the performance of the D4PG algorithm across a variety of continuous control tasks. To do so, in each environment we run our learning procedure and periodically snapshot the policy in order to test it without exploration noise. We will primarily be interested in the performance as a function of wall clock time, however we will also examine the data efficiency. Most interestingly, from a scientific perspective, we also perform a number of ablations which individually remove components of the D4PG algorithm in order to determine their specific contributions.
+
+First, we experiment with and without distributional updates. In this setting we focus on use of a categorical distribution as we found in preliminary experiments that the use of a mixture of Gaussians performed worse and was less stable with respect to hyperparameter values across different tasks; a selection of these runs can be found in Appendix C. Across all tasks—except for one which we will introduce later—we use 51 atoms for the categorical distribution. In what follows we will refer to non-distributional variants of this algorithm as Distributed DDPG (D3PG).
+
+Next, we consider prioritized and non-prioritized versions of these algorithm variants. For the nonprioritized variants, transitions are sampled from replay uniformly. For prioritized variants we use the absolute TD-error to sample from replay in the case of D3PG, and for D4PG we use the absolute distributional TD-error as described in Section A. We also vary the trajectory length $N \in \{ 1 , 5 \}$ .
+
+In all experiments we use a replay table of size $R = 1 \times 1 0 ^ { 6 }$ and only consider behavior policies which add fixed Gaussian noise $\dot { \epsilon } { \mathcal N } ( 0 , 1 )$ to the current online policy; in all experiments we use a value of $\epsilon = 0 . 3$ . We experimented with correlated noise drawn from an Ornstein-Uhlenbeck process, as suggested by (Lillicrap et al., 2016), however we found this was unnecessary and did not add to performance. For all algorithms we initialize the learning rates for both actor and critic updates to the same value. In the next section we will present a suite of simple control problems for which this value corresponds to $\alpha _ { 0 } = \beta _ { 0 } = 1 \times 1 0 ^ { - 4 }$ ; for the following, harder problems we set this to a smaller value of $\alpha _ { 0 } ^ { \mathrm { { - } } } = \beta _ { 0 } = 5 \times 1 0 ^ { - 5 }$ . Similarly for the control suite we utilize a batch size of $M = 2 5 6$ and for all subsequent problems we will increase this to $M = 5 1 2$ .
+
+# 4.1 STANDARD CONTROL SUITE
+
+We first consider evaluating performance on a number of simple, physical control tasks by utilizing a suite of benchmark tasks (Tassa et al., 2018) developed in the MuJoCo physics simulator (Todorov et al., 2012). Each task is run for exactly 1000 steps and provides either an immediate dense reward $r _ { t } \in [ 0 , 1 ]$ or sparse reward $r _ { t } \in \{ 0 , 1 \}$ depending on the particular task. For each domain, the inputs presented to the agent consist of reasonably low-dimensional observations, many consisting of physical state, joint angles, etc. These observations range between 6 and 60 dimensions, however note that the difficulty of the task is not immediately associated with its dimensionality. For example the acrobot is one of the lowest dimensional tasks in this suite which, due to its level of controllability, can prove much more difficult to learn than other, higher dimensional tasks. For an illustration of these domains see Figure 9; see Appendix D for more details.
+
+![](images/08ebd135e1f61e73ac160cea282b92bfe75334a0f4699b20be1ed73f0dd625e9.jpg)  
+Figure 2: Experimental results across domains in the control suite.
+
+For algorithms in these experiments we consider actor and critic architectures of the form given in Figure 1 and for each experiment we use $K = 3 2$ actors. Figure 2 shows the performance of D4PG and its various ablations across the entire suite of control tasks. This set of plots is quite busy, however it serves as a broad set of tasks with which we can obtain a general idea of the algorithms performance. Later experiments on harder domains look more closely at the difference between algorithms. Here we also compare against the canonical (non-distributed) DDPG algorithm as a baseline, shown as a dotted black line. This removes all the enhancements proposed in this paper, and we can see that except on the simplest domain, Cartpole (Swingup), it performs worse than all other methods. This performance disparity worsens as we increase the difficulty of tasks, and hence for further experiments we will drop this line from the plot.
+
+Next, across all tasks we see that the best performance is obtained by the full D4PG algorithm (shown in purple and bold). Here we see that the longer unroll length of $N = 5$ is uniformly better (we show these as solid lines), and in particular we sometimes see for both D3PG and D4PG that an unroll length of $N = 1$ (shown as dashed lines) can occasionally result in instability. This is especially apparent in the Cheetah (Walk) and Cartpole (Swingup Sparse) tasks.
+
+The next biggest gain is arguably due to the inclusion of the distributional critic update, where it is particularly helpful on the hardest tasks e.g. Humanoid (Run) and Acrobot. The manipulator is also quite difficult among this suite of tasks, and here we see that the inclusion of the distributional update does not help as much as in other tasks, although note that here the D3PG and D4PG variants obtain approximately the same performance. As far as the use of prioritization is concerned, it does not appear to contribute significantly to the performance of D4PG. This is not the case for D3PG, however, which on many tasks is helped significantly by the inclusion of prioritization.
+
+![](images/9ed7390ca0bd378d7d53a8914dc484884e54d52e15b51e221f3ec26d9056fe52.jpg)  
+Figure 3: Experimental results for tasks in the manipulation domain.
+
+# 4.2 MANIPULATION
+
+Next, we consider a set of tasks designed to highlight the ability of the D4PG agent to learn dexterous manipulation. Tasks of this form can prove difficult for many reasons, most notably the higher dimensionality of the control task, intermittent contact dynamics, and potential under-actuation of the manipulator.
+
+Here we use a simulated hand model implemented within MuJoCo, consisting of 13 actuators which control 22 degrees of freedom. For these experiments the wrist site is attached to a fixed location in space, about which it is allowed to rotate axially. In particular this allows the hand to pick up objects, rotate into a palm-up position, and manipulate them. We first consider a task in which a cylinder is dropped onto the hand from a random height, and the goal of the task is to catch the falling cylinder. The next task requires the agent to pick up an object from the tabletop and then maneuver it to a target position and orientation. The final task is one wherein a broad cylinder must be rotated inhand in order to match a target orientation. See Appendix E for further details regarding both the model and the tasks. For these tasks we use the same network architectures as in the previous section as well as $K = 6 4$ actors.
+
+In Figure 3 we again compare the D4PG algorithm against ablations of its constituent components. Here we split the algorithms between $N = 1$ in the top row and $N = 5$ in the bottom row, and in particular we can see that across all algorithms $N = 5$ is uniformly better. For all tasks, the full D4PG algorithm performs either at the same level or better than other ablations; this is particularly apparent in the $N = 5$ case. Overall the use of priorization never seems to harm D4PG, however it does appear to be of limited additional value. Interestingly this is not necessarily the case with the D3PG variant (i.e. without distributional updates). Here we can see that prioritization sometimes harms the performance of D3PG, and this is very readily seen in the $N = 1$ case where the algorithm can either become unstable, or in the case of the Pickup and Orient task it completely fails to learn.
+
+# 4.3 PARKOUR
+
+Finally, we consider the parkour domain introduced by (Heess et al., 2017). In this setting the agent controls a simplified robotic walker which is rewarded for forward movement, but is impeded by a number of randomly sampled obstacles; see Figure 4 for a visualization and refer to the earlier work for further details. The first of our experiments considers a two-dimensional walker, i.e. a domain in which the walker is allowed to move horizontally and vertically, but is constrained to a fixed depth position. In this domain the obstacles presented to the agent include gaps in the floor surface, barriers it must jump over, and platforms that it can either run over or underneath. The agent is presented with proprioceptive observations $\mathbf { x } _ { \mathrm { p r o p r i o } } \in \mathbb { R } ^ { 1 9 }$ corresponding to the angles of its limbs and other functions of these quantities. It is also given access to observations $\mathbf { x } _ { \mathrm { t e r r a i n } } \in \mathbb { R } ^ { 1 0 1 }$ which includes features such as a depth map of the upcoming terrain, etc. In order to accommodate these inputs we utilize a network architecture as specified in Figure 1. In particular we make use of a stack of feed-forward layers which process the terrain information to reduce it to a smaller number of hidden units before concatenating with the proporioceptive information for further processing. The actions in this domain take the form of torque controls $\mathbf { a } \in \mathbb { R } ^ { 6 }$ .
+
+![](images/7eb78bca7db3ce270e23c976b1305e4c3d33378edef9e29e2b96058c047028ae.jpg)  
+Figure 4: Example frames taken from trained agents running in the two parkour domains.
+
+In order to examine the performance of the D4PG algorithm in this setting we consider the ablations of the previous sections and we have further introduced a PPO baseline as utilized in the earlier paper of (Heess et al., 2017). For all algorithms, including PPO, we use $K = 6 4$ actors. These results are shown in Figure 5 in the top row. As before we examine the performance separately for $N = 1$ and $N = 5$ , and again we see that the higher unroll length results in better performance. Note that we show the PPO baseline on both plots for consistency, but in both plots this is the same algorithm, with settings proposed in the earlier paper and unrolls of length 50.
+
+Here we again see a clear delineation and clear gains for each of the other algorithm components. The biggest gain comes from the inclusion of the distributional update, which we can see by comparing the non-prioritized D3PG/D4PG variants. We see marginal benefit to using prioritization for D3PG, but this gain disappears when we consider the distributional update. Finally, we can see when comparing to the PPO baseline that this algorithm compares favorably to D3PG in the case of $N = 1$ , however is outperformed by D4PG; when $N = 5$ all algorithms outperform PPO.
+
+Next, in the plots shown in Figure 5 on the bottom row we also consider the performance not just in terms of training time, but also in terms of the sample complexity. In order to do so we plot the performance of each algorithm versus the number of actor steps, i.e. the quantity of transitions collected. This is perhaps more favorable to PPO, as the parallel actors considered in this work are not necessarily tuned for sample efficiency. Here we see that PPO is able to out-perform the non-prioritized version of D3PG, and early on in training is favorable compared to the prioritized version, although this trails off. However, we still see significant performance gains by utilizing the distributional updates, both in a prioritized and non-prioritized setting. Interestingly we see that the use of prioritization does not gain much, if any over the non-prioritized D4PG version. Early in the trajectory for $N \ = \ 5$ , in fact, we see that the non-prioritized D4PG exhibits better performance, however later these performance curves level out. With respect to wall-clock time these small differences may be due to small latencies in the scheduling of different runs, as we see that this difference is less for the plot with respect to actor steps.
+
+Finally we consider a humanoid walker which is able to move in all three dimensions. The obstacles in this domain consist of gaps in the floor, barriers that must be jumped over, and walls with gaps that allow the agent to run through. For this experiment we utilize the same network architecture as in the previous experiment, except now the observations are of size $\mathbf { x } _ { \mathrm { p r o p r i o } } \in \mathbb { R } ^ { 7 9 }$ and $\mathbf { X } _ { \mathrm { t e r r a i n } } \in \mathbb { R } ^ { 4 6 1 }$ . Again actions are torque controls, but in 21 dimensions. In this task we also increased the number of atoms for the categorical distribution from 51 to 101. This change increases the level of resolution for the distribution in order to keep the resolution roughly consistent with other tasks. This is a much higher dimensional problem than the previous parkour task with a significantly more difficult control task: the walker is more unstable and there are many more ways for the agent to fail than in the previous experiment. The results for this particular domain are displayed in Figure 6, and here we concentrate on performance as a function of wall-clock time, restricted to the previously best performing roll-out length of $N = 5$ . In this setting we see a clear delineation between first the PPO results which are the poorest performing, the D3PG results where the prioritized version has a slight edge, and finally the D4PG results. Interestingly for D4PG we again see as in the twodimensional walker case, the use of prioritization seems to have no benefit, with both versions have almost identical performance curves; in fact the performance here is perhaps even closer than that of the previous set of experiments.
+
+![](images/d04d91404dd0fff45753b756171e9fbf5a79eed30c4d0c0aec9509c3e3d92ef5.jpg)  
+Figure 5: Experimental results for the two-dimensional (walker) parkour domain when compared first versus wall-clock time (top) and versus actor steps (bottom).
+
+![](images/63b94a5a33a744bd986ec42c5dac028ce8f4ea2cc594bfe8337f63f49a72c585.jpg)  
+Figure 6: Experimental results for the three-dimensional (humanoid) parkour domain.
+
+# 5 DISCUSSION
+
+In this work we introduced the D4PG, or Distributed Distributional DDPG, algorithm. Our main contributions include the inclusion of a distributional updates to the DDPG algorithm, combined with the use of multiple distributed workers all writing into the same replay table. We also consider a number of other, smaller changes to the algorithm. All of these simple modifications contribute to the overall performance of the D4PG algorithm; the biggest performance gain of these simple changes is arguably the use of $N$ -step returns. Interestingly we found that the use of priority was less crucial to the overall D4PG algorithm especially on harder problems. While the use of prioritization was definitely able to increase the performance of the D3PG algorithm, we found that it can also lead to unstable updates. This was most apparent in the manipulation tasks.
+
+Finally, as our results can attest, the D4PG algorithm is capable of state-of-the-art performance on a number of very difficult continuous control problems.
+
+# REFERENCES
+
+Marc G Bellemare, Will Dabney, and Remi Munos. A distributional perspective on reinforcement ´ learning. In International Conference on Machine Learning, pp. 449–458, 2017.
+
+Peter W Glynn. Likelihood ratio gradient estimation for stochastic systems. Communications of the ACM, 33(10):75–84, 1990.
+
+Roland Hafner and Martin Riedmiller. Reinforcement learning in feedback control. Machine Learning, 84(1-2):137–169, jul 2011. doi: 10.1007/s10994-011-5235-x.
+
+Nicolas Heess, Dhruva TB, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, and David Silver. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017.
+
+Matteo Hessel, Joseph Modayil, Hado Van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. arXiv preprint arXiv:1710.02298, 2017.
+
+Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado van Hasselt, and David Silver. Distributed prioritized experience replay. International Conference on Learning Representations, 2018.
+
+Matthew S. Johannes, John D. Bigelow, James M. Burck, Stuart D. Harshbarger, Matthew V. Kozlowski, and Thomas Van Doren. An overview of the developmental process for the modular prosthetic limb. Johns Hopkins APL Technical Digest (Applied Physics Laboratory), 30(3):207– 216, 2011.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.
+
+Vikash Kumar and Emanuel Todorov. MuJoCo HAPTIX: A virtual reality system for hand manipulation. In IEEE-RAS International Conference on Humanoid Robots, volume 2015-December, pp. 657–663. IEEE, 2015. doi: 10.1109/HUMANOIDS.2015.7363441.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. In International Conference on Learning Representations, 2016.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, 2016.
+
+Tetsuro Morimura, Hirotaka Hachiya, Masashi Sugiyama, Toshiyuki Tanaka, and Hisashi Kashima. Parametric Return Density Estimation for Reinforcement Learning. In Proceedings of the Conference on Uncertainty in Artificial Intelligence (UAI), 2010.
+
+Jan Peters and Stefan Schaal. Natural actor-critic. Neurocomputing, 71(7):1180–1190, 2008.
+
+Ivaylo Popov, Nicolas Heess, Timothy Lillicrap, Roland Hafner, Gabriel Barth-Maron, Matej Vecerik, Thomas Lampe, Yuval Tassa, Tom Erez, and Martin Riedmiller. Data-efficient deep reinforcement learning for dexterous manipulation. arXiv preprint arXiv:1704.03073, 2017.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. International Conference on Learning Representations, 2016.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1889–1897, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic policy gradient algorithms. In International Conference on Machine Learning, 2014.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+Matthew J. Sobel. The variance of discounted markov decision processes. Journal of Applied Probability, 19(04):794–802, 1982.
+
+Richard S Sutton, David A McAllester, Satinder P Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In Advances in Neural Information Processing Systems, pp. 1057–1063, 2000.
+
+Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, Timothy Lillicrap, and Martin Riedmiller. Deepmind control suite, 2018. URL http://arxiv.org/abs/1801.00690.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.
+
+George E Uhlenbeck and Leonard S Ornstein. On the theory of the brownian motion. Physical review, 36(5):823, 1930.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
+
+![](images/98849cea38df35b1083c9397e9360d4621388c0e1e48c5ba5ff1137a9294a6f4.jpg)  
+Figure 7: Output layers corresponding to different distribution parameterizations. From left to right these include the Categorical, Mixture of Gaussians, and finally the standard scalar value function.
+
+# A DISTRIBUTIONS AND LOSSES
+
+In this section we consider two potential parameterized distributions for D4PG. Parameterized distributions, in this framework, are implemented as a neural network layer mapping the output of the critic torso (see Figure 1) to the parameters of a given distribution (e.g. mean and variance). In what follows we will detail the distributions and their corresponding losses.
+
+Categorical Following Bellemare et al. (2017), we first consider the categorical parameterization, a layer whose parameters are the logits $\omega _ { i }$ of a discrete-valued distribution defined over a fixed set of atoms $z _ { i }$ . This distribution has hyperparameters for the number of atoms $\ell$ , and the bounds on the support $( V _ { \mathrm { m i n } } , V _ { \mathrm { m a x } } )$ . Given these, $\begin{array} { r } { \dot { \Delta } = \frac { { { V _ { \mathrm { { m a x } } } } - { V _ { \mathrm { { m i n } } } } } } { { \ell - 1 } } } \end{array}$ corresponds to the distance between atoms, and $z _ { i } = V _ { \operatorname* { m i n } } + i \Delta$ gives the location of each atom. We can then define the action-value distribution as
+
+$$
+Z = z _ { i } \quad \mathrm { w . p . } \quad p _ { i } \mathrm { \infty } \exp \{ \omega _ { i } \} .
+$$
+
+Observe that this distributional layer simply corresponds to a linear layer from the critic torso to the logits $\omega$ , followed by a softmax activation (see Figure 7, left).
+
+However, this distribution is not closed under the Bellman operator defined earlier, due to the fact that adding and scaling these values will no longer lie on the support defined by the atoms. This support is explicitly defined by the $( V _ { \mathrm { m i n } } , V _ { \mathrm { m a x } } )$ hyperparameters. As a result we instead use a projected version of the distributional Bellman operator (Bellemare et al., 2017); see Appendix B for more details. Letting $p ^ { \prime }$ be the probabilities of the projected distributional Bellman operator $\Phi \mathcal { T } _ { \pi }$ applied to some target distribution $Z _ { \mathrm { t a r g e t } }$ , we can write the loss in terms of the cross-entropy
+
+$$
+d ( \Phi { \mathcal { T } } _ { \pi } Z _ { \mathrm { t a r g e t } } , Z ) = \sum _ { i = 0 } ^ { \ell - 1 } p _ { i } ^ { \prime } { \frac { \exp \{ \omega _ { i } \} } { \sum _ { j } \exp \{ \omega _ { j } \} } } .
+$$
+
+Mixture of Gaussians We can also consider parameterizing the action-value distribution using a mixture of Gaussians; here the random variable $Z$ has density given by
+
+$$
+p ( z ) \propto \sum _ { i = 0 } ^ { \ell - 1 } \omega _ { i } \mathcal { N } ( z | \mu _ { i } , \sigma _ { i } ^ { 2 } ) .
+$$
+
+Thus, the distribution layer maps, through a linear layer, from the critic torso to the mixture weight $\omega _ { i }$ , mean $\mu _ { i }$ , and variance $\sigma _ { i } ^ { 2 }$ for each mixture component $0 \leqslant i \leqslant \ell - 1$ (see Figure 7, center). We can then specify a loss corresponding to the cross-entropy portion of the KL divergence between two distributions. Given a sample transition $( { \bf x } , { \bf a } , r , { \bf x } ^ { \prime } )$ we can take samples from the target density $z _ { j } \sim p _ { \mathrm { t a r g e t } }$ and approximate the cross-entropy term using
+
+$$
+d ( { \mathcal { T } } _ { \pi } Z _ { \mathrm { t a r g e t } } , Z ) \approx \sum _ { j } \log p ( r + \gamma z _ { j } ) .
+$$
+
+# B CATEGORICAL PROJECTION OPERATOR
+
+The categorical parameterized distribution has finite support. Thus, the result of applying the distributional Bellman equation will generally not coincide with this support. Therefore, some projection
+
+![](images/a94f731f7c5c5e8b7d5572d94a0c96378c6cec861fd576821785439adecadd9e.jpg)  
+Figure 8: Results for using a mixture of Gaussians distribution on select control suite tasks. Shown are two learning rates as denoted in the legends as well as Categorical.
+
+step is required before minimizing the cross-entropy. The categorical projection of Bellemare et al.ř (2017) is given by $\begin{array} { r } { ( \Phi p ) _ { i } = \sum _ { j = 0 } ^ { \ell - 1 } \bar { h } _ { z _ { i } } ( z _ { j } ) p _ { j } } \end{array}$ , $\forall i$ , where $h$ is a piecewise linear ‘hat’ function,
+
+$$
+h _ { z _ { i } } ( z ) = \left\{ \begin{array} { l l } { 1 } & { z \leqslant V _ { \mathrm { m i n } } \mathrm { a n d } i = 0 , } \\ { \frac { z - z _ { i - 1 } } { z _ { i } - z _ { i - 1 } } } & { \mathrm { ~ f o r ~ } z _ { i - 1 } \leqslant z \leqslant z _ { i } , } \\ { \frac { z _ { i + 1 } - z } { z _ { i + 1 } - z _ { i } } } & { \mathrm { ~ f o r ~ } z _ { i } \leqslant z \leqslant z _ { i + 1 } , } \\ { 1 } & { z \geqslant V _ { \mathrm { m a x } } \mathrm { a n d } i = \ell - 1 . } \end{array} \right.
+$$
+
+# C MIXTURES OF GAUSSIANS CONTROL SUITE RESULTS
+
+In Figure 8 we display results of running D4PG on a selection of control suite tasks using a mixture of Gaussians output distribution for two choices of learning rates. Here the distributional TD loss is minimized using the sample-based KL introduced earlier. While this is definitely a technique that is worth further exploration, we found in initial experiments that this choice of distribution underperformed the Categorical distribution by a fair margin. This lends further credence to the choice of distribution made in (Bellemare et al., 2017).
+
+# D CONTROL SUITE DETAILS
+
+In this section we provide further details for the control suite domains. In particular see Figure 9 for images of the control suite tasks. The physics state $s$ , action $\mathcal { A }$ , and observation $\mathcal { X }$ dimensionalities for each task are provided in Table 1.
+
+# E MANIPULATION DETAILS
+
+For the dexterous manipulation tasks we used a simulated model of the Johns Hopkins Modular Prosthetic Limb hand (Johannes et al., 2011) implemented in MuJoCo (Kumar & Todorov, 2015). This anthropomorphic hand has a total of 22 degrees of freedom (19 in the fingers, 3 in the wrist), which are driven by a set of 13 position actuators (PD-controllers). The underactuation of the hand is due to coupling between some of the finger joints. For these experiments the wrist was positioned in a fixed location above a table, such that rotation and flexion about the wrist joints allowed the hand to pick up objects from the table, rotate into a palm-up position, and then manipulate them.
+
+We focused on a set of three tasks where the agent must learn to manipulate a cylindrical object (Figure 10). In each of these tasks, the observations contain the positions and velocities of all of the joints in the hand, the current position targets for the actuators in the hand, the position and quaternion of the object being manipulated, and its translational and rotational velocities. The observations given in each task are summarized in Table 2. The agent’s actions are increments applied to the position targets for the actuators.
+
+![](images/80e5fa3b2cbfcdd859c221734df8e61ca5e7ff5eb1e17b3af4945eba95b98417.jpg)
+
+Figure 9: Control Suite domains used for benchmarking. Top: acrobot, cartpole, cheetah, finger, fish, hopper. Bottom: humanoid, manipulator, pendulum, reacher, swimmer6, swimmer15, walker.   
+Table 1: Domains and tasks in the Control Suite.   
+
+<table><tr><td>Domain</td><td>Task</td><td>|A</td><td>|S</td><td>x</td></tr><tr><td>acrobot</td><td>swingup swingup_sparse</td><td>1</td><td>4</td><td>6</td></tr><tr><td>cartpole</td><td>swingup swingup_sparse</td><td>1</td><td>4</td><td>5</td></tr><tr><td>cheetah</td><td>walk</td><td>6</td><td>18</td><td>17</td></tr><tr><td>finger</td><td>turn_easy turn_hard</td><td>2</td><td>6</td><td>12</td></tr><tr><td>fish</td><td>upright swim</td><td>5</td><td>27</td><td>24</td></tr><tr><td>hopper</td><td>stand</td><td>4</td><td>14</td><td>15</td></tr><tr><td>humanoid</td><td>stand walk run</td><td>21</td><td>55</td><td>67</td></tr><tr><td>manipulator</td><td>bring_ball</td><td>2</td><td>22</td><td>37</td></tr><tr><td>swimmer</td><td>swimmer6 swimmer15</td><td>5 14</td><td>16 34</td><td>25 61</td></tr></table>
+
+Table 2: Observation components given in each of the manipulation tasks, and their corresponding dimensionalities. Here $\mathrm { \ s i n _ { z } }$ , $\mathrm { c o s } _ { \mathrm { z } }$ refers to the sine and cosine of the target frame’s angle of rotation about the $z$ -axis.   
+
+<table><tr><td rowspan="2" colspan="3"></td><td colspan="3">Task</td></tr><tr><td>Catch</td><td>Pick-up-and-orient</td><td>Rotate-in-hand</td></tr><tr><td rowspan="3">Hand</td><td> joint positions</td><td>22</td><td>√</td><td>√</td><td>√</td></tr><tr><td> joint velocities</td><td>22</td><td>√</td><td>√</td><td>√</td></tr><tr><td> actuator targets</td><td>13</td><td>√</td><td>√</td><td>√</td></tr><tr><td rowspan="3">Object</td><td>position</td><td>3</td><td>√</td><td>√</td><td>√</td></tr><tr><td>quaternion</td><td>4</td><td>√</td><td>√</td><td>&lt;</td></tr><tr><td>velocity</td><td>6</td><td>√</td><td>√</td><td>√</td></tr><tr><td rowspan="3">Target</td><td>position</td><td>3</td><td>1</td><td>√</td><td>1</td></tr><tr><td>quaternion</td><td>4</td><td>1</td><td>√</td><td>1</td></tr><tr><td>sinz, COSz</td><td>2</td><td>1</td><td>1</td><td>√</td></tr><tr><td>Total</td><td></td><td></td><td>70</td><td>77</td><td>72</td></tr></table>
+
+![](images/1fc22329665ff2bb15967cf6a63a440ed1267ae494ff61f9c0a0b4b3ea5e87ee.jpg)  
+Figure 10: Sequences of frames illustrating the dexterous manipulation tasks we attempt to solve using D4PG. Top to bottom: ‘catch’, ‘pick-up-and-orient’, ‘rotate-in-hand’. The translucent objects shown in ‘pick-up-and-orient’ and ‘rotate-in-hand’ represent the goal states.
+
+In the ‘catch’ task the agent must learn to catch a falling object before it strikes the table below. The position, height, and orientation of the object are randomly initialized at the start of each episode. The reward is given by
+
+$$
+r = \psi ( \mathrm { p a l m } _ { \mathrm { h e i g h t } } - \mathrm { o b j } _ { \mathrm { h e i g h t } } ; c , m )
+$$
+
+where $\psi ( \epsilon ; c , m )$ is a soft indicator function similar to one described by Hafner & Riedmiller (2011)
+
+$$
+\psi ( \epsilon ; c , m ) = \left\{ { \begin{array} { l l } { 1 - \operatorname { t a n h } ( { \frac { w } { m } } \epsilon ) ^ { 2 } } & { { \mathrm { i f ~ } } \epsilon > c , } \\ { 1 } & { { \mathrm { o t h e r w i s e . } } } \end{array} } \right.
+$$
+
+Here $w = \operatorname { t a n h } ^ { - 1 } ( { \sqrt { 0 . 9 5 } } )$ , and the tolerance $c$ and margin $m$ parameters are $0 \mathrm { c m }$ and $5 \mathrm { c m }$ respectively. Contact between the object and the table causes the current episode to terminate immediately with no reward, otherwise it will continue until a 500 step limit is reached.
+
+In the ‘pick-up-and-orient’ task, the agent must pick up a cylindrical object from the table and maneuver it into a target position and orientation. Both the initial position and orientation of the object, and the position and orientation of the target are randomized between episodes. The reward function consists of two additive components that depend on the distance from the object to the target position, and on the angle between the $z$ -axes of the object and target body frames
+
+$$
+r = 0 . 5 \psi ( | | \mathrm { o b j } _ { \mathrm { p o s } } - \mathrm { o b j } _ { \mathrm { p o s } } ^ { \mathrm { t a r g e t } } | | _ { 2 } ; c _ { \mathrm { p o s } } , m _ { \mathrm { p o s } } ) ( 1 + \psi ( \cos ^ { - 1 } ( \mathrm { o b j } _ { \mathrm { z a x i s } } \cdot \mathrm { o b j } _ { \mathrm { z a x i s } } ^ { \mathrm { t a r g e t } } ) ; c _ { \mathrm { o r i } } , m _ { \mathrm { o r i } } ) )
+$$
+
+where $c _ { \mathrm { p o s } } { = } 1$ cm, $m _ { \mathrm { p o s } } { = } 5 \mathrm { c m }$ , $c _ { \mathrm { o r i } } { = } 5 ^ { \circ }$ , $m _ { \mathrm { o r i } } { = } 1 0 ^ { \circ }$ . Note that the distance-dependent component of the reward multiplicatively gates the orientation component. This helps to encourage the agent to pick up the object before attempting to orient it to match the target. Each episode has a fixed duration of 500 steps.
+
+Finally, in the ‘rotate-in-hand’ task the agent begins with a broad cylinder in its palm, and must rotate it axially in order to match a moving target. This requires dynamically forming and breaking contacts with the object being manipulated. The target angle is initialized uniformly, and then incremented on each time step using temporally correlated noise drawn from an Ornstein-Uhlenbeck process $\scriptstyle \sigma = 0 . 0 2 5 ^ { \circ }$ , $\scriptstyle \theta = 0 . 0 1$ ; Uhlenbeck & Ornstein 1930). The reward consists of two multiplicative components
+
+$$
+r = \psi { \bigl ( } \cos ^ { - 1 } ( \mathrm { o b j } _ { \mathrm { y a x i s } } | \times \mathrm { y , ~ o b j } _ { \mathrm { y a x i s } } ^ { \mathrm { t a r g e t } } | \times \mathrm { y } ) { \bigr ) } ; c _ { \mathrm { r o t } } , m _ { \mathrm { r o t } } { \bigr ) } \psi { \bigl ( } \cos ^ { - 1 } ( \mathrm { o b j } _ { \mathrm { z a x i s } } , \mathrm { o b j } _ { \mathrm { z a x i s } } ^ { \mathrm { t a r g e t } } ) ; c _ { \mathrm { o r i } } , m _ { \mathrm { o r i } } { \bigr ) }
+$$
+
+where $c _ { \mathrm { r o t } } { = } 5 ^ { \circ }$ , $m _ { \mathrm { r o t } } { = } 4 0 ^ { \circ }$ , $c _ { \mathrm { o r i } } { = } 4 5 ^ { \circ }$ , $m _ { \mathrm { o r i } } { = } 4 5 ^ { \circ }$ , and $| | \mathrm { x y }$ denotes projection onto the global $x y$ plane. The first component provides an incentive to match the axial rotation of the target, and the second component penalizes the agent for allowing the orientation of the cylinder’s long axis to deviate too far from that of the target. The maximum episode duration is 1000 steps, with early termination if the object makes contact with the table.

parse/train/SyZipzbCb/SyZipzbCb_content_list.json

@@ -0,0 +1,1800 @@
+[
+    {
+        "type": "text",
+        "text": "DISTRIBUTED DISTRIBUTIONAL DETERMINISTIC POLICY GRADIENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            761,
+            143
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Barth-Maron˚, Matthew W. Hoffman˚, David Budden, Will Dabney, Dan Horgan, Dhruva TB, Alistair Muldal, Nicolas Heess, Timothy Lillicrap DeepMind   \nLondon, UK   \n{gabrielbm, mwhoffman, budden, wdabney, horgan, dhruvat, alimuldal, heess, countzero}@google.com ",
+        "bbox": [
+            184,
+            167,
+            720,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            285,
+            544,
+            300
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This work adopts the very successful distributional perspective on reinforcement learning and adapts it to the continuous control setting. We combine this within a distributed framework for off-policy learning in order to develop what we call the Distributed Distributional Deep Deterministic Policy Gradient algorithm, D4PG. We also combine this technique with a number of additional, simple improvements such as the use of $N$ -step returns and prioritized experience replay. Experimentally we examine the contribution of each of these individual components, and show how they interact, as well as their combined contributions. Our results show that across a wide variety of simple control tasks, difficult manipulation tasks, and a set of hard obstacle-based locomotion tasks the D4PG algorithm achieves state of the art performance. ",
+        "bbox": [
+            233,
+            316,
+            764,
+            462
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            336,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The ability to solve complex control tasks with high-dimensional input and action spaces is a key milestone in developing real-world artificial intelligence. The use of reinforcement learning to solve these types of tasks has exploded following the work of the Deep Q Network (DQN) algorithm (Mnih et al., 2015), capable of human-level performance on many Atari games. Similarly, ground breaking achievements have been made in classical games such as Go (Silver et al., 2016). However, these algorithms are restricted to problems with a finite number of discrete actions. ",
+        "bbox": [
+            174,
+            520,
+            823,
+            599
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In control tasks, commonly seen in the robotics domain, continuous action spaces are the norm. For algorithms such as DQN the policy is only implicitly defined in terms of its value function, with actions selected by maximizing this function. In the continuous control domain this would require either a costly optimization step or discretization of the action space. While discretization is perhaps the most straightforward solution, this can prove a particularly poor approximation in highdimensional settings or those that require finer grained control. Instead, a more principled approach is to parameterize the policy explicitly and directly optimize the long term value of following this policy. ",
+        "bbox": [
+            174,
+            607,
+            823,
+            713
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work we consider a number of modifications to the Deep Deterministic Policy Gradient (DDPG) algorithm (Lillicrap et al., 2015). This algorithm has several properties that make it ideal for the enhancements we consider, which is at its core an off-policy actor-critic method. In particular, the policy gradient used to update the actor network depends only on a learned critic. This means that any improvements to the critic learning procedure will directly improve the quality of the actor updates. In this work we utilize a distributional (Bellemare et al., 2017) version of the critic update which provides a better, more stable learning signal. Such distributions model the randomness due to intrinsic factors, among these is the inherent uncertainty imposed by function approximation in a continuous environment. We will see that using this distributional update directly results in better gradients and hence improves the performance of the learning algorithm. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            852
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Due to the fact that DDPG is capable of learning off-policy it is also possible to modify the way in which experience is gathered. In this work we utilize this fact to run many actors in parallel, all feeding into a single replay table. This allows us to seamlessly distribute the task of gathering experience, which we implement using the ApeX framework (Horgan et al., 2018). This results in significant savings in terms of wall-clock time for difficult control tasks. We will also introduce a number of small improvements to the DDPG algorithm, and in our experiments will show the individual contributions of each component. Finally, this algorithm, which we call the Distributed Distributional DDPG algorithm (D4PG), obtains state-of-the-art performance across a wide variety of control tasks, including hard manipulation and locomotion tasks. ",
+        "bbox": [
+            176,
+            858,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            184
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            199,
+            326,
+            213
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Historically, estimation of the policy gradient has relied on the likelihood ratio trick (see e.g. Glynn, 1990), more commonly known as REINFORCE (Williams, 1992) in the reinforcement learning community. Modern variants of these so-called “vanilla” policy gradient methods include the work of (Mnih et al., 2016). Alternatively, one can consider second-order or “natural” variants of this objective, a set of techniques that include e.g. the Natural Actor-Critic (Peters & Schaal, 2008) and Trust Region Policy Optimization (TRPO) (Schulman et al., 2015) algorithms. More recently Proximal Policy Optimization (PPO) (Schulman et al., 2017), which can be seen as an approximation of TRPO, has proven very effective in large-scale distributed settings. Often, however, algorithms of this form are restricted to learning on-policy, which can limit both the amount of data-reuse as well as restrict the types of policies that are used for exploration. ",
+        "bbox": [
+            174,
+            224,
+            825,
+            358
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Deterministic Policy Gradient (DPG) algorithm (Silver et al., 2014) upon which this work is based starts from a different set of ideas, namely the policy gradient theorem of (Sutton et al., 2000). The deterministic policy gradient theorem builds upon this earlier approach, but replaces the stochastic policy with one that includes no randomness. This approach is particularly important because it had previously been believed that the deterministic policy gradient did not exist in a model-free setting. The form of this gradient is also interesting in that it does not require one to integrate over the action space, and hence may require less samples to learn. DPG was later built upon by Lillicrap et al. (2015) who extended this algorithm and made use of a deep neural network as the function approximator, primarily as a mechanism for extending these results to work with vision-based inputs. Further, this entire endeavor lends itself very readily to an off-policy actorcritic architecture such that the actor’s gradients depend only on derivatives through the learned critic. This means that by improving estimation of the critic one is directly able to improve the actor gradients. Most interestingly, there have also been recent attempts to distribute updates for the DDPG algorithm, (e.g. Popov et al., 2017) and more generally in this work we build on work of (Horgan et al., 2018) for implementing distributed actors. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            561
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, Bellemare et al. (2017) showed that the distribution over returns, whose expectation is the value function, obeys a distributional Bellman equation. Although the idea of estimating a distribution over returns has been revisited before (Sobel, 1982; Morimura et al., 2010), Bellemare et al. demonstrated that this estimation alone was enough to achieve state-of-the-art results on the Atari 2600 benchmarks. Crucially, this technique achieves these gains by directly improving updates for the critic. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            648
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            667,
+            326,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work we consider a standard reinforcement learning setting wherein an agent interacts with an environment in discrete time. At each timestep $t$ the agent makes observations $\\bar { \\mathbf { x } } _ { t } \\in \\mathcal { X }$ , takes actions ${ \\bf a } _ { t } \\in \\mathcal A$ , and receives rewards $r ( \\mathbf { x } _ { t } , \\mathbf { a } _ { t } ) \\in \\mathbb { R }$ . Although we will in general make no assumptions about the inputs $\\mathcal { X }$ , we will assume that the environments considered in this work have real-valued actions $\\ b { A } = \\mathbb { R } ^ { d }$ . ",
+        "bbox": [
+            174,
+            698,
+            825,
+            766
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this standard setup, the agent’s behavior is controlled by a policy $\\pi : \\mathcal { X }  \\mathcal { A }$ which maps each observation to an action. The state-action value function, which describes the expected return conditioned on first taking action $\\mathbf { a } \\in { \\mathcal { A } }$ from state $\\mathbf { x } \\in \\mathcal { X }$ and subsequently acting according to $\\pi$ , is defined as ",
+        "bbox": [
+            174,
+            772,
+            823,
+            827
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9a6e2e571e3cea7858af8b587c75efe2ad860505e8512b0d758321309f2364a.jpg",
+        "text": "$$\n\\begin{array} { r } { \\begin{array} { r } { Q _ { \\pi } ( \\mathbf { x } , \\mathbf { a } ) = \\mathbb { E } \\Big [ \\displaystyle \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r ( \\mathbf { x } _ { t } , \\mathbf { a } _ { t } ) \\Big ] \\quad \\mathrm { w h e r e } \\quad \\mathbf { x } _ { 0 } = \\mathbf { x } , \\mathbf { a } _ { 0 } = \\mathbf { a } , } \\\\ { \\quad \\mathbf { x } _ { t } \\sim p ( \\cdot | \\mathbf { x } _ { t - 1 } , \\mathbf { a } _ { t - 1 } ) , } \\\\ { \\quad \\mathbf { a } _ { t } = \\pi ( \\mathbf { x } _ { t } ) , } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            827,
+            715,
+            895
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "and is commonly used to evaluate the quality of a policy. While it is possible to derive an updated policy directly from $Q _ { \\pi }$ , such an approach typically requires maximizing this function with respect to a and is made complicated by the continuous action space. Instead we will consider a parameterized policy $\\pi _ { \\theta }$ and maximize the expected value of this policy by optimizing $J ( \\theta ) \\ = \\ \\mathbb { E } [ Q _ { \\pi _ { \\theta } } ( \\mathbf { x } , \\pi _ { \\theta } ( \\mathbf { \\bar { x } } ) ) ]$ . By making use of the deterministic policy gradient theorem (Silver et al., 2014) one can write the gradient of this objective as” ",
+        "bbox": [
+            173,
+            896,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            157
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4d2b9198309772d562a22e426d3a66942541b678fae395a5abbac53cbea91fd6.jpg",
+        "text": "$$\n\\begin{array} { r } { \\nabla _ { \\theta } J ( \\theta ) \\approx \\mathbb { E } _ { \\rho } \\Big [ \\nabla _ { \\theta } \\pi _ { \\theta } ( \\mathbf { x } ) \\nabla _ { \\mathbf { a } } Q _ { \\pi _ { \\theta } } ( \\mathbf { x } , \\mathbf { a } ) \\big | _ { \\mathbf { a } = \\pi _ { \\theta } ( \\mathbf { x } ) } \\Big ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            159,
+            658,
+            185
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\rho$ is the state-visitation distribution associated with some behavior policy. Note that by letting the behavior policy differ from $\\pi$ we are able to empirically evaluate this gradient using data gathered off-policy. ",
+        "bbox": [
+            173,
+            186,
+            825,
+            227
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the exact gradient given by (2) assumes access to the true value function of the current policy, we can instead approximate this quantity with a parameterized critic $Q _ { w } ( \\mathbf { x } , \\mathbf { a } )$ . By introducing the Bellman operator ",
+        "bbox": [
+            176,
+            233,
+            820,
+            272
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b7b82533d7f9f54b41bb1117ff821e83c7a00c5be4da19addcd7e65221f4ee40.jpg",
+        "text": "$$\n( \\mathcal { T } _ { \\pi } Q ) ( \\mathbf { x } , \\mathbf { a } ) = r ( \\mathbf { x } , \\mathbf { a } ) + \\gamma \\mathbb { E } \\big [ Q ( \\mathbf { x } ^ { \\prime } , \\pi ( \\mathbf { x } ^ { \\prime } ) ) \\big | \\mathbf { x } , \\mathbf { a } \\big ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            272,
+            665,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "whose expectation is taken with respect to the next state $\\mathbf { x } ^ { \\prime }$ , we can minimize the temporal difference (TD) error, i.e. the difference between the value function before and after applying the Bellman update. Typically the TD error will be evaluated under separate target policy and value networks, i.e. networks with separate parameters $( \\theta ^ { \\prime } , w ^ { \\prime } )$ , in order to stabilize learning. By taking the twonorm of this error we can write the resulting loss as ",
+        "bbox": [
+            173,
+            291,
+            825,
+            358
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aa0a367f34f19296686d464b0b43951bb442e7a74bd6d53fa3811b1b92f5b362.jpg",
+        "text": "$$\nL ( w ) = \\mathbb { E } _ { \\rho } \\Big [ ( Q _ { w } ( \\mathbf { x } , \\mathbf { a } ) - ( \\mathcal { T } _ { \\pi _ { \\theta ^ { \\prime } } } Q _ { w ^ { \\prime } } ) ( \\mathbf { x } , \\mathbf { a } ) ) ^ { 2 } \\Big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            359,
+            651,
+            386
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In practice we will periodically replace the target networks with copies of the current network weights. Finally, by training a neural network policy using the deterministic policy gradient in (2) and training a deep neural to minimize the TD error in (4) we obtain the Deep Deterministic Policy Gradient (DDPG) algorithm (Lillicrap et al., 2016). Here a sample-based approximation to these gradients is employed by using data gathered in some replay table. ",
+        "bbox": [
+            173,
+            387,
+            825,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DISTRIBUTED DISTRIBUTIONAL DDPG ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            472,
+            535,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The approach taken in this work starts from the DDPG algorithm and includes a number of enhancements. These extensions, which we will detail in this section, include a distributional critic update, the use of distributed parallel actors, $N$ -step returns, and prioritization of the experience replay. ",
+        "bbox": [
+            176,
+            501,
+            821,
+            544
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "First, and perhaps most crucially, we consider the inclusion of a distributional critic as introduced in Bellemare et al. (2017). In order to introduce the distributional update we first revisit (1) in terms of the return as a random variable $Z _ { \\pi }$ , such that $Q _ { \\pi } ( \\mathbf { x } , \\mathbf { a } ) = \\mathbb { E } Z _ { \\pi } ( \\mathbf { x } , \\mathbf { a } )$ . The distributional Bellman operator can be defined as ",
+        "bbox": [
+            173,
+            549,
+            825,
+            603
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2a124c04f3814d060ea75a11c52cd51faa34680a9971d9242e43809882eff549.jpg",
+        "text": "$$\n( \\mathcal { T } _ { \\pi } Z ) ( \\mathbf { x } , \\mathbf { a } ) = r ( \\mathbf { x } , \\mathbf { a } ) + \\gamma \\mathbb { E } \\big [ Z ( \\mathbf { x } ^ { \\prime } , \\pi ( \\mathbf { x } ^ { \\prime } ) ) \\big | \\mathbf { x } , \\mathbf { a } \\big ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            604,
+            665,
+            623
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where equality is with respect to the probability law of the random variables; note that this expectation is taken with respect to distribution of $Z$ as well as the transition dynamics. ",
+        "bbox": [
+            179,
+            625,
+            820,
+            651
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the definition of this operator looks very similar to the canonical Bellman operator defined in (3), it differs in the types of functions it acts on. The distributional variant takes functions which map from state-action pairs to distributions, and returns a function of the same form. In order to use this function within the context of the actor-critic architecture introduced above, we must parameterize this distribution and define a loss similar to that of Equation 4. We will write the loss as ",
+        "bbox": [
+            173,
+            656,
+            825,
+            723
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a86342a807fa99cec6c0af41a5ac0ad130bd29b5bb54e6420e0194ecdf170aad.jpg",
+        "text": "$$\nL ( w ) = \\mathbb { E } _ { \\rho } \\Big [ d ( { \\mathcal { T } } _ { \\pi _ { \\theta ^ { \\prime } } } Z _ { w ^ { \\prime } } ( \\mathbf { x } , \\mathbf { a } ) , Z _ { w } ( \\mathbf { x } , \\mathbf { a } ) ) \\Big ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            726,
+            637,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for some metric $d$ that measures the distance between two distributions. Two components that can have a significant impact on the performance of this algorithm are the specific parameterization used for $\\bar { Z } _ { w }$ and the metric $d$ used to measure the distributional TD error. In both cases we will give further details in Appendix A; in the experiments that follow we will use the Categorical distribution detailed in that section. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            820
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We can complete this distributional policy gradient algorithm by including the action-value distribution inside the actor update from Equation 2. This is done by taking the expectation with respect to the action-value distribution, i.e. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            866
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c64c1ecbcc391f8e932c567c6fd7c5aec64f094c4434ad7c2c396daac1f0567.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla _ { \\boldsymbol { \\theta } } J ( \\boldsymbol { \\theta } ) \\approx \\mathbb { E } _ { \\boldsymbol { \\rho } } \\Big [ \\nabla _ { \\boldsymbol { \\theta } } \\pi _ { \\boldsymbol { \\theta } } ( \\mathbf { x } ) \\nabla _ { \\mathbf { a } } Q _ { w } ( \\mathbf { x } , \\mathbf { a } ) \\big | _ { \\mathbf { a } = \\pi _ { \\boldsymbol { \\theta } } ( \\mathbf { x } ) } \\Big ] , } \\\\ & { \\qquad = \\mathbb { E } _ { \\boldsymbol { \\rho } } \\Big [ \\nabla _ { \\boldsymbol { \\theta } } \\pi _ { \\boldsymbol { \\theta } } ( \\mathbf { x } ) \\mathbb { E } \\big [ \\nabla _ { \\mathbf { a } } Z _ { w } ( \\mathbf { x } , \\mathbf { a } ) \\big ] \\big | _ { \\mathbf { a } = \\pi _ { \\boldsymbol { \\theta } } ( \\mathbf { x } ) } \\Big ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            867,
+            668,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 D4PG ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            305,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: batch size $M$ , trajectory length $N$ , number of actors $K$ , replay size $R$ , exploration constant \u000f, initial learning rates $\\alpha _ { 0 }$ and $\\beta _ { 0 }$ ",
+        "bbox": [
+            178,
+            119,
+            821,
+            148
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "6: Construct the target distributions “ N´1n“0 γnri\\`n \\` γN Zw1 pxi\\`N , πθ1 pxi\\`N qq   \n7: Compute the actor and critic updates ",
+        "bbox": [
+            179,
+            226,
+            766,
+            257
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe45e38858e1725c804e3b4645a236b44e750fb60cce60bf824ba5c36ee2b259.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\delta _ { w } = \\frac { 1 } { M } \\sum _ { i } \\nabla _ { w } ( R p _ { i } ) ^ { - 1 } \\boldsymbol { d } ( Y _ { i } , Z _ { w } ( \\mathbf { x } _ { i } , \\mathbf { a } _ { i } ) ) } \\\\ { \\displaystyle \\delta _ { \\theta } = \\frac { 1 } { M } \\sum _ { i } \\nabla _ { \\theta } \\pi _ { \\theta } ( \\mathbf { x } _ { i } ) \\left. \\mathbb { E } [ \\nabla _ { \\mathbf { a } } Z _ { w } ( \\mathbf { x } _ { i } , \\mathbf { a } ) ] \\right. _ { \\mathbf { a } = \\pi _ { \\theta } ( \\mathbf { x } _ { i } ) } } \\\\ { \\displaystyle \\quad \\left. \\cfrac { \\mathrm { ~ \\rho ~ } } { \\mathrm { ~ \\rho ~ } } \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            263,
+            681,
+            334
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": ": Update network parameters $\\theta \\gets \\theta + \\alpha _ { t } \\delta _ { \\theta }$ , $w \\gets w + \\beta _ { t } \\delta _ { w }$ ",
+        "bbox": [
+            191,
+            332,
+            612,
+            344
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "9: If $t = 0$ mod $t _ { \\mathrm { t a r g e t } }$ , update the target networks $( \\theta ^ { \\prime } , w ^ { \\prime } )  ( \\theta , w )$ ",
+        "bbox": [
+            187,
+            345,
+            622,
+            358
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "0: If $t = 0$ mod $t _ { \\mathrm { a c t o r s } }$ , replicate network weights to the actors ",
+        "bbox": [
+            189,
+            359,
+            619,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "11: end for   \n12: return policy parameters $\\theta$ ",
+        "bbox": [
+            176,
+            372,
+            385,
+            398
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Actor ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            406,
+            215,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: repeat   \n2: Sample action $\\mathbf { a } = \\pi _ { \\boldsymbol { \\theta } } ( \\mathbf { x } ) + \\epsilon \\mathcal { N } ( 0 , 1 )$   \n3: Execute action a, observe reward $r$ and state $\\mathbf { x } ^ { \\prime }$   \n4: Store $( { \\bf x } , { \\bf a } , r , { \\bf x } ^ { \\prime } )$ in replay   \n5: until learner finishes ",
+        "bbox": [
+            179,
+            422,
+            529,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As before, this update can be empirically evaluated by replacing the outer expectation with a samplebased approximation. ",
+        "bbox": [
+            174,
+            525,
+            821,
+            553
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, we consider a modification to the DDPG update which utilizes $N$ -step returns when estimating the TD error. This can be seen as replacing the Bellman operator with an $N$ -step variant ",
+        "bbox": [
+            173,
+            559,
+            826,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d8501fb2d2d9e260ed66d1f0d3eacf97aab7e81bfd3a9a9f878c1d5c8abd1ea.jpg",
+        "text": "$$\n( \\mathcal T _ { \\pi } ^ { N } Q ) ( { \\bf x } _ { 0 } , { \\bf a } _ { 0 } ) = r ( { \\bf x } _ { 0 } , { \\bf a } _ { 0 } ) + \\mathbb E \\big [ \\sum _ { n = 1 } ^ { N - 1 } \\gamma ^ { n } r ( { \\bf x } _ { n } , { \\bf a } _ { n } ) + \\gamma ^ { N } Q ( { \\bf x } _ { N } , \\pi ( { \\bf x } _ { N } ) ) \\big | { \\bf x } _ { 0 } , { \\bf a } _ { 0 } \\big ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            602,
+            771,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the expectation is with respect to the $N$ -step transition dynamics. Although not used by Lillicrap et al. (2016), $N$ -step returns are widely used in the context of many policy gradient algorithms (e.g. Mnih et al., 2016) as well as Q-learning variants (Hessel et al., 2017). This modification can be applied analogously to the distributional Bellman operator in order to make use of it when updating the distributional critic. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            724
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, we also modify the standard training procedure in order to distribute the process of gathering experience. Note from Equations (2,4) that the actor and critic updates rely entirely on sampling from some state-visitation distribution $\\rho$ . We can parallelize this process by using $K$ independent actors, each writing to the same replay table. A learner process can then sample from some replay table of size $R$ and perform the necessary network updates using this data. Additionally sampling can be implemented using non-uniform priorities $p _ { i }$ as in Schaul et al. (2016). Note that this requires the use of importance sampling, implemented by weighting the critic update by a factor of $1 { \\bar { / } } R p _ { i }$ . We implement this procedure using the ApeX framework (Horgan et al., 2018) and refer the reader there for more details. ",
+        "bbox": [
+            173,
+            731,
+            825,
+            851
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm pseudocode for the D4PG algorithm which includes all the above-mentioned modifications can be found in Algorithm 1. Here the actor and critic parameters are updated using stochastic gradient descent with learning rates, $\\alpha _ { t }$ and $\\beta _ { t }$ respectively, which are adjusted online using ADAM (Kingma & Ba, 2015). While this pseudocode focuses on the learning process, also shown is pseudocode for actor processes which in parallel fill the replay table with data. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/cad84abe7c40d3060704f8949c7b9a752da8327f6de12c18aba43592d48ab6aa.jpg",
+        "image_caption": [
+            "Figure 1: Architectural variants used for each domain. The left-most set illustrates the actor network and critic torso used for the standard control and manipulation domains. The full critic architecture is completed by feeding the output of the critic torso into a relevant distribution, e.g. the categorical distribution, as defined in Section A. The right half of the figure similarly illustrates the architecture used by the parkour domains. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            103,
+            823,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            417,
+            281,
+            433
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section we describe the performance of the D4PG algorithm across a variety of continuous control tasks. To do so, in each environment we run our learning procedure and periodically snapshot the policy in order to test it without exploration noise. We will primarily be interested in the performance as a function of wall clock time, however we will also examine the data efficiency. Most interestingly, from a scientific perspective, we also perform a number of ablations which individually remove components of the D4PG algorithm in order to determine their specific contributions. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First, we experiment with and without distributional updates. In this setting we focus on use of a categorical distribution as we found in preliminary experiments that the use of a mixture of Gaussians performed worse and was less stable with respect to hyperparameter values across different tasks; a selection of these runs can be found in Appendix C. Across all tasks—except for one which we will introduce later—we use 51 atoms for the categorical distribution. In what follows we will refer to non-distributional variants of this algorithm as Distributed DDPG (D3PG). ",
+        "bbox": [
+            174,
+            547,
+            825,
+            627
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, we consider prioritized and non-prioritized versions of these algorithm variants. For the nonprioritized variants, transitions are sampled from replay uniformly. For prioritized variants we use the absolute TD-error to sample from replay in the case of D3PG, and for D4PG we use the absolute distributional TD-error as described in Section A. We also vary the trajectory length $N \\in \\{ 1 , 5 \\}$ . ",
+        "bbox": [
+            174,
+            633,
+            823,
+            688
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In all experiments we use a replay table of size $R = 1 \\times 1 0 ^ { 6 }$ and only consider behavior policies which add fixed Gaussian noise $\\dot { \\epsilon } { \\mathcal N } ( 0 , 1 )$ to the current online policy; in all experiments we use a value of $\\epsilon = 0 . 3$ . We experimented with correlated noise drawn from an Ornstein-Uhlenbeck process, as suggested by (Lillicrap et al., 2016), however we found this was unnecessary and did not add to performance. For all algorithms we initialize the learning rates for both actor and critic updates to the same value. In the next section we will present a suite of simple control problems for which this value corresponds to $\\alpha _ { 0 } = \\beta _ { 0 } = 1 \\times 1 0 ^ { - 4 }$ ; for the following, harder problems we set this to a smaller value of $\\alpha _ { 0 } ^ { \\mathrm { { - } } } = \\beta _ { 0 } = 5 \\times 1 0 ^ { - 5 }$ . Similarly for the control suite we utilize a batch size of $M = 2 5 6$ and for all subsequent problems we will increase this to $M = 5 1 2$ . ",
+        "bbox": [
+            174,
+            695,
+            825,
+            815
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 STANDARD CONTROL SUITE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            832,
+            406,
+            844
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first consider evaluating performance on a number of simple, physical control tasks by utilizing a suite of benchmark tasks (Tassa et al., 2018) developed in the MuJoCo physics simulator (Todorov et al., 2012). Each task is run for exactly 1000 steps and provides either an immediate dense reward $r _ { t } \\in [ 0 , 1 ]$ or sparse reward $r _ { t } \\in \\{ 0 , 1 \\}$ depending on the particular task. For each domain, the inputs presented to the agent consist of reasonably low-dimensional observations, many consisting of physical state, joint angles, etc. These observations range between 6 and 60 dimensions, however note that the difficulty of the task is not immediately associated with its dimensionality. For example the acrobot is one of the lowest dimensional tasks in this suite which, due to its level of controllability, can prove much more difficult to learn than other, higher dimensional tasks. For an illustration of these domains see Figure 9; see Appendix D for more details. ",
+        "bbox": [
+            174,
+            857,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/08ebd135e1f61e73ac160cea282b92bfe75334a0f4699b20be1ed73f0dd625e9.jpg",
+        "image_caption": [
+            "Figure 2: Experimental results across domains in the control suite. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            818,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            545,
+            825,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For algorithms in these experiments we consider actor and critic architectures of the form given in Figure 1 and for each experiment we use $K = 3 2$ actors. Figure 2 shows the performance of D4PG and its various ablations across the entire suite of control tasks. This set of plots is quite busy, however it serves as a broad set of tasks with which we can obtain a general idea of the algorithms performance. Later experiments on harder domains look more closely at the difference between algorithms. Here we also compare against the canonical (non-distributed) DDPG algorithm as a baseline, shown as a dotted black line. This removes all the enhancements proposed in this paper, and we can see that except on the simplest domain, Cartpole (Swingup), it performs worse than all other methods. This performance disparity worsens as we increase the difficulty of tasks, and hence for further experiments we will drop this line from the plot. ",
+        "bbox": [
+            174,
+            618,
+            825,
+            751
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Next, across all tasks we see that the best performance is obtained by the full D4PG algorithm (shown in purple and bold). Here we see that the longer unroll length of $N = 5$ is uniformly better (we show these as solid lines), and in particular we sometimes see for both D3PG and D4PG that an unroll length of $N = 1$ (shown as dashed lines) can occasionally result in instability. This is especially apparent in the Cheetah (Walk) and Cartpole (Swingup Sparse) tasks. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The next biggest gain is arguably due to the inclusion of the distributional critic update, where it is particularly helpful on the hardest tasks e.g. Humanoid (Run) and Acrobot. The manipulator is also quite difficult among this suite of tasks, and here we see that the inclusion of the distributional update does not help as much as in other tasks, although note that here the D3PG and D4PG variants obtain approximately the same performance. As far as the use of prioritization is concerned, it does not appear to contribute significantly to the performance of D4PG. This is not the case for D3PG, however, which on many tasks is helped significantly by the inclusion of prioritization. ",
+        "bbox": [
+            173,
+            830,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/9ed7390ca0bd378d7d53a8914dc484884e54d52e15b51e221f3ec26d9056fe52.jpg",
+        "image_caption": [
+            "Figure 3: Experimental results for tasks in the manipulation domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            98,
+            816,
+            359
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 MANIPULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            326,
+            425
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, we consider a set of tasks designed to highlight the ability of the D4PG agent to learn dexterous manipulation. Tasks of this form can prove difficult for many reasons, most notably the higher dimensionality of the control task, intermittent contact dynamics, and potential under-actuation of the manipulator. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            491
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here we use a simulated hand model implemented within MuJoCo, consisting of 13 actuators which control 22 degrees of freedom. For these experiments the wrist site is attached to a fixed location in space, about which it is allowed to rotate axially. In particular this allows the hand to pick up objects, rotate into a palm-up position, and manipulate them. We first consider a task in which a cylinder is dropped onto the hand from a random height, and the goal of the task is to catch the falling cylinder. The next task requires the agent to pick up an object from the tabletop and then maneuver it to a target position and orientation. The final task is one wherein a broad cylinder must be rotated inhand in order to match a target orientation. See Appendix E for further details regarding both the model and the tasks. For these tasks we use the same network architectures as in the previous section as well as $K = 6 4$ actors. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            630
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Figure 3 we again compare the D4PG algorithm against ablations of its constituent components. Here we split the algorithms between $N = 1$ in the top row and $N = 5$ in the bottom row, and in particular we can see that across all algorithms $N = 5$ is uniformly better. For all tasks, the full D4PG algorithm performs either at the same level or better than other ablations; this is particularly apparent in the $N = 5$ case. Overall the use of priorization never seems to harm D4PG, however it does appear to be of limited additional value. Interestingly this is not necessarily the case with the D3PG variant (i.e. without distributional updates). Here we can see that prioritization sometimes harms the performance of D3PG, and this is very readily seen in the $N = 1$ case where the algorithm can either become unstable, or in the case of the Pickup and Orient task it completely fails to learn. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 PARKOUR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            775,
+            282,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we consider the parkour domain introduced by (Heess et al., 2017). In this setting the agent controls a simplified robotic walker which is rewarded for forward movement, but is impeded by a number of randomly sampled obstacles; see Figure 4 for a visualization and refer to the earlier work for further details. The first of our experiments considers a two-dimensional walker, i.e. a domain in which the walker is allowed to move horizontally and vertically, but is constrained to a fixed depth position. In this domain the obstacles presented to the agent include gaps in the floor surface, barriers it must jump over, and platforms that it can either run over or underneath. The agent is presented with proprioceptive observations $\\mathbf { x } _ { \\mathrm { p r o p r i o } } \\in \\mathbb { R } ^ { 1 9 }$ corresponding to the angles of its limbs and other functions of these quantities. It is also given access to observations $\\mathbf { x } _ { \\mathrm { t e r r a i n } } \\in \\mathbb { R } ^ { 1 0 1 }$ which includes features such as a depth map of the upcoming terrain, etc. In order to accommodate these inputs we utilize a network architecture as specified in Figure 1. In particular we make use of a stack of feed-forward layers which process the terrain information to reduce it to a smaller number of hidden units before concatenating with the proporioceptive information for further processing. The actions in this domain take the form of torque controls $\\mathbf { a } \\in \\mathbb { R } ^ { 6 }$ . ",
+        "bbox": [
+            174,
+            801,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7eb78bca7db3ce270e23c976b1305e4c3d33378edef9e29e2b96058c047028ae.jpg",
+        "image_caption": [
+            "Figure 4: Example frames taken from trained agents running in the two parkour domains. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            101,
+            758,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            287,
+            825,
+            353
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to examine the performance of the D4PG algorithm in this setting we consider the ablations of the previous sections and we have further introduced a PPO baseline as utilized in the earlier paper of (Heess et al., 2017). For all algorithms, including PPO, we use $K = 6 4$ actors. These results are shown in Figure 5 in the top row. As before we examine the performance separately for $N = 1$ and $N = 5$ , and again we see that the higher unroll length results in better performance. Note that we show the PPO baseline on both plots for consistency, but in both plots this is the same algorithm, with settings proposed in the earlier paper and unrolls of length 50. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            454
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Here we again see a clear delineation and clear gains for each of the other algorithm components. The biggest gain comes from the inclusion of the distributional update, which we can see by comparing the non-prioritized D3PG/D4PG variants. We see marginal benefit to using prioritization for D3PG, but this gain disappears when we consider the distributional update. Finally, we can see when comparing to the PPO baseline that this algorithm compares favorably to D3PG in the case of $N = 1$ , however is outperformed by D4PG; when $N = 5$ all algorithms outperform PPO. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            540
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Next, in the plots shown in Figure 5 on the bottom row we also consider the performance not just in terms of training time, but also in terms of the sample complexity. In order to do so we plot the performance of each algorithm versus the number of actor steps, i.e. the quantity of transitions collected. This is perhaps more favorable to PPO, as the parallel actors considered in this work are not necessarily tuned for sample efficiency. Here we see that PPO is able to out-perform the non-prioritized version of D3PG, and early on in training is favorable compared to the prioritized version, although this trails off. However, we still see significant performance gains by utilizing the distributional updates, both in a prioritized and non-prioritized setting. Interestingly we see that the use of prioritization does not gain much, if any over the non-prioritized D4PG version. Early in the trajectory for $N \\ = \\ 5$ , in fact, we see that the non-prioritized D4PG exhibits better performance, however later these performance curves level out. With respect to wall-clock time these small differences may be due to small latencies in the scheduling of different runs, as we see that this difference is less for the plot with respect to actor steps. ",
+        "bbox": [
+            173,
+            547,
+            825,
+            718
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally we consider a humanoid walker which is able to move in all three dimensions. The obstacles in this domain consist of gaps in the floor, barriers that must be jumped over, and walls with gaps that allow the agent to run through. For this experiment we utilize the same network architecture as in the previous experiment, except now the observations are of size $\\mathbf { x } _ { \\mathrm { p r o p r i o } } \\in \\mathbb { R } ^ { 7 9 }$ and $\\mathbf { X } _ { \\mathrm { t e r r a i n } } \\in \\mathbb { R } ^ { 4 6 1 }$ . Again actions are torque controls, but in 21 dimensions. In this task we also increased the number of atoms for the categorical distribution from 51 to 101. This change increases the level of resolution for the distribution in order to keep the resolution roughly consistent with other tasks. This is a much higher dimensional problem than the previous parkour task with a significantly more difficult control task: the walker is more unstable and there are many more ways for the agent to fail than in the previous experiment. The results for this particular domain are displayed in Figure 6, and here we concentrate on performance as a function of wall-clock time, restricted to the previously best performing roll-out length of $N = 5$ . In this setting we see a clear delineation between first the PPO results which are the poorest performing, the D3PG results where the prioritized version has a slight edge, and finally the D4PG results. Interestingly for D4PG we again see as in the twodimensional walker case, the use of prioritization seems to have no benefit, with both versions have almost identical performance curves; in fact the performance here is perhaps even closer than that of the previous set of experiments. ",
+        "bbox": [
+            174,
+            726,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d04d91404dd0fff45753b756171e9fbf5a79eed30c4d0c0aec9509c3e3d92ef5.jpg",
+        "image_caption": [
+            "Figure 5: Experimental results for the two-dimensional (walker) parkour domain when compared first versus wall-clock time (top) and versus actor steps (bottom). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            102,
+            723,
+            364
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/63b94a5a33a744bd986ec42c5dac028ce8f4ea2cc594bfe8337f63f49a72c585.jpg",
+        "image_caption": [
+            "Figure 6: Experimental results for the three-dimensional (humanoid) parkour domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            272,
+            430,
+            715,
+            555
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            614,
+            823,
+            642
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            664,
+            310,
+            680
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work we introduced the D4PG, or Distributed Distributional DDPG, algorithm. Our main contributions include the inclusion of a distributional updates to the DDPG algorithm, combined with the use of multiple distributed workers all writing into the same replay table. We also consider a number of other, smaller changes to the algorithm. All of these simple modifications contribute to the overall performance of the D4PG algorithm; the biggest performance gain of these simple changes is arguably the use of $N$ -step returns. Interestingly we found that the use of priority was less crucial to the overall D4PG algorithm especially on harder problems. While the use of prioritization was definitely able to increase the performance of the D3PG algorithm, we found that it can also lead to unstable updates. This was most apparent in the manipulation tasks. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            815
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, as our results can attest, the D4PG algorithm is capable of state-of-the-art performance on a number of very difficult continuous control problems. ",
+        "bbox": [
+            174,
+            821,
+            823,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            872,
+            285,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc G Bellemare, Will Dabney, and Remi Munos. A distributional perspective on reinforcement ´ learning. In International Conference on Machine Learning, pp. 449–458, 2017. ",
+        "bbox": [
+            174,
+            896,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Peter W Glynn. Likelihood ratio gradient estimation for stochastic systems. Communications of the ACM, 33(10):75–84, 1990. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            131
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Roland Hafner and Martin Riedmiller. Reinforcement learning in feedback control. Machine Learning, 84(1-2):137–169, jul 2011. doi: 10.1007/s10994-011-5235-x. ",
+        "bbox": [
+            171,
+            140,
+            821,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Dhruva TB, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, and David Silver. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017. ",
+        "bbox": [
+            176,
+            178,
+            823,
+            219
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matteo Hessel, Joseph Modayil, Hado Van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. arXiv preprint arXiv:1710.02298, 2017. ",
+        "bbox": [
+            174,
+            228,
+            823,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado van Hasselt, and David Silver. Distributed prioritized experience replay. International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            174,
+            279,
+            823,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew S. Johannes, John D. Bigelow, James M. Burck, Stuart D. Harshbarger, Matthew V. Kozlowski, and Thomas Van Doren. An overview of the developmental process for the modular prosthetic limb. Johns Hopkins APL Technical Digest (Applied Physics Laboratory), 30(3):207– 216, 2011. ",
+        "bbox": [
+            173,
+            329,
+            825,
+            383
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            171,
+            393,
+            823,
+            421
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vikash Kumar and Emanuel Todorov. MuJoCo HAPTIX: A virtual reality system for hand manipulation. In IEEE-RAS International Conference on Humanoid Robots, volume 2015-December, pp. 657–663. IEEE, 2015. doi: 10.1109/HUMANOIDS.2015.7363441. ",
+        "bbox": [
+            176,
+            430,
+            823,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            174,
+            481,
+            823,
+            522
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. In International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            174,
+            531,
+            823,
+            573
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            176,
+            582,
+            823,
+            623
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, 2016. ",
+        "bbox": [
+            176,
+            632,
+            823,
+            674
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tetsuro Morimura, Hirotaka Hachiya, Masashi Sugiyama, Toshiyuki Tanaka, and Hisashi Kashima. Parametric Return Density Estimation for Reinforcement Learning. In Proceedings of the Conference on Uncertainty in Artificial Intelligence (UAI), 2010. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            724
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jan Peters and Stefan Schaal. Natural actor-critic. Neurocomputing, 71(7):1180–1190, 2008. ",
+        "bbox": [
+            171,
+            733,
+            782,
+            750
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ivaylo Popov, Nicolas Heess, Timothy Lillicrap, Roland Hafner, Gabriel Barth-Maron, Matej Vecerik, Thomas Lampe, Yuval Tassa, Tom Erez, and Martin Riedmiller. Data-efficient deep reinforcement learning for dexterous manipulation. arXiv preprint arXiv:1704.03073, 2017. ",
+        "bbox": [
+            174,
+            757,
+            823,
+            799
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            173,
+            808,
+            821,
+            837
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1889–1897, 2015. ",
+        "bbox": [
+            173,
+            844,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            171,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic policy gradient algorithms. In International Conference on Machine Learning, 2014. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            143
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            176,
+            152,
+            821,
+            194
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew J. Sobel. The variance of discounted markov decision processes. Journal of Applied Probability, 19(04):794–802, 1982. ",
+        "bbox": [
+            171,
+            203,
+            823,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, David A McAllester, Satinder P Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In Advances in Neural Information Processing Systems, pp. 1057–1063, 2000. ",
+        "bbox": [
+            171,
+            238,
+            823,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, Timothy Lillicrap, and Martin Riedmiller. Deepmind control suite, 2018. URL http://arxiv.org/abs/1801.00690. ",
+        "bbox": [
+            174,
+            287,
+            823,
+            330
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012. ",
+        "bbox": [
+            173,
+            338,
+            823,
+            378
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "George E Uhlenbeck and Leonard S Ornstein. On the theory of the brownian motion. Physical review, 36(5):823, 1930. ",
+        "bbox": [
+            173,
+            387,
+            823,
+            415
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            452
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/98849cea38df35b1083c9397e9360d4621388c0e1e48c5ba5ff1137a9294a6f4.jpg",
+        "image_caption": [
+            "Figure 7: Output layers corresponding to different distribution parameterizations. From left to right these include the Categorical, Mixture of Gaussians, and finally the standard scalar value function. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            331,
+            99,
+            661,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A DISTRIBUTIONS AND LOSSES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            290,
+            452,
+            305
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this section we consider two potential parameterized distributions for D4PG. Parameterized distributions, in this framework, are implemented as a neural network layer mapping the output of the critic torso (see Figure 1) to the parameters of a given distribution (e.g. mean and variance). In what follows we will detail the distributions and their corresponding losses. ",
+        "bbox": [
+            173,
+            319,
+            825,
+            375
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Categorical Following Bellemare et al. (2017), we first consider the categorical parameterization, a layer whose parameters are the logits $\\omega _ { i }$ of a discrete-valued distribution defined over a fixed set of atoms $z _ { i }$ . This distribution has hyperparameters for the number of atoms $\\ell$ , and the bounds on the support $( V _ { \\mathrm { m i n } } , V _ { \\mathrm { m a x } } )$ . Given these, $\\begin{array} { r } { \\dot { \\Delta } = \\frac { { { V _ { \\mathrm { { m a x } } } } - { V _ { \\mathrm { { m i n } } } } } } { { \\ell - 1 } } } \\end{array}$ corresponds to the distance between atoms, and $z _ { i } = V _ { \\operatorname* { m i n } } + i \\Delta$ gives the location of each atom. We can then define the action-value distribution as ",
+        "bbox": [
+            173,
+            387,
+            825,
+            460
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd63af59a9a3d9f533855ed17e574015d56120df3fa17536b981c3e773c91eb4.jpg",
+        "text": "$$\nZ = z _ { i } \\quad \\mathrm { w . p . } \\quad p _ { i } \\mathrm { \\infty } \\exp \\{ \\omega _ { i } \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            465,
+            598,
+            482
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Observe that this distributional layer simply corresponds to a linear layer from the critic torso to the logits $\\omega$ , followed by a softmax activation (see Figure 7, left). ",
+        "bbox": [
+            174,
+            487,
+            826,
+            515
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "However, this distribution is not closed under the Bellman operator defined earlier, due to the fact that adding and scaling these values will no longer lie on the support defined by the atoms. This support is explicitly defined by the $( V _ { \\mathrm { m i n } } , V _ { \\mathrm { m a x } } )$ hyperparameters. As a result we instead use a projected version of the distributional Bellman operator (Bellemare et al., 2017); see Appendix B for more details. Letting $p ^ { \\prime }$ be the probabilities of the projected distributional Bellman operator $\\Phi \\mathcal { T } _ { \\pi }$ applied to some target distribution $Z _ { \\mathrm { t a r g e t } }$ , we can write the loss in terms of the cross-entropy ",
+        "bbox": [
+            173,
+            520,
+            825,
+            602
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/06e6124107943a3bce108e9766a4945565b753441eefec61301e066d66bb7d2e.jpg",
+        "text": "$$\nd ( \\Phi { \\mathcal { T } } _ { \\pi } Z _ { \\mathrm { t a r g e t } } , Z ) = \\sum _ { i = 0 } ^ { \\ell - 1 } p _ { i } ^ { \\prime } { \\frac { \\exp \\{ \\omega _ { i } \\} } { \\sum _ { j } \\exp \\{ \\omega _ { j } \\} } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            607,
+            633,
+            650
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mixture of Gaussians We can also consider parameterizing the action-value distribution using a mixture of Gaussians; here the random variable $Z$ has density given by ",
+        "bbox": [
+            171,
+            661,
+            825,
+            689
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/011bd901ea714768d1f1c587e8e45c6aa997a1fa0d2197b556c415f8a8cb9590.jpg",
+        "text": "$$\np ( z ) \\propto \\sum _ { i = 0 } ^ { \\ell - 1 } \\omega _ { i } \\mathcal { N } ( z | \\mu _ { i } , \\sigma _ { i } ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            695,
+            589,
+            738
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thus, the distribution layer maps, through a linear layer, from the critic torso to the mixture weight $\\omega _ { i }$ , mean $\\mu _ { i }$ , and variance $\\sigma _ { i } ^ { 2 }$ for each mixture component $0 \\leqslant i \\leqslant \\ell - 1$ (see Figure 7, center). We can then specify a loss corresponding to the cross-entropy portion of the KL divergence between two distributions. Given a sample transition $( { \\bf x } , { \\bf a } , r , { \\bf x } ^ { \\prime } )$ we can take samples from the target density $z _ { j } \\sim p _ { \\mathrm { t a r g e t } }$ and approximate the cross-entropy term using ",
+        "bbox": [
+            173,
+            742,
+            825,
+            810
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/03b53bc7bb8085563aacbe8eb6b1bf987ba94a1e273955a9d64c2109184e5c22.jpg",
+        "text": "$$\nd ( { \\mathcal { T } } _ { \\pi } Z _ { \\mathrm { t a r g e t } } , Z ) \\approx \\sum _ { j } \\log p ( r + \\gamma z _ { j } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            815,
+            625,
+            849
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B CATEGORICAL PROJECTION OPERATOR",
+        "text_level": 1,
+        "bbox": [
+            173,
+            866,
+            532,
+            882
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The categorical parameterized distribution has finite support. Thus, the result of applying the distributional Bellman equation will generally not coincide with this support. Therefore, some projection ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/a94f731f7c5c5e8b7d5572d94a0c96378c6cec861fd576821785439adecadd9e.jpg",
+        "image_caption": [
+            "Figure 8: Results for using a mixture of Gaussians distribution on select control suite tasks. Shown are two learning rates as denoted in the legends as well as Categorical. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            820,
+            297
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "step is required before minimizing the cross-entropy. The categorical projection of Bellemare et al.ř (2017) is given by $\\begin{array} { r } { ( \\Phi p ) _ { i } = \\sum _ { j = 0 } ^ { \\ell - 1 } \\bar { h } _ { z _ { i } } ( z _ { j } ) p _ { j } } \\end{array}$ , $\\forall i$ , where $h$ is a piecewise linear ‘hat’ function, ",
+        "bbox": [
+            171,
+            381,
+            820,
+            415
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/22a99ada54f12864ff4785bcf2472fe5f436302f080f320ce0f4dec98e6991a6.jpg",
+        "text": "$$\nh _ { z _ { i } } ( z ) = \\left\\{ \\begin{array} { l l } { 1 } & { z \\leqslant V _ { \\mathrm { m i n } } \\mathrm { a n d } i = 0 , } \\\\ { \\frac { z - z _ { i - 1 } } { z _ { i } - z _ { i - 1 } } } & { \\mathrm { ~ f o r ~ } z _ { i - 1 } \\leqslant z \\leqslant z _ { i } , } \\\\ { \\frac { z _ { i + 1 } - z } { z _ { i + 1 } - z _ { i } } } & { \\mathrm { ~ f o r ~ } z _ { i } \\leqslant z \\leqslant z _ { i + 1 } , } \\\\ { 1 } & { z \\geqslant V _ { \\mathrm { m a x } } \\mathrm { a n d } i = \\ell - 1 . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            424,
+            655,
+            491
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C MIXTURES OF GAUSSIANS CONTROL SUITE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            510,
+            647,
+            526
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Figure 8 we display results of running D4PG on a selection of control suite tasks using a mixture of Gaussians output distribution for two choices of learning rates. Here the distributional TD loss is minimized using the sample-based KL introduced earlier. While this is definitely a technique that is worth further exploration, we found in initial experiments that this choice of distribution underperformed the Categorical distribution by a fair margin. This lends further credence to the choice of distribution made in (Bellemare et al., 2017). ",
+        "bbox": [
+            173,
+            541,
+            825,
+            622
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D CONTROL SUITE DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            643,
+            421,
+            660
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section we provide further details for the control suite domains. In particular see Figure 9 for images of the control suite tasks. The physics state $s$ , action $\\mathcal { A }$ , and observation $\\mathcal { X }$ dimensionalities for each task are provided in Table 1. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            717
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E MANIPULATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            738,
+            416,
+            753
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the dexterous manipulation tasks we used a simulated model of the Johns Hopkins Modular Prosthetic Limb hand (Johannes et al., 2011) implemented in MuJoCo (Kumar & Todorov, 2015). This anthropomorphic hand has a total of 22 degrees of freedom (19 in the fingers, 3 in the wrist), which are driven by a set of 13 position actuators (PD-controllers). The underactuation of the hand is due to coupling between some of the finger joints. For these experiments the wrist was positioned in a fixed location above a table, such that rotation and flexion about the wrist joints allowed the hand to pick up objects from the table, rotate into a palm-up position, and then manipulate them. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            864
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We focused on a set of three tasks where the agent must learn to manipulate a cylindrical object (Figure 10). In each of these tasks, the observations contain the positions and velocities of all of the joints in the hand, the current position targets for the actuators in the hand, the position and quaternion of the object being manipulated, and its translational and rotational velocities. The observations given in each task are summarized in Table 2. The agent’s actions are increments applied to the position targets for the actuators. ",
+        "bbox": [
+            174,
+            871,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/80e5fa3b2cbfcdd859c221734df8e61ca5e7ff5eb1e17b3af4945eba95b98417.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            108,
+            812,
+            270
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/b552b0ecd6dfafaa9a976924b3d5d77a18806e37bab4ed281e3a879154c17bb5.jpg",
+        "table_caption": [
+            "Figure 9: Control Suite domains used for benchmarking. Top: acrobot, cartpole, cheetah, finger, fish, hopper. Bottom: humanoid, manipulator, pendulum, reacher, swimmer6, swimmer15, walker. ",
+            "Table 1: Domains and tasks in the Control Suite. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Domain</td><td>Task</td><td>|A</td><td>|S</td><td>x</td></tr><tr><td>acrobot</td><td>swingup swingup_sparse</td><td>1</td><td>4</td><td>6</td></tr><tr><td>cartpole</td><td>swingup swingup_sparse</td><td>1</td><td>4</td><td>5</td></tr><tr><td>cheetah</td><td>walk</td><td>6</td><td>18</td><td>17</td></tr><tr><td>finger</td><td>turn_easy turn_hard</td><td>2</td><td>6</td><td>12</td></tr><tr><td>fish</td><td>upright swim</td><td>5</td><td>27</td><td>24</td></tr><tr><td>hopper</td><td>stand</td><td>4</td><td>14</td><td>15</td></tr><tr><td>humanoid</td><td>stand walk run</td><td>21</td><td>55</td><td>67</td></tr><tr><td>manipulator</td><td>bring_ball</td><td>2</td><td>22</td><td>37</td></tr><tr><td>swimmer</td><td>swimmer6 swimmer15</td><td>5 14</td><td>16 34</td><td>25 61</td></tr></table>",
+        "bbox": [
+            321,
+            332,
+            671,
+            623
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/cc1060e7cd2de7c0a7602b73430b1ede207eab3db2ee66d7521f03114c6a10dd.jpg",
+        "table_caption": [
+            "Table 2: Observation components given in each of the manipulation tasks, and their corresponding dimensionalities. Here $\\mathrm { \\ s i n _ { z } }$ , $\\mathrm { c o s } _ { \\mathrm { z } }$ refers to the sine and cosine of the target frame’s angle of rotation about the $z$ -axis. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\" colspan=\"3\"></td><td colspan=\"3\">Task</td></tr><tr><td>Catch</td><td>Pick-up-and-orient</td><td>Rotate-in-hand</td></tr><tr><td rowspan=\"3\">Hand</td><td> joint positions</td><td>22</td><td>√</td><td>√</td><td>√</td></tr><tr><td> joint velocities</td><td>22</td><td>√</td><td>√</td><td>√</td></tr><tr><td> actuator targets</td><td>13</td><td>√</td><td>√</td><td>√</td></tr><tr><td rowspan=\"3\">Object</td><td>position</td><td>3</td><td>√</td><td>√</td><td>√</td></tr><tr><td>quaternion</td><td>4</td><td>√</td><td>√</td><td>&lt;</td></tr><tr><td>velocity</td><td>6</td><td>√</td><td>√</td><td>√</td></tr><tr><td rowspan=\"3\">Target</td><td>position</td><td>3</td><td>1</td><td>√</td><td>1</td></tr><tr><td>quaternion</td><td>4</td><td>1</td><td>√</td><td>1</td></tr><tr><td>sinz, COSz</td><td>2</td><td>1</td><td>1</td><td>√</td></tr><tr><td>Total</td><td></td><td></td><td>70</td><td>77</td><td>72</td></tr></table>",
+        "bbox": [
+            222,
+            666,
+            772,
+            866
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/1fc22329665ff2bb15967cf6a63a440ed1267ae494ff61f9c0a0b4b3ea5e87ee.jpg",
+        "image_caption": [
+            "Figure 10: Sequences of frames illustrating the dexterous manipulation tasks we attempt to solve using D4PG. Top to bottom: ‘catch’, ‘pick-up-and-orient’, ‘rotate-in-hand’. The translucent objects shown in ‘pick-up-and-orient’ and ‘rotate-in-hand’ represent the goal states. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            386
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            476,
+            821,
+            503
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In the ‘catch’ task the agent must learn to catch a falling object before it strikes the table below. The position, height, and orientation of the object are randomly initialized at the start of each episode. The reward is given by ",
+        "bbox": [
+            174,
+            510,
+            825,
+            551
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/349fe95c816af76609c16a64bc04dc6a72e4ab216db606fe5efff1979c7f81c0.jpg",
+        "text": "$$\nr = \\psi ( \\mathrm { p a l m } _ { \\mathrm { h e i g h t } } - \\mathrm { o b j } _ { \\mathrm { h e i g h t } } ; c , m )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            569,
+            620,
+            587
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $\\psi ( \\epsilon ; c , m )$ is a soft indicator function similar to one described by Hafner & Riedmiller (2011) ",
+        "bbox": [
+            176,
+            593,
+            821,
+            609
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/340892476874b55e8d44a107c2f909aada8d9b4994550a6bd7e3ae85013399d3.jpg",
+        "text": "$$\n\\psi ( \\epsilon ; c , m ) = \\left\\{ { \\begin{array} { l l } { 1 - \\operatorname { t a n h } ( { \\frac { w } { m } } \\epsilon ) ^ { 2 } } & { { \\mathrm { i f ~ } } \\epsilon > c , } \\\\ { 1 } & { { \\mathrm { o t h e r w i s e . } } } \\end{array} } \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            625,
+            642,
+            660
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here $w = \\operatorname { t a n h } ^ { - 1 } ( { \\sqrt { 0 . 9 5 } } )$ , and the tolerance $c$ and margin $m$ parameters are $0 \\mathrm { c m }$ and $5 \\mathrm { c m }$ respectively. Contact between the object and the table causes the current episode to terminate immediately with no reward, otherwise it will continue until a 500 step limit is reached. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            710
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In the ‘pick-up-and-orient’ task, the agent must pick up a cylindrical object from the table and maneuver it into a target position and orientation. Both the initial position and orientation of the object, and the position and orientation of the target are randomized between episodes. The reward function consists of two additive components that depend on the distance from the object to the target position, and on the angle between the $z$ -axes of the object and target body frames ",
+        "bbox": [
+            173,
+            717,
+            825,
+            785
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8bd2436da84f48236bd7515a8263fb0c3498af27bedbe98be7015c6d9c07d4b8.jpg",
+        "text": "$$\nr = 0 . 5 \\psi ( | | \\mathrm { o b j } _ { \\mathrm { p o s } } - \\mathrm { o b j } _ { \\mathrm { p o s } } ^ { \\mathrm { t a r g e t } } | | _ { 2 } ; c _ { \\mathrm { p o s } } , m _ { \\mathrm { p o s } } ) ( 1 + \\psi ( \\cos ^ { - 1 } ( \\mathrm { o b j } _ { \\mathrm { z a x i s } } \\cdot \\mathrm { o b j } _ { \\mathrm { z a x i s } } ^ { \\mathrm { t a r g e t } } ) ; c _ { \\mathrm { o r i } } , m _ { \\mathrm { o r i } } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            806,
+            787,
+            825
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $c _ { \\mathrm { p o s } } { = } 1$ cm, $m _ { \\mathrm { p o s } } { = } 5 \\mathrm { c m }$ , $c _ { \\mathrm { o r i } } { = } 5 ^ { \\circ }$ , $m _ { \\mathrm { o r i } } { = } 1 0 ^ { \\circ }$ . Note that the distance-dependent component of the reward multiplicatively gates the orientation component. This helps to encourage the agent to pick up the object before attempting to orient it to match the target. Each episode has a fixed duration of 500 steps. ",
+        "bbox": [
+            174,
+            835,
+            825,
+            890
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Finally, in the ‘rotate-in-hand’ task the agent begins with a broad cylinder in its palm, and must rotate it axially in order to match a moving target. This requires dynamically forming and breaking contacts with the object being manipulated. The target angle is initialized uniformly, and then incremented on each time step using temporally correlated noise drawn from an Ornstein-Uhlenbeck process $\\scriptstyle \\sigma = 0 . 0 2 5 ^ { \\circ }$ , $\\scriptstyle \\theta = 0 . 0 1$ ; Uhlenbeck & Ornstein 1930). The reward consists of two multiplicative components ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            157
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/484b50d96e917e84ce43868f8428131a078d130320b9dc5f8cb24a2bf3e5e7e1.jpg",
+        "text": "$$\nr = \\psi { \\bigl ( } \\cos ^ { - 1 } ( \\mathrm { o b j } _ { \\mathrm { y a x i s } } | \\times \\mathrm { y , ~ o b j } _ { \\mathrm { y a x i s } } ^ { \\mathrm { t a r g e t } } | \\times \\mathrm { y } ) { \\bigr ) } ; c _ { \\mathrm { r o t } } , m _ { \\mathrm { r o t } } { \\bigr ) } \\psi { \\bigl ( } \\cos ^ { - 1 } ( \\mathrm { o b j } _ { \\mathrm { z a x i s } } , \\mathrm { o b j } _ { \\mathrm { z a x i s } } ^ { \\mathrm { t a r g e t } } ) ; c _ { \\mathrm { o r i } } , m _ { \\mathrm { o r i } } { \\bigr ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            183,
+            785,
+            204
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "where $c _ { \\mathrm { r o t } } { = } 5 ^ { \\circ }$ , $m _ { \\mathrm { r o t } } { = } 4 0 ^ { \\circ }$ , $c _ { \\mathrm { o r i } } { = } 4 5 ^ { \\circ }$ , $m _ { \\mathrm { o r i } } { = } 4 5 ^ { \\circ }$ , and $| | \\mathrm { x y }$ denotes projection onto the global $x y$ plane. The first component provides an incentive to match the axial rotation of the target, and the second component penalizes the agent for allowing the orientation of the cylinder’s long axis to deviate too far from that of the target. The maximum episode duration is 1000 steps, with early termination if the object makes contact with the table. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            286
+        ],
+        "page_idx": 15
+    }
+]

parse/train/rkTBjG-AZ/rkTBjG-AZ.md

@@ -0,0 +1,371 @@
+# DEEPARCHITECT: AUTOMATICALLY DESIGNING ANDTRAINING DEEP ARCHITECTURES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In deep learning, performance is strongly affected by the choice of architecture and hyperparameters. While there has been extensive work on automatic hyperparameter optimization for simple spaces, complex spaces such as the space of deep architectures remain largely unexplored. As a result, the choice of architecture is done manually by the human expert through a slow trial and error process guided mainly by intuition. In this paper we describe a framework for automatically designing and training deep models. We propose an extensible and modular language that allows the human expert to compactly represent complex search spaces over architectures and their hyperparameters. The resulting search spaces are treestructured and therefore easy to traverse. Models can be automatically compiled to computational graphs once values for all hyperparameters have been chosen. We can leverage the structure of the search space to introduce different model search algorithms, such as random search, Monte Carlo tree search (MCTS), and sequential model-based optimization (SMBO). We present experiments comparing the different algorithms on CIFAR-10 and show that MCTS and SMBO outperform random search. We also present experiments on MNIST, showing that the same search space achieves near state-of-the-art performance with a few samples. These experiments show that our framework can be used effectively for model discovery, as it is possible to describe expressive search spaces and discover competitive models without much effort from the human expert. Code for our framework and experiments has been made publicly available.
+
+# 1 INTRODUCTION
+
+Deep learning has seen a surge in popularity due to breakthroughs in applications such as computer vision, natural language processing, and reinforcement learning (He et al., 2016; Karpathy & FeiFei, 2015; Silver et al., 2016; Sutskever et al., 2014). An important observation in much of the recent work is that complex architectures are important for achieving high performance (He et al., 2016; Mnih et al., 2013). Larger datasets and more powerful computing infrastructures are likely to increase our ability to effectively train larger, deeper, and more complex architectures. However, improving the performance of a neural network is not as simple as adding more layers or parameters—it often requires clever ideas such as creating more branches (Szegedy et al., 2015) or adding skip connections (He et al., 2016). Even popular techniques such as dropout (Srivastava et al., 2014) and batch normalization (Ioffe & Szegedy, 2015) do not always lead to better performance, and need to be judiciously applied to be helpful.
+
+Currently, choosing appropriate values for these architectural hyperparameters requires close supervision by a human expert, in a trial and error manual search process largely guided by intuition. The expert is burdened by having to make the large number of choices involved in the specification of a deep model. Choices interact in non-obvious ways and strongly impact performance. The typical workflow has the expert specify a single model, train it, and compute a validation score. Based on the validation score, previous experience, and information gathered during training, the expert decides if the trained model is satisfactory or not. If the model is considered unsatisfactory, the expert has to think about model variations that may lead to better performance.
+
+From the perspective of the expert, it would be convenient to search over architectures automatically, just as we search over simple scalar hyperparameters, such as the learning rate and the regularization coefficient. Ideally, the expert would have control in setting up the search space to incorporate inductive biases about the task being solved and constraints about computational resources. Prior to this work, achieving this goal was hard because expressing model search spaces using general hyperparameter optimization tools requires the human expert to manually distill a set of relevant scalar architectural hyperparameters.
+
+The main contributions of our work are
+
+1. a modular, compositional, and extensible language for compactly representing expressive search spaces over models that
+
+(a) gives control to the human expert over what model variations to consider; (b) makes it easy to automatically search for performant models in the search space; (c) allows models to be directly compiled to computational graphs without the human expert having to write additional code.
+
+2. model search algorithms that rely on the tree-structured search spaces induced by our language to systematically and efficiently search for performant models; namely, we
+
+(a) show that by using constructs in our language, even random search can be effective;   
+(b) compare different model search algorithms experimentally, and show that random search is outperformed by algorithms that leverage the structure of the search space to generalize more effectively across different models.
+
+The main differences between our work and previous work are that we develop a modular, composable and extensible language, focusing on the problem of searching over deep architectures. This focus allows the expert to compactly set up a search space, search over it, and automatically compile models to their corresponding computational graphs. Our language can be seen as an effort to combine the functionalities of a deep model specification language (e.g., Tensorflow (Abadi et al., 2016)) and a structured hyperparameter search language (e.g., Hyperopt (Yamins et al., 2013)).
+
+# 2 RELATED WORK
+
+Model search has a long and rich history in machine learning and statistics. There has been a wide variety of theoretical and empirical research in this area (Agarwal et al., 2011; Bergstra et al., 2011; Bergstra & Bengio, 2012; Sabharwal et al., 2015), including Bayesian optimization methods (Hutter et al., 2011; Kandasamy et al., 2015; Snoek et al., 2012). However, conventional methods are primarily designed for searching over hyperparameters living in Euclidean space. Such methods are ill suited in today’s context, where the discrete architectural choices are just as important as the numerical values of the hyperparameters. Searching over architectures using current hyperparameter optimization algorithms requires the expert to distill structural choices into scalar hyperparameters. As a result, typically only a few simple global structural hyperparameters are considered, e.g., the depth of the network or whether to use dropout or not. This constrains the richness of the search space, preventing the expert from finding unexpected model variations leading to better performance; e.g., perhaps dropout is useful only after certain types of layers, or batch normalization only helps in the first half of the network.
+
+Architecture search has also been considered under the topic of neuroevolution (Stanley & Miikkulainen, 2002), which uses evolutionary (i.e., genetic) strategies to define and search a space of models. In classical approaches, neuroevolution attempts to jointly choose the topology and the parameters of the architecture using genetic algorithms.
+
+Architecture search has received renewed interest recently. Wierstra et al. (2005), Floreano et al. (2008), and Real et al. (2017) use evolutionary algorithms which start from an initial model and evolve it based on its validation performance. Zoph & Le (2017) propose a reinforcement learning procedure based on policy gradient for searching for convolutional and LSTM architectures. Baker et al. (2016) propose a reinforcement learning procedure based on Q-learning for searching for convolutional architectures.
+
+Unfortunately all these approaches consider fixed hard-coded model search spaces that do not easily allow the human expert to incorporate inductive biases about the task being solved, making them unsuitable as general tools for architecture search. For example, evolutionary approaches require an encoding for the models in the search space and genetic operators (e.g., mutation and crossover) which generate encodings for new models out of encodings of old ones. These aspects are handcrafted and hard-coded so it is hard for the human expert to change the search space in flexible ways. Perhaps different model encodings or genetic operators can be considered, but these knobs give somewhat loose and indirect control over the model search space. The reinforcement learning approaches considered suffer from similar issues—the search spaces are hard-coded and not easily modifiable. None of these approaches have the compositionality, modularity, and extensibility properties of our language.
+
+Bergstra et al. (2011) propose Tree of Parzen Estimators (TPE), which can be used to search over structured hyperparameter spaces, and use it to tune the hyperparameters of a Deep Boltzmann Machine. Yamins et al. (2013) use TPE to search for values of the hyperparameters of a computer vision system, and show that it can find better values than the best ones previously known.
+
+TPE is a general hyperparameter search algorithm, and therefore requires considerable effort to use—for any fixed model search space, using TPE requires the human expert to distill the hyperparameters of the search space, express the search space in Hyperopt (Yamins et al., 2013) (an implementation of TPE), and write the code describing how values of the hyperparameters in the search space compile to a computational graph. In contrast, our language is modular and composable in the sense that:
+
+1. search spaces (defined through modules) are constructed compositionally out of simpler search spaces (i.e., simpler modules);   
+2. hyperparameters for composite modules are derived automatically from the hyperparameters of simpler modules;   
+3. once values for all hyperparameters of a module have been chosen, the resulting model can be automatically mapped to a computational graph without the human expert having to write additional code.
+
+# 3 ROADMAP TO THE DEEPARCHITECT FRAMEWORK
+
+Our framework reduces the problem of searching over models into three modular components: the model search space specification language, the model search algorithm, and the model evaluation algorithm.
+
+Model Search Specification Language: The model search space specification language is built around the concept of a modular computational module. This is akin to the concept of a module (Bottou & Gallinari, 1991) used in deep learning frameworks such as Torch (Collobert et al., 2011): by implementing the module interface, the internal implementation becomes irrelevant. These modules allow one to express easily complex design choices such as whether to include a module or not, choose between modules of different types, or choose how many times to repeat a module structure. The main insight is that complex modules can be created compositionally out of simpler ones. The behavior of complex modules is generated automatically out of the behavior of simpler modules. Furthermore, our language is extensible, allowing the implementation of new types of modules by implementing a high-level interface local to the module.
+
+Model Search Algorithm: The way the model search space is explored is determined by the model search algorithm. This part of the framework decides how much effort to allocate to each part of the search space based on the performance observed for previous models. The model search algorithm typically requires a model evaluation algorithm that computes the performance of a fully specified model. The search algorithm will then use this information to determine which models to try next. The search algorithm interacts with the search space only through a minimal interface that allows it to traverse the space of models and evaluate models discovered this way. This interface is the same irrespective of the specific search space under consideration. We experiment with different search algorithms, such as Monte Carlo tree search (Browne et al., 2012) and Sequential Model Based Optimization (Hutter et al., 2011).
+
+Model Evaluation Algorithm: Having fully specified a model, i.e., having reached a leaf in the tree defined by our model search space, we can evaluate how good this model is according to some criterion defined by the expert. This typically involves training the model on a training set and evaluating it on a validation set. The training procedure often has multiple hyperparameters that can be tuned (e.g., the choice of the optimization algorithm and its hyperparameters, and the learning rate schedule). If the expert does not know how to write down a reasonable training procedure for every model in the search space, the expert can introduce hyperparameters for the evaluation algorithm and search over them using our specification language.
+
+Any of the above components can be changed, improved, or extended, while keeping the others fixed. The fact that different components interact only through well-defined interfaces makes it possible to extend and reuse this framework. We believe that DeepArchitect will be an interesting platform for future research in deep learning and hyperparameter tuning for architecture search.
+
+# 4 MODEL SEARCH SPACE SPECIFICATION LANGUAGE
+
+# 4.1 SEARCH SPACE DEFINITION
+
+The computational module is the fundamental unit of our model search space specification language. We define a computational module as a function
+
+$$
+f : n \to \left( \mathcal { H } \to ( \mathbb { R } ^ { p } \to ( \mathbb { R } ^ { n } \to \mathbb { R } ^ { m } ) ) \right) ,
+$$
+
+where $n$ is the dimensionality of the input, $\mathcal { H }$ is the set of valid values for the hyperparameters, $p$ is the number of parameters, and $m$ is the dimensionality of the output. The set $\mathcal { H }$ can be structured or simply the cross product of scalar hyperparameter sets, i.e., $\mathcal { H } = \mathcal { H } _ { 1 } \times . . . \times \mathcal { H } _ { H }$ , where $H$ is the number of scalar hyperparameters. The set $\mathcal { H }$ is assumed to be discrete in both cases.
+
+Definition (1) merits some discussion. For conciseness we have not explicitly represented it, but the number of parameters $p$ and the output dimensionality $m$ can both be functions of the input dimensionality $n$ and the chosen hyperparameter values $h \in \mathcal H$ . For example, an affine module with $h$ dense hidden units has output dimensionality $m = h$ and number of parameters $p = ( n + 1 ) h$ : a weight matrix $W \in \mathbb { R } ^ { h \times n }$ and a bias vector $b \in \mathbb { R } ^ { h }$ . A similar reasoning can be carried out for a convolutional module: the number of parameters $p$ depends on the input dimensionality, the number of filters, and the size of the filters; the dimensionality of the output $m$ depends on the input dimensionality, the number of filters, the size of the filters, the stride, and the padding scheme. The fact that $p$ and $m$ are functions of the input dimensionality and the chosen hyperparameter values is one of the main observations that allows us to do architecture search—once we know the input dimensionality and have fixed values for the hyperparameters, the structure of the computation performed by the module is determined, and this information can be propagated to other modules. We say that a module is fully specified when values for all hyperparameters of the module have been chosen and the input dimensionality is known.
+
+We focus on search spaces for architectures that have a single input terminal and a single output terminal. By this, we only mean that the input and output of the module have to be a single tensor of arbitrary order and dimensionality. For example, convolutional modules take as input an order three tensor and return as output an order three tensor, therefore they are single-input single-output modules under our definition. We also assume that the output of a module is used as input to at most a single module, i.e., we assume no output sharing.
+
+These restrictions were introduced to simplify exposition. The single-input single-output case with no sharing is simpler to develop and exemplifies the main ideas that allow us to develop a framework for automatic architecture search. The ideas developed in this work extend naturally to the multipleinput multiple-output case with sharing. Additionally, often we can represent modules that are not single-input single-output by defining new modules that encapsulate many signal paths from input to output. For example, a residual module (He et al., 2016) can be treated in our framework by noting that it is single-input before the skip connection split and single-output after the skip connection merge. Many top performing architectures, such as AlexNet (Krizhevsky et al., 2012), VGG (Simonyan & Zisserman, 2014), and ResNet (He et al., 2016), are captured in our language.
+
+We distinguish between basic computational modules and composite computational modules. Basic modules do some well defined transformation. Affine, batch normalization, and dropout are examples of basic modules. Composite modules are defined in terms of other (composite or basic) modules, i.e., the instantiation of a composite module takes other modules as arguments. Composite modules may introduce hyperparameters of their own and inherit hyperparameters of the modules taken as arguments. For example, an $\bigcirc \mathtt { r }$ module takes a list of modules and chooses one of the modules to use. It introduces a discrete hyperparameter for which module to use, and chooses values for the hyperparameters of the chosen module; the hyperparameters available are conditional on the choice of the module to use. Most of the representational power of our language arises from the compositionality of composite and basic modules.
+
+![](images/bb872f8c94981e2eaa50d8b197b91805347946a6f3f2ed2d97f86cdfc41dbfaf.jpg)  
+Figure 1: (a) A simple search space with 24 different models. (b) A path through the search space encoding a convolutional module with 64 filters of size $3 \times 3$ , with stride 1, followed by batch normalization, ReLU and affine modules. The model does not use dropout. Branches encoding hyperparameters with a single choice were omitted.
+
+The ideas developed in this section are perhaps best illustrated with an example. See Figure 1a for the definition of an example search space in LISP-like pseudocode that closely parallels our implementation. The search space, which results from the composition of several modules, and therefore is also a module itself, encodes 24 different models, corresponding to the different 24 possible paths from the root to the leaves of the tree. The space is defined using three composite modules (Concat, MaybeSwap, and Optional) and five basic modules (Conv2D, BatchNormalization, ReLU, Dropout, and Affine). Concat introduces no additional hyperparameters, but it has to specify all the modules that have been delegated to it; MaybeSwap introduces a binary hyperparameter that encodes whether to swap the order of the pair of modules or not; Optional introduces a binary hyperparameter that encodes whether to include the module or not. The behavior of the basic modules in Figure 1a is simple: Conv2D takes lists of possible values for the number of filters, the size of the filters, and the stride; BatchNormalization and ReLU have no hyperparameters; Dropout takes a list for the possible values for the dropout probability; Affine takes a list for the possible values of the number of hidden units.
+
+Choosing different values for the hyperparameters of the composite modules may affect the structure of the resulting architecture, while choosing different values for the hyperparameters of the basic modules only affects the structure of the corresponding local transformations. The search space of Figure 1a results from the composition of basic and composite modules; therefore it is a module itself and can be characterized by its input, output, parameters, and hyperparameters. Our set of composite modules in not minimal: e.g., given an Empty basic module, which has no hyperparameters or parameters and simply does the identity transformation, and a Or composite module, which introduces an extra hyperparameter encoding the choice of a specific module in its list, the composite modules Optional and MaybeSwap can be defined as (Optional B) $=$ ( $\bigcirc \mathtt { r }$ Empty B) and (MaybeSwap B1 B2) $=$ (Or (Concat B1 B2), (Concat B2 B1)).
+
+# 4.2 SEARCH SPACE TRAVERSAL
+
+Given a search space defined by a module, there is an underlying tree over fully specified models: we build this tree by sequentially assigning values to each of the hyperparameters of the module.
+
+Each internal node in the tree corresponds to some partial assignment to the hyperparameters of the module, and each terminal node (i.e., each leaf) corresponds to a fully specified model. We can also think about an internal node as corresponding to the state of a module before assigning a value to the next unassigned hyperparameter. The branching factor of a node corresponds to the number of possible values for the hyperparameter under consideration at that node, and traversing a specific edge from that node to a child corresponds to assigning the value encoded by that edge to the hyperparameter under consideration. As a tree has a single path between the root and any leaf, the paths from root to leaves are in one-to-one correspondence with fully specified models. A leaf is reached when there are no hyperparameters left to specify.
+
+In Figure 1b we have drawn a path through the search space of Figure 1a from the root (labeled node 0), where all hyperparameters are unassigned, to a terminal node (labeled node 4), where all hyperparameters have been assigned values. Each branch in the tree corresponds to the assignment of some value to some hyperparameter. At node 0, we are choosing between 32 or 64 filters; at node 1, we are choosing between filters of size 3 or 5; at node 2, we are choosing between applying batch normalization before or after ReLU; at node 3, we are choosing whether to do dropout or not. Node 4 is terminal and corresponds to a fully specified model. Decisions at each node are conditional on decisions previously made. Internal nodes with a single child (i.e., branches for hyperparameters with a single possible value) have been collapsed and omitted from Figure 1a. Other paths may have different lengths, e.g., picking a path through the right child of node 3 corresponds to adding a Dropout module, which requires an additional hyperparameter choice for the dropout probability when compared to the path from the root to node 4.
+
+Search spaces arising from module composition have their traversal functionality automatically derived from the traversal functionality of their component modules: a basic module knows how to sequentially assign values to its hyperparameters, and a composite module knows how to sequentially assign values to its hyperparameters and call the sequential assignment functionality for its component modules. This is akin to recursive expression evaluation in programming languages.
+
+To traverse the search space, i.e., to assign values to all hyperparameters of the module defining the search space, all that it is needed is that each module knows how to sequentially specify itself. Modules resulting from the composition of modules will then be automatically sequentially specifiable. The three local operations that a module needs to implement for traversal are: to test whether it is fully specified (i.e., whether it has reached a leaf yet); if it is not specified, to return which hyperparameter it is specifying and what are the possible values for it; and given a choice for the current hyperparameter under consideration, to traverse the edge to the child of the current node corresponding to chosen value.
+
+# 4.3 COMPILATION
+
+Once values for all hyperparameters of a module have been chosen, the fully specified model can be automatically mapped to its corresponding computational graph. We call this mapping compilation. This operation only requires that each module knows how to locally map itself to a computational graph: compilation is derived recursively from the compilation of simpler modules. For example, if we know how to compile Conv2D, ReLU, and $\bigcirc \mathtt { r }$ modules, we will automatically be able to compile all modules built from them. This behavior is also similar to recursive expression evaluation in programming languages.
+
+# 5 MODEL SEARCH ALGORITHMS
+
+In this section, we consider different search algorithms that are built on top of the functionality described above. Some of these algorithms rely on the search space being tree structured. One of the challenges of our setting is that deep models are expensive to train, so unless we have access to extraordinary computational resources, only a moderate number of evaluations will be practical.
+
+# 5.1 RANDOM SEARCH
+
+Random search is the simplest algorithm that we can consider. At each node of the tree, we choose an outgoing edge uniformly at random, until we reach a leaf node (i.e., a model). Even just random
+
+search is interesting, as the model search space specification language allows us to capture expressive structural search spaces. Without our language, randomly selecting an interesting architecture to try would not be possible without considerable effort from the human expert.
+
+# 5.2 MONTE CARLO TREE SEARCH
+
+Monte Carlo tree search (MCTS) (Browne et al., 2012; Kocsis & Szepesvari, 2006) is an approxi- ´ mate planning technique that has been used effectively in many domains (Silver et al., 2016). Contrary to random search, MCTS uses the information gathered so far to steer its policy towards better performing parts of the search space. MCTS maintains a search tree that is expanded incrementally one node at a time. MCTS uses two policies: a tree policy, which determines the path to be traversed from the root to the frontier of the already expanded tree; and a rollout policy, which determines the path to be traversed from the frontier of the already expanded tree until a leaf is reached. Once a leaf is reached, the model encoded by it is evaluated (e.g., trained on the training set and evaluated on the validation set), and the resulting score is used to update the statistics of the nodes in the currently expanded tree in the path to the leaf. Each node in the expanded tree keeps statistics about the number of times it was visited and the average score of the models that were evaluated in the subtree at that node. The rollout policy is often simple, e.g., the random policy described in Section 5.1.
+
+The tree policy typically uses an upper confidence bound (UCB) approach. Let $n$ be the number of visits of a node $v \in \mathcal T$ , where $\tau$ denotes the currently expanded tree, and $n _ { 1 } , \ldots , n _ { b }$ and ${ \bar { X } } _ { 1 } , \dots , { \bar { X } } _ { b }$ be, respectively, the number of visits and the average scores of the $b$ children of $v$ . The tree policy at $x$ chooses to traverse an edge corresponding to a child maximizing the UCB score:
+
+$$
+\operatorname* { m a x } _ { i \in \{ 1 , \dots , b \} } { \bar { X } } _ { i } + 2 c \sqrt { \frac { 2 \log n } { n _ { i } } } ,
+$$
+
+where $c \in \mathbb { R } _ { + }$ is a constant capturing the trade-off between exploration and exploitation—larger values of $c$ correspond to larger amounts of exploration. If at node $x$ , some of its children have not been added to the tree, there will be some $i \in \{ 1 , \ldots , b \}$ for which $n _ { i } = 0$ ; in this case we define the UCB score to be infinite, and therefore, unexpanded children always take precedence over expanded children. If multiple unexpanded children are available, we expand one uniformly at random.
+
+# 5.3 MONTE CARLO TREE SEARCH WITH TREE RESTRUCTURING
+
+When MCTS visits a node in the expanded part of the tree, it has to expand all children of that node before expanding any children of its currently expanded children. This is undesirable when there are hyperparameters that can take a large number of related values.
+
+We often consider hyperparameters which take numeric values, and similar values result in similar performance. For example, choosing between 64 or 80 filters for a convolutional module might not have a dramatic impact on performance. A way of addressing such hyperparameters is to restructure the branches of the tree by doing bisection. Assume that the set of hyperparameters has a natural ordering. At a node, rather than committing directly to a value of the hyperparameter, we commit sequentially—first we decide if we are choosing a value in the first or second half of the set of hyperparameters, and then we recurse on the chosen half until we have narrow it down to a single value. See an example tree in Figure 2a and the corresponding restructured tree in Figure 2b.
+
+Tree restructuring involves a tradeoff between depth and breadth: the tree in Figure 2a has depth 1, while the tree in Figure 2b has depth 3. The restructured tree can have better properties in the sense that there more sharing between different values of the hyperparameters. We could also consider restructured trees with branching factors different than two, again trading off depth and breadth. If the branching factor of the restructured tree is larger than the number of children of the hyperparameter, the restructuring has no effect, i.e., the original and restructured trees are equal. The restructuring operation allows MCTS to effectively consider hyperparameters with a large number of possible values.
+
+# 5.4 SEQUENTIAL MODEL BASED OPTIMIZATION
+
+MCTS is tabular in the sense that it keeps statistics for each node in the tree. While the restructuring operation described in Section 5.3 increases sharing between different hyperparameter values, it still suffers from the problem that nodes have no way of sharing information other than through common ancestors. This is problematic because differences in hyperparameter values at the top levels of the tree lead to little sharing between models, even if the resulting models happen to be very similar.
+
+![](images/a3f4ace9438913fcb7b6f80a0bfe719b426907201ad9f9f0f978caff30fee613.jpg)  
+Figure 2: (a) A tree encoding an hyperparameter and its five possible values. MCTS applied to this tree is sample-inefficient as there is no sharing of information between the different child nodes. (b) The result of restructuring the tree with bisection. MCTS applied to this tree results in more sharing when compared to the original tree. For example, sampling a path reaching node 1 provides information about nodes 1, 2, and 3.
+
+Sequential Model Based Optimization (SMBO) (Hutter et al., 2011) allows us to address this problem by introducing a surrogate function which can be used to capture relationships between models and how promising it is to evaluate any specific model. The surrogate function can use expressive features to capture architecture patterns that influence performance, e.g., features about sequences of basic modules that occur in the model.
+
+The surrogate function can then be optimized to choose which model to evaluate next. Exactly optimizing the surrogate function over a search space can be difficult as often there is a combinatorially large number of models. To approximately optimize the surrogate function, we do some number of random rollouts from the root of the tree until we hit leaf nodes (i.e., models), we evaluate the surrogate function (i.e., we determine, according to the surrogate function, how promising it is to evaluate that model), and evaluate the model that has the highest score according to the surrogate function. We also introduce an exploratory component where we flip a biased coin and choose between evaluating a random model or evaluating the best model according to the surrogate function. The surrogate function is updated after each evaluation.
+
+In our experiments, we use a simple surrogate function: we train a ridge regressor to predict model performance, using the models evaluated so far and their corresponding performances as training data. We only use features based on $n$ -grams of sequences of basic modules, disregarding the values of the hyperparameters. More complex features, surrogate functions, and training losses are likely to lead to better search performance, but we leave these to future work.
+
+# 6 MODEL EVALUATION ALGORITHMS
+
+As a reminder, once we assign values to all hyperparameters of the module defining the search space, we need to compute a score for the resulting model, i.e., a score for the path from the root to the corresponding leaf encoding the model to evaluate. The specific way to compute scores is defined by the human expert, and it typically amounts to training the model on a training set and evaluating the trained model on a validation set. The score of the model is the resulting validation performance. The training process often has its own hyperparameters, such as: what optimization algorithm to use and its corresponding hyperparameters, the learning rate schedule (e.g., the initial learning rate, the learning rate reduction multiplier, and how many epochs without improving the validation performance the algorithm waits before reducing the learning rate), how many epochs without improving the validation performance the algorithm waits before terminating the training process (i.e., early stopping), and what data augmentation strategies to use and their corresponding hyperparameters. The behavior of the evaluation algorithm with respect to the values of its hyperparameters is defined by the expert for the task being considered, so the compilation step described in Section 4.3 for this functionality has to be implemented by the expert. Nonetheless, these user hyperparameters can be included in the search space and searched over in the same way as the architecture hyperparameters described in Section 4.1.
+
+![](images/6d743b8e33d55a478268550929c1fe86684dcf62792e5b154ba8785db470486f.jpg)  
+Figure 3: (a, b) Average maximum validation score achieved as a function of the number of evaluation across five repetitions. The error bars indicate standard error. The range of 64 evaluations is split into two plots for clearer visualization. (c) Percentage of models above a given validation threshold performance. MCTS with bisection and SMBO outperform random search. The error bars have size equal to the standard error.
+
+# 7 EXPERIMENTS
+
+We illustrate how our framework can be used to search over all hyperparameters of a model, i.e., both architecture and training hyperparameters, using only high-level insights. We choose a search space of deep convolutional models based around the ideas that depth is important, batch normalization helps convergence, and dropout is sometimes helpful. We search over architectures and evaluate our models on CIFAR-10 (Krizhevsky, 2009).
+
+The training hyperparameters that we consider are whether to use ADAM or SGD with momentum, the initial learning rate, the learning rate reduction multiplier, and the rate reduction patience, i.e., how many epochs without improvement to wait before reducing the current learning rate. We use standard data augmentation techniques: we zero pad the CIFAR-10 images to size $4 0 \times 4 0 \times 3$ , randomly crop a $3 2 \times 3 2$ portion, and flip horizontally at random. We could search over these too if desired.
+
+We compare the search algorithms described in Section 5 in terms of the best model found, according to validation performance, as a function of the number of evaluations. We run each algorithm 5 times, for 64 model evaluations each time. All models were trained for 30 minutes on GeForce GTX 970 GPUs in machines with similar specifications.
+
+In Figure 3a and Figure 3b, we see that all search algorithms find performant solutions (around $8 9 \%$ accuracy) after 64 evaluations. In Figure 3a, we see that for fewer than 6 evaluations there is considerable variance between the different algorithms; the more sophisticated model search algorithms are not able to outperform random search with so few evaluations. In Figure 3b, we see that both SMBO and MCTS with bisection eventually outperform random search; MCTS with bisection starts outperforming random search around 32 evaluations, while for SMBO, it happens around 16 evaluations.
+
+Surprisingly, MCTS without restructuring does not outperform random search. We think that this is because there are too many possible values for the first few hyperparameters in the tree, so MCTS will not be able to identify and focus on high-performance regions of the search space within the number of evaluations available. MCTS with bisection and SMBO do not suffer from these problems, and therefore can identify and focus on high performance regions of the search space earlier. In addition to achieving a higher top accuracy, MCTS with bisection and SMBO evaluate a larger fraction of high-performance models when compared to random search, as can be seen in Figure 3c.
+
+The main goal of the previous experiment is to show that more complex model search algorithms can outperform random search by better leveraging the structure of the search. We are not attempting to achieve state-of-the-art performance. We now show that using the same search space on MNIST with a larger time budget leads to close to state-of-the-art performance. The data augmentation scheme is slightly different, as we no longer randomly flip the image horizontally, but now consider random rotations where the maximum angle of rotation is also added as a hyperparameter to the search space.
+
+In this experiment, we randomly sample 16 models in the search space and train them for up to 3 hours or until the validation performance fails to increase for more than 128 epochs. The best model among the models sampled chosen according to validation performance obtained among the 16 sampled models has test accuracy equal to $9 9 . { \bar { 7 } } 2 \%$ , which is close to the single model state-of-theart of $9 9 . 7 7 \%$ (Sato et al., 2015). Additionally, taking a simple majority voting emsemble of the 5 best performing models yielded the same validation accuracy as the best single model and increased test accuracy to $9 9 . 7 5 \%$ . The performance profile of the sampled models and the architecture and hyperparameters of the best model are presented in Appendix A.
+
+We can build good ensembles by sampling models in the search space and building an ensemble out of the best ones. It has been observed in the literature that model diversity often improves emsemble performance. Our results suggest that it is possible to define search spaces that work well across a range of tasks, having the potential to significantly reduce the burden on the human expert.
+
+# 8 CONCLUSION
+
+We described a framework for automatically designing and training deep models. This framework consists of three fundamental components: the model search space specification language, the model search algorithm, and the model evaluation algorithm. The model search space specification language is composable, modular, and extensible, and allows us to easily define expressive search spaces over architectures. The model evaluation algorithm determines how to compute a score for a model in the search space. Models can be automatically compiled to their corresponding computational graphs. Using the model search space specification language and the model evaluation algorithm, we can introduce model search algorithms for exploring the search space. Using our framework, it is possible to do random search over interesting spaces of architectures without much effort from the expert. We also described more complex model search algorithms, such as MCTS, MCTS with tree restructuring, and SMBO. We present experiments on CIFAR-10 comparing different model search algorithms and show that MCTS with tree restructuring and SMBO outperform random search. Code for our framework and experiments has been made publicly available. We hope that this paper will lead to more work and better tools for automatic architecture search.
+
+# REFERENCES
+
+Martın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv:1603.04467, 2016.   
+Alekh Agarwal, John Duchi, Peter Bartlett, and Clement Levrard. Oracle inequalities for computationally budgeted model selection. In Conference on Learning Theory, 2011.   
+Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. arXiv:1611.02167, 2016.   
+James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13(Feb):281–305, 2012.   
+James Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper-parameter ´ optimization. In Neural Information Processing Systems, 2011.   
+Leon Bottou and Patrick Gallinari. ´ A framework for the cooperation of learning algorithms. 1991.   
+Cameron Browne, Edward Powley, Daniel Whitehouse, Simon Lucas, Peter Cowling, Philipp Rohlfshagen, Stephen Tavener, Diego Perez, Spyridon Samothrakis, and Simon Colton. A survey of
+
+Monte Carlo tree search methods. IEEE Transactions on Computational Intelligence and AI in Games, 4(1):1–43, 2012.
+
+Ronan Collobert, Koray Kavukcuoglu, and Clement Farabet. Torch7: A Matlab-like environment ´ for machine learning. In BigLearn, NIPS Workshop, 2011.
+
+Dario Floreano, Peter Durr, and Claudio Mattiussi. Neuroevolution: from architectures to learning. ¨ Evolutionary Intelligence, 1(1):47–62, 2008.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In International Conference on Artificial Intelligence and Statistics, 2010.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In International Conference on Computer Vision, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Conference on Computer Vision and Pattern Recognition, 2016.
+
+Frank Hutter, Holger Hoos, and Kevin Leyton-Brown. Sequential model-based optimization for general algorithm configuration. In International Conference on Learning and Intelligent Optimization, 2011.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv:1502.03167, 2015.
+
+Kirthevasan Kandasamy, Jeff Schneider, and Barnabas P ´ oczos. High dimensional Bayesian opti- ´ misation and bandits via additive models. In International Conference on Machine Learning, 2015.
+
+Andrej Karpathy and Li Fei-Fei. Deep visual-semantic alignments for generating image descriptions. In Conference on Computer Vision and Pattern Recognition, 2015.
+
+Levente Kocsis and Csaba Szepesvari. Bandit based Monte Carlo planning. In ´ European Conference on Machine Learning, 2006.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton. ImageNet classification with deep convolutional neural networks. In Neural Information Processing Systems, 2012.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing Atari with deep reinforcement learning. arXiv:1312.5602, 2013.
+
+Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon, Quoc Le, and Alex Kurakin. Large-scale evolution of image classifiers. arXiv:1703.01041, 2017.
+
+Ashish Sabharwal, Horst Samulowitz, and Gerald Tesauro. Selecting near-optimal learners via incremental data allocation. In AAAI, 2015.
+
+Ikuro Sato, Hiroki Nishimura, and Kensuke Yokoi. APAC: Augmented pattern classification with neural networks. arXiv:1505.03229, 2015.
+
+David Silver, Aja Huang, Chris Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of Go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv:1409.1556, 2014.
+
+Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical Bayesian optimization of machine learning algorithms. In Neural Information Processing Systems, 2012.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Kenneth Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary Computation, 10(2):99–127, 2002.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc Le. Sequence to sequence learning with neural networks. In Neural Information Processing Systems, 2014.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Conference on Computer Vision and Pattern Recognition, 2015.
+
+Daan Wierstra, Faustino Gomez, and Jurgen Schmidhuber. Modeling systems with internal state �� using Evolino. In Proceedings of the 7th Annual Conference on Genetic and Evolutionary Computation, 2005.
+
+Daniel Yamins, David Tax, and James Bergstra. Making a science of model search: hyperparameter optimization in hundreds of dimensions for vision architectures. In International Conference on Machine Learning, 2013.
+
+Barret Zoph and Quoc Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations, 2017.
+
+# A DETAILED EXPERIMENTAL SETUP
+
+In Section 7, we considered a search space of deep convolutional models having structural hyperparameters for the depth of the network, whether to apply batch normalization before or after ReLU, and whether to use dropout; hyperparameters for the number and size of the convolutional filters; training hyperparameters for the learning rate schedule. We show in Figure 4 the LISP-like pseudocode for the search space considered in Section 7, and in Figure 5 the corresponding runnable Python implementation in our framework.
+
+![](images/3fca8eca08d3a80a997b55b4924b4900803f668303c0b43409e65dbada73dc48.jpg)  
+Figure 4: Specification of the model search space used in Section 7 in LISP-like pseudocode. See Figure 5 for the corresponding runnable Python code.
+
+In Figure 4 and Figure 5, to include training hyperparameters in the search space, we concatenate the module that encapsulates the training hyperparameters (the module assigned to MH) and the modules that encapsulate the remaining model hyperparameters (the modules other than MH in the declaration of M).
+
+The Python specification of the model search space in Figure 5 is remarkably close in both semantics and length to the LISP-like pseudocode in Figure 4. We omit some hyperparameters in Figure 4 because we did not consider multiple values for them, e.g., for Conv2D modules, we always used same size padding and the initialization scheme described in He et al. (2015).
+
+Our implementation has code modularity and reusability benefits. For example, we can define an auxiliary function to instantiate modules and then use it in the instantiation of the module for the complete search space. This is illustrated in Figure 5 with the definition of Module fn and its use in the declaration of M.
+
+See Figure 6a for the performance profile of 16 models randomly sampled from the search space in Figure 5. See Figure 6b for the architecture and training hyperparameters of the best model found in the 16 samples.
+
+# B LIST OF MODULES
+
+We provide a brief description of a representative subset of the types of basic and composite modules that we have implemented in our framework. It is simple to define new modules this list by implementing the module interface described in Section C.
+
+# B.1 BASIC MODULES
+
+Basic modules take no other modules when instantiated, having only local hyperparameters and parameters.
+
+• Affine: Dense affine transformation. Hyperparameters: number of the hidden units and initialization scheme of the parameters. Parameters: dense matrix and bias vector.
+
+MH $=$ UserHyperparams([’optimizer_type’, ’learning_rate_init’, ’rate_mult’, ’rate_patience’, ’stop_patience’, ’learning_rate_min’, ’angle_delta’, ’scale_delta’, ’weight_decay_coeff’], [[’adam’, ’sgd_mom’], list( np.logspace(-2, -6, num=32) ), list( np.logspace(-2, np.log10(0.9), num=8) ), range(8, 65, 4), [128], [1e-6], [0, 5, 10, 15, 20, 25, 30, 35], [0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35], [0.0, 1e-6, 1e-5, 1e-4] ])
+
+conv_initers $=$ [ kaiming2015delving_initializer_conv(1.0) ] aff_initers $=$ [ xavier_initializer_affine( 1.0 )]
+
+def Module_fn(filter_ns, filter_ls, keep_ps, repeat_ns): b $=$ RepeatTied( Concat([ Conv2D(filter_ns, filter_ls, [1], ["SAME"], conv_initers), MaybeSwap_fn( ReLU(), BatchNormalization() ), Optional_fn( Dropout(keep_ps) ) ]), repeat_ns) return b
+
+filter_nums $=$ range(48, 129, 16) repeat_nums $= \ [ 2 \star \star$ i for i in xrange(6)] mult_fn $=$ lambda ls, alpha: list(alpha $^ { \star }$ np.array(ls))
+
+$\mathrm { ~ \textmu ~ } =$ Concat([MH, Conv2D(filter_nums, [3, 5, 7], [2], ["SAME"], conv_initers), Module_fn(filter_nums, [3, 5], [0.5, 0.9], repeat_nums), Conv2D(filter_nums, [3, 5, 7], [2], ["SAME"], conv_initers), Module_fn(mult_fn(filter_nums, 2), [3, 5], [0.5, 0.9], repeat_nums), Affine([num_classes], aff_initers) ])
+
+Figure 5: Runnable specification of the model search space used in Section 7 in our Python implementation of the framework. See Figure 4 for the specification of the same search space in the LISP-like pseudocode used throughout this paper.
+
+![](images/e9dfe1470fda96d5d091cfb2a08416f6aa85abf62b9f987c6fbc047cc64c5627.jpg)  
+Figure 6: (a) The performance profile of the 16 sampled models in decreasing order of their validation accuracy. The model with the highest validation accuracy $( 9 9 . 8 0 \% )$ has also the highest test accuracy $( 9 9 . 7 2 \% )$ ). (b) The best performing model found from sampling 16 models of search space in Figure 5 with a random model searcher. The hyperparameters of UserHyperparams are as in the search space in Figure 5. The hyperparameters of the layers are as described in Appendix B. The parameters of the Affine and Conv2d modules were initialized according to Glorot & Bengio (2010) and He et al. (2015), respectively.
+
+( ( ’UserHyperparams’,   
+’adam’,   
+0.003046989570903508,   
+0.24882127247602889,   
+52,   
+128,   
+1e-06,   
+15,   
+0.1,   
+1e-06),   
+(’Conv2D’, 80, 7, 2, ’SAME’),   
+(’Conv2D’, 96, 3, 1, ’SAME’),   
+(’ReLU’,),   
+(’BatchNormalization’,),   
+(’Dropout’, 0.9),   
+(’Conv2D’, 96, 3, 1, ’SAME’),   
+(’ReLU’,),   
+(’BatchNormalization’,),   
+(’Dropout’, 0.9),   
+(’Conv2D’, 96, 3, 1, ’SAME’),   
+(’ReLU’,),   
+(’BatchNormalization’,),   
+(’Dropout’, 0.9),   
+(’Conv2D’, 96, 3, 1, ’SAME’),   
+(’ReLU’,),   
+(’BatchNormalization’,),   
+(’Dropout’, 0.9),   
+(’Conv2D’, 96, 3, 1, ’SAME’),   
+(’ReLU’,),   
+(’BatchNormalization’,),   
+(’Dropout’, 0.9),   
+(’Conv2D’, 96, 3, 1, ’SAME’),   
+(’ReLU’,),   
+(’BatchNormalization’,),   
+(’Dropout’, 0.9),   
+(’Conv2D’, 96, 3, 1, ’SAME’),   
+(’ReLU’,),   
+(’BatchNormalization’,),   
+(’Dropout’, 0.9),   
+(’Conv2D’, 96, 3, 1, ’SAME’),   
+(’ReLU’,),   
+(’BatchNormalization’,),   
+(’Dropout’, 0.9),   
+(’Conv2D’, 128, 7, 2, ’SAME’),   
+(’Conv2D’, 128, 3, 1, ’SAME’),   
+(’BatchNormalization’,),   
+(’ReLU’,),   
+(’Dropout’, 0.5),   
+(’Affine’, 10))   
+• ReLU: ReLU nonlinearity. Hyperparameters: none. Parameters: none.   
+• Dropout: Dropout. Hyperparameter: dropout probability. Parameters: none.   
+• Conv2D: Two-dimensional convolution. Hyperparameters: number of filters, size of the filters, stride, padding scheme, and initialization scheme of the parameters. Parameters: convolutional filters and bias vector.   
+• MaxPooling2D: Two-dimensional max pooling. Hyperparameters: size of the filters, stride, and padding scheme. Parameters: none.   
+• BatchNormalization: Batch normalization. Hyperparameters: none. Parameters: translation coefficients and scaling coefficients.   
+• UserHyperparams: User-defined hyperparameters. Hyperparameters: hyperparameters determined by the user expert. Parameters: none.   
+• Empty: Identity. Hyperparameters: none. Parameters: none.
+
+# B.2 COMPOSITE MODULES
+
+Composite modules take other modules as arguments when instantiated, which we will call submodules. The behavior of a composite module depends on its submodules. The hyperparameters which a composite module has to specify depend on the values of the hyperparameters of the composite module and the hyperparameters of the submodules; e.g., $\bigcirc \mathtt { r }$ takes a list of submodules but it only has to specify the hyperparameters of the submodule that it ends up choosing. A composite module is responsible for specifying its submodules, which is done through calls to the module interfaces of the submodules.
+
+• Concat: Takes a list of submodules and connects them in series. Hyperparameters: hyperparameters of the submodules. Parameters: parameters of the submodules.   
+• Or: Chooses one of its submodules to use. Hyperparameters: which submodule to use and hyperparameters of the submodule chosen. Parameters: parameters of the submodule chosen.   
+• Repeat: Repeats a submodule some number of times, connecting the repetitions in series; values for the hyperparameters of the repetitions are chosen independently. Hyperparameters: number of times to repeat the submodule and hyperparameters of the repetitions of the submodule. Parameters: parameters of the repetitions of the submodule. RepeatTied: Same as Repeat, but values for the hyperparameters of the submodule are chosen once and used for all the submodule repetitions. Hyperparameters: the number of times to repeat the submodule and hyperparameters of the submodule. Parameters: parameters of the repetitions of the submodule. Optional: Takes a submodule and chooses whether to use it or not. Hyperparameters: whether to include the submodule or not and, if included, hyperparameters of the submodule. Parameters: if included, parameters of the submodule. Residual: Takes a submodule and implements a skip connection adding the input and output; if the input and output have different dimensions, they are padded to make addition possible. Hyperparameters: hyperparameters of the submodule. Parameters: parameters of the submodule. MaybeSwap: Takes two submodules and connects them in series, choosing which submodule comes first. Hyperparameters: which of the submodules comes first and hyperparameters of the submodules. Parameters: parameters of the submodules.
+
+# C MODULE INTERFACE
+
+We describe the module interface as we implemented it in Python. To implement a new type of module, one only needs to implement the module interface.
+
+class Module(object): def initialize(self, in_d, scope) def get_outdim(self) def is_specified(self) def get_choices(self) def choose(self, choice_i) def compile(self, in_x, train_feed, eval_feed)
+
+Figure 7: Module interface used by all modules irrespective if they are basic or composite. To implement a new type of module, the human expert only needs to implement the module interface.
+
+• initialize: Tells a module its input dimensionality. A composite module is responsible for initializing the submodules that it uses.
+
+get outdim: Once a module is fully specified, we can determine its output dimensionality by calling get outdim. The output dimensionality is a function of the input dimensionality (which is determined when initialize is called) and the values of the hyperparameters chosen. is specified: Tests whether a module is fully specified. If a module is fully specified, outdim and compile may be called.   
+• get choices: Returns a list of the possible values for the hyperparameter currently being specified.   
+• choose: Chooses one of the possible values for the hyperparameter being specified. The module assigns the chosen value to that hyperparameter and either transitions to the next hyperparameter to specify or becomes fully specified. The module maintains internally the state of its search process. compile: Creates the computational graph of the model in a deep learning model specification language, such as Tensorflow or PyTorch. For composite modules, compilation can be performed recursively, through calls to the compile functions of its submodules.
+
+Composite modules rely on calls to the module interfaces of its submodules to implement their own module interfaces. For example, Concat needs to call out dim for the last submodule of the series connection to determine its own output dimensionality, and needs to call choose on the submodules to specify itself. One of the design choices that make the language modular is the fact that a composite module can implement its own module interface through calls to the module interfaces of its submodules. All information about the specification of a module is local to itself or kept within its submodules.
+
+# D BEYOND SINGLE-INPUT SINGLE-OUTPUT MODULES
+
+We can define new modules with complex signal paths as long as their existence is encapsulated, i.e., a module may have many signal paths as long they fork from a single input and merge to a single output, as illustrated in Figure 8.
+
+![](images/adc1987400f5aef02f1aba4ccf30c4e0d319f284bd979f6e51eff22d8811b261.jpg)  
+Figure 8: A module with many signal paths from input to output. To implement a module, the human expert only needs to implement its module interface. M1, M2, M3, and M4 are arbitrary single-input single-output modules; $g _ { 1 }$ and $g _ { 2 }$ are arbitrary transformations that may have additional hyperparameters. The hyperparameters of $g _ { 1 }$ and $g _ { 2 }$ can be managed internally by NewModule.
+
+In Figure 8 there is a single input fed into M1, M2, and M3. M1, M2, M3, M4, M5 are arbitrary single-input single-output submodules of NewModule. The module interface of NewModule can be implemented using the module interfaces of its submodules. Instantiating a module of type NewModule requires submodules for M1, M2, M3, M4, and M5, and potentially lists of possible values for the hyperparameters of $g _ { 1 }$ and $g _ { 2 }$ . A residual module which chooses what type of merging function to apply, e.g., additive or multiplicative, is an example of a module with hyperparameters for the merging functions
+
+A module of the type NewModule is fully specified after we choose values for all the hyperparameters of M1, M2, M3, M4, M5, $g _ { 1 }$ , and $g _ { 2 }$ . Testing if M1, M2, M3, M4, and M5 are fully specified can be done by calling is specified on the corresponding submodule.
+
+The output dimensionality of NewModule can be computed as a function of the values of the hyperparameters of $g _ { 2 }$ and the output dimensionality of M5 and M4, which can be obtained by calling get outdim. Similarly, for get choices we have to keep track of which hyperparameter we are specifying, which can either come from M1, M2, M3, M4, and M5, or from $g _ { 1 }$ and $g _ { 2 }$ . If we are choosing values for an hyperparameter in M1, M2, M3, M4, and M5 we can call get choices and choose on that submodule, while for the hyperparameters of $g _ { 1 }$ and $g _ { 2 }$ we have to keep track of the state in NewModule. compile is similar in the sense that it is implemented using calls to the compile functionality of the submodules.

parse/train/rkTBjG-AZ/rkTBjG-AZ_content_list.json

@@ -0,0 +1,1748 @@
+[
+    {
+        "type": "text",
+        "text": "DEEPARCHITECT: AUTOMATICALLY DESIGNING ANDTRAINING DEEP ARCHITECTURES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In deep learning, performance is strongly affected by the choice of architecture and hyperparameters. While there has been extensive work on automatic hyperparameter optimization for simple spaces, complex spaces such as the space of deep architectures remain largely unexplored. As a result, the choice of architecture is done manually by the human expert through a slow trial and error process guided mainly by intuition. In this paper we describe a framework for automatically designing and training deep models. We propose an extensible and modular language that allows the human expert to compactly represent complex search spaces over architectures and their hyperparameters. The resulting search spaces are treestructured and therefore easy to traverse. Models can be automatically compiled to computational graphs once values for all hyperparameters have been chosen. We can leverage the structure of the search space to introduce different model search algorithms, such as random search, Monte Carlo tree search (MCTS), and sequential model-based optimization (SMBO). We present experiments comparing the different algorithms on CIFAR-10 and show that MCTS and SMBO outperform random search. We also present experiments on MNIST, showing that the same search space achieves near state-of-the-art performance with a few samples. These experiments show that our framework can be used effectively for model discovery, as it is possible to describe expressive search spaces and discover competitive models without much effort from the human expert. Code for our framework and experiments has been made publicly available. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            585,
+            336,
+            602
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has seen a surge in popularity due to breakthroughs in applications such as computer vision, natural language processing, and reinforcement learning (He et al., 2016; Karpathy & FeiFei, 2015; Silver et al., 2016; Sutskever et al., 2014). An important observation in much of the recent work is that complex architectures are important for achieving high performance (He et al., 2016; Mnih et al., 2013). Larger datasets and more powerful computing infrastructures are likely to increase our ability to effectively train larger, deeper, and more complex architectures. However, improving the performance of a neural network is not as simple as adding more layers or parameters—it often requires clever ideas such as creating more branches (Szegedy et al., 2015) or adding skip connections (He et al., 2016). Even popular techniques such as dropout (Srivastava et al., 2014) and batch normalization (Ioffe & Szegedy, 2015) do not always lead to better performance, and need to be judiciously applied to be helpful. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Currently, choosing appropriate values for these architectural hyperparameters requires close supervision by a human expert, in a trial and error manual search process largely guided by intuition. The expert is burdened by having to make the large number of choices involved in the specification of a deep model. Choices interact in non-obvious ways and strongly impact performance. The typical workflow has the expert specify a single model, train it, and compute a validation score. Based on the validation score, previous experience, and information gathered during training, the expert decides if the trained model is satisfactory or not. If the model is considered unsatisfactory, the expert has to think about model variations that may lead to better performance. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "From the perspective of the expert, it would be convenient to search over architectures automatically, just as we search over simple scalar hyperparameters, such as the learning rate and the regularization coefficient. Ideally, the expert would have control in setting up the search space to incorporate inductive biases about the task being solved and constraints about computational resources. Prior to this work, achieving this goal was hard because expressing model search spaces using general hyperparameter optimization tools requires the human expert to manually distill a set of relevant scalar architectural hyperparameters. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contributions of our work are ",
+        "bbox": [
+            176,
+            180,
+            431,
+            195
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. a modular, compositional, and extensible language for compactly representing expressive search spaces over models that ",
+        "bbox": [
+            212,
+            207,
+            825,
+            234
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(a) gives control to the human expert over what model variations to consider; (b) makes it easy to automatically search for performant models in the search space; (c) allows models to be directly compiled to computational graphs without the human expert having to write additional code. ",
+        "bbox": [
+            238,
+            238,
+            825,
+            299
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2. model search algorithms that rely on the tree-structured search spaces induced by our language to systematically and efficiently search for performant models; namely, we ",
+        "bbox": [
+            214,
+            304,
+            821,
+            332
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(a) show that by using constructs in our language, even random search can be effective;   \n(b) compare different model search algorithms experimentally, and show that random search is outperformed by algorithms that leverage the structure of the search space to generalize more effectively across different models. ",
+        "bbox": [
+            238,
+            335,
+            823,
+            393
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main differences between our work and previous work are that we develop a modular, composable and extensible language, focusing on the problem of searching over deep architectures. This focus allows the expert to compactly set up a search space, search over it, and automatically compile models to their corresponding computational graphs. Our language can be seen as an effort to combine the functionalities of a deep model specification language (e.g., Tensorflow (Abadi et al., 2016)) and a structured hyperparameter search language (e.g., Hyperopt (Yamins et al., 2013)). ",
+        "bbox": [
+            174,
+            405,
+            825,
+            489
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            344,
+            525
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Model search has a long and rich history in machine learning and statistics. There has been a wide variety of theoretical and empirical research in this area (Agarwal et al., 2011; Bergstra et al., 2011; Bergstra & Bengio, 2012; Sabharwal et al., 2015), including Bayesian optimization methods (Hutter et al., 2011; Kandasamy et al., 2015; Snoek et al., 2012). However, conventional methods are primarily designed for searching over hyperparameters living in Euclidean space. Such methods are ill suited in today’s context, where the discrete architectural choices are just as important as the numerical values of the hyperparameters. Searching over architectures using current hyperparameter optimization algorithms requires the expert to distill structural choices into scalar hyperparameters. As a result, typically only a few simple global structural hyperparameters are considered, e.g., the depth of the network or whether to use dropout or not. This constrains the richness of the search space, preventing the expert from finding unexpected model variations leading to better performance; e.g., perhaps dropout is useful only after certain types of layers, or batch normalization only helps in the first half of the network. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            719
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Architecture search has also been considered under the topic of neuroevolution (Stanley & Miikkulainen, 2002), which uses evolutionary (i.e., genetic) strategies to define and search a space of models. In classical approaches, neuroevolution attempts to jointly choose the topology and the parameters of the architecture using genetic algorithms. ",
+        "bbox": [
+            174,
+            728,
+            823,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Architecture search has received renewed interest recently. Wierstra et al. (2005), Floreano et al. (2008), and Real et al. (2017) use evolutionary algorithms which start from an initial model and evolve it based on its validation performance. Zoph & Le (2017) propose a reinforcement learning procedure based on policy gradient for searching for convolutional and LSTM architectures. Baker et al. (2016) propose a reinforcement learning procedure based on Q-learning for searching for convolutional architectures. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately all these approaches consider fixed hard-coded model search spaces that do not easily allow the human expert to incorporate inductive biases about the task being solved, making them unsuitable as general tools for architecture search. For example, evolutionary approaches require an encoding for the models in the search space and genetic operators (e.g., mutation and crossover) which generate encodings for new models out of encodings of old ones. These aspects are handcrafted and hard-coded so it is hard for the human expert to change the search space in flexible ways. Perhaps different model encodings or genetic operators can be considered, but these knobs give somewhat loose and indirect control over the model search space. The reinforcement learning approaches considered suffer from similar issues—the search spaces are hard-coded and not easily modifiable. None of these approaches have the compositionality, modularity, and extensibility properties of our language. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Bergstra et al. (2011) propose Tree of Parzen Estimators (TPE), which can be used to search over structured hyperparameter spaces, and use it to tune the hyperparameters of a Deep Boltzmann Machine. Yamins et al. (2013) use TPE to search for values of the hyperparameters of a computer vision system, and show that it can find better values than the best ones previously known. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "TPE is a general hyperparameter search algorithm, and therefore requires considerable effort to use—for any fixed model search space, using TPE requires the human expert to distill the hyperparameters of the search space, express the search space in Hyperopt (Yamins et al., 2013) (an implementation of TPE), and write the code describing how values of the hyperparameters in the search space compile to a computational graph. In contrast, our language is modular and composable in the sense that: ",
+        "bbox": [
+            174,
+            285,
+            825,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. search spaces (defined through modules) are constructed compositionally out of simpler search spaces (i.e., simpler modules);   \n2. hyperparameters for composite modules are derived automatically from the hyperparameters of simpler modules;   \n3. once values for all hyperparameters of a module have been chosen, the resulting model can be automatically mapped to a computational graph without the human expert having to write additional code. ",
+        "bbox": [
+            212,
+            382,
+            823,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ROADMAP TO THE DEEPARCHITECT FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            622,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our framework reduces the problem of searching over models into three modular components: the model search space specification language, the model search algorithm, and the model evaluation algorithm. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            603
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Model Search Specification Language: The model search space specification language is built around the concept of a modular computational module. This is akin to the concept of a module (Bottou & Gallinari, 1991) used in deep learning frameworks such as Torch (Collobert et al., 2011): by implementing the module interface, the internal implementation becomes irrelevant. These modules allow one to express easily complex design choices such as whether to include a module or not, choose between modules of different types, or choose how many times to repeat a module structure. The main insight is that complex modules can be created compositionally out of simpler ones. The behavior of complex modules is generated automatically out of the behavior of simpler modules. Furthermore, our language is extensible, allowing the implementation of new types of modules by implementing a high-level interface local to the module. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Model Search Algorithm: The way the model search space is explored is determined by the model search algorithm. This part of the framework decides how much effort to allocate to each part of the search space based on the performance observed for previous models. The model search algorithm typically requires a model evaluation algorithm that computes the performance of a fully specified model. The search algorithm will then use this information to determine which models to try next. The search algorithm interacts with the search space only through a minimal interface that allows it to traverse the space of models and evaluate models discovered this way. This interface is the same irrespective of the specific search space under consideration. We experiment with different search algorithms, such as Monte Carlo tree search (Browne et al., 2012) and Sequential Model Based Optimization (Hutter et al., 2011). ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Model Evaluation Algorithm: Having fully specified a model, i.e., having reached a leaf in the tree defined by our model search space, we can evaluate how good this model is according to some criterion defined by the expert. This typically involves training the model on a training set and evaluating it on a validation set. The training procedure often has multiple hyperparameters that can be tuned (e.g., the choice of the optimization algorithm and its hyperparameters, and the learning rate schedule). If the expert does not know how to write down a reasonable training procedure for every model in the search space, the expert can introduce hyperparameters for the evaluation algorithm and search over them using our specification language. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Any of the above components can be changed, improved, or extended, while keeping the others fixed. The fact that different components interact only through well-defined interfaces makes it possible to extend and reuse this framework. We believe that DeepArchitect will be an interesting platform for future research in deep learning and hyperparameter tuning for architecture search. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 MODEL SEARCH SPACE SPECIFICATION LANGUAGE",
+        "text_level": 1,
+        "bbox": [
+            174,
+            304,
+            635,
+            320
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 SEARCH SPACE DEFINITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            334,
+            408,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The computational module is the fundamental unit of our model search space specification language. We define a computational module as a function ",
+        "bbox": [
+            174,
+            361,
+            821,
+            388
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/080d7dd1107b13a87cfa7ad7d10f256c365b82a45056e8f28a968e7bb7af867b.jpg",
+        "text": "$$\nf : n \\to \\left( \\mathcal { H } \\to ( \\mathbb { R } ^ { p } \\to ( \\mathbb { R } ^ { n } \\to \\mathbb { R } ^ { m } ) ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            391,
+            629,
+            407
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $n$ is the dimensionality of the input, $\\mathcal { H }$ is the set of valid values for the hyperparameters, $p$ is the number of parameters, and $m$ is the dimensionality of the output. The set $\\mathcal { H }$ can be structured or simply the cross product of scalar hyperparameter sets, i.e., $\\mathcal { H } = \\mathcal { H } _ { 1 } \\times . . . \\times \\mathcal { H } _ { H }$ , where $H$ is the number of scalar hyperparameters. The set $\\mathcal { H }$ is assumed to be discrete in both cases. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            464
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition (1) merits some discussion. For conciseness we have not explicitly represented it, but the number of parameters $p$ and the output dimensionality $m$ can both be functions of the input dimensionality $n$ and the chosen hyperparameter values $h \\in \\mathcal H$ . For example, an affine module with $h$ dense hidden units has output dimensionality $m = h$ and number of parameters $p = ( n + 1 ) h$ : a weight matrix $W \\in \\mathbb { R } ^ { h \\times n }$ and a bias vector $b \\in \\mathbb { R } ^ { h }$ . A similar reasoning can be carried out for a convolutional module: the number of parameters $p$ depends on the input dimensionality, the number of filters, and the size of the filters; the dimensionality of the output $m$ depends on the input dimensionality, the number of filters, the size of the filters, the stride, and the padding scheme. The fact that $p$ and $m$ are functions of the input dimensionality and the chosen hyperparameter values is one of the main observations that allows us to do architecture search—once we know the input dimensionality and have fixed values for the hyperparameters, the structure of the computation performed by the module is determined, and this information can be propagated to other modules. We say that a module is fully specified when values for all hyperparameters of the module have been chosen and the input dimensionality is known. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            666
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We focus on search spaces for architectures that have a single input terminal and a single output terminal. By this, we only mean that the input and output of the module have to be a single tensor of arbitrary order and dimensionality. For example, convolutional modules take as input an order three tensor and return as output an order three tensor, therefore they are single-input single-output modules under our definition. We also assume that the output of a module is used as input to at most a single module, i.e., we assume no output sharing. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "These restrictions were introduced to simplify exposition. The single-input single-output case with no sharing is simpler to develop and exemplifies the main ideas that allow us to develop a framework for automatic architecture search. The ideas developed in this work extend naturally to the multipleinput multiple-output case with sharing. Additionally, often we can represent modules that are not single-input single-output by defining new modules that encapsulate many signal paths from input to output. For example, a residual module (He et al., 2016) can be treated in our framework by noting that it is single-input before the skip connection split and single-output after the skip connection merge. Many top performing architectures, such as AlexNet (Krizhevsky et al., 2012), VGG (Simonyan & Zisserman, 2014), and ResNet (He et al., 2016), are captured in our language. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We distinguish between basic computational modules and composite computational modules. Basic modules do some well defined transformation. Affine, batch normalization, and dropout are examples of basic modules. Composite modules are defined in terms of other (composite or basic) modules, i.e., the instantiation of a composite module takes other modules as arguments. Composite modules may introduce hyperparameters of their own and inherit hyperparameters of the modules taken as arguments. For example, an $\\bigcirc \\mathtt { r }$ module takes a list of modules and chooses one of the modules to use. It introduces a discrete hyperparameter for which module to use, and chooses values for the hyperparameters of the chosen module; the hyperparameters available are conditional on the choice of the module to use. Most of the representational power of our language arises from the compositionality of composite and basic modules. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb872f8c94981e2eaa50d8b197b91805347946a6f3f2ed2d97f86cdfc41dbfaf.jpg",
+        "image_caption": [
+            "Figure 1: (a) A simple search space with 24 different models. (b) A path through the search space encoding a convolutional module with 64 filters of size $3 \\times 3$ , with stride 1, followed by batch normalization, ReLU and affine modules. The model does not use dropout. Branches encoding hyperparameters with a single choice were omitted. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            97,
+            745,
+            295
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            390,
+            825,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The ideas developed in this section are perhaps best illustrated with an example. See Figure 1a for the definition of an example search space in LISP-like pseudocode that closely parallels our implementation. The search space, which results from the composition of several modules, and therefore is also a module itself, encodes 24 different models, corresponding to the different 24 possible paths from the root to the leaves of the tree. The space is defined using three composite modules (Concat, MaybeSwap, and Optional) and five basic modules (Conv2D, BatchNormalization, ReLU, Dropout, and Affine). Concat introduces no additional hyperparameters, but it has to specify all the modules that have been delegated to it; MaybeSwap introduces a binary hyperparameter that encodes whether to swap the order of the pair of modules or not; Optional introduces a binary hyperparameter that encodes whether to include the module or not. The behavior of the basic modules in Figure 1a is simple: Conv2D takes lists of possible values for the number of filters, the size of the filters, and the stride; BatchNormalization and ReLU have no hyperparameters; Dropout takes a list for the possible values for the dropout probability; Affine takes a list for the possible values of the number of hidden units. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Choosing different values for the hyperparameters of the composite modules may affect the structure of the resulting architecture, while choosing different values for the hyperparameters of the basic modules only affects the structure of the corresponding local transformations. The search space of Figure 1a results from the composition of basic and composite modules; therefore it is a module itself and can be characterized by its input, output, parameters, and hyperparameters. Our set of composite modules in not minimal: e.g., given an Empty basic module, which has no hyperparameters or parameters and simply does the identity transformation, and a Or composite module, which introduces an extra hyperparameter encoding the choice of a specific module in its list, the composite modules Optional and MaybeSwap can be defined as (Optional B) $=$ ( $\\bigcirc \\mathtt { r }$ Empty B) and (MaybeSwap B1 B2) $=$ (Or (Concat B1 B2), (Concat B2 B1)). ",
+        "bbox": [
+            174,
+            709,
+            825,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 SEARCH SPACE TRAVERSAL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            868,
+            408,
+            882
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given a search space defined by a module, there is an underlying tree over fully specified models: we build this tree by sequentially assigning values to each of the hyperparameters of the module. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Each internal node in the tree corresponds to some partial assignment to the hyperparameters of the module, and each terminal node (i.e., each leaf) corresponds to a fully specified model. We can also think about an internal node as corresponding to the state of a module before assigning a value to the next unassigned hyperparameter. The branching factor of a node corresponds to the number of possible values for the hyperparameter under consideration at that node, and traversing a specific edge from that node to a child corresponds to assigning the value encoded by that edge to the hyperparameter under consideration. As a tree has a single path between the root and any leaf, the paths from root to leaves are in one-to-one correspondence with fully specified models. A leaf is reached when there are no hyperparameters left to specify. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Figure 1b we have drawn a path through the search space of Figure 1a from the root (labeled node 0), where all hyperparameters are unassigned, to a terminal node (labeled node 4), where all hyperparameters have been assigned values. Each branch in the tree corresponds to the assignment of some value to some hyperparameter. At node 0, we are choosing between 32 or 64 filters; at node 1, we are choosing between filters of size 3 or 5; at node 2, we are choosing between applying batch normalization before or after ReLU; at node 3, we are choosing whether to do dropout or not. Node 4 is terminal and corresponds to a fully specified model. Decisions at each node are conditional on decisions previously made. Internal nodes with a single child (i.e., branches for hyperparameters with a single possible value) have been collapsed and omitted from Figure 1a. Other paths may have different lengths, e.g., picking a path through the right child of node 3 corresponds to adding a Dropout module, which requires an additional hyperparameter choice for the dropout probability when compared to the path from the root to node 4. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            401
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Search spaces arising from module composition have their traversal functionality automatically derived from the traversal functionality of their component modules: a basic module knows how to sequentially assign values to its hyperparameters, and a composite module knows how to sequentially assign values to its hyperparameters and call the sequential assignment functionality for its component modules. This is akin to recursive expression evaluation in programming languages. ",
+        "bbox": [
+            174,
+            410,
+            823,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To traverse the search space, i.e., to assign values to all hyperparameters of the module defining the search space, all that it is needed is that each module knows how to sequentially specify itself. Modules resulting from the composition of modules will then be automatically sequentially specifiable. The three local operations that a module needs to implement for traversal are: to test whether it is fully specified (i.e., whether it has reached a leaf yet); if it is not specified, to return which hyperparameter it is specifying and what are the possible values for it; and given a choice for the current hyperparameter under consideration, to traverse the edge to the child of the current node corresponding to chosen value. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 COMPILATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            616,
+            313,
+            630
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Once values for all hyperparameters of a module have been chosen, the fully specified model can be automatically mapped to its corresponding computational graph. We call this mapping compilation. This operation only requires that each module knows how to locally map itself to a computational graph: compilation is derived recursively from the compilation of simpler modules. For example, if we know how to compile Conv2D, ReLU, and $\\bigcirc \\mathtt { r }$ modules, we will automatically be able to compile all modules built from them. This behavior is also similar to recursive expression evaluation in programming languages. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            741
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 MODEL SEARCH ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            762,
+            464,
+            777
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we consider different search algorithms that are built on top of the functionality described above. Some of these algorithms rely on the search space being tree structured. One of the challenges of our setting is that deep models are expensive to train, so unless we have access to extraordinary computational resources, only a moderate number of evaluations will be practical. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            851
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 RANDOM SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            341,
+            882
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Random search is the simplest algorithm that we can consider. At each node of the tree, we choose an outgoing edge uniformly at random, until we reach a leaf node (i.e., a model). Even just random ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "search is interesting, as the model search space specification language allows us to capture expressive structural search spaces. Without our language, randomly selecting an interesting architecture to try would not be possible without considerable effort from the human expert. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 MONTE CARLO TREE SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            161,
+            426,
+            176
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Monte Carlo tree search (MCTS) (Browne et al., 2012; Kocsis & Szepesvari, 2006) is an approxi- ´ mate planning technique that has been used effectively in many domains (Silver et al., 2016). Contrary to random search, MCTS uses the information gathered so far to steer its policy towards better performing parts of the search space. MCTS maintains a search tree that is expanded incrementally one node at a time. MCTS uses two policies: a tree policy, which determines the path to be traversed from the root to the frontier of the already expanded tree; and a rollout policy, which determines the path to be traversed from the frontier of the already expanded tree until a leaf is reached. Once a leaf is reached, the model encoded by it is evaluated (e.g., trained on the training set and evaluated on the validation set), and the resulting score is used to update the statistics of the nodes in the currently expanded tree in the path to the leaf. Each node in the expanded tree keeps statistics about the number of times it was visited and the average score of the models that were evaluated in the subtree at that node. The rollout policy is often simple, e.g., the random policy described in Section 5.1. ",
+        "bbox": [
+            174,
+            188,
+            825,
+            354
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The tree policy typically uses an upper confidence bound (UCB) approach. Let $n$ be the number of visits of a node $v \\in \\mathcal T$ , where $\\tau$ denotes the currently expanded tree, and $n _ { 1 } , \\ldots , n _ { b }$ and ${ \\bar { X } } _ { 1 } , \\dots , { \\bar { X } } _ { b }$ be, respectively, the number of visits and the average scores of the $b$ children of $v$ . The tree policy at $x$ chooses to traverse an edge corresponding to a child maximizing the UCB score: ",
+        "bbox": [
+            174,
+            362,
+            825,
+            417
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f8494244b1fccc66511643324e2fb86146073a86a34427566330fb5e06c6bb1e.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { i \\in \\{ 1 , \\dots , b \\} } { \\bar { X } } _ { i } + 2 c \\sqrt { \\frac { 2 \\log n } { n _ { i } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            422,
+            593,
+            458
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $c \\in \\mathbb { R } _ { + }$ is a constant capturing the trade-off between exploration and exploitation—larger values of $c$ correspond to larger amounts of exploration. If at node $x$ , some of its children have not been added to the tree, there will be some $i \\in \\{ 1 , \\ldots , b \\}$ for which $n _ { i } = 0$ ; in this case we define the UCB score to be infinite, and therefore, unexpanded children always take precedence over expanded children. If multiple unexpanded children are available, we expand one uniformly at random. ",
+        "bbox": [
+            174,
+            462,
+            823,
+            531
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 MONTE CARLO TREE SEARCH WITH TREE RESTRUCTURING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            633,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When MCTS visits a node in the expanded part of the tree, it has to expand all children of that node before expanding any children of its currently expanded children. This is undesirable when there are hyperparameters that can take a large number of related values. ",
+        "bbox": [
+            176,
+            574,
+            825,
+            616
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We often consider hyperparameters which take numeric values, and similar values result in similar performance. For example, choosing between 64 or 80 filters for a convolutional module might not have a dramatic impact on performance. A way of addressing such hyperparameters is to restructure the branches of the tree by doing bisection. Assume that the set of hyperparameters has a natural ordering. At a node, rather than committing directly to a value of the hyperparameter, we commit sequentially—first we decide if we are choosing a value in the first or second half of the set of hyperparameters, and then we recurse on the chosen half until we have narrow it down to a single value. See an example tree in Figure 2a and the corresponding restructured tree in Figure 2b. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            734
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Tree restructuring involves a tradeoff between depth and breadth: the tree in Figure 2a has depth 1, while the tree in Figure 2b has depth 3. The restructured tree can have better properties in the sense that there more sharing between different values of the hyperparameters. We could also consider restructured trees with branching factors different than two, again trading off depth and breadth. If the branching factor of the restructured tree is larger than the number of children of the hyperparameter, the restructuring has no effect, i.e., the original and restructured trees are equal. The restructuring operation allows MCTS to effectively consider hyperparameters with a large number of possible values. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.4 SEQUENTIAL MODEL BASED OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            524,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "MCTS is tabular in the sense that it keeps statistics for each node in the tree. While the restructuring operation described in Section 5.3 increases sharing between different hyperparameter values, it still suffers from the problem that nodes have no way of sharing information other than through common ancestors. This is problematic because differences in hyperparameter values at the top levels of the tree lead to little sharing between models, even if the resulting models happen to be very similar. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a3f4ace9438913fcb7b6f80a0bfe719b426907201ad9f9f0f978caff30fee613.jpg",
+        "image_caption": [
+            "Figure 2: (a) A tree encoding an hyperparameter and its five possible values. MCTS applied to this tree is sample-inefficient as there is no sharing of information between the different child nodes. (b) The result of restructuring the tree with bisection. MCTS applied to this tree results in more sharing when compared to the original tree. For example, sampling a path reaching node 1 provides information about nodes 1, 2, and 3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            810,
+            268
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            377,
+            820,
+            420
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Sequential Model Based Optimization (SMBO) (Hutter et al., 2011) allows us to address this problem by introducing a surrogate function which can be used to capture relationships between models and how promising it is to evaluate any specific model. The surrogate function can use expressive features to capture architecture patterns that influence performance, e.g., features about sequences of basic modules that occur in the model. ",
+        "bbox": [
+            174,
+            426,
+            823,
+            496
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The surrogate function can then be optimized to choose which model to evaluate next. Exactly optimizing the surrogate function over a search space can be difficult as often there is a combinatorially large number of models. To approximately optimize the surrogate function, we do some number of random rollouts from the root of the tree until we hit leaf nodes (i.e., models), we evaluate the surrogate function (i.e., we determine, according to the surrogate function, how promising it is to evaluate that model), and evaluate the model that has the highest score according to the surrogate function. We also introduce an exploratory component where we flip a biased coin and choose between evaluating a random model or evaluating the best model according to the surrogate function. The surrogate function is updated after each evaluation. ",
+        "bbox": [
+            174,
+            502,
+            823,
+            627
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we use a simple surrogate function: we train a ridge regressor to predict model performance, using the models evaluated so far and their corresponding performances as training data. We only use features based on $n$ -grams of sequences of basic modules, disregarding the values of the hyperparameters. More complex features, surrogate functions, and training losses are likely to lead to better search performance, but we leave these to future work. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            705
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 MODEL EVALUATION ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            726,
+            504,
+            741
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As a reminder, once we assign values to all hyperparameters of the module defining the search space, we need to compute a score for the resulting model, i.e., a score for the path from the root to the corresponding leaf encoding the model to evaluate. The specific way to compute scores is defined by the human expert, and it typically amounts to training the model on a training set and evaluating the trained model on a validation set. The score of the model is the resulting validation performance. The training process often has its own hyperparameters, such as: what optimization algorithm to use and its corresponding hyperparameters, the learning rate schedule (e.g., the initial learning rate, the learning rate reduction multiplier, and how many epochs without improving the validation performance the algorithm waits before reducing the learning rate), how many epochs without improving the validation performance the algorithm waits before terminating the training process (i.e., early stopping), and what data augmentation strategies to use and their corresponding hyperparameters. The behavior of the evaluation algorithm with respect to the values of its hyperparameters is defined by the expert for the task being considered, so the compilation step described in Section 4.3 for this functionality has to be implemented by the expert. Nonetheless, these user hyperparameters can be included in the search space and searched over in the same way as the architecture hyperparameters described in Section 4.1. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6d743b8e33d55a478268550929c1fe86684dcf62792e5b154ba8785db470486f.jpg",
+        "image_caption": [
+            "Figure 3: (a, b) Average maximum validation score achieved as a function of the number of evaluation across five repetitions. The error bars indicate standard error. The range of 64 evaluations is split into two plots for clearer visualization. (c) Percentage of models above a given validation threshold performance. MCTS with bisection and SMBO outperform random search. The error bars have size equal to the standard error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            803,
+            243
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            363,
+            823,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            453,
+            326,
+            468
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We illustrate how our framework can be used to search over all hyperparameters of a model, i.e., both architecture and training hyperparameters, using only high-level insights. We choose a search space of deep convolutional models based around the ideas that depth is important, batch normalization helps convergence, and dropout is sometimes helpful. We search over architectures and evaluate our models on CIFAR-10 (Krizhevsky, 2009). ",
+        "bbox": [
+            174,
+            492,
+            825,
+            560
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The training hyperparameters that we consider are whether to use ADAM or SGD with momentum, the initial learning rate, the learning rate reduction multiplier, and the rate reduction patience, i.e., how many epochs without improvement to wait before reducing the current learning rate. We use standard data augmentation techniques: we zero pad the CIFAR-10 images to size $4 0 \\times 4 0 \\times 3$ , randomly crop a $3 2 \\times 3 2$ portion, and flip horizontally at random. We could search over these too if desired. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We compare the search algorithms described in Section 5 in terms of the best model found, according to validation performance, as a function of the number of evaluations. We run each algorithm 5 times, for 64 model evaluations each time. All models were trained for 30 minutes on GeForce GTX 970 GPUs in machines with similar specifications. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Figure 3a and Figure 3b, we see that all search algorithms find performant solutions (around $8 9 \\%$ accuracy) after 64 evaluations. In Figure 3a, we see that for fewer than 6 evaluations there is considerable variance between the different algorithms; the more sophisticated model search algorithms are not able to outperform random search with so few evaluations. In Figure 3b, we see that both SMBO and MCTS with bisection eventually outperform random search; MCTS with bisection starts outperforming random search around 32 evaluations, while for SMBO, it happens around 16 evaluations. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Surprisingly, MCTS without restructuring does not outperform random search. We think that this is because there are too many possible values for the first few hyperparameters in the tree, so MCTS will not be able to identify and focus on high-performance regions of the search space within the number of evaluations available. MCTS with bisection and SMBO do not suffer from these problems, and therefore can identify and focus on high performance regions of the search space earlier. In addition to achieving a higher top accuracy, MCTS with bisection and SMBO evaluate a larger fraction of high-performance models when compared to random search, as can be seen in Figure 3c. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The main goal of the previous experiment is to show that more complex model search algorithms can outperform random search by better leveraging the structure of the search. We are not attempting to achieve state-of-the-art performance. We now show that using the same search space on MNIST with a larger time budget leads to close to state-of-the-art performance. The data augmentation scheme is slightly different, as we no longer randomly flip the image horizontally, but now consider random rotations where the maximum angle of rotation is also added as a hyperparameter to the search space. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we randomly sample 16 models in the search space and train them for up to 3 hours or until the validation performance fails to increase for more than 128 epochs. The best model among the models sampled chosen according to validation performance obtained among the 16 sampled models has test accuracy equal to $9 9 . { \\bar { 7 } } 2 \\%$ , which is close to the single model state-of-theart of $9 9 . 7 7 \\%$ (Sato et al., 2015). Additionally, taking a simple majority voting emsemble of the 5 best performing models yielded the same validation accuracy as the best single model and increased test accuracy to $9 9 . 7 5 \\%$ . The performance profile of the sampled models and the architecture and hyperparameters of the best model are presented in Appendix A. ",
+        "bbox": [
+            174,
+            208,
+            823,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We can build good ensembles by sampling models in the search space and building an ensemble out of the best ones. It has been observed in the literature that model diversity often improves emsemble performance. Our results suggest that it is possible to define search spaces that work well across a range of tasks, having the potential to significantly reduce the burden on the human expert. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            382
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            402,
+            318,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We described a framework for automatically designing and training deep models. This framework consists of three fundamental components: the model search space specification language, the model search algorithm, and the model evaluation algorithm. The model search space specification language is composable, modular, and extensible, and allows us to easily define expressive search spaces over architectures. The model evaluation algorithm determines how to compute a score for a model in the search space. Models can be automatically compiled to their corresponding computational graphs. Using the model search space specification language and the model evaluation algorithm, we can introduce model search algorithms for exploring the search space. Using our framework, it is possible to do random search over interesting spaces of architectures without much effort from the expert. We also described more complex model search algorithms, such as MCTS, MCTS with tree restructuring, and SMBO. We present experiments on CIFAR-10 comparing different model search algorithms and show that MCTS with tree restructuring and SMBO outperform random search. Code for our framework and experiments has been made publicly available. We hope that this paper will lead to more work and better tools for automatic architecture search. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            650,
+            285,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv:1603.04467, 2016.   \nAlekh Agarwal, John Duchi, Peter Bartlett, and Clement Levrard. Oracle inequalities for computationally budgeted model selection. In Conference on Learning Theory, 2011.   \nBowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. arXiv:1611.02167, 2016.   \nJames Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13(Feb):281–305, 2012.   \nJames Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper-parameter ´ optimization. In Neural Information Processing Systems, 2011.   \nLeon Bottou and Patrick Gallinari. ´ A framework for the cooperation of learning algorithms. 1991.   \nCameron Browne, Edward Powley, Daniel Whitehouse, Simon Lucas, Peter Cowling, Philipp Rohlfshagen, Stephen Tavener, Diego Perez, Spyridon Samothrakis, and Simon Colton. A survey of ",
+        "bbox": [
+            171,
+            671,
+            828,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Monte Carlo tree search methods. IEEE Transactions on Computational Intelligence and AI in Games, 4(1):1–43, 2012. ",
+        "bbox": [
+            183,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ronan Collobert, Koray Kavukcuoglu, and Clement Farabet. Torch7: A Matlab-like environment ´ for machine learning. In BigLearn, NIPS Workshop, 2011. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dario Floreano, Peter Durr, and Claudio Mattiussi. Neuroevolution: from architectures to learning. ¨ Evolutionary Intelligence, 1(1):47–62, 2008. ",
+        "bbox": [
+            174,
+            180,
+            821,
+            210
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In International Conference on Artificial Intelligence and Statistics, 2010. ",
+        "bbox": [
+            173,
+            219,
+            823,
+            248
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In International Conference on Computer Vision, 2015. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Conference on Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            173,
+            310,
+            821,
+            340
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Frank Hutter, Holger Hoos, and Kevin Leyton-Brown. Sequential model-based optimization for general algorithm configuration. In International Conference on Learning and Intelligent Optimization, 2011. ",
+        "bbox": [
+            173,
+            349,
+            823,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv:1502.03167, 2015. ",
+        "bbox": [
+            169,
+            401,
+            823,
+            431
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kirthevasan Kandasamy, Jeff Schneider, and Barnabas P ´ oczos. High dimensional Bayesian opti- ´ misation and bandits via additive models. In International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            176,
+            440,
+            823,
+            484
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrej Karpathy and Li Fei-Fei. Deep visual-semantic alignments for generating image descriptions. In Conference on Computer Vision and Pattern Recognition, 2015. ",
+        "bbox": [
+            171,
+            493,
+            823,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Levente Kocsis and Csaba Szepesvari. Bandit based Monte Carlo planning. In ´ European Conference on Machine Learning, 2006. ",
+        "bbox": [
+            173,
+            531,
+            821,
+            561
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            570,
+            692,
+            587
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton. ImageNet classification with deep convolutional neural networks. In Neural Information Processing Systems, 2012. ",
+        "bbox": [
+            173,
+            595,
+            820,
+            626
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing Atari with deep reinforcement learning. arXiv:1312.5602, 2013. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            678
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon, Quoc Le, and Alex Kurakin. Large-scale evolution of image classifiers. arXiv:1703.01041, 2017. ",
+        "bbox": [
+            173,
+            686,
+            823,
+            717
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Sabharwal, Horst Samulowitz, and Gerald Tesauro. Selecting near-optimal learners via incremental data allocation. In AAAI, 2015. ",
+        "bbox": [
+            171,
+            726,
+            825,
+            756
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ikuro Sato, Hiroki Nishimura, and Kensuke Yokoi. APAC: Augmented pattern classification with neural networks. arXiv:1505.03229, 2015. ",
+        "bbox": [
+            169,
+            765,
+            825,
+            794
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of Go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            176,
+            803,
+            823,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv:1409.1556, 2014. ",
+        "bbox": [
+            169,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical Bayesian optimization of machine learning algorithms. In Neural Information Processing Systems, 2012. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kenneth Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary Computation, 10(2):99–127, 2002. ",
+        "bbox": [
+            169,
+            155,
+            821,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc Le. Sequence to sequence learning with neural networks. In Neural Information Processing Systems, 2014. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Conference on Computer Vision and Pattern Recognition, 2015. ",
+        "bbox": [
+            176,
+            229,
+            823,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daan Wierstra, Faustino Gomez, and Jurgen Schmidhuber. Modeling systems with internal state ¨ using Evolino. In Proceedings of the 7th Annual Conference on Genetic and Evolutionary Computation, 2005. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            324
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Yamins, David Tax, and James Bergstra. Making a science of model search: hyperparameter optimization in hundreds of dimensions for vision architectures. In International Conference on Machine Learning, 2013. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A DETAILED EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            495,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Section 7, we considered a search space of deep convolutional models having structural hyperparameters for the depth of the network, whether to apply batch normalization before or after ReLU, and whether to use dropout; hyperparameters for the number and size of the convolutional filters; training hyperparameters for the learning rate schedule. We show in Figure 4 the LISP-like pseudocode for the search space considered in Section 7, and in Figure 5 the corresponding runnable Python implementation in our framework. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            217
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/3fca8eca08d3a80a997b55b4924b4900803f668303c0b43409e65dbada73dc48.jpg",
+        "image_caption": [
+            "Figure 4: Specification of the model search space used in Section 7 in LISP-like pseudocode. See Figure 5 for the corresponding runnable Python code. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            231,
+            598,
+            414
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4 and Figure 5, to include training hyperparameters in the search space, we concatenate the module that encapsulates the training hyperparameters (the module assigned to MH) and the modules that encapsulate the remaining model hyperparameters (the modules other than MH in the declaration of M). ",
+        "bbox": [
+            174,
+            482,
+            825,
+            537
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The Python specification of the model search space in Figure 5 is remarkably close in both semantics and length to the LISP-like pseudocode in Figure 4. We omit some hyperparameters in Figure 4 because we did not consider multiple values for them, e.g., for Conv2D modules, we always used same size padding and the initialization scheme described in He et al. (2015). ",
+        "bbox": [
+            174,
+            545,
+            825,
+            602
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Our implementation has code modularity and reusability benefits. For example, we can define an auxiliary function to instantiate modules and then use it in the instantiation of the module for the complete search space. This is illustrated in Figure 5 with the definition of Module fn and its use in the declaration of M. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            664
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "See Figure 6a for the performance profile of 16 models randomly sampled from the search space in Figure 5. See Figure 6b for the architecture and training hyperparameters of the best model found in the 16 samples. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            713
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B LIST OF MODULES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            734,
+            366,
+            751
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We provide a brief description of a representative subset of the types of basic and composite modules that we have implemented in our framework. It is simple to define new modules this list by implementing the module interface described in Section C. ",
+        "bbox": [
+            174,
+            766,
+            823,
+            809
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.1 BASIC MODULES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            338,
+            840
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Basic modules take no other modules when instantiated, having only local hyperparameters and parameters. ",
+        "bbox": [
+            176,
+            853,
+            823,
+            882
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• Affine: Dense affine transformation. Hyperparameters: number of the hidden units and initialization scheme of the parameters. Parameters: dense matrix and bias vector. ",
+        "bbox": [
+            217,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "MH $=$ UserHyperparams([’optimizer_type’, ’learning_rate_init’, ’rate_mult’, ’rate_patience’, ’stop_patience’, ’learning_rate_min’, ’angle_delta’, ’scale_delta’, ’weight_decay_coeff’], [[’adam’, ’sgd_mom’], list( np.logspace(-2, -6, num=32) ), list( np.logspace(-2, np.log10(0.9), num=8) ), range(8, 65, 4), [128], [1e-6], [0, 5, 10, 15, 20, 25, 30, 35], [0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35], [0.0, 1e-6, 1e-5, 1e-4] ]) ",
+        "bbox": [
+            184,
+            270,
+            655,
+            452
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "conv_initers $=$ [ kaiming2015delving_initializer_conv(1.0) ] aff_initers $=$ [ xavier_initializer_affine( 1.0 )] ",
+        "bbox": [
+            186,
+            460,
+            593,
+            482
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "def Module_fn(filter_ns, filter_ls, keep_ps, repeat_ns): b $=$ RepeatTied( Concat([ Conv2D(filter_ns, filter_ls, [1], [\"SAME\"], conv_initers), MaybeSwap_fn( ReLU(), BatchNormalization() ), Optional_fn( Dropout(keep_ps) ) ]), repeat_ns) return b ",
+        "bbox": [
+            186,
+            492,
+            692,
+            573
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "filter_nums $=$ range(48, 129, 16) repeat_nums $= \\ [ 2 \\star \\star$ i for i in xrange(6)] mult_fn $=$ lambda ls, alpha: list(alpha $^ { \\star }$ np.array(ls)) ",
+        "bbox": [
+            187,
+            582,
+            557,
+            613
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "$\\mathrm { ~ \\textmu ~ } =$ Concat([MH, Conv2D(filter_nums, [3, 5, 7], [2], [\"SAME\"], conv_initers), Module_fn(filter_nums, [3, 5], [0.5, 0.9], repeat_nums), Conv2D(filter_nums, [3, 5, 7], [2], [\"SAME\"], conv_initers), Module_fn(mult_fn(filter_nums, 2), [3, 5], [0.5, 0.9], repeat_nums), Affine([num_classes], aff_initers) ]) ",
+        "bbox": [
+            186,
+            622,
+            736,
+            684
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 5: Runnable specification of the model search space used in Section 7 in our Python implementation of the framework. See Figure 4 for the specification of the same search space in the LISP-like pseudocode used throughout this paper. ",
+        "bbox": [
+            174,
+            708,
+            823,
+            751
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/e9dfe1470fda96d5d091cfb2a08416f6aa85abf62b9f987c6fbc047cc64c5627.jpg",
+        "image_caption": [
+            "Figure 6: (a) The performance profile of the 16 sampled models in decreasing order of their validation accuracy. The model with the highest validation accuracy $( 9 9 . 8 0 \\% )$ has also the highest test accuracy $( 9 9 . 7 2 \\% )$ ). (b) The best performing model found from sampling 16 models of search space in Figure 5 with a random model searcher. The hyperparameters of UserHyperparams are as in the search space in Figure 5. The hyperparameters of the layers are as described in Appendix B. The parameters of the Affine and Conv2d modules were initialized according to Glorot & Bengio (2010) and He et al. (2015), respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            104,
+            576,
+            342
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "( ( ’UserHyperparams’,   \n’adam’,   \n0.003046989570903508,   \n0.24882127247602889,   \n52,   \n128,   \n1e-06,   \n15,   \n0.1,   \n1e-06),   \n(’Conv2D’, 80, 7, 2, ’SAME’),   \n(’Conv2D’, 96, 3, 1, ’SAME’),   \n(’ReLU’,),   \n(’BatchNormalization’,),   \n(’Dropout’, 0.9),   \n(’Conv2D’, 96, 3, 1, ’SAME’),   \n(’ReLU’,),   \n(’BatchNormalization’,),   \n(’Dropout’, 0.9),   \n(’Conv2D’, 96, 3, 1, ’SAME’),   \n(’ReLU’,),   \n(’BatchNormalization’,),   \n(’Dropout’, 0.9),   \n(’Conv2D’, 96, 3, 1, ’SAME’),   \n(’ReLU’,),   \n(’BatchNormalization’,),   \n(’Dropout’, 0.9),   \n(’Conv2D’, 96, 3, 1, ’SAME’),   \n(’ReLU’,),   \n(’BatchNormalization’,),   \n(’Dropout’, 0.9),   \n(’Conv2D’, 96, 3, 1, ’SAME’),   \n(’ReLU’,),   \n(’BatchNormalization’,),   \n(’Dropout’, 0.9),   \n(’Conv2D’, 96, 3, 1, ’SAME’),   \n(’ReLU’,),   \n(’BatchNormalization’,),   \n(’Dropout’, 0.9),   \n(’Conv2D’, 96, 3, 1, ’SAME’),   \n(’ReLU’,),   \n(’BatchNormalization’,),   \n(’Dropout’, 0.9),   \n(’Conv2D’, 128, 7, 2, ’SAME’),   \n(’Conv2D’, 128, 3, 1, ’SAME’),   \n(’BatchNormalization’,),   \n(’ReLU’,),   \n(’Dropout’, 0.5),   \n(’Affine’, 10))   \n• ReLU: ReLU nonlinearity. Hyperparameters: none. Parameters: none.   \n• Dropout: Dropout. Hyperparameter: dropout probability. Parameters: none.   \n• Conv2D: Two-dimensional convolution. Hyperparameters: number of filters, size of the filters, stride, padding scheme, and initialization scheme of the parameters. Parameters: convolutional filters and bias vector.   \n• MaxPooling2D: Two-dimensional max pooling. Hyperparameters: size of the filters, stride, and padding scheme. Parameters: none.   \n• BatchNormalization: Batch normalization. Hyperparameters: none. Parameters: translation coefficients and scaling coefficients.   \n• UserHyperparams: User-defined hyperparameters. Hyperparameters: hyperparameters determined by the user expert. Parameters: none.   \n• Empty: Identity. Hyperparameters: none. Parameters: none. ",
+        "bbox": [
+            604,
+            95,
+            808,
+            599
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            215,
+            758,
+            826,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            215,
+            103,
+            823,
+            151
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.2 COMPOSITE MODULES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            167,
+            377,
+            183
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Composite modules take other modules as arguments when instantiated, which we will call submodules. The behavior of a composite module depends on its submodules. The hyperparameters which a composite module has to specify depend on the values of the hyperparameters of the composite module and the hyperparameters of the submodules; e.g., $\\bigcirc \\mathtt { r }$ takes a list of submodules but it only has to specify the hyperparameters of the submodule that it ends up choosing. A composite module is responsible for specifying its submodules, which is done through calls to the module interfaces of the submodules. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "• Concat: Takes a list of submodules and connects them in series. Hyperparameters: hyperparameters of the submodules. Parameters: parameters of the submodules.   \n• Or: Chooses one of its submodules to use. Hyperparameters: which submodule to use and hyperparameters of the submodule chosen. Parameters: parameters of the submodule chosen.   \n• Repeat: Repeats a submodule some number of times, connecting the repetitions in series; values for the hyperparameters of the repetitions are chosen independently. Hyperparameters: number of times to repeat the submodule and hyperparameters of the repetitions of the submodule. Parameters: parameters of the repetitions of the submodule. RepeatTied: Same as Repeat, but values for the hyperparameters of the submodule are chosen once and used for all the submodule repetitions. Hyperparameters: the number of times to repeat the submodule and hyperparameters of the submodule. Parameters: parameters of the repetitions of the submodule. Optional: Takes a submodule and chooses whether to use it or not. Hyperparameters: whether to include the submodule or not and, if included, hyperparameters of the submodule. Parameters: if included, parameters of the submodule. Residual: Takes a submodule and implements a skip connection adding the input and output; if the input and output have different dimensions, they are padded to make addition possible. Hyperparameters: hyperparameters of the submodule. Parameters: parameters of the submodule. MaybeSwap: Takes two submodules and connects them in series, choosing which submodule comes first. Hyperparameters: which of the submodules comes first and hyperparameters of the submodules. Parameters: parameters of the submodules. ",
+        "bbox": [
+            214,
+            305,
+            825,
+            656
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "C MODULE INTERFACE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            676,
+            385,
+            691
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We describe the module interface as we implemented it in Python. To implement a new type of module, one only needs to implement the module interface. ",
+        "bbox": [
+            176,
+            708,
+            823,
+            736
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "class Module(object): def initialize(self, in_d, scope) def get_outdim(self) def is_specified(self) def get_choices(self) def choose(self, choice_i) def compile(self, in_x, train_feed, eval_feed) ",
+        "bbox": [
+            187,
+            748,
+            529,
+            820
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Figure 7: Module interface used by all modules irrespective if they are basic or composite. To implement a new type of module, the human expert only needs to implement the module interface. ",
+        "bbox": [
+            173,
+            844,
+            823,
+            873
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "• initialize: Tells a module its input dimensionality. A composite module is responsible for initializing the submodules that it uses. ",
+        "bbox": [
+            217,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "get outdim: Once a module is fully specified, we can determine its output dimensionality by calling get outdim. The output dimensionality is a function of the input dimensionality (which is determined when initialize is called) and the values of the hyperparameters chosen. is specified: Tests whether a module is fully specified. If a module is fully specified, outdim and compile may be called.   \n• get choices: Returns a list of the possible values for the hyperparameter currently being specified.   \n• choose: Chooses one of the possible values for the hyperparameter being specified. The module assigns the chosen value to that hyperparameter and either transitions to the next hyperparameter to specify or becomes fully specified. The module maintains internally the state of its search process. compile: Creates the computational graph of the model in a deep learning model specification language, such as Tensorflow or PyTorch. For composite modules, compilation can be performed recursively, through calls to the compile functions of its submodules. ",
+        "bbox": [
+            214,
+            103,
+            825,
+            335
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Composite modules rely on calls to the module interfaces of its submodules to implement their own module interfaces. For example, Concat needs to call out dim for the last submodule of the series connection to determine its own output dimensionality, and needs to call choose on the submodules to specify itself. One of the design choices that make the language modular is the fact that a composite module can implement its own module interface through calls to the module interfaces of its submodules. All information about the specification of a module is local to itself or kept within its submodules. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            446
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "D BEYOND SINGLE-INPUT SINGLE-OUTPUT MODULES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            468,
+            648,
+            484
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We can define new modules with complex signal paths as long as their existence is encapsulated, i.e., a module may have many signal paths as long they fork from a single input and merge to a single output, as illustrated in Figure 8. ",
+        "bbox": [
+            174,
+            501,
+            826,
+            542
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/adc1987400f5aef02f1aba4ccf30c4e0d319f284bd979f6e51eff22d8811b261.jpg",
+        "image_caption": [
+            "Figure 8: A module with many signal paths from input to output. To implement a module, the human expert only needs to implement its module interface. M1, M2, M3, and M4 are arbitrary single-input single-output modules; $g _ { 1 }$ and $g _ { 2 }$ are arbitrary transformations that may have additional hyperparameters. The hyperparameters of $g _ { 1 }$ and $g _ { 2 }$ can be managed internally by NewModule. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            554,
+            710,
+            743
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Figure 8 there is a single input fed into M1, M2, and M3. M1, M2, M3, M4, M5 are arbitrary single-input single-output submodules of NewModule. The module interface of NewModule can be implemented using the module interfaces of its submodules. Instantiating a module of type NewModule requires submodules for M1, M2, M3, M4, and M5, and potentially lists of possible values for the hyperparameters of $g _ { 1 }$ and $g _ { 2 }$ . A residual module which chooses what type of merging function to apply, e.g., additive or multiplicative, is an example of a module with hyperparameters for the merging functions ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A module of the type NewModule is fully specified after we choose values for all the hyperparameters of M1, M2, M3, M4, M5, $g _ { 1 }$ , and $g _ { 2 }$ . Testing if M1, M2, M3, M4, and M5 are fully specified can be done by calling is specified on the corresponding submodule. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "The output dimensionality of NewModule can be computed as a function of the values of the hyperparameters of $g _ { 2 }$ and the output dimensionality of M5 and M4, which can be obtained by calling get outdim. Similarly, for get choices we have to keep track of which hyperparameter we are specifying, which can either come from M1, M2, M3, M4, and M5, or from $g _ { 1 }$ and $g _ { 2 }$ . If we are choosing values for an hyperparameter in M1, M2, M3, M4, and M5 we can call get choices and choose on that submodule, while for the hyperparameters of $g _ { 1 }$ and $g _ { 2 }$ we have to keep track of the state in NewModule. compile is similar in the sense that it is implemented using calls to the compile functionality of the submodules. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 17
+    }
+]