Add files using upload-large-folder tool

parse/train/BJQRKzbA-/BJQRKzbA-.md

@@ -0,0 +1,299 @@
+# HIERARCHICAL REPRESENTATIONS FOR EFFICIENT ARCHITECTURE SEARCH
+
+Hanxiao Liu∗ Carnegie Mellon University hanxiaol@cs.cmu.edu
+
+Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, Koray Kavukcuoglu DeepMind {simonyan,vinyals,chrisantha,korayk}@google.com
+
+# ABSTRACT
+
+We explore efficient neural architecture search methods and show that a simple yet powerful evolutionary algorithm can discover new architectures with excellent performance. Our approach combines a novel hierarchical genetic representation scheme that imitates the modularized design pattern commonly adopted by human experts, and an expressive search space that supports complex topologies. Our algorithm efficiently discovers architectures that outperform a large number of manually designed models for image classification, obtaining top-1 error of $3 . 6 \%$ on CIFAR-10 and $2 0 . 3 \%$ when transferred to ImageNet, which is competitive with the best existing neural architecture search approaches. We also present results using random search, achieving $0 . 3 \%$ less top-1 accuracy on CIFAR-10 and $0 . 1 \%$ less on ImageNet whilst reducing the search time from 36 hours down to 1 hour.
+
+# 1 INTRODUCTION
+
+Discovering high-performance neural network architectures required years of extensive research by human experts through trial and error. As far as the image classification task is concerned, state-ofthe-art convolutional neural networks are going beyond deep, chain-structured layout (Simonyan & Zisserman, 2014; He et al., 2016a) towards increasingly more complex, graph-structured topologies (Szegedy et al., 2015; 2016; 2017; Larsson et al., 2016; Xie et al., 2016; Huang et al., 2016). The combinatorial explosion in the design space makes handcrafted architectures not only expensive to obtain, but also likely to be suboptimal in performance.
+
+Recently, there has been a surge of interest in using algorithms to automate the manual process of architecture design. Their goal can be described as finding the optimal architecture in a given search space such that the validation accuracy is maximized on the given task. Representative architecture search algorithms can be categorized as random with weights prediction (Brock et al., 2017), Monte Carlo Tree Search (Negrinho & Gordon, 2017), evolution (Stanley & Miikkulainen, 2002; Xie & Yuille, 2017; Miikkulainen et al., 2017; Real et al., 2017), and reinforcement learning (Baker et al., 2016; Zoph & Le, 2016; Zoph et al., 2017; Zhong et al., 2017), among which reinforcement learning approaches have demonstrated the strongest empirical performance so far.
+
+Architecture search can be computationally very intensive as each evaluation typically requires training a neural network. Therefore, it is common to restrict the search space to reduce complexity and increase efficiency of architecture search. Various constraints that have been used include: growing a convolutional “backbone” with skip connections (Real et al., 2017), a linear sequence of filter banks (Brock et al., 2017), or a directed graph where every node has exactly two predecessors (Zoph et al., 2017). In this work we constrain the search space by imposing a hierarchical network structure, while allowing flexible network topologies (directed acyclic graphs) at each level of the hierarchy. Starting from a small set of primitives such as convolutional and pooling operations at the bottom level of the hierarchy, higher-level computation graphs, or motifs, are formed by using lower-level motifs as their building blocks. The motifs at the top of the hierarchy are stacked multiple times to form the final neural network. This approach enables search algorithms to implement powerful hierarchical modules where any change in the motifs is propagated across the whole network immediately. This is analogous to the modularized design patterns used in many handcrafted architectures, e.g. VGGNet (Simonyan & Zisserman, 2014), ResNet (He et al., 2016a), and Inception (Szegedy et al., 2016) are all comprised of building blocks. In our case, a hierarchical architecture is discovered through evolutionary or random search.
+
+The evolution of neural architectures was studied as a sub-task of neuroevolution (Holland, 1975; Miller et al., 1989; Yao, 1999; Stanley & Miikkulainen, 2002; Floreano et al., 2008), where the topology of a neural network is simultaneously evolved along with its weights and hyperparameters. The benefits of indirect encoding schemes, such as multi-scale representations, have historically been discussed in Gruau et al. (1994); Kitano (1990); Stanley (2007); Stanley et al. (2009). Despite these pioneer studies, evolutionary or random architecture search has not been investigated at larger scale on image classification benchmarks until recently (Real et al., 2017; Miikkulainen et al., 2017; Xie & Yuille, 2017; Brock et al., 2017; Negrinho & Gordon, 2017). Our work shows that the power of simple search methods can be substantially enhanced using well-designed search spaces.
+
+Our experimental setup resembles Zoph et al. (2017), where an architecture found using reinforcement learning obtained the state-of-the-art performance on ImageNet. Our work reveals that random or evolutionary methods, which so far have been seen as less efficient, can scale and achieve competitive performance on this task if combined with a powerful architecture representation, whilst utilizing significantly less computational resources.
+
+To summarize, our main contributions are:
+
+1. We introduce hierarchical representations for describing neural network architectures. 2. We show that competitive architectures for image classification can be obtained even with simplistic random search, which demonstrates the importance of search space construction. 3. We present a scalable variant of evolutionary search which further improves the results and achieves the best published results1 among evolutionary architecture search techniques.
+
+# 2 ARCHITECTURE REPRESENTATIONS
+
+We first describe flat representations of neural architectures (Sect. 2.1), where each architecture is represented as a single directed acyclic graph of primitive operations. Then we move on to hierarchical representations (Sect. 2.2) where smaller graph motifs are used as building blocks to form larger motifs. Primitive operations are discussed in Sect. 2.3.
+
+# 2.1 FLAT ARCHITECTURE REPRESENTATION
+
+We consider a family of neural network architectures represented by a single-source, single-sink computation graph that transforms the input at the source to the output at the sink. Each node of the graph corresponds to a feature map, and each directed edge is associated with some primitive operation (e.g. convolution, pooling, etc.) that transforms the feature map in the input node and passes it to the output node.
+
+Formally, an architecture is defined by the representation $( G , o )$ , consisting of two ingredients:
+
+1. A set of available operations $\pmb { o } = \{ o _ { 1 } , o _ { 2 } , \dots \}$ . 2. An adjacency matrix $G$ specifying the neural network graph of operations, where $G _ { i j } = k$ means that the $k$ -th operation $o _ { k }$ is to be placed between nodes $i$ and $j$ .
+
+The architecture is obtained by assembling operations $^ o$ according to the adjacency matrix $G$
+
+$$
+a r c h = a s s e m b l e ( G , \pmb { o } )
+$$
+
+![](images/c45da3f31f9a063b5d3741f0f079db094eddcf5d00b57e45b7a52a27b551e687.jpg)  
+Figure 1: An example of a three-level hierarchical architecture representation. The bottom row shows how level-1 primitive operations $o _ { 1 } ^ { ( 1 ) } , o _ { 2 } ^ { ( 1 ) } , o _ { 3 } ^ { ( 1 ) }$ o( ) are assembled into a level-2 motif o(2)1 . The top row shows how level-2 motifs $o _ { 1 } ^ { ( 2 ) } , o _ { 2 } ^ { ( 2 ) } , o _ { 3 } ^ { ( 2 ) }$ are then assembled into a level-3 motif $o _ { 1 } ^ { ( 3 ) }$
+
+in a way that the resulting neural network sequentially computes the feature map $x _ { i }$ of each node $i$ from the feature maps $x _ { j }$ of its predecessor nodes $j$ following the topological ordering:
+
+$$
+x _ { i } = m e r g e \left[ \left\{ o _ { G _ { i j } } ( x _ { j } ) \right\} _ { j < i } \right] , \quad i = 2 , \ldots , \left| { \cal G } \right|
+$$
+
+Here, $| G |$ is the number of nodes in a graph, and merge is an operation combining multiple feature maps into one, which in our experiments was implemented as depthwise concatenation. An alternative option of element-wise addition is less flexible as it requires the incoming feature maps to contain the same number of channels, and is strictly subsumed by concatenation if the resulting $x _ { i }$ is immediately followed by a $1 \times 1$ convolution.
+
+# 2.2 HIERARCHICAL ARCHITECTURE REPRESENTATION
+
+The key idea of the hierarchical architecture representation is to have several motifs at different levels of hierarchy, where lower-level motifs are used as building blocks (operations) during the construction of higher-level motifs.
+
+Consider a hierarchy of $L$ levels where the $\ell$ -th level contains $M _ { \ell }$ motifs. The highest-level $\ell = L$ contains only a single motif corresponding to the full architecture, and the lowest level $\ell = 1$ is the set of primitive operations. We recursively define $o _ { m } ^ { ( \ell ) }$ , the $m$ -th motif in level $\ell$ , as the composition of lower-level motifs $\pmb { o } ^ { ( \ell - 1 ) } = \bigl \{ o _ { 1 } ^ { ( \ell - 1 ) } , o _ { 2 } ^ { ( \ell - 1 ) } , . . . , o _ { M _ { ( \ell - 1 ) } } ^ { ( \ell - 1 ) } \bigr \}$ according to its network structure $G _ { m } ^ { ( \ell ) }$
+
+$$
+o _ { m } ^ { ( \ell ) } = a s s e m b l e \left( G _ { m } ^ { ( \ell ) } , o ^ { ( \ell - 1 ) } \right) , \quad \forall \ell = 2 , \ldots , L
+$$
+
+A hierarchical architecture representation is therefore defined by $\left( \big \{ \{ G _ { m } ^ { ( \ell ) } \} _ { m = 1 } ^ { M _ { \ell } } \big \} _ { \ell = 2 } ^ { L } , o ^ { ( 1 ) } \right)$ , as it is assembly process is illustrated in Fig. 1.
+
+# 2.3 PRIMITIVE OPERATIONS
+
+We consider the following six primitives at the bottom level of the hierarchy $\ell = 1 , M _ { \ell } = 6 )$ :
+
+• $1 \times 1$ convolution of $C$ channels • $3 \times 3$ depthwise convolution • $3 \times 3$ separable convolution of $C$ channels • $3 \times 3$ max-pooling
+
+• $3 \times 3$ average-pooling • identity
+
+If applicable, all primitives are of stride one and the convolved feature maps are padded to preserve their spatial resolution. All convolutional operations are followed by batch normalization and ReLU activation (Ioffe & Szegedy, 2015); their number of channels is fixed to a constant $C$ . We note that convolutions with larger receptive fields and more channels can be expressed as motifs of such primitives. Indeed, large receptive fields can be obtained by stacking $3 \times 3$ convolutions in a chain structure (Simonyan & Zisserman, 2014), and wider convolutions with more channels can be obtained by merging the outputs of multiple convolutions through depthwise concatenation.
+
+We also introduce a special none op, which indicates that there is no edge between nodes $i$ and $j$ . It is added to the pool of operations at each level.
+
+# 3 EVOLUTIONARY ARCHITECTURE SEARCH
+
+Evolutionary search over neural network architectures can be performed by treating the representations of Sect. 2 as genotypes. We first introduce an action space for mutating hierarchical genotypes (Sect. 3.1), as well as a diversification-based scheme to obtain the initial population (Sect. 3.2). We then describe tournament selection and random search in Sect. 3.3, and our distributed implementation in Sect. 3.4.
+
+# 3.1 MUTATION
+
+A single mutation of a hierarchical genotype consists of the following sequence of actions:
+
+1. Sample a target non-primitive level $\ell \geq 2$ .   
+2. Sample a target motif $m$ in the target level.   
+3. Sample a random successor node $i$ in the target motif.   
+4. Sample a random predecessor node $j$ in the target motif.   
+5. Replace the current operation $o _ { k } ^ { ( \ell - 1 ) }$ between $j$ and $i$ with a randomly sampled operation   
+$o _ { k ^ { \prime } } ^ { ( \ell - 1 ) }$
+
+In the case of flat genotypes which consist of two levels (one of which is the fixed level of primitives), the first step is omitted and $\ell$ is set to 2. The mutation can be summarized as:
+
+$$
+[ G _ { m } ^ { ( \ell ) } ] _ { i j } = k ^ { \prime }
+$$
+
+where $\ell , m , i , j , k ^ { \prime }$ are randomly sampled from uniform distributions over their respective domains. Notably, the above mutation process is powerful enough to perform various modifications on the target motif, such as:
+
+1. Add a new edge: if $o _ { k } ^ { ( \ell - 1 ) } = n o n e$ and $o _ { k ^ { \prime } } ^ { ( \ell - 1 ) } \neq n o n e .$   
+2. Alter an existing edge: if $o _ { k } ^ { ( \ell - 1 ) } \neq n o n e$ and $o _ { k ^ { \prime } } ^ { ( \ell - 1 ) } \neq n o n e$ and $o _ { k ^ { \prime } } ^ { ( \ell - 1 ) } \neq o _ { k } ^ { ( \ell - 1 ) }$   
+3. Remove an existing edge: if $o _ { k } ^ { ( \ell - 1 ) } \neq n o n e$ and if $o _ { \boldsymbol { k } ^ { \prime } } ^ { ( \ell - 1 ) } = n o n e$
+
+# 3.2 INITIALIZATION
+
+To initialize the population of genotypes, we use the following strategy:
+
+1. Create a “trivial” genotype where each motif is set to a chain of identity mappings.   
+2. Diversify the genotype by applying a large number (e.g. 1000) of random mutations.
+
+In contrast to several previous works where genotypes are initialized by trivial networks (Stanley & Miikkulainen, 2002; Real et al., 2017), the above diversification-based scheme not only offers a
+
+Input: Data queue $\mathcal { Q }$ containing initial genotypes; Memory table $\mathcal { M }$ recording evaluated genotypes and their fitness.   
+while True do if HASIDLEWORKER() then genotype $\gets$ ASYNCTOURNAMENTSELECT $( \mathcal { M } )$ genotype $^ \prime \gets$ MUTATE(genotype) $\mathcal { Q }  \mathcal { Q } \cup g e n o t y p e ^ { \prime }$
+
+# Algorithm 2: ASYNCEVO Asynchronous Evolution (Worker)
+
+Input: Training set $\tau$ , validation set $\nu$ ; Shared memory table $\mathcal { M }$ and data queue $\mathcal { Q }$ .   
+while True do if $| \mathcal { Q } | > 0$ then genotype $ \mathcal { Q }$ .pop() $a r c h \gets \mathrm { A s s E M B L E } ( q e n o t y p e )$ ) $m o d e l \gets \mathrm { T R A I N } ( a r c h , \mathcal { T } )$ f itness ← EVALUATE(model, V) M ← M ∪ (genotype, f itness)
+
+good initial coverage of the search space with non-trivial architectures, but also helps to avoid an additional bias introduced by handcrafted initialization routines. In fact, this strategy ensures initial architectures are reasonably well-performing even without any search, as suggested by our random sample results in Table 1.
+
+# 3.3 SEARCH ALGORITHMS
+
+Our evolutionary search algorithm is based on tournament selection (Goldberg & Deb, 1991). Starting from an initial population of random genotypes, tournament selection provides a mechanism to pick promising genotypes from the population, and to place its mutated offspring back into the population. By repeating this process, the quality of the population keeps being refined over time. We always train a model from scratch for a fixed number of iterations, and we refer to the training and evaluation of a single model as an evolution step. The genotype with the highest fitness (validation accuracy) among the entire population is selected as the final output after a fixed amount of time.
+
+A tournament is formed by a random set of genotypes sampled from the current effective population, among which the individual with the highest fitness value wins the tournament. The selection pressure is controlled by the tournament size, which is set to $5 \%$ of the population size in our case. We do not remove any genotypes from the population, allowing it to grow with time, maintaining architecture diversity. Our evolution algorithm is similar to the binary tournament selection used in a recent large-scale evolutionary method (Real et al., 2017).
+
+We also investigated random search, a simpler strategy which has not been sufficiently explored in the literature, as an alternative to evolution. In this case, a population of genotypes is generated randomly, the fitness is computed for each genotype in the same way as done in evolution, and the genotype with the highest fitness is selected as the final output. The main advantage of this method is that it can be run in parallel over the entire population, substantially reducing the search time.
+
+# 3.4 IMPLEMENTATION
+
+Our distributed implementation is asynchronous, consisting of a single controller responsible for performing evolution over the genotypes, and a set of workers responsible for their evaluation. Both parties have access to a shared tabular memory $\mathcal { M }$ recording the population of genotypes and their fitness, as well as a data queue $\mathcal { Q }$ containing the genotypes with unknown fitness which should be evaluated.
+
+Specifically, the controller will perform tournament selection of a genotype from $\mathcal { M }$ whenever a worker becomes available, followed by the mutation of the selected genotype and its insertion into $\mathcal { Q }$ for fitness evaluation (Algorithm 1). A worker will pick up an unevaluated genotype from $\mathcal { Q }$ whenever there is one available, assemble it into an architecture, carry out training and validation, and then record the validation accuracy (fitness) in $\mathcal { M }$ (Algorithm 2). Architectures are trained from scratch for a fixed number of steps with random weight initialization. We do not rely on weight inheritance as in (Real et al., 2017), though incorporating it into our system is possible. Note that during architecture evolution no synchronization is required, and all workers are fully occupied.
+
+# 4 EXPERIMENTS AND RESULTS
+
+# 4.1 EXPERIMENTAL SETUP
+
+In our experiments, we use the proposed search framework to learn the architecture of a convolutional cell, rather than the entire model. The reason is that we would like to be able to quickly compute the fitness of the candidate architecture and then transfer it to a larger model, which is achieved by using less cells for fitness computation and more cells for full model evaluation. A similar approach has recently been used in (Zoph et al., 2017; Zhong et al., 2017).
+
+Architecture search is carried out entirely on the CIFAR-10 training set, which we split into two sub-sets of 40K training and 10K validation images. Candidate models are trained on the training subset, and evaluated on the validation subset to obtain the fitness. Once the search process is over, the selected cell is plugged into a large model which is trained on the combination of training and validation sub-sets, and the accuracy is reported on the CIFAR-10 test set. We note that the test set is never used for model selection, and it is only used for final model evaluation. We also evaluate the cells, learned on CIFAR-10, in a large-scale setting on the ImageNet challenge dataset (Sect. 4.3).
+
+![](images/90de7a8e7bec6abe5c35e8f938d8e02218cef231e40a3cc092e4429200a63956.jpg)  
+Figure 2: Image classification models constructed using the cells optimized with architecture search. Top-left: small model used during architecture search on CIFAR-10. Top-right: large CIFAR-10 model used for learned cell evaluation. Bottom: ImageNet model used for learned cell evaluation.
+
+For CIFAR-10 experiments we use a model which consists of $3 \times 3$ convolution with $c _ { 0 }$ channels, followed by 3 groups of learned convolutional cells, each group containing $N$ cells. After each cell (with $c$ input channels) we insert $3 \times 3$ separable convolution which has stride 2 and $2 c$ channels if it is the last cell of the group, and stride 1 and $c$ channels otherwise. The purpose of these convolutions is to control the number of channels as well as reduce the spatial resolution. The last cell is followed by global average pooling and a linear softmax layer.
+
+For fitness computation we use a smaller model with $c _ { 0 } = 1 6$ and $N = 1$ , shown in Fig. 2 (top-left). It is trained using SGD with 0.9 momentum for 5000 steps, starting with the learning rate 0.1, which is reduced by 10x after 4000 and 4500 steps. The batch size is 256, and the weight decay value is $3 \cdot 1 0 ^ { - 4 }$ . We employ standard training data augmentation where a $2 4 \times 2 4$ crop is randomly sampled from a $3 2 \times 3 2$ image, followed by random horizontal flipping. The evaluation is performed on the full size $3 2 \times 3 2$ image.
+
+A note on variance. We found that the variance due to optimization was non-negligible, and we believe that reporting it is important for performing a fair comparison and assessing model capabilities. When training CIFAR models, we have observed standard deviation of up to $0 . 2 \%$ using the exact same setup. The solution we adopted was to compute the fitness as the average accuracy over 4 training-evaluation runs.
+
+For the evaluation of the learned cell architecture on CIFAR-10, we use a larger model with $c _ { 0 } =$ 64 and $N = 2$ , shown in Fig. 2 (top-right). The larger model is trained for 80K steps, starting with a learning rate 0.1, which is reduced by 10x after 40K, 60K, and 70K steps. The rest of the training settings are the same as used for fitness computation. We report mean and standard deviation computed over 5 training-evaluation runs.
+
+For the evaluation on the ILSVRC ImageNet challenge dataset (Russakovsky et al., 2015), we use an architecture similar to the one used for CIFAR, with the following changes. An input $2 9 9 \times 2 9 9$ image is passed through two convolutional layers with 32 and 64 channels and stride 2 each. It is followed by 4 groups of convolutional cells where the first group contains a single cell (and has $c _ { 0 } = 6 4$ input channels), and the remaining three groups have $N = 2$ cells each (Fig. 2, bottom). We use SGD with momentum which is run for 200K steps, starting with a learning rate of 0.1, which is reduced by $1 0 \mathrm { x }$ after 100K, 150K, and 175K steps. The batch size is 1024, and weight decay is $1 0 ^ { - 4 }$ . We did not use auxiliary losses, weight averaging, label smoothing or path dropout empirically found effective in (Zoph et al., 2017). The training augmentation is the same as in (Szegedy et al., 2016), and consists in random crops, horizontal flips and brightness and contrast changes. We report the single-crop top-1 and top-5 error on the ILSVRC validation set.
+
+![](images/d99fa53a5043a8ad1f7392e8acdbaa662066f399b32247746013b1020659f9bf.jpg)  
+4.2 ARCHITECTURE SEARCH ON CIFAR-10   
+Figure 3: Fitness and number of parameters vs evolution step for flat and hierarchical representations. Left: fitness of a genotype generated at each evolution step. Middle: maximum fitness across all genotypes generated before each evolution step. Right: number of parameters in the small CIFAR-10 model constructed using the genotype generated at each evolution step.
+
+We run the evolution on flat and hierarchical genotypes for 7000 steps using 200 GPU workers. The initial size of the randomly initialized population is 200, which later grows as a result of tournament selection and mutation (Sect. 3). For the hierarchical representation, we use three levels $ { \boldsymbol { L } } = 3$ ), with $M _ { 1 } = 6 , M _ { 2 } = 6 , M _ { 3 } = 1$ . Each of the level-2 motifs is a graph with $| G ^ { ( 2 ) } | = 4$ nodes, and the level-3 motif is a graph with $| G ^ { ( 3 ) } | = 5$ nodes. Each level-2 motif is followed by a $1 \times 1$ convolution with the same number of channels as on the motif input to reduce the number of parameters. For the flat representation, we used a graph with 11 nodes to achieve a comparable number of edges.
+
+The evolution process is visualized in Fig. 3. The left plot shows the fitness of the genotype generated at each step of evolution: the fitness grows fast initially, and plateaus over time. The middle plot shows the best fitness observed by each evolution step. Since the first 200 steps correspond to a random initialization and mutation starts after that, the best architecture found at step 200 corresponds to the output of random search over 200 architectures.
+
+Fig. 3 (right) shows the number of parameters in the small network (used for fitness computation), constructed using the genotype produced at each step. Notably, flat genotypes achieve higher fitness, but at the cost of larger parameter count. We thus also consider a parameter-constrained variant of the flat genotype, where only the genotypes with the number of parameters under a fixed threshold are permitted; the threshold is chosen so that the flat genotype has a similar number of parameters to the hierarchical one. In this setting hierarchical and flat genotypes achieve similar fitness.
+
+To demonstrate that improvement in fitness of the hierarchical architecture is correlated with the improvement in the accuracy of the corresponding large model trained till convergence, we plot the relative accuracy improvements in Fig. 4.
+
+![](images/8fe9b7d2f36de478b031f059225e5578a7c7b2bcf6997b7bacd0702b618a6a22.jpg)  
+Figure 4: Accuracy improvement over the course of evolution, measured with respect to the first random genotype. The small model is the model used for fitness computation during evolution (its absolute fitness value is shown with the red curve in Fig. 3 (middle)). The large model is the model where the evolved cell architecture is deployed for training and evaluation.
+
+As far as the architecture search time is concerned, it takes 1 hour to compute the fitness of one architecture on a single P100 GPU (which involves 4 rounds of training and evaluation). Using 200 GPUs, it thus takes 1 hour to perform random search over 200 architectures and 1.5 days to do the evolutionary search with 7000 steps. This is significantly faster than 11 days using 250 GPUs reported by (Real et al., 2017) and 4 days using 450 GPUs reported by (Zoph et al., 2017).
+
+<table><tr><td>Search Method</td><td>CIFAR-10 error (%)</td><td>ImageNet Top-1/Top-5 error (%)</td></tr><tr><td>Flat repr-n, random architecture</td><td>4.56 ± 0.11</td><td>21.4/5.8</td></tr><tr><td>Flat repr-n,random search (2O0 samples)</td><td>4.02 ± 0.11</td><td>20.8/5.7</td></tr><tr><td>Flat repr-n,evolution (70o0 samples)</td><td>3.92 ±0.06</td><td>20.6/5.6</td></tr><tr><td>Flat repr-n,parameter-constrained,evolution (7ooo samples)</td><td>4.17 ± 0.08</td><td>21.2/5.8</td></tr><tr><td>Hier. repr-n, random architecture</td><td>4.21 ± 0.11</td><td>21.5/5.8</td></tr><tr><td>Hier. repr-n,random search (2O0 samples)</td><td>4.04±0.2</td><td>20.4/5.3</td></tr><tr><td>Hier.repr-n,random search (7ooo samples)</td><td>3.91 ± 0.15</td><td>21.0/5.5</td></tr><tr><td>Hier. repr-n, evolution (70oO samples)</td><td>3.75 ±0.12</td><td>20.3/5.2</td></tr></table>
+
+Table 1: Classification results on the CIFAR-10 test set and ILSVRC validation set obtained using the architectures found using various representations and search methods.
+
+# 4.3 ARCHITECTURE EVALUATION ON CIFAR-10 AND IMAGENET
+
+We now turn to the evaluation of architectures found using random and evolutionary search on CIFAR-10 and ImageNet. The results are presented in Table 1.
+
+First, we note that randomly sampled architectures already perform surprisingly well, which we attribute to the representation power of our architecture spaces. Second, random search over 200 architectures achieves very competitive results on both CIFAR-10 and ImageNet, which is remarkable considering it took 1 hour to carry out. This demonstrates that well-constructed architecture representations, coupled with diversified sampling and simple search form a simple but strong baseline for architecture search. Our best results are achieved using evolution over hierarchical representations: $3 . 7 5 \% \pm 0 . 1 2 \%$ classification error on the CIFAR-10 test set (using $c _ { 0 } = 6 4$ channels), which is further improved to $3 . 6 3 \% \pm 0 . 1 0 \%$ with more channels $c _ { 0 } = 1 2 8 )$ ). On the ImageNet validation set, we achieve $2 0 . 3 \%$ top-1 classification error and $5 . 2 \%$ top-5 error. We put these results in the context of the state of the art in Tables 2 and 3. We achieve the best published results on CIFAR-10 using evolutionary architecture search, and also demonstrate competitive performance compared to the best published methods on both CIFAR-10 and ImageNet. Our ImageNet model has 64M parameters, which is comparable to Inception-ResNet-v2 (55.8M) but larger than NASNet-A (22.6M).
+
+Table 2: Classification error on the CIFAR-10 test set obtained using state-of-the-art models as well as the best-performing architecture found using the proposed architecture search framework. Existing models are grouped as (from top to bottom): handcrafted architectures, architectures found using reinforcement learning, and architectures found using random or evolutionary search.   
+
+<table><tr><td>Model</td><td>Error (%)</td></tr><tr><td>ResNet-1001 + pre-activation (He et al., 2016b)</td><td>4.62</td></tr><tr><td>Wide ResNet-40-10 + dropout (Zagoruyko &amp; Komodakis,2016)</td><td>3.8</td></tr><tr><td>DenseNet (k=24) (Huang et al.,2016)</td><td>3.74</td></tr><tr><td>DenseNet-BC (k=40) (Huang et al.,2016)</td><td>3.46</td></tr><tr><td>MetaQNN (Baker et al., 2016)</td><td>6.92</td></tr><tr><td>NAS v3 (Zoph &amp; Le,2016)</td><td>3.65</td></tr><tr><td>Block-QNN-A (Zhong et al., 2017)</td><td>3.60</td></tr><tr><td>NASNet-A (Zoph et al., 2017)</td><td>3.41</td></tr><tr><td>Evolving DNN (Miikkulainen et al., 2017)</td><td>7.3</td></tr><tr><td>Genetic CNN(Xie &amp; Yuille,2017)</td><td>7.10</td></tr><tr><td>Large-scale Evolution (Real et al., 2017)</td><td>5.4</td></tr><tr><td>SMASH (Brock et al., 2017)</td><td>4.03</td></tr><tr><td>Evolutionary search,hier. repr.,Co = 64</td><td>3.75 ± 0.12</td></tr><tr><td>Evolutionary search,hier. repr.,Co = 128</td><td>3.63 ± 0.10</td></tr></table>
+
+<table><tr><td>Model</td><td>Top-1 error (%)</td><td>Top-5 error (%)</td></tr><tr><td>Inception-v3 (Szegedy et al., 2016)</td><td>21.2</td><td>5.6</td></tr><tr><td>Xception (Chollet,2016)</td><td>21.0</td><td>5.5</td></tr><tr><td>Inception-ResNet-v2 (Szegedy et al., 2017)</td><td>19.9</td><td>4.9</td></tr><tr><td>NASNet-A (Zoph et al., 2017)</td><td>19.2</td><td>4.7</td></tr><tr><td>Evolutionary search, hier. repr., Co = 64</td><td>20.3</td><td>5.2</td></tr></table>
+
+Table 3: Classification error on the ImageNet validation set obtained using state-of-the-art models as well as the best-performing architecture found using our framework.
+
+The evolved hierarchical cell is visualized in Appendix A, which shows that architecture search have discovered a number of skip connections. For example, the cell contains a direct skip connection between input and output: nodes 1 and 5 are connected by Motif 4, which in turn contains a direct connection between input and output. The cell also contains several internal skip connections, through Motif 5 (which again comes with an input-to-output skip connection similar to Motif 4).
+
+# 5 CONCLUSION
+
+We have presented an efficient evolutionary method that identifies high-performing neural architectures based on a novel hierarchical representation scheme, where smaller operations are used as the building blocks to form the larger ones. Notably, we show that strong results can be obtained even using simplistic search algorithms, such as evolution or random search, when coupled with a well-designed architecture representation. Our best architecture yields the state-of-the-art result on
+
+CIFAR-10 among evolutionary methods and successfully scales to ImageNet with highly competitive performance.
+
+# ACKNOWLEDGEMENTS
+
+The authors thank Jacob Menick, Pushmeet Kohli, Yujia Li, Simon Osindero, and many other colleagues at DeepMind for helpful comments and discussions.
+
+# REFERENCES
+
+Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. arXiv preprint arXiv:1611.02167, 2016.
+
+Andrew Brock, Theodore Lim, JM Ritchie, and Nick Weston. Smash: One-shot model architecture search through hypernetworks. arXiv preprint arXiv:1708.05344, 2017.
+
+Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. arXiv preprint arXiv:1610.02357, 2016.
+
+Dario Floreano, Peter Durr, and Claudio Mattiussi. Neuroevolution: from architectures to learning. ¨ Evolutionary Intelligence, 1(1):47–62, 2008.
+
+David E Goldberg and Kalyanmoy Deb. A comparative analysis of selection schemes used in genetic algorithms. Foundations of genetic algorithms, 1:69–93, 1991.
+
+Frdric Gruau, L’universite Claude Bernard lyon I, Of A Diplome De Doctorat, M. Jacques Demongeot, Examinators M. Michel Cosnard, M. Jacques Mazoyer, M. Pierre Peretto, and M. Darell Whitley. Neural network synthesis using cellular encoding and the genetic algorithm., 1994.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016a.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pp. 630–645. Springer, 2016b.
+
+John Henry Holland. Adaptation in natural and artificial systems: an introductory analysis with applications to biology, control, and artificial intelligence. MIT press, 1975.
+
+Gao Huang, Zhuang Liu, Kilian Q Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. arXiv preprint arXiv:1608.06993, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015.
+
+Hiroaki Kitano. Designing neural networks using genetic algorithms with graph generation system. Complex systems, 4(4):461–476, 1990.
+
+Gustav Larsson, Michael Maire, and Gregory Shakhnarovich. Fractalnet: Ultra-deep neural networks without residuals. arXiv preprint arXiv:1605.07648, 2016.
+
+Risto Miikkulainen, Jason Liang, Elliot Meyerson, Aditya Rawal, Dan Fink, Olivier Francon, Bala Raju, Arshak Navruzyan, Nigel Duffy, and Babak Hodjat. Evolving deep neural networks. arXiv preprint arXiv:1703.00548, 2017.
+
+Geoffrey F Miller, Peter M Todd, and Shailesh U Hegde. Designing neural networks using genetic algorithms. In ICGA, volume 89, pp. 379–384, 1989.
+
+Renato Negrinho and Geoff Gordon. Deeparchitect: Automatically designing and training deep architectures. arXiv preprint arXiv:1704.08792, 2017.
+
+Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Quoc Le, and Alex Kurakin. Large-scale evolution of image classifiers. arXiv preprint arXiv:1703.01041, 2017.
+
+Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. arXiv preprint arXiv:1802.01548, 2018.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael S. Bernstein, Alexander C. Berg, and Fei-Fei Li. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Kenneth O Stanley. Compositional pattern producing networks: A novel abstraction of development. Genetic programming and evolvable machines, 8(2):131–162, 2007.
+
+Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.
+
+Kenneth O Stanley, David B D’Ambrosio, and Jason Gauci. A hypercube-based encoding for evolving large-scale neural networks. Artificial life, 15(2):185–212, 2009.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016.
+
+Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, inception-resnet and the impact of residual connections on learning. In AAAI, pp. 4278–4284, 2017.
+
+Lingxi Xie and Alan Yuille. Genetic cnn. arXiv preprint arXiv:1703.01513, 2017.
+
+Saining Xie, Ross Girshick, Piotr Dollr, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. arXiv preprint arXiv:1611.05431, 2016.
+
+Xin Yao. Evolving artificial neural networks. Proceedings of the IEEE, 87(9):1423–1447, 1999.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+Zhao Zhong, Junjie Yan, and Cheng-Lin Liu. Practical network blocks design with q-learning. arXiv preprint arXiv:1708.05552, 2017.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. arXiv preprint arXiv:1707.07012, 2017.
+
+# A ARCHITECTURE VISUALIZATION
+
+Visualization of the learned cell and motifs of our best-performing hierarchical architecture. Note that only motifs 1,3,4,5 are used to construct the cell, among which motifs 3 and 5 are dominating.
+
+![](images/5827378350fc085340b2d704abc7bd516db0964177d21b1eb69aeeaefc759904.jpg)  
+Figure 5: Cell
+
+![](images/6d191ff74417a17da2feca8679070bab9b511eeefc971ead32998b8cb237191f.jpg)  
+Figure 6: Motif 1
+
+![](images/925ac3abc0524f08842c3c905b90c557795a478f32da5a5bd39e634e0db1dba3.jpg)  
+Figure 7: Motif 2
+
+![](images/fe72644435436421486a53f70aead4d477cc168c5ab16d5aa605227bb30f0b2a.jpg)  
+Figure 8: Motif 3
+
+![](images/18042d3b8a85bb8ddc43d1394aa95e8015aa64b257c4e43ff2457c7dda07a7cc.jpg)  
+Figure 9: Motif 4
+
+![](images/ebb0cb2926cd67f6b4f918039f5e0b48989afbcdd159da66c83963e267fa5269.jpg)  
+Figure 10: Motif 5
+
+![](images/36e4397ee8301a3e9c1e305ac1d5a735a0554dd806d6e11141358d26e62ebacf.jpg)  
+Figure 11: Motif 6

parse/train/BJQRKzbA-/BJQRKzbA-_content_list.json

@@ -0,0 +1,1582 @@
+[
+    {
+        "type": "text",
+        "text": "HIERARCHICAL REPRESENTATIONS FOR EFFICIENT ARCHITECTURE SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            655,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu∗ Carnegie Mellon University hanxiaol@cs.cmu.edu ",
+        "bbox": [
+            183,
+            170,
+            372,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, Koray Kavukcuoglu DeepMind {simonyan,vinyals,chrisantha,korayk}@google.com ",
+        "bbox": [
+            184,
+            232,
+            712,
+            276
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            311,
+            544,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We explore efficient neural architecture search methods and show that a simple yet powerful evolutionary algorithm can discover new architectures with excellent performance. Our approach combines a novel hierarchical genetic representation scheme that imitates the modularized design pattern commonly adopted by human experts, and an expressive search space that supports complex topologies. Our algorithm efficiently discovers architectures that outperform a large number of manually designed models for image classification, obtaining top-1 error of $3 . 6 \\%$ on CIFAR-10 and $2 0 . 3 \\%$ when transferred to ImageNet, which is competitive with the best existing neural architecture search approaches. We also present results using random search, achieving $0 . 3 \\%$ less top-1 accuracy on CIFAR-10 and $0 . 1 \\%$ less on ImageNet whilst reducing the search time from 36 hours down to 1 hour. ",
+        "bbox": [
+            233,
+            345,
+            764,
+            497
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            336,
+            545
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Discovering high-performance neural network architectures required years of extensive research by human experts through trial and error. As far as the image classification task is concerned, state-ofthe-art convolutional neural networks are going beyond deep, chain-structured layout (Simonyan & Zisserman, 2014; He et al., 2016a) towards increasingly more complex, graph-structured topologies (Szegedy et al., 2015; 2016; 2017; Larsson et al., 2016; Xie et al., 2016; Huang et al., 2016). The combinatorial explosion in the design space makes handcrafted architectures not only expensive to obtain, but also likely to be suboptimal in performance. ",
+        "bbox": [
+            174,
+            563,
+            823,
+            660
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, there has been a surge of interest in using algorithms to automate the manual process of architecture design. Their goal can be described as finding the optimal architecture in a given search space such that the validation accuracy is maximized on the given task. Representative architecture search algorithms can be categorized as random with weights prediction (Brock et al., 2017), Monte Carlo Tree Search (Negrinho & Gordon, 2017), evolution (Stanley & Miikkulainen, 2002; Xie & Yuille, 2017; Miikkulainen et al., 2017; Real et al., 2017), and reinforcement learning (Baker et al., 2016; Zoph & Le, 2016; Zoph et al., 2017; Zhong et al., 2017), among which reinforcement learning approaches have demonstrated the strongest empirical performance so far. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            779
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Architecture search can be computationally very intensive as each evaluation typically requires training a neural network. Therefore, it is common to restrict the search space to reduce complexity and increase efficiency of architecture search. Various constraints that have been used include: growing a convolutional “backbone” with skip connections (Real et al., 2017), a linear sequence of filter banks (Brock et al., 2017), or a directed graph where every node has exactly two predecessors (Zoph et al., 2017). In this work we constrain the search space by imposing a hierarchical network structure, while allowing flexible network topologies (directed acyclic graphs) at each level of the hierarchy. Starting from a small set of primitives such as convolutional and pooling operations at the bottom level of the hierarchy, higher-level computation graphs, or motifs, are formed by using lower-level motifs as their building blocks. The motifs at the top of the hierarchy are stacked multiple times to form the final neural network. This approach enables search algorithms to implement powerful hierarchical modules where any change in the motifs is propagated across the whole network immediately. This is analogous to the modularized design patterns used in many handcrafted architectures, e.g. VGGNet (Simonyan & Zisserman, 2014), ResNet (He et al., 2016a), and Inception (Szegedy et al., 2016) are all comprised of building blocks. In our case, a hierarchical architecture is discovered through evolutionary or random search. ",
+        "bbox": [
+            174,
+            785,
+            823,
+            896
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The evolution of neural architectures was studied as a sub-task of neuroevolution (Holland, 1975; Miller et al., 1989; Yao, 1999; Stanley & Miikkulainen, 2002; Floreano et al., 2008), where the topology of a neural network is simultaneously evolved along with its weights and hyperparameters. The benefits of indirect encoding schemes, such as multi-scale representations, have historically been discussed in Gruau et al. (1994); Kitano (1990); Stanley (2007); Stanley et al. (2009). Despite these pioneer studies, evolutionary or random architecture search has not been investigated at larger scale on image classification benchmarks until recently (Real et al., 2017; Miikkulainen et al., 2017; Xie & Yuille, 2017; Brock et al., 2017; Negrinho & Gordon, 2017). Our work shows that the power of simple search methods can be substantially enhanced using well-designed search spaces. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our experimental setup resembles Zoph et al. (2017), where an architecture found using reinforcement learning obtained the state-of-the-art performance on ImageNet. Our work reveals that random or evolutionary methods, which so far have been seen as less efficient, can scale and achieve competitive performance on this task if combined with a powerful architecture representation, whilst utilizing significantly less computational resources. ",
+        "bbox": [
+            176,
+            353,
+            825,
+            424
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize, our main contributions are: ",
+        "bbox": [
+            176,
+            431,
+            452,
+            445
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We introduce hierarchical representations for describing neural network architectures. 2. We show that competitive architectures for image classification can be obtained even with simplistic random search, which demonstrates the importance of search space construction. 3. We present a scalable variant of evolutionary search which further improves the results and achieves the best published results1 among evolutionary architecture search techniques. ",
+        "bbox": [
+            212,
+            457,
+            825,
+            537
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 ARCHITECTURE REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            558,
+            503,
+            574
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We first describe flat representations of neural architectures (Sect. 2.1), where each architecture is represented as a single directed acyclic graph of primitive operations. Then we move on to hierarchical representations (Sect. 2.2) where smaller graph motifs are used as building blocks to form larger motifs. Primitive operations are discussed in Sect. 2.3. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 FLAT ARCHITECTURE REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            661,
+            495,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider a family of neural network architectures represented by a single-source, single-sink computation graph that transforms the input at the source to the output at the sink. Each node of the graph corresponds to a feature map, and each directed edge is associated with some primitive operation (e.g. convolution, pooling, etc.) that transforms the feature map in the input node and passes it to the output node. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            757
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Formally, an architecture is defined by the representation $( G , o )$ , consisting of two ingredients: ",
+        "bbox": [
+            169,
+            763,
+            794,
+            780
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. A set of available operations $\\pmb { o } = \\{ o _ { 1 } , o _ { 2 } , \\dots \\}$ . 2. An adjacency matrix $G$ specifying the neural network graph of operations, where $G _ { i j } = k$ means that the $k$ -th operation $o _ { k }$ is to be placed between nodes $i$ and $j$ . ",
+        "bbox": [
+            207,
+            790,
+            826,
+            838
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The architecture is obtained by assembling operations $^ o$ according to the adjacency matrix $G$ ",
+        "bbox": [
+            173,
+            849,
+            785,
+            864
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5ba253401fc2ef0bfbb095015d0664b41dee2e0be3038a0db4b20a585ab50c22.jpg",
+        "text": "$$\na r c h = a s s e m b l e ( G , \\pmb { o } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            871,
+            581,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/c45da3f31f9a063b5d3741f0f079db094eddcf5d00b57e45b7a52a27b551e687.jpg",
+        "image_caption": [
+            "Figure 1: An example of a three-level hierarchical architecture representation. The bottom row shows how level-1 primitive operations $o _ { 1 } ^ { ( 1 ) } , o _ { 2 } ^ { ( 1 ) } , o _ { 3 } ^ { ( 1 ) }$ o( ) are assembled into a level-2 motif o(2)1 . The top row shows how level-2 motifs $o _ { 1 } ^ { ( 2 ) } , o _ { 2 } ^ { ( 2 ) } , o _ { 3 } ^ { ( 2 ) }$ are then assembled into a level-3 motif $o _ { 1 } ^ { ( 3 ) }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            102,
+            808,
+            308
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "in a way that the resulting neural network sequentially computes the feature map $x _ { i }$ of each node $i$ from the feature maps $x _ { j }$ of its predecessor nodes $j$ following the topological ordering: ",
+        "bbox": [
+            173,
+            395,
+            825,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/28295c4c71f6d85e16dc578af7dcbec13d5e285d0a548734fa748bdbe27137ed.jpg",
+        "text": "$$\nx _ { i } = m e r g e \\left[ \\left\\{ o _ { G _ { i j } } ( x _ { j } ) \\right\\} _ { j < i } \\right] , \\quad i = 2 , \\ldots , \\left| { \\cal G } \\right|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            431,
+            658,
+            452
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $| G |$ is the number of nodes in a graph, and merge is an operation combining multiple feature maps into one, which in our experiments was implemented as depthwise concatenation. An alternative option of element-wise addition is less flexible as it requires the incoming feature maps to contain the same number of channels, and is strictly subsumed by concatenation if the resulting $x _ { i }$ is immediately followed by a $1 \\times 1$ convolution. ",
+        "bbox": [
+            173,
+            458,
+            825,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 HIERARCHICAL ARCHITECTURE REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            545,
+            568,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The key idea of the hierarchical architecture representation is to have several motifs at different levels of hierarchy, where lower-level motifs are used as building blocks (operations) during the construction of higher-level motifs. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider a hierarchy of $L$ levels where the $\\ell$ -th level contains $M _ { \\ell }$ motifs. The highest-level $\\ell = L$ contains only a single motif corresponding to the full architecture, and the lowest level $\\ell = 1$ is the set of primitive operations. We recursively define $o _ { m } ^ { ( \\ell ) }$ , the $m$ -th motif in level $\\ell$ , as the composition of lower-level motifs $\\pmb { o } ^ { ( \\ell - 1 ) } = \\bigl \\{ o _ { 1 } ^ { ( \\ell - 1 ) } , o _ { 2 } ^ { ( \\ell - 1 ) } , . . . , o _ { M _ { ( \\ell - 1 ) } } ^ { ( \\ell - 1 ) } \\bigr \\}$ according to its network structure $G _ { m } ^ { ( \\ell ) }$ ",
+        "bbox": [
+            173,
+            621,
+            825,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4b3251d06c8ef3e59c0e502a84297dbedce3c294f30830a7c1b60e68f401107.jpg",
+        "text": "$$\no _ { m } ^ { ( \\ell ) } = a s s e m b l e \\left( G _ { m } ^ { ( \\ell ) } , o ^ { ( \\ell - 1 ) } \\right) , \\quad \\forall \\ell = 2 , \\ldots , L\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            695,
+            666,
+            722
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A hierarchical architecture representation is therefore defined by $\\left( \\big \\{ \\{ G _ { m } ^ { ( \\ell ) } \\} _ { m = 1 } ^ { M _ { \\ell } } \\big \\} _ { \\ell = 2 } ^ { L } , o ^ { ( 1 ) } \\right)$ , as it is assembly process is illustrated in Fig. 1. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            781
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 PRIMITIVE OPERATIONS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            797,
+            385,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider the following six primitives at the bottom level of the hierarchy $\\ell = 1 , M _ { \\ell } = 6 )$ : ",
+        "bbox": [
+            169,
+            824,
+            789,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• $1 \\times 1$ convolution of $C$ channels • $3 \\times 3$ depthwise convolution • $3 \\times 3$ separable convolution of $C$ channels • $3 \\times 3$ max-pooling ",
+        "bbox": [
+            215,
+            851,
+            514,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• $3 \\times 3$ average-pooling • identity ",
+        "bbox": [
+            215,
+            103,
+            380,
+            137
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If applicable, all primitives are of stride one and the convolved feature maps are padded to preserve their spatial resolution. All convolutional operations are followed by batch normalization and ReLU activation (Ioffe & Szegedy, 2015); their number of channels is fixed to a constant $C$ . We note that convolutions with larger receptive fields and more channels can be expressed as motifs of such primitives. Indeed, large receptive fields can be obtained by stacking $3 \\times 3$ convolutions in a chain structure (Simonyan & Zisserman, 2014), and wider convolutions with more channels can be obtained by merging the outputs of multiple convolutions through depthwise concatenation. ",
+        "bbox": [
+            173,
+            148,
+            825,
+            247
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We also introduce a special none op, which indicates that there is no edge between nodes $i$ and $j$ . It is added to the pool of operations at each level. ",
+        "bbox": [
+            173,
+            253,
+            823,
+            282
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EVOLUTIONARY ARCHITECTURE SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            303,
+            555,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Evolutionary search over neural network architectures can be performed by treating the representations of Sect. 2 as genotypes. We first introduce an action space for mutating hierarchical genotypes (Sect. 3.1), as well as a diversification-based scheme to obtain the initial population (Sect. 3.2). We then describe tournament selection and random search in Sect. 3.3, and our distributed implementation in Sect. 3.4. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 MUTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            421,
+            290,
+            436
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A single mutation of a hierarchical genotype consists of the following sequence of actions: ",
+        "bbox": [
+            169,
+            446,
+            767,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Sample a target non-primitive level $\\ell \\geq 2$ .   \n2. Sample a target motif $m$ in the target level.   \n3. Sample a random successor node $i$ in the target motif.   \n4. Sample a random predecessor node $j$ in the target motif.   \n5. Replace the current operation $o _ { k } ^ { ( \\ell - 1 ) }$ between $j$ and $i$ with a randomly sampled operation   \n$o _ { k ^ { \\prime } } ^ { ( \\ell - 1 ) }$ ",
+        "bbox": [
+            210,
+            473,
+            825,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the case of flat genotypes which consist of two levels (one of which is the fixed level of primitives), the first step is omitted and $\\ell$ is set to 2. The mutation can be summarized as: ",
+        "bbox": [
+            173,
+            599,
+            823,
+            627
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe20ece67bfb545f78676d6cefd8385d6745edd1e497997529a782dfd1d7d392.jpg",
+        "text": "$$\n[ G _ { m } ^ { ( \\ell ) } ] _ { i j } = k ^ { \\prime }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            454,
+            633,
+            544,
+            654
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\ell , m , i , j , k ^ { \\prime }$ are randomly sampled from uniform distributions over their respective domains. Notably, the above mutation process is powerful enough to perform various modifications on the target motif, such as: ",
+        "bbox": [
+            174,
+            660,
+            825,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Add a new edge: if $o _ { k } ^ { ( \\ell - 1 ) } = n o n e$ and $o _ { k ^ { \\prime } } ^ { ( \\ell - 1 ) } \\neq n o n e .$   \n2. Alter an existing edge: if $o _ { k } ^ { ( \\ell - 1 ) } \\neq n o n e$ and $o _ { k ^ { \\prime } } ^ { ( \\ell - 1 ) } \\neq n o n e$ and $o _ { k ^ { \\prime } } ^ { ( \\ell - 1 ) } \\neq o _ { k } ^ { ( \\ell - 1 ) }$   \n3. Remove an existing edge: if $o _ { k } ^ { ( \\ell - 1 ) } \\neq n o n e$ and if $o _ { \\boldsymbol { k } ^ { \\prime } } ^ { ( \\ell - 1 ) } = n o n e$ ",
+        "bbox": [
+            212,
+            714,
+            777,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 INITIALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            328,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To initialize the population of genotypes, we use the following strategy: ",
+        "bbox": [
+            173,
+            823,
+            643,
+            838
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Create a “trivial” genotype where each motif is set to a chain of identity mappings.   \n2. Diversify the genotype by applying a large number (e.g. 1000) of random mutations. ",
+        "bbox": [
+            209,
+            848,
+            785,
+            885
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In contrast to several previous works where genotypes are initialized by trivial networks (Stanley & Miikkulainen, 2002; Real et al., 2017), the above diversification-based scheme not only offers a ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: Data queue $\\mathcal { Q }$ containing initial genotypes; Memory table $\\mathcal { M }$ recording evaluated genotypes and their fitness.   \nwhile True do if HASIDLEWORKER() then genotype $\\gets$ ASYNCTOURNAMENTSELECT $( \\mathcal { M } )$ genotype $^ \\prime \\gets$ MUTATE(genotype) $\\mathcal { Q }  \\mathcal { Q } \\cup g e n o t y p e ^ { \\prime }$ ",
+        "bbox": [
+            174,
+            125,
+            761,
+            234
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2: ASYNCEVO Asynchronous Evolution (Worker) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            262,
+            583,
+            276
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input: Training set $\\tau$ , validation set $\\nu$ ; Shared memory table $\\mathcal { M }$ and data queue $\\mathcal { Q }$ .   \nwhile True do if $| \\mathcal { Q } | > 0$ then genotype $ \\mathcal { Q }$ .pop() $a r c h \\gets \\mathrm { A s s E M B L E } ( q e n o t y p e )$ ) $m o d e l \\gets \\mathrm { T R A I N } ( a r c h , \\mathcal { T } )$ f itness ← EVALUATE(model, V) M ← M ∪ (genotype, f itness) ",
+        "bbox": [
+            174,
+            280,
+            727,
+            405
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "good initial coverage of the search space with non-trivial architectures, but also helps to avoid an additional bias introduced by handcrafted initialization routines. In fact, this strategy ensures initial architectures are reasonably well-performing even without any search, as suggested by our random sample results in Table 1. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            494
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 SEARCH ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            515,
+            372,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our evolutionary search algorithm is based on tournament selection (Goldberg & Deb, 1991). Starting from an initial population of random genotypes, tournament selection provides a mechanism to pick promising genotypes from the population, and to place its mutated offspring back into the population. By repeating this process, the quality of the population keeps being refined over time. We always train a model from scratch for a fixed number of iterations, and we refer to the training and evaluation of a single model as an evolution step. The genotype with the highest fitness (validation accuracy) among the entire population is selected as the final output after a fixed amount of time. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A tournament is formed by a random set of genotypes sampled from the current effective population, among which the individual with the highest fitness value wins the tournament. The selection pressure is controlled by the tournament size, which is set to $5 \\%$ of the population size in our case. We do not remove any genotypes from the population, allowing it to grow with time, maintaining architecture diversity. Our evolution algorithm is similar to the binary tournament selection used in a recent large-scale evolutionary method (Real et al., 2017). ",
+        "bbox": [
+            174,
+            646,
+            825,
+            729
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We also investigated random search, a simpler strategy which has not been sufficiently explored in the literature, as an alternative to evolution. In this case, a population of genotypes is generated randomly, the fitness is computed for each genotype in the same way as done in evolution, and the genotype with the highest fitness is selected as the final output. The main advantage of this method is that it can be run in parallel over the entire population, substantially reducing the search time. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            806
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            341,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our distributed implementation is asynchronous, consisting of a single controller responsible for performing evolution over the genotypes, and a set of workers responsible for their evaluation. Both parties have access to a shared tabular memory $\\mathcal { M }$ recording the population of genotypes and their fitness, as well as a data queue $\\mathcal { Q }$ containing the genotypes with unknown fitness which should be evaluated. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Specifically, the controller will perform tournament selection of a genotype from $\\mathcal { M }$ whenever a worker becomes available, followed by the mutation of the selected genotype and its insertion into $\\mathcal { Q }$ for fitness evaluation (Algorithm 1). A worker will pick up an unevaluated genotype from $\\mathcal { Q }$ whenever there is one available, assemble it into an architecture, carry out training and validation, and then record the validation accuracy (fitness) in $\\mathcal { M }$ (Algorithm 2). Architectures are trained from scratch for a fixed number of steps with random weight initialization. We do not rely on weight inheritance as in (Real et al., 2017), though incorporating it into our system is possible. Note that during architecture evolution no synchronization is required, and all workers are fully occupied. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS AND RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            237,
+            447,
+            253
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            270,
+            375,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we use the proposed search framework to learn the architecture of a convolutional cell, rather than the entire model. The reason is that we would like to be able to quickly compute the fitness of the candidate architecture and then transfer it to a larger model, which is achieved by using less cells for fitness computation and more cells for full model evaluation. A similar approach has recently been used in (Zoph et al., 2017; Zhong et al., 2017). ",
+        "bbox": [
+            174,
+            296,
+            823,
+            367
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Architecture search is carried out entirely on the CIFAR-10 training set, which we split into two sub-sets of 40K training and 10K validation images. Candidate models are trained on the training subset, and evaluated on the validation subset to obtain the fitness. Once the search process is over, the selected cell is plugged into a large model which is trained on the combination of training and validation sub-sets, and the accuracy is reported on the CIFAR-10 test set. We note that the test set is never used for model selection, and it is only used for final model evaluation. We also evaluate the cells, learned on CIFAR-10, in a large-scale setting on the ImageNet challenge dataset (Sect. 4.3). ",
+        "bbox": [
+            173,
+            373,
+            825,
+            472
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/90de7a8e7bec6abe5c35e8f938d8e02218cef231e40a3cc092e4429200a63956.jpg",
+        "image_caption": [
+            "Figure 2: Image classification models constructed using the cells optimized with architecture search. Top-left: small model used during architecture search on CIFAR-10. Top-right: large CIFAR-10 model used for learned cell evaluation. Bottom: ImageNet model used for learned cell evaluation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            484,
+            825,
+            678
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For CIFAR-10 experiments we use a model which consists of $3 \\times 3$ convolution with $c _ { 0 }$ channels, followed by 3 groups of learned convolutional cells, each group containing $N$ cells. After each cell (with $c$ input channels) we insert $3 \\times 3$ separable convolution which has stride 2 and $2 c$ channels if it is the last cell of the group, and stride 1 and $c$ channels otherwise. The purpose of these convolutions is to control the number of channels as well as reduce the spatial resolution. The last cell is followed by global average pooling and a linear softmax layer. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For fitness computation we use a smaller model with $c _ { 0 } = 1 6$ and $N = 1$ , shown in Fig. 2 (top-left). It is trained using SGD with 0.9 momentum for 5000 steps, starting with the learning rate 0.1, which is reduced by 10x after 4000 and 4500 steps. The batch size is 256, and the weight decay value is $3 \\cdot 1 0 ^ { - 4 }$ . We employ standard training data augmentation where a $2 4 \\times 2 4$ crop is randomly sampled from a $3 2 \\times 3 2$ image, followed by random horizontal flipping. The evaluation is performed on the full size $3 2 \\times 3 2$ image. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A note on variance. We found that the variance due to optimization was non-negligible, and we believe that reporting it is important for performing a fair comparison and assessing model capabilities. When training CIFAR models, we have observed standard deviation of up to $0 . 2 \\%$ using the exact same setup. The solution we adopted was to compute the fitness as the average accuracy over 4 training-evaluation runs. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the evaluation of the learned cell architecture on CIFAR-10, we use a larger model with $c _ { 0 } =$ 64 and $N = 2$ , shown in Fig. 2 (top-right). The larger model is trained for 80K steps, starting with a learning rate 0.1, which is reduced by 10x after 40K, 60K, and 70K steps. The rest of the training settings are the same as used for fitness computation. We report mean and standard deviation computed over 5 training-evaluation runs. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            250
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the evaluation on the ILSVRC ImageNet challenge dataset (Russakovsky et al., 2015), we use an architecture similar to the one used for CIFAR, with the following changes. An input $2 9 9 \\times 2 9 9$ image is passed through two convolutional layers with 32 and 64 channels and stride 2 each. It is followed by 4 groups of convolutional cells where the first group contains a single cell (and has $c _ { 0 } = 6 4$ input channels), and the remaining three groups have $N = 2$ cells each (Fig. 2, bottom). We use SGD with momentum which is run for 200K steps, starting with a learning rate of 0.1, which is reduced by $1 0 \\mathrm { x }$ after 100K, 150K, and 175K steps. The batch size is 1024, and weight decay is $1 0 ^ { - 4 }$ . We did not use auxiliary losses, weight averaging, label smoothing or path dropout empirically found effective in (Zoph et al., 2017). The training augmentation is the same as in (Szegedy et al., 2016), and consists in random crops, horizontal flips and brightness and contrast changes. We report the single-crop top-1 and top-5 error on the ILSVRC validation set. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            410
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d99fa53a5043a8ad1f7392e8acdbaa662066f399b32247746013b1020659f9bf.jpg",
+        "image_caption": [
+            "4.2 ARCHITECTURE SEARCH ON CIFAR-10 ",
+            "Figure 3: Fitness and number of parameters vs evolution step for flat and hierarchical representations. Left: fitness of a genotype generated at each evolution step. Middle: maximum fitness across all genotypes generated before each evolution step. Right: number of parameters in the small CIFAR-10 model constructed using the genotype generated at each evolution step. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            472,
+            818,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We run the evolution on flat and hierarchical genotypes for 7000 steps using 200 GPU workers. The initial size of the randomly initialized population is 200, which later grows as a result of tournament selection and mutation (Sect. 3). For the hierarchical representation, we use three levels $ { \\boldsymbol { L } } = 3$ ), with $M _ { 1 } = 6 , M _ { 2 } = 6 , M _ { 3 } = 1$ . Each of the level-2 motifs is a graph with $| G ^ { ( 2 ) } | = 4$ nodes, and the level-3 motif is a graph with $| G ^ { ( 3 ) } | = 5$ nodes. Each level-2 motif is followed by a $1 \\times 1$ convolution with the same number of channels as on the motif input to reduce the number of parameters. For the flat representation, we used a graph with 11 nodes to achieve a comparable number of edges. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The evolution process is visualized in Fig. 3. The left plot shows the fitness of the genotype generated at each step of evolution: the fitness grows fast initially, and plateaus over time. The middle plot shows the best fitness observed by each evolution step. Since the first 200 steps correspond to a random initialization and mutation starts after that, the best architecture found at step 200 corresponds to the output of random search over 200 architectures. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 (right) shows the number of parameters in the small network (used for fitness computation), constructed using the genotype produced at each step. Notably, flat genotypes achieve higher fitness, but at the cost of larger parameter count. We thus also consider a parameter-constrained variant of the flat genotype, where only the genotypes with the number of parameters under a fixed threshold are permitted; the threshold is chosen so that the flat genotype has a similar number of parameters to the hierarchical one. In this setting hierarchical and flat genotypes achieve similar fitness. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate that improvement in fitness of the hierarchical architecture is correlated with the improvement in the accuracy of the corresponding large model trained till convergence, we plot the relative accuracy improvements in Fig. 4. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            236
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8fe9b7d2f36de478b031f059225e5578a7c7b2bcf6997b7bacd0702b618a6a22.jpg",
+        "image_caption": [
+            "Figure 4: Accuracy improvement over the course of evolution, measured with respect to the first random genotype. The small model is the model used for fitness computation during evolution (its absolute fitness value is shown with the red curve in Fig. 3 (middle)). The large model is the model where the evolved cell architecture is deployed for training and evaluation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            338,
+            252,
+            658,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As far as the architecture search time is concerned, it takes 1 hour to compute the fitness of one architecture on a single P100 GPU (which involves 4 rounds of training and evaluation). Using 200 GPUs, it thus takes 1 hour to perform random search over 200 architectures and 1.5 days to do the evolutionary search with 7000 steps. This is significantly faster than 11 days using 250 GPUs reported by (Real et al., 2017) and 4 days using 450 GPUs reported by (Zoph et al., 2017). ",
+        "bbox": [
+            174,
+            516,
+            825,
+            587
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/448061aa9b1441920ae2ccc0b59588fad9aa9b3b8e73cb3bbf6f67fb089bfe73.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Search Method</td><td>CIFAR-10 error (%)</td><td>ImageNet Top-1/Top-5 error (%)</td></tr><tr><td>Flat repr-n, random architecture</td><td>4.56 ± 0.11</td><td>21.4/5.8</td></tr><tr><td>Flat repr-n,random search (2O0 samples)</td><td>4.02 ± 0.11</td><td>20.8/5.7</td></tr><tr><td>Flat repr-n,evolution (70o0 samples)</td><td>3.92 ±0.06</td><td>20.6/5.6</td></tr><tr><td>Flat repr-n,parameter-constrained,evolution (7ooo samples)</td><td>4.17 ± 0.08</td><td>21.2/5.8</td></tr><tr><td>Hier. repr-n, random architecture</td><td>4.21 ± 0.11</td><td>21.5/5.8</td></tr><tr><td>Hier. repr-n,random search (2O0 samples)</td><td>4.04±0.2</td><td>20.4/5.3</td></tr><tr><td>Hier.repr-n,random search (7ooo samples)</td><td>3.91 ± 0.15</td><td>21.0/5.5</td></tr><tr><td>Hier. repr-n, evolution (70oO samples)</td><td>3.75 ±0.12</td><td>20.3/5.2</td></tr></table>",
+        "bbox": [
+            176,
+            601,
+            821,
+            736
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Classification results on the CIFAR-10 test set and ILSVRC validation set obtained using the architectures found using various representations and search methods. ",
+        "bbox": [
+            171,
+            751,
+            825,
+            780
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 ARCHITECTURE EVALUATION ON CIFAR-10 AND IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            806,
+            640,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now turn to the evaluation of architectures found using random and evolutionary search on CIFAR-10 and ImageNet. The results are presented in Table 1. ",
+        "bbox": [
+            174,
+            832,
+            820,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "First, we note that randomly sampled architectures already perform surprisingly well, which we attribute to the representation power of our architecture spaces. Second, random search over 200 architectures achieves very competitive results on both CIFAR-10 and ImageNet, which is remarkable considering it took 1 hour to carry out. This demonstrates that well-constructed architecture representations, coupled with diversified sampling and simple search form a simple but strong baseline for architecture search. Our best results are achieved using evolution over hierarchical representations: $3 . 7 5 \\% \\pm 0 . 1 2 \\%$ classification error on the CIFAR-10 test set (using $c _ { 0 } = 6 4$ channels), which is further improved to $3 . 6 3 \\% \\pm 0 . 1 0 \\%$ with more channels $c _ { 0 } = 1 2 8 )$ ). On the ImageNet validation set, we achieve $2 0 . 3 \\%$ top-1 classification error and $5 . 2 \\%$ top-5 error. We put these results in the context of the state of the art in Tables 2 and 3. We achieve the best published results on CIFAR-10 using evolutionary architecture search, and also demonstrate competitive performance compared to the best published methods on both CIFAR-10 and ImageNet. Our ImageNet model has 64M parameters, which is comparable to Inception-ResNet-v2 (55.8M) but larger than NASNet-A (22.6M). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5bfe89e630499685bbfdcea86bd930b63ee442cc9966e1cafd4bbe1c75ece8f.jpg",
+        "table_caption": [
+            "Table 2: Classification error on the CIFAR-10 test set obtained using state-of-the-art models as well as the best-performing architecture found using the proposed architecture search framework. Existing models are grouped as (from top to bottom): handcrafted architectures, architectures found using reinforcement learning, and architectures found using random or evolutionary search. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Error (%)</td></tr><tr><td>ResNet-1001 + pre-activation (He et al., 2016b)</td><td>4.62</td></tr><tr><td>Wide ResNet-40-10 + dropout (Zagoruyko &amp; Komodakis,2016)</td><td>3.8</td></tr><tr><td>DenseNet (k=24) (Huang et al.,2016)</td><td>3.74</td></tr><tr><td>DenseNet-BC (k=40) (Huang et al.,2016)</td><td>3.46</td></tr><tr><td>MetaQNN (Baker et al., 2016)</td><td>6.92</td></tr><tr><td>NAS v3 (Zoph &amp; Le,2016)</td><td>3.65</td></tr><tr><td>Block-QNN-A (Zhong et al., 2017)</td><td>3.60</td></tr><tr><td>NASNet-A (Zoph et al., 2017)</td><td>3.41</td></tr><tr><td>Evolving DNN (Miikkulainen et al., 2017)</td><td>7.3</td></tr><tr><td>Genetic CNN(Xie &amp; Yuille,2017)</td><td>7.10</td></tr><tr><td>Large-scale Evolution (Real et al., 2017)</td><td>5.4</td></tr><tr><td>SMASH (Brock et al., 2017)</td><td>4.03</td></tr><tr><td>Evolutionary search,hier. repr.,Co = 64</td><td>3.75 ± 0.12</td></tr><tr><td>Evolutionary search,hier. repr.,Co = 128</td><td>3.63 ± 0.10</td></tr></table>",
+        "bbox": [
+            251,
+            244,
+            746,
+            468
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d351ca1f11da68aebe5ae0a0ca2f3506f95e71edd181f0b4e6fcde9cfff3e3f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1 error (%)</td><td>Top-5 error (%)</td></tr><tr><td>Inception-v3 (Szegedy et al., 2016)</td><td>21.2</td><td>5.6</td></tr><tr><td>Xception (Chollet,2016)</td><td>21.0</td><td>5.5</td></tr><tr><td>Inception-ResNet-v2 (Szegedy et al., 2017)</td><td>19.9</td><td>4.9</td></tr><tr><td>NASNet-A (Zoph et al., 2017)</td><td>19.2</td><td>4.7</td></tr><tr><td>Evolutionary search, hier. repr., Co = 64</td><td>20.3</td><td>5.2</td></tr></table>",
+        "bbox": [
+            236,
+            568,
+            759,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Classification error on the ImageNet validation set obtained using state-of-the-art models as well as the best-performing architecture found using our framework. ",
+        "bbox": [
+            173,
+            681,
+            823,
+            710
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The evolved hierarchical cell is visualized in Appendix A, which shows that architecture search have discovered a number of skip connections. For example, the cell contains a direct skip connection between input and output: nodes 1 and 5 are connected by Motif 4, which in turn contains a direct connection between input and output. The cell also contains several internal skip connections, through Motif 5 (which again comes with an input-to-output skip connection similar to Motif 4). ",
+        "bbox": [
+            174,
+            728,
+            825,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            820,
+            318,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have presented an efficient evolutionary method that identifies high-performing neural architectures based on a novel hierarchical representation scheme, where smaller operations are used as the building blocks to form the larger ones. Notably, we show that strong results can be obtained even using simplistic search algorithms, such as evolution or random search, when coupled with a well-designed architecture representation. Our best architecture yields the state-of-the-art result on ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10 among evolutionary methods and successfully scales to ImageNet with highly competitive performance. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            154,
+            367,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors thank Jacob Menick, Pushmeet Kohli, Yujia Li, Simon Osindero, and many other colleagues at DeepMind for helpful comments and discussions. ",
+        "bbox": [
+            174,
+            184,
+            823,
+            213
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            234,
+            287,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. arXiv preprint arXiv:1611.02167, 2016. ",
+        "bbox": [
+            173,
+            257,
+            821,
+            287
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Theodore Lim, JM Ritchie, and Nick Weston. Smash: One-shot model architecture search through hypernetworks. arXiv preprint arXiv:1708.05344, 2017. ",
+        "bbox": [
+            173,
+            296,
+            823,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Franc¸ois Chollet. Xception: Deep learning with depthwise separable convolutions. arXiv preprint arXiv:1610.02357, 2016. ",
+        "bbox": [
+            173,
+            335,
+            823,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dario Floreano, Peter Durr, and Claudio Mattiussi. Neuroevolution: from architectures to learning. ¨ Evolutionary Intelligence, 1(1):47–62, 2008. ",
+        "bbox": [
+            174,
+            375,
+            821,
+            404
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David E Goldberg and Kalyanmoy Deb. A comparative analysis of selection schemes used in genetic algorithms. Foundations of genetic algorithms, 1:69–93, 1991. ",
+        "bbox": [
+            173,
+            412,
+            825,
+            443
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Frdric Gruau, L’universite Claude Bernard lyon I, Of A Diplome De Doctorat, M. Jacques Demongeot, Examinators M. Michel Cosnard, M. Jacques Mazoyer, M. Pierre Peretto, and M. Darell Whitley. Neural network synthesis using cellular encoding and the genetic algorithm., 1994. ",
+        "bbox": [
+            176,
+            452,
+            821,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016a. ",
+        "bbox": [
+            176,
+            503,
+            821,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pp. 630–645. Springer, 2016b. ",
+        "bbox": [
+            173,
+            556,
+            823,
+            587
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Henry Holland. Adaptation in natural and artificial systems: an introductory analysis with applications to biology, control, and artificial intelligence. MIT press, 1975. ",
+        "bbox": [
+            173,
+            595,
+            821,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Kilian Q Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. arXiv preprint arXiv:1608.06993, 2016. ",
+        "bbox": [
+            174,
+            633,
+            823,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            715
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hiroaki Kitano. Designing neural networks using genetic algorithms with graph generation system. Complex systems, 4(4):461–476, 1990. ",
+        "bbox": [
+            174,
+            726,
+            821,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gustav Larsson, Michael Maire, and Gregory Shakhnarovich. Fractalnet: Ultra-deep neural networks without residuals. arXiv preprint arXiv:1605.07648, 2016. ",
+        "bbox": [
+            169,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Risto Miikkulainen, Jason Liang, Elliot Meyerson, Aditya Rawal, Dan Fink, Olivier Francon, Bala Raju, Arshak Navruzyan, Nigel Duffy, and Babak Hodjat. Evolving deep neural networks. arXiv preprint arXiv:1703.00548, 2017. ",
+        "bbox": [
+            176,
+            803,
+            825,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey F Miller, Peter M Todd, and Shailesh U Hegde. Designing neural networks using genetic algorithms. In ICGA, volume 89, pp. 379–384, 1989. ",
+        "bbox": [
+            174,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Renato Negrinho and Geoff Gordon. Deeparchitect: Automatically designing and training deep architectures. arXiv preprint arXiv:1704.08792, 2017. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Quoc Le, and Alex Kurakin. Large-scale evolution of image classifiers. arXiv preprint arXiv:1703.01041, 2017. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. arXiv preprint arXiv:1802.01548, 2018. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael S. Bernstein, Alexander C. Berg, and Fei-Fei Li. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015. ",
+        "bbox": [
+            173,
+            178,
+            825,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenneth O Stanley. Compositional pattern producing networks: A novel abstraction of development. Genetic programming and evolvable machines, 8(2):131–162, 2007. ",
+        "bbox": [
+            174,
+            281,
+            821,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002. ",
+        "bbox": [
+            173,
+            319,
+            821,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenneth O Stanley, David B D’Ambrosio, and Jason Gauci. A hypercube-based encoding for evolving large-scale neural networks. Artificial life, 15(2):185–212, 2009. ",
+        "bbox": [
+            174,
+            357,
+            821,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "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 Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            489
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, inception-resnet and the impact of residual connections on learning. In AAAI, pp. 4278–4284, 2017. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            541
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lingxi Xie and Alan Yuille. Genetic cnn. arXiv preprint arXiv:1703.01513, 2017. ",
+        "bbox": [
+            173,
+            549,
+            714,
+            565
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Ross Girshick, Piotr Dollr, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. arXiv preprint arXiv:1611.05431, 2016. ",
+        "bbox": [
+            173,
+            573,
+            820,
+            603
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xin Yao. Evolving artificial neural networks. Proceedings of the IEEE, 87(9):1423–1447, 1999. ",
+        "bbox": [
+            173,
+            611,
+            803,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            174,
+            635,
+            823,
+            664
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhao Zhong, Junjie Yan, and Cheng-Lin Liu. Practical network blocks design with q-learning. arXiv preprint arXiv:1708.05552, 2017. ",
+        "bbox": [
+            173,
+            672,
+            823,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016. ",
+        "bbox": [
+            173,
+            710,
+            823,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. arXiv preprint arXiv:1707.07012, 2017. ",
+        "bbox": [
+            173,
+            748,
+            825,
+            779
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A ARCHITECTURE VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            482,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Visualization of the learned cell and motifs of our best-performing hierarchical architecture. Note that only motifs 1,3,4,5 are used to construct the cell, among which motifs 3 and 5 are dominating. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            162
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/5827378350fc085340b2d704abc7bd516db0964177d21b1eb69aeeaefc759904.jpg",
+        "image_caption": [
+            "Figure 5: Cell "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            180,
+            800,
+            318
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/6d191ff74417a17da2feca8679070bab9b511eeefc971ead32998b8cb237191f.jpg",
+        "image_caption": [
+            "Figure 6: Motif 1 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            378,
+            766,
+            502
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/925ac3abc0524f08842c3c905b90c557795a478f32da5a5bd39e634e0db1dba3.jpg",
+        "image_caption": [
+            "Figure 7: Motif 2 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            558,
+            766,
+            680
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe72644435436421486a53f70aead4d477cc168c5ab16d5aa605227bb30f0b2a.jpg",
+        "image_caption": [
+            "Figure 8: Motif 3 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            122,
+            766,
+            246
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/18042d3b8a85bb8ddc43d1394aa95e8015aa64b257c4e43ff2457c7dda07a7cc.jpg",
+        "image_caption": [
+            "Figure 9: Motif 4 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            343,
+            766,
+            450
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/ebb0cb2926cd67f6b4f918039f5e0b48989afbcdd159da66c83963e267fa5269.jpg",
+        "image_caption": [
+            "Figure 10: Motif 5 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            264,
+            545,
+            733,
+            656
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/36e4397ee8301a3e9c1e305ac1d5a735a0554dd806d6e11141358d26e62ebacf.jpg",
+        "image_caption": [
+            "Figure 11: Motif 6 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            742,
+            766,
+            866
+        ],
+        "page_idx": 12
+    }
+]

parse/train/Bk6qQGWRb/Bk6qQGWRb.md

@@ -0,0 +1,331 @@
+# EFFICIENT EXPLORATION THROUGH BAYESIAN DEEPQ-NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose Bayesian Deep Q-Network (BDQN), a practical Thompson sampling based Reinforcement Learning (RL) Algorithm. Thompson sampling allows for targeted exploration in high dimensions through posterior sampling, but is usually computationally expensive. We address this limitation by introducing uncertainty only at the output layer of the network through a Bayesian Linear Regression (BLR) model, which can be trained with fast closed-form updates and its samples can be drawn efficiently through the Gaussian distribution. We apply our method to a wide range of Atari Arcade Learning Environments. Since BDQN carries out more efficient exploration, it is able to reach higher rewards substantially faster than a key baseline, DDQN.
+
+# 1 INTRODUCTION
+
+Designing algorithms that achieve an optimal trade-off between exploration and exploitation is one of the primary goal of reinforcement learning (RL). However, targeted exploration in high dimensional spaces is a challenging problem in RL. Recent advances in deep RL mostly deploy simple exploration strategies such as $\varepsilon$ -greedy, where the agent chooses the optimistic action, the action with highest promising return, with probability $( 1 - \varepsilon )$ , otherwise, uniformly at random picks one of the available actions. Due to this uniform sampling, the $\varepsilon$ -greedy method scales poorly with the dimensionality of state and action spaces. Recent work has considered scaling exploration strategies to large domains (Bellemare et al., 2016; Tang et al., 2016). Several of these papers have focused on employing optimism-under-uncertainty approaches, which essentially rely on computing confidence bounds over different actions, and acting optimistically with respect to that uncertainty.
+
+An alternative to optimism-under-uncertainty (Brafman & Tennenholtz, 2003) is Thompson Sampling (TS) (Thompson, 1933), one of the oldest heuristics for multi arm bandits. TS is a Bayesian approach where one starts with a prior distribution over the belief and compute the posterior beliefs based on the collected data through the interaction with the environment and then maximizes the expected return under the sampled belief. The TS based posterior sampling can provide more targeted exploration since it can trade off uncertainty with the expected return of actions. In contrast, the $\varepsilon$ -greedy strategy is indifferent to uncertainty of the actions and the expected rewards of sub-optimistic ones (set of actions excluding the optimistic action).
+
+There has been relatively little work on scaling Thompson Sampling to large state spaces. The primary difficulty in implementing Thompson sampling is the difficulty of sampling from general posterior distributions. Prior efforts in this space have generally required extremely expensive computations (e.g. (Ghavamzadeh et al., 2015; Strens, 2000))
+
+We derive a practical Thompson sampling framework, termed as Bayesian deep Q-networks (BDQN), where we approximate the posterior distribution on the set of Q-functions and sample from this approximated posterior. BDQN is computationally efficient since it incorporates uncertainty only at the output layer, in the form of a Bayesian linear regression model. Due to linearity and by choosing a Gaussian prior, we derive a closed-form analytical update to the approximated posterior distribution over Q functions. We can also draw samples efficiently from the Gaussian distribution. As addressed in Mnih et al. (2015), one of the major benefits of function approximation methods in deep RL is that the estimation of the Q-value, given a state-action pair, can generalize well to other state-action pairs, even if they are visited rarely. We expect this to hold in BDQN as well, but additionally, we also expect the uncertainty of state-action pairs to generalize well.
+
+We test BDQN on a wide range of Arcade Learning Environment Atari games (Bellemare et al., 2013; Brockman et al., 2016) against a strong baseline DDQN (Van Hasselt et al., 2016). Aside from simplicity and popularity of DDQN, BDQN and DDQN share the same architecture, and follow same target objective. These are the main reasons we choose DDQN for our comparisons.
+
+In table. 1 we see significant gains for BDQN over DDQN. BDQN is able to learn significantly faster and reach higher returns due to more efficient exploration. The evidence of this is further seen from the fact that we are able to train BDQN with much higher learning rates compared to DDQN. This suggests that BDQN is able to learn faster and reach better scores.
+
+These promising results suggest that BDQN can further benefit from additional modifications that were done to DQN, e.g. Prioritized Experience Replay (Schaul et al., 2015), Dueling approach (Wang et al., 2015), A3C (Mnih et al., 2016), safe exploration (Lipton et al., 2016a), and etc. This is because BDQN only changes that exploration strategy of DQN, and can easily accommodate additional improvements to DQN.
+
+<table><tr><td rowspan=1 colspan=1>Game</td><td rowspan=1 colspan=1>BDQNDDQN</td><td rowspan=1 colspan=1>BDQNDDQNt</td><td rowspan=1 colspan=1>BDQNHUMAN</td><td rowspan=1 colspan=1>Step</td></tr><tr><td rowspan=1 colspan=1>Amidar</td><td rowspan=1 colspan=1>558%</td><td rowspan=1 colspan=1>788%</td><td rowspan=1 colspan=1>325%</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Alien</td><td rowspan=1 colspan=1>103%</td><td rowspan=1 colspan=1>103%</td><td rowspan=1 colspan=1>43%</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Assault</td><td rowspan=1 colspan=1>396%</td><td rowspan=1 colspan=1>176%</td><td rowspan=1 colspan=1>589%</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Asteroids</td><td rowspan=1 colspan=1>2517%</td><td rowspan=1 colspan=1>1516%</td><td rowspan=1 colspan=1>108%</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Asterix</td><td rowspan=1 colspan=1>531%</td><td rowspan=1 colspan=1>385%</td><td rowspan=1 colspan=1>687%</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>BeamRider</td><td rowspan=1 colspan=1>207%</td><td rowspan=1 colspan=1>114%</td><td rowspan=1 colspan=1>150%</td><td rowspan=1 colspan=1>70M</td></tr><tr><td rowspan=1 colspan=1>BattleZone</td><td rowspan=1 colspan=1>281%</td><td rowspan=1 colspan=1>253%</td><td rowspan=1 colspan=1>172%</td><td rowspan=1 colspan=1>50M</td></tr><tr><td rowspan=1 colspan=1>Atlantis</td><td rowspan=1 colspan=1>80604%</td><td rowspan=1 colspan=1>49413%</td><td rowspan=1 colspan=1>11172%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>DemonAttack</td><td rowspan=1 colspan=1>292%</td><td rowspan=1 colspan=1>114%</td><td rowspan=1 colspan=1>326%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>Centipede</td><td rowspan=1 colspan=1>114%</td><td rowspan=1 colspan=1>178%</td><td rowspan=1 colspan=1>61%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>BankHeist</td><td rowspan=1 colspan=1>211%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>CrazyClimber</td><td rowspan=1 colspan=1>148%k</td><td rowspan=1 colspan=1>122%</td><td rowspan=1 colspan=1>350%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>ChopperCommand</td><td rowspan=1 colspan=1>14500%</td><td rowspan=1 colspan=1>1576%</td><td rowspan=1 colspan=1>732%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>Enduro</td><td rowspan=1 colspan=1>295%</td><td rowspan=1 colspan=1>350%</td><td rowspan=1 colspan=1>361%</td><td rowspan=1 colspan=1>30M</td></tr><tr><td rowspan=1 colspan=1>Pong</td><td rowspan=1 colspan=1>112%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>226%</td><td rowspan=1 colspan=1>5M</td></tr></table>
+
+Table 1: The first column presents the score ratio after last column steps. The second column is the score ratio of BDQN after the number of steps in the last column compared to the score of $\mathrm { D D Q N } ^ { \dagger }$ , the reported scores of DDQN in Van Hasselt et al. (2016) after running for 200M samples during evaluation time, and the third column is with respect to Human score reported at Mnih et al. (2015).
+
+# 2 RELATED WORK
+
+The complexity of the exploration-exploitation trade-off has been vastly investigated in RL literature (Kearns & Singh, 2002; Brafman & Tennenholtz, 2003; Strehl et al., 2009; Bartlett & Tewari, 2009; Azar et al., 2017; Dann et al., 2017). Auer (2002) addresses this question for multi-armed bandit problems where regret guarantees are provided. Jaksch et al. (2010) investigates the regret analyses in MDPs where exploration happens through the optimal policy of optimistic model, a well-known Optimism in Face of Uncertainty (OFU) principle where a high probability regret upper bound is guaranteed. Azizzadenesheli et al. (2016a) deploys OFU in order to propose the high probability regret upper bound for Partially Observable MDPs (POMDPs) and finally, Bartók et al. (2014) tackles a general case of partial monitoring games and provides minimax regret guarantee which is polynomial in certain dimensions of the problem.
+
+In multi arm bandit, there is compelling empirical evidence that Thompson Sampling can provide better results than optimism-under-uncertainty approaches (Chapelle & Li, 2011), while the state of the art performance bounds are preserved (Russo & Van Roy, 2014; Agrawal & Goyal, 2012; Gopalan & Mannor, 2015; Abeille & Lazaric, 2017). A natural adaptation of this algorithm to RL, posterior sampling RL (PSRL), first proposed by Strens (2000) also shown to have good frequentist and Bayesian performance guarantees (Osband et al., 2013; Gopalan & Mannor, 2015; Agrawal & Jia, 2017; Abbasi-Yadkori & Szepesvári, 2015; Ouyang et al., 2017; Theocharous et al., 2017; Russo et al., 2017). Even though the theoretical RL addresses the exploration and exploitation trade-offs, these problems are still prominent in empirical reinforcement learning research (Mnih et al., 2015; Jiang et al., 2016; Abel et al., 2016; Azizzadenesheli et al., 2016b). On the empirical side, the recent success in the video games has sparked a flurry of research interest. Following the success of Deep RL on Atari games (Mnih et al., 2015) and the board game Go (Silver et al., 2017), many researchers have begun exploring practical applications of deep reinforcement learning (DRL). Some investigated applications include, robotics (Levine et al., 2016), energy management (Night, 2016), and self-driving cars (Shalev-Shwartz et al., 2016). Among the mentioned literature, the prominent exploration strategy for Deep RL agent has been $\varepsilon$ -greedy.
+
+Inevitably for PSRL, the act of posterior sampling for policy or value is computationally intractable with large systems, so PSRL can not be easily leveraged to high dimensional problems. To remedy these failings Osband et al. (2017) consider the use of randomized value functions to approximate posterior samples for the value function in a computationally efficient manner. They show that with a suitable linear value function approximation, using the approximated Bayesian linear regression for randomized least-squares value iteration method can remain statistically efficient (Osband et al., 2014) but still is not scalable to large scale RL with deep neural networks.
+
+To combat these shortcomings, Osband et al. (2016) suggests a bootstrapped-ensemble approach that trains several models in parallel to approximate uncertainty. Other works suggest using a variational approximation to the Q-networks (Lipton et al., 2016b) or noisy network (Fortunato et al., 2017). However, most of these approaches significantly increase the computational cost of DQN and neither approaches produced much beyond modest gains on Atari games. Applying Bayesian regression in last layer of neural network was investigated in Snoek et al. (2015) for object recognition, image caption generation, and etc. where a significant advantage has been provided.
+
+In this work we present another alternative approach that extends randomized least-squares value iteration method (Osband et al., 2014) to deep neural networks: we approximate the posterior by a Bayesian linear regression only on the last layer of the neural network. This approach has several benefits, e.g. simplicity, robustness, targeted exploration, and most importantly, we find that this method is much more effective than any of these predecessors in terms of sample complexity and final performance.
+
+Concurrently, O’Donoghue et al. (2017) studies how to construct the frequentist confidence of the regression on the feature space of the neural network for RL problems by learning the uncertainties through a shallow network while Levine et al. (2017), similar to BDQN, suggests running linear regression on the representation layer of the deep network in order to learn the state-action value. Drop-out, as another randomized exploration method is proposed by Gal & Ghahramani (2016) but Osband et al. (2016) argues about its estimated uncertainty and hardness in driving a suitable exploitation of it. It is worth noting that most of proposed methods are based on $\varepsilon$ -exploration.
+
+# 3 THOMPSON SAMPLING VS ε−GREEDY
+
+In this section, we enumerate a few benefits of TS over $\varepsilon$ -greedy strategies. We show how TS strategies exploit the uncertainties and expected returns to design a randomized exploration while $\varepsilon -$ greedy strategies disregard all these useful information for the exploration.
+
+Fig. 1(a) expresses the agent’s estimated values and uncertainties for the available actions at a given state $x$ . While $\varepsilon -$ greedy strategy mostly focus on the action 1, the optimistic action, the TS based strategy randomizes, mostly, over actions 1 through 4, utilizing their approximated returns and uncertainties, and with low frequency tries actions 5, 6. Not only the $\varepsilon -$ greedy strategy explores actions 5 and 6, where the RL agent is almost sure about low return of these actions, as frequent as other sub-optimistic actions, but also spends the network capacity to accurately estimate their values.
+
+![](images/44bda5713030c894fc2cad5c544c21705f3a46c15c61d88172fcc2dd85e2db1b.jpg)  
+Figure 1: A cartoon representation of TS vs $\varepsilon$ -greedy. The red crosses are the true Q-values, the diamonds are the mean of estimated Q-values with blue intervals as uncertainties (e.g. $c \cdot$ variance)
+
+A commonly used technique in deep RL is a moving window of replay buffer to store the recent experiences. The TS based agent, after a few tries of actions 5 and 6 builds a belief in low return of these actions given the current target values. Since the replay buffer is bounded moving window, lack of samples of these actions pushes the posterior belief of these actions to the prior, over time, and the agent tries them again in order to update its belief Fig. $1 ( b )$ . In general, TS based strategy advances the exploration-exploitation trade-off by making trade-off between the expected returns and the uncertainties, while $\varepsilon -$ greedy strategy ignores all of this information.
+
+Another superiority of TS over $\varepsilon$ -greedy can be described using Fig. $1 ( c )$ . Consider an episodic maze-inspired deterministic game, with episode length $H$ of shortest pass from the start to the destination. The agent is placed to the start point at the beginning of each episode where the goal state is to reach the destination and receive a reward of 1 otherwise reward is 0. Consider an agent, which is given a hypothesis set of Q-functions where the true Q-function is within the set and is the most optimistic function in the set. In this situation, TS randomizes over the Q-functions with high promising returns and relatively high uncertainty, including the true Q-function. When it picks the true Q-function, it increases the posterior probability of this Q-function because it matches the likelihood. When TS chooses other functions, they predict deterministically wrong values and the posterior update of those functions set to zero, therefore, the agent will not choose them again, i.e. TS finds the true Q-function very fast. For $\varepsilon$ -greedy agent, even though it chooses the true function at the beginning (it is the optimistic one), at each time step, it randomizes its action with the probability $\varepsilon$ . Therefore, it takes exponentially many trials in order to get to the target in this game.
+
+# 4 PRELIMINARIES
+
+An infinite horizon $\gamma$ -discounted MDP $M$ is a tuple $\langle \mathcal { X } , \mathcal { A } , T , R \rangle$ , with state space $\mathcal { X }$ , action space $\mathcal { A }$ , and the transition kernel $T$ , accompanied with reward function of $R$ where $0 < \gamma \leq 1$ . At each time step $t$ , the environment is at a state $x _ { t }$ , called current state, where the agent needs to make a decision $a _ { t }$ under its policy. Given the current state and action, the environment stochastically proceed to a successor state $x _ { t + 1 }$ under probability distribution $T ( X _ { t + 1 } | x _ { t } , a _ { t } ) : = \mathbb { P } ( X _ { t + 1 } | x _ { t } , a _ { t } )$ and provides a stochastic reward $r _ { t }$ with mean of $\mathbb { E } [ r | x = x _ { t } , a = a _ { t } ] = R ( x _ { t } , a _ { t } )$ . The agent objective is to optimize the overall expected discounted reward over its policy $\pi : = \mathcal { X }  \mathcal { A }$ , a stochastic mapping from states to actions, ${ \bar { \pi } } ( a | x ) : = \mathbb { P } ( a | x )$ .
+
+$$
+\eta ^ { * } = \eta ( \pi ^ { * } ) = \operatorname* { m a x } _ { \pi } \eta ( \pi ) = \operatorname* { m a x } _ { \pi } \operatorname* { l i m } _ { N  \infty } \mathbb { E } _ { \pi } [ \sum _ { t = 0 } ^ { N } \gamma ^ { t } r _ { t } ]
+$$
+
+The expectation in Eq. 1 is with respect to the randomness in the distribution of initial state, transition probabilities, stochastic rewards, and policy, under stationary distribution, where $\eta ^ { * } , \pi ^ { * }$ are optimal return and optimal policy, respectively. Let $Q _ { \pi } ( x , a )$ denote the average discounted reward under policy $\pi$ starting off from state $x$ and taking action $a$ in the first place.
+
+$$
+Q _ { \pi } ( x , a ) : = \operatorname* { l i m } _ { N \to \infty } \mathbb { E } _ { \pi } \left[ \sum _ { t = 0 } ^ { N } \gamma ^ { t } r _ { t } | x _ { 0 } = x , a _ { 0 } = a \right]
+$$
+
+For a given policy $\pi$ and Markovian assumption of the model, we can rewrite the equation for the Q functions as follows:
+
+$$
+Q _ { \pi } ( x , a ) = R ( x , a ) + \gamma \sum _ { x ^ { \prime } , a ^ { \prime } } T ( x ^ { \prime } | x , a ) \pi ( a ^ { \prime } | x ^ { \prime } ) Q _ { \pi } ( x ^ { \prime } , a ^ { \prime } )
+$$
+
+To find the optimal policy, one can solve the Linear Programing problem in Eq. 1 or follow the corresponding Bellman equation Eq. 2 where both of optimization methods turn to
+
+$$
+Q ^ { * } ( x , a ) = R ( x , a ) + \gamma \sum _ { x ^ { \prime } } T ( x ^ { \prime } | x , a ) \operatorname* { m a x } _ { a ^ { \prime } } Q ^ { * } ( x ^ { \prime } , a ^ { \prime } )
+$$
+
+where $Q ^ { * } ( x , a ) = Q _ { \pi ^ { * } } ( x , a )$ and the optimal policy is a deterministic mapping from state to actions in $\mathcal { A }$ , i.e. $x \to a r g \operatorname* { m a x } _ { a } Q ^ { * } ( x , a )$ . In RL, we do not know the transition kernel and the reward function in advance, therefore, we can not solve the posed Bellman equation directly. In order to tackle this problem, (Lagoudakis & Parr, 2003; Antos et al., 2008) studies the property of minimizing the Bellman residual of a given Q-function
+
+$$
+\mathcal { L } ( Q ) = \mathbb { E } _ { \pi } \left[ \left( Q ( x , a ) - r - \gamma Q ( x ^ { \prime } , a ^ { \prime } ) \right) ^ { 2 } \right]
+$$
+
+Where the tuple $( x , a , r , x ^ { \prime } , a ^ { \prime } )$ consists of consecutive samples under behavioral policy $\pi$ . Furthermore, (Mnih et al., 2015) carries the same idea, and introduce Deep Q-Network (DQN) where the Q-functions are parameterized by a DNN. To improve the quality of Q function, they use back propagation on loss $\mathcal { L } ( Q )$ using TD update (Sutton $\&$ Barto, 1998). In the following we describe the setting used in DDQN. In order to reduce the bias of the estimator, they introduce target network ${ Q } ^ { t a r g e t }$ and target value $y = r + \gamma Q ^ { t a r g e t } ( x ^ { \prime } , \hat { a } )$ where $\hat { a } = \arg \operatorname* { m a x } _ { a ^ { \prime } } Q ( x ^ { \prime } , a ^ { \prime } )$ with a new loss $\mathcal { L } ( Q , Q ^ { t a r g e t } )$
+
+$$
+\mathcal { L } ( Q , Q ^ { t a r g e t } ) = \mathbb { E } _ { \boldsymbol \pi } \left[ \left( Q ( \boldsymbol x , a ) - y \right) ^ { 2 } \right]
+$$
+
+Minimizing this regression loss, and respectably its estimation $\widehat { \mathcal { L } } ( Q , Q ^ { t a r g e t } )$ , matches the $Q$ to the target $y$ . Once in a while, the algorithm sets ${ Q } ^ { t a r g e t }$ network to $Q$ network, peruses the regression with the new target value, and provides an biased estimator of the target.
+
+# 5 BAYESIAN DEEP Q-NETWORKS
+
+We propose a Bayesian method to approximate the $Q$ -function and match it to the target value. We utilize the DQN architecture, remove its last layer, and build a Bayesian linear regression (BLR) (Rasmussen & Williams, 2006) on the feature representation layer, $\dot { \phi } _ { \theta } ( x ) \in \mathbb { R } ^ { d }$ , parametrized by $\theta$ . We deploy BLR to efficiently approximate the distribution over the Q-values where the uncertainty over the values is captured. A common assumption in DNN is that the feature representation is suitable for linear classification or regression (same assumption in DQN).
+
+The Q-functions can be approximated as a linear combination of features, i.e. for a given pair of state-action, $Q ( x , a ) = \phi _ { \boldsymbol { \theta } } ( \bar { x } ) ^ { \top } w _ { a }$ . Therefore, by deploying BLR, we can approximate the generative model of the Q-function using its corresponding target value: $y = r + \stackrel {  } { \gamma } \phi ^ { t a r g e t } w ^ { t a r g e \acute { t } } \hat { a }$ , where φtargetθ (x) ∈ Rd denotes the feature representation of target network, for any (x, a) as follows
+
+$$
+\boldsymbol { y } = \boldsymbol { Q } ( \boldsymbol { x } , \boldsymbol { a } ) + \epsilon = \boldsymbol { w } _ { \boldsymbol { a } } ^ { \top } \phi ( \boldsymbol { x } ) + \epsilon , \quad \forall \boldsymbol { x } \in \mathcal { X } , \boldsymbol { a } \in \mathcal { A }
+$$
+
+where $\epsilon \sim \mathcal { N } ( 0 , \sigma _ { \epsilon } ^ { 2 } )$ is an iid noise. Furthermore, we consider $w _ { a } \in \mathbb { R } ^ { d }$ for $a \in { \mathcal { A } }$ are drawn approximately from a Gaussian prior ${ \mathcal { N } } ( 0 , \sigma ^ { 2 } )$ . Therefore, $y | x , a , w _ { a } \sim \mathcal { N } ( \phi ( x ) ^ { \top } w _ { a } , \sigma _ { \epsilon } ^ { 2 } )$ . Moreover, the distribution of the target value $y$ is $\begin{array} { r } { \mathbb { P } \left( y \vert a \right) = \int _ { w _ { a } } \mathbb { P } \left( y \vert w _ { a } \right) \mathbb { P } \left( w _ { a } \right) d w _ { a } } \end{array}$ . Given a dataset $\mathcal { D } = \{ x _ { \tau } , a _ { \tau } , y _ { \tau } \} _ { \tau = 1 } ^ { D }$ , we construct $| { \cal A } |$ disjoint datasets for each action, $\mathcal { D } _ { a }$ , where $\mathcal { D } = \cup _ { a \in \mathcal { A } } \mathcal { D } _ { a }$ and $\mathcal { D } _ { a }$ is a set of tuples $x _ { \tau } , a _ { \tau } , y _ { \tau }$ with the action $a _ { \tau } = a$ and size $D _ { a }$ . We are interested in $\mathbb { P } ( w _ { a } | \mathcal { D } _ { a } )$ and $\mathbb { P } ( Q ( x , a ) | \mathcal { D } _ { a } ) , \forall x \in \mathcal { X }$ . We construct a matrix $\Phi _ { a } \in \mathbb { R } ^ { d \times D _ { a } }$ , a concatenation of feature column vectors distribu $\{ \phi ( x _ { i } ) \} _ { i = 1 } ^ { D _ { a } }$ , and llow $\mathbf { y } _ { a } \in \mathbb { R } ^ { D _ { a } }$ , a concatenation of target values in set $\mathcal { D } _ { a }$ . Therefore the posterior
+
+$$
+w _ { a } \sim { \mathcal { N } } \left( { \frac { 1 } { \sigma _ { \epsilon } ^ { 2 } } } \Xi _ { a } \Phi _ { a } \mathbf { y } _ { a } , \Xi _ { a } \right) , w h e r e \Xi _ { a } = \left( { \frac { 1 } { \sigma _ { \epsilon } ^ { 2 } } } \Phi _ { a } \Phi _ { a } ^ { \top } + { \frac { 1 } { \sigma ^ { 2 } } } \mathbb { 1 } \right) ^ { - 1 }
+$$
+
+# Algorithm 1 BDQN
+
+1: Initialize parameter sets $\theta$ , $\theta ^ { t a r g e t }$ , $W$ , $W ^ { t a r g e t }$ , and $C o v$ using a normal distribution.   
+2: Initialize replay buffer and set counter $= ~ 0$   
+3: for episode $= 1$ to inf do   
+4: Initialize $x _ { 1 }$ to the initial state of the environment   
+5: for $t = \mathrm { t o }$ the end of episode do   
+6: if count mod $T ^ { s a m p l e } = 0$ then   
+7: sample $W \sim \mathcal { N } \left( W ^ { t a r g e t } , C o v \right)$   
+8: end if   
+9: Select action $a _ { t } = a r g m a x _ { a ^ { \prime } }$ $\big [ W ^ { \top } \phi _ { \theta } ( x _ { t } ) \big ] _ { a ^ { \prime } }$   
+10: Execute action $a _ { t }$ a in environment, observing reward $r _ { t }$ and successor state $x _ { t + 1 }$   
+11: Store transition $( x _ { t } , a _ { t } , r _ { t } , x _ { t + 1 } )$ in replay buffer   
+12: Sample a random minibatch of transitions $( x _ { \tau } , a _ { \tau } , r _ { \tau } , x _ { \tau + 1 } )$ from replay buffer   
+13: $\begin{array} { l } { { y _ { \tau } \gets \left\{ \begin{array} { l l } { { r _ { \tau } , } } \\ { { r _ { \tau } + \left[ W ^ { t a r g e t } { } ^ { \top } \phi _ { \theta ^ { t a r g e t } } ( x _ { \tau + 1 } ) \right] _ { \hat { a } } ; \hat { a } = a r g m a x _ { a ^ { \prime } } \left[ W ^ { \top } \phi _ { \theta } ( x _ { \tau + 1 } ) \right] _ { a ^ { \prime } } } } \end{array} \right. } } \\ { { \theta \gets \theta - \eta \cdot \nabla _ { \theta } ( y _ { \tau } - \left[ W ^ { \top } \phi _ { \theta } ( x _ { \tau } ) \right] _ { a _ { \tau } } ) ^ { 2 } } } \end{array}$ for non-terminal xτ+1 for terminal xτ+1   
+14:   
+15: if count mod $T ^ { t a r g e t } = 0$ then   
+16: set $\theta ^ { t a r g e t }  \theta$   
+17: end if   
+18: if count mod $T ^ { B a y e s ~ t a r g e t } = 0$ then   
+19: Update $W ^ { t a r g e t }$ and $C o v$   
+20: end if   
+21: count $=$ count + 1   
+22: end for   
+23: end for
+
+$\mathbb { 1 } \in \mathbb { R } ^ { d }$ is a identity matrix, and $Q ( x , a ) | \mathcal { D } _ { a } = w _ { a } ^ { \top } \phi ( x )$ . Since the prior and likelihood are conjugate of each other we have the posterior distribution over the discounted return approximated as
+
+$$
+\sum _ { t = 0 } ^ { N } \gamma ^ { t } r _ { t } | x _ { 0 } = x , a _ { 0 } = a , \mathcal { D } _ { a } \sim \mathcal { N } \left( \frac { 1 } { \sigma _ { \epsilon } ^ { 2 } } \phi ( x ) ^ { \top } \Xi _ { a } \Phi _ { a } \mathbf { y } _ { a } , \phi ( x ) ^ { \top } \Xi _ { a } \phi ( x ) \right)
+$$
+
+The expression in Eqs. 5 gives the posterior distribution over weights $w _ { a }$ and the function $Q$ . As TS suggests, for the exploration, we exploit the expression in Eq. 5. For all the actions, we set $w _ { a } ^ { t a r g e t }$ as the mean of posterior distribution over $w _ { a }$ . For each action, we sample a wight vector $w _ { a }$ in order to have samples of mean $\mathrm { Q }$ -value. Then we act optimally with respect to the sampled means
+
+$$
+a _ { \mathrm { T S } } = \arg \operatorname* { m a x } _ { a } w _ { a } ^ { \top } \phi _ { \theta } ( x ) .
+$$
+
+Let $W = \{ w _ { a } \} _ { a = 1 } ^ { | \mathcal { A } | }$ , respectively $W ^ { t a r g e t } = \{ w _ { a } ^ { t a r g e t } \} _ { a = 1 } ^ { | { \cal A } | }$ , and $C o v = \{ \Xi _ { a } \} _ { a = 1 } ^ { | { \cal A } | }$ . In BDQN, the agent interacts with the environment through applying the actions proposed by TS, i.e. utilize a notion of experience replay buffer where the agent stores its recent experiences. The agent draws $W \sim \mathcal N \left( W ^ { t { \bar { a } } r g e t } , C o v \right)$ (abbreviation for sampling of vector $w$ for each action separately) every $T ^ { s a m p l e }$ steps and act optimally with respect to the drawn weights. During the inner loop of the algorithm, we draw a minibatch of data from replay buffer and use loss
+
+$$
+\left( \boldsymbol { y } _ { \tau } - \left[ \boldsymbol { W } ^ { \top } \phi _ { \boldsymbol { \theta } } ( \boldsymbol { x } _ { \tau } ) \right] _ { a _ { \tau } } \right) ^ { 2 }
+$$
+
+$$
+y _ { \tau } : = r _ { \tau } + \left[ { \cal W } ^ { t a r g e t ^ { \top } } \phi _ { \theta ^ { t a r g e t } } ( x _ { \tau + 1 } ) \right] _ { \hat { a } } ; \hat { a } = a r g m a x _ { a ^ { \prime } } \left[ { \cal W } ^ { \top } \phi _ { \theta } ( x _ { \tau + 1 } ) \right] _ { a ^ { \prime } }
+$$
+
+and update the weights of network: $\theta  \theta - \eta \cdot \nabla _ { \theta } ( y _ { \tau } - [ W ^ { \top } \phi _ { \theta } ( x _ { \tau } ) ] _ { a _ { \tau } } ) ^ { 2 } .$
+
+We update the target network every $T ^ { t a r g e t }$ steps and set $\theta ^ { t a r g e t }$ to $\theta$ . With the period of $T ^ { B a y e s }$ target the agent updates its posterior distribution using larger minibatch of data drawn from replay buffer and sample $W$ with respect to the updated posterior. Algorithm 1 gives the full description of BDQN.
+
+# 6 EXPERIMENTS
+
+We apply BDQN on a variety of games in the OpenAiGym 1(Brockman et al., 2016). As a baseline2, we run DDQN algorithm and evaluate BDQN on the measures of sample complexity and score.
+
+![](images/3e28849de6a30dd5651b659aeecf1240468e80b8a948672f5d16fc64e046559e.jpg)  
+Figure 2: The fast targeted exploration of BDQN
+
+Network architecture: The input to the network part of BDQN is $4 \times 8 4 \times 8 4$ tensor with a rescaled and averaged over channels of the last four observations. The first convolution layer has 32 filters of size 8 with a stride of 4. The second convolution layer has 64 filters of size 4 with stride 2. The last convolution layer has 64 filters of size 3 followed by a fully connected layers with size 512. We add a BLR layer on top of this.
+
+Choice of hyper-parameters: For BDQN, we set the values of $W ^ { t a r g e t }$ to the mean of the posterior distribution over the weights of BLR with covariances $C o v$ and draw $W$ from this posterior. For the fixed $W$ and $W ^ { t a r g e t }$ , we randomly initialize the parameters of network part of BDQN, $\theta$ , and train it using RMSProp, with learning rate of 0.0025, and a momentum of 0.95, inspired by (Mnih et al., 2015) where the discount factor is $\gamma = 0 . 9 9$ , the number of steps between target updates $T ^ { t a r g e t } = 1 0 k$ steps, and weights $W$ are re-sampled from their posterior distribution every $\hat { T } ^ { s a m p l e }$ step. We update the network part of BDQN every 4 steps by uniformly at random sampling a mini-batch of size 32 samples from the replay buffer. We update the posterior distribution of the weight set $W$ every $T ^ { B a y e s }$ target using mini-batch of size $B$ (if size of replay buffer is less than $B$ at the current step, we choose the minimum of these two ), with entries sampled uniformly form replay buffer. The experience replay contains the $1 M$ most recent transitions. Further hyper-parameters, are equivalent to ones in DQN setting.
+
+Hyper-parameters tunning: For the BLR, we have noise variance $\sigma _ { \epsilon }$ , variance of prior over weights $\sigma$ , sample size $B$ , posterior update period $T ^ { B a y e s ~ t a r g e t }$ , and the posterior sampling period $T ^ { s a \overline { { m } } p l e }$ . To optimize for this set of hyper-parameters we set up a very simple, fast, and cheap hyper-parameter tunning procedure which proves the robustness of BDQN. To fine the first three, we set up a simple hyper-parameter search. We used a pretrained DQN model for the game of Assault, and removed the last fully connected layer in order to have access to its already trained feature representation. Then we tried combination of $B = \{ T ^ { t a r g e t } , 1 0 \cdot T ^ { t a r g e t } \}$ , $\sigma \overset { \cdot } { = } \{ 1 , 0 . 1 , 0 . 0 0 1 \}$ and $\sigma _ { \epsilon } = \{ 1 , 1 0 \}$ and test for 1000 episode of the game. We set these parameters to their best $B = 1 0 \cdot T ^ { t a r g e t }$ , $\sigma = 0 . 0 0 1 , \sigma = 1$ .
+
+The above hyper-parameter tuning is cheap and fast since it requires only a few times $B$ number of forward passes. For the remaining parameter, we ran BDQN ( with weights randomly initialized) on the same game, Assault, for $5 M$ time steps, with a set of $T ^ { B a y e s t a r g e t } = \{ T ^ { t a r g \bar { e } t } , 1 0 \cdot T ^ { t a r g e t } \}$ and $\begin{array} { r } { T ^ { s a m p l e } = \{ \frac { T ^ { t a r g e t } } { 1 0 } , \frac { T ^ { t a r g e t } } { 1 0 0 } \} } \end{array}$ where BDQN performed better with choice of $T ^ { B a y e s ~ t a r g e t } =$ $1 0 \cdot T ^ { t a r g e t }$ . For both choices of $T ^ { s a m p l e }$ , it performed almost equal where we choose the higher one. We started off with the learning rate of 0.0025 and did not tune for that. Thanks to the efficient TS exploration and closed form BLR, BDQN can learn a better policy in even shorter period of time. In contrast, it is well known for DQN based methods that changing the learning rate causes a major degradation in the performance, Apx. A. The proposed hyper-parameter search is very simple where the exhaustive hyper-parameter search is likely to provide even better performance. In order to compare the fairness in sample usage, we argue in Apx. A, that the network part of BDQN and its corresponding part in DDQN observe the same number of samples but the BLR part of BDQN uses 16 times less samples compared to its corresponding last layer in DDQN, Apx. A. All the implementations are coded in MXNet framework (Chen et al., 2015) and are available at ..... .
+
+Results: The results are provided in Fig. 2 and Table. 2. Mostly the focus of the experiments are on sample complexity in Deep-RL, even though, BDQN provides much larger scores compared to base line. For example, for the game Atlantis, DDQN† gives score of $6 4 . 6 7 k$ after $2 0 0 M$ samples during evaluation time, while BDQN reaches $3 . 2 4 M$ after $4 0 M$ samples. As it is been shown in Fig. 2, BDQN saturates for Atlantis after 20M samples. We realized that BDQN reaches the internal OpenAIGym limit of max_episode, where relaxing it improves score after $1 5 M$ steps to $6 2 M$ .
+
+We can observe that BDQN can immediately learn significantly better policies due to its targeted exploration in much shorter period of time. Since BDQN on game Atlantis promise a big jump around time step $2 0 M$ , we ran it five more times in order to make sure it was not just a coincidence. We did the same additional five experiments for the game Amidar as well. We observed that the improvements are consistent among the different runs. For the game Pong, we ran the experiment for a longer period but just plotted the beginning of it in order to observe the difference. For some games we did not run the experiment to $1 0 0 M$ samples since the reached their plateau.
+
+<table><tr><td rowspan=1 colspan=1>Game</td><td rowspan=1 colspan=1>BDQN</td><td rowspan=1 colspan=1>DDQN</td><td rowspan=1 colspan=1>DDQNt</td><td rowspan=1 colspan=1>Human</td><td rowspan=1 colspan=1>SC</td><td rowspan=1 colspan=1>SCt</td><td rowspan=1 colspan=1>Step</td></tr><tr><td rowspan=1 colspan=1>Amidar</td><td rowspan=1 colspan=1>5.52k</td><td rowspan=1 colspan=1>0.99k</td><td rowspan=1 colspan=1>0.7k</td><td rowspan=1 colspan=1>1.7k</td><td rowspan=1 colspan=1>22.9M</td><td rowspan=1 colspan=1>4.4M</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Alien</td><td rowspan=1 colspan=1>3k</td><td rowspan=1 colspan=1>2.9k</td><td rowspan=1 colspan=1>2.9k</td><td rowspan=1 colspan=1>6.9k</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>36.27M</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Assault</td><td rowspan=1 colspan=1>8.84k</td><td rowspan=1 colspan=1>2.23k</td><td rowspan=1 colspan=1>5.02k</td><td rowspan=1 colspan=1>1.5k</td><td rowspan=1 colspan=1>1.6M</td><td rowspan=1 colspan=1>24.3M</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Asteroids</td><td rowspan=1 colspan=1>14.1k</td><td rowspan=1 colspan=1>0.56k</td><td rowspan=1 colspan=1>0.93k</td><td rowspan=1 colspan=1>13.1k</td><td rowspan=1 colspan=1>58.2M</td><td rowspan=1 colspan=1>9.7M</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Asterix</td><td rowspan=1 colspan=1>58.4k</td><td rowspan=1 colspan=1>11k</td><td rowspan=1 colspan=1>15.15k</td><td rowspan=1 colspan=1>8.5k</td><td rowspan=1 colspan=1>3.6M</td><td rowspan=1 colspan=1>5.7M</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>BeamRider</td><td rowspan=1 colspan=1>8.7k</td><td rowspan=1 colspan=1>4.2k</td><td rowspan=1 colspan=1>7.6k</td><td rowspan=1 colspan=1>5.8k</td><td rowspan=1 colspan=1>4.0M</td><td rowspan=1 colspan=1>8.1M</td><td rowspan=1 colspan=1>70M</td></tr><tr><td rowspan=1 colspan=1>BattleZone</td><td rowspan=1 colspan=1>65.2k</td><td rowspan=1 colspan=1>23.2k</td><td rowspan=1 colspan=1>24.7k</td><td rowspan=1 colspan=1>38k</td><td rowspan=1 colspan=1>25.1M</td><td rowspan=1 colspan=1>14.9M</td><td rowspan=1 colspan=1>50M</td></tr><tr><td rowspan=1 colspan=1>Atlantis</td><td rowspan=1 colspan=1>3.24M</td><td rowspan=1 colspan=1>39.7k</td><td rowspan=1 colspan=1>64.76k</td><td rowspan=1 colspan=1>29.0k</td><td rowspan=1 colspan=1>3.3M</td><td rowspan=1 colspan=1>5.1M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>DemonAttack</td><td rowspan=1 colspan=1>11.1k</td><td rowspan=1 colspan=1>3.8k</td><td rowspan=1 colspan=1>9.7k</td><td rowspan=1 colspan=1>3.4k</td><td rowspan=1 colspan=1>2.0M</td><td rowspan=1 colspan=1>19.9M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>Centipede</td><td rowspan=1 colspan=1>7.3k</td><td rowspan=1 colspan=1>6.4k</td><td rowspan=1 colspan=1>4.1k</td><td rowspan=1 colspan=1>12.0k</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>4.2M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>BankHeist</td><td rowspan=1 colspan=1>0.72k</td><td rowspan=1 colspan=1>0.34k</td><td rowspan=1 colspan=1>0.72k</td><td rowspan=1 colspan=1>0.72k</td><td rowspan=1 colspan=1>2.1M</td><td rowspan=1 colspan=1>10.1M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>CrazyClimber</td><td rowspan=1 colspan=1>124k</td><td rowspan=1 colspan=1>84k</td><td rowspan=1 colspan=1>102k</td><td rowspan=1 colspan=1>35.4k</td><td rowspan=1 colspan=1>0.12M</td><td rowspan=1 colspan=1>2.1M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>ChopperCommand</td><td rowspan=1 colspan=1>72.5k</td><td rowspan=1 colspan=1>0.5k</td><td rowspan=1 colspan=1>4.6 k</td><td rowspan=1 colspan=1>9.9k</td><td rowspan=1 colspan=1>4.4M</td><td rowspan=1 colspan=1>2.2M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>Enduro</td><td rowspan=1 colspan=1>1.12k</td><td rowspan=1 colspan=1>0.38k</td><td rowspan=1 colspan=1>0.32k</td><td rowspan=1 colspan=1>0.31</td><td rowspan=1 colspan=1>0.82M</td><td rowspan=1 colspan=1>0.8M</td><td rowspan=1 colspan=1>30M</td></tr><tr><td rowspan=1 colspan=1>Pong</td><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>18.82</td><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>9.3</td><td rowspan=1 colspan=1>1.2M</td><td rowspan=1 colspan=1>2.4M</td><td rowspan=1 colspan=1>5M</td></tr></table>
+
+Table 2: Comparison of scores and sample complexities(scores in the first two columns are average of 100 consecutive episodes). $S C$ represents the number of samples the BDQN requires to bit the human score (Mnih et al., 2015)(“ − ” means BDQN could not bit) and $S C ^ { \dagger }$ is the number number of samples the BDQN requires to bit the score of DDQN †.
+
+# 7 CONCLUSION
+
+In this work we proposed BDQN, a practical TS based RL algorithm which provides targeted exploration in a computationally efficient manner. It involved making simple modifications to the DDQN architecture by replacing the last layer with a Bayesian linear regression. Under the Gaussian prior, we obtained fast closed-form updates for the posterior distribution. We demonstrated significantly faster training and enormously better rewards over a strong baseline DDQN.
+
+This suggests that BDQN can benefit even more from further modifications to DQN such as e.g. Prioritized Experience Replay (Schaul et al., 2015), Dueling approach (Wang et al., 2015), A3C (Mnih et al., 2016), safe exploration (Lipton et al., 2016a), and etc. We plan to explore the benefit of these modifications up to small changes in the future. We also plan to combine strategies that incorporate uncertainty over model parameters with BDQN. In RL, policy gradient (Sutton et al., 2000; Kakade, 2002; Schulman et al., 2015) is another approach which directly learn the policy. In practical policy gradient, even though the optimal policy, given Markovian assumption, needs to be deterministic, the policy regularization is a dominant approach to make the policy stochastic and preserve the exploration thorough the stochasticity of the policy (Neu et al., 2017; Schulman et al., 2017). We plan to explore the advantage of TS based exploration instead of regularizing the policy and make it stochastic.
+
+# REFERENCES
+
+Yasin Abbasi-Yadkori and Csaba Szepesvári. Bayesian optimal control of smoothly parameterized systems. In UAI, pp. 1–11, 2015.
+
+Marc Abeille and Alessandro Lazaric. Linear thompson sampling revisited. In AISTATS 2017-20th International Conference on Artificial Intelligence and Statistics, 2017.
+
+David Abel, Alekh Agarwal, Fernando Diaz, Akshay Krishnamurthy, and Robert E Schapire. Exploratory gradient boosting for reinforcement learning in complex domains. arXiv, 2016.
+
+Shipra Agrawal and Navin Goyal. Analysis of thompson sampling for the multi-armed bandit problem. In COLT, 2012.
+
+Shipra Agrawal and Randy Jia. Posterior sampling for reinforcement learning: worst-case regret bounds. arXiv, 2017.
+
+András Antos, Csaba Szepesvári, and Rémi Munos. Learning near-optimal policies with bellman-residual minimization based fitted policy iteration and a single sample path. Machine Learning, 2008.
+
+Peter Auer. Using confidence bounds for exploitation-exploration trade-offs. Journal of Machine Learning Research, 2002.
+
+Mohammad Gheshlaghi Azar, Ian Osband, and Rémi Munos. Minimax regret bounds for reinforcement learning. arXiv preprint arXiv:1703.05449, 2017.
+
+Kamyar Azizzadenesheli, Alessandro Lazaric, and Animashree Anandkumar. Reinforcement learning of pomdps using spectral methods. In Proceedings of the 29th Annual Conference on Learning Theory (COLT), 2016a.
+
+Kamyar Azizzadenesheli, Alessandro Lazaric, and Animashree Anandkumar. Reinforcement learning in rich-observation mdps using spectral methods. arXiv preprint arXiv:1611.03907, 2016b.
+
+Peter L. Bartlett and Ambuj Tewari. REGAL: A regularization based algorithm for reinforcement learning in weakly communicating MDPs. In Proceedings of the 25th Annual Conference on Uncertainty in Artificial Intelligence, 2009.
+
+Gábor Bartók, Dean P Foster, Dávid Pál, Alexander Rakhlin, and Csaba Szepesvári. Partial monitoring—classification, regret bounds, and algorithms. Mathematics of Operations Research, 2014.
+
+Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, pp. 1471–1479, 2016.
+
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 2013.
+
+Ronen I Brafman and Moshe Tennenholtz. R-max-a general polynomial time algorithm for near-optimal reinforcement learning. The Journal of Machine Learning Research, 3:213–231, 2003.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.
+
+Olivier Chapelle and Lihong Li. An empirical evaluation of thompson sampling. In Advances in neural information processing systems, pp. 2249–2257, 2011.
+
+Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. Mxnet: A flexible and efficient machine learning library for heterogeneous distributed systems. arXiv, 2015.
+
+Christoph Dann, Tor Lattimore, and Emma Brunskill. Ubev-a more practical algorithm for episodic rl with near-optimal pac and regret guarantees. arXiv preprint arXiv:1703.07710, 2017.
+
+Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, et al. Noisy networks for exploration. arXiv preprint arXiv:1706.10295, 2017.
+
+Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In international conference on machine learning, 2016.
+
+Mohammad Ghavamzadeh, Shie Mannor, Joelle Pineau, Aviv Tamar, et al. Bayesian reinforcement learning: A survey. Foundations and Trends $\textsuperscript { \textregistered }$ in Machine Learning, 2015.
+
+Aditya Gopalan and Shie Mannor. Thompson sampling for learning parameterized markov decision processes. In COLT, 2015.
+
+Thomas Jaksch, Ronald Ortner, and Peter Auer. Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 2010.
+
+Nan Jiang, Akshay Krishnamurthy, Alekh Agarwal, John Langford, and Robert E Schapire. Contextual decision processes with low bellman rank are pac-learnable. arXiv, 2016.
+
+Sham M Kakade. A natural policy gradient. In Advances in neural information processing systems, 2002.
+
+Michael Kearns and Satinder Singh. Near-optimal reinforcement learning in polynomial time. Machine Learning, 49(2-3):209–232, 2002.
+
+Michail G Lagoudakis and Ronald Parr. Least-squares policy iteration. Journal of machine learning research, 4 (Dec):1107–1149, 2003.
+
+Nir Levine, Tom Zahavy, Daniel J Mankowitz, Aviv Tamar, and Shie Mannor. Shallow updates for deep reinforcement learning. arXiv preprint arXiv:1705.07461, 2017.
+
+Sergey Levine et al. End-to-end training of deep visuomotor policies. JMLR, 2016.
+
+Zachary C Lipton, Jianfeng Gao, Lihong Li, Jianshu Chen, and Li Deng. Combating reinforcement learning’s sisyphean curse with intrinsic fear. arXiv preprint arXiv:1611.01211, 2016a.
+
+Zachary C Lipton, Jianfeng Gao, Lihong Li, Xiujun Li, Faisal Ahmed, and Li Deng. Efficient exploration for dialogue policy learning with bbq networks & replay buffer spiking. arXiv preprint arXiv:1608.05081, 2016b.
+
+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, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, 2016.
+
+Gergely Neu, Anders Jonsson, and Vicenç Gómez. A unified view of entropy-regularized markov decision processes. arXiv, 2017.
+
+Will Night. The AI that cut google’s energy bill could soon help you. MIT Tech Review, 2016.
+
+Brendan O’Donoghue, Ian Osband, Remi Munos, and Volodymyr Mnih. The uncertainty bellman equation and exploration. arXiv preprint arXiv:1709.05380, 2017.
+
+Ian Osband, Dan Russo, and Benjamin Van Roy. (more) efficient reinforcement learning via posterior sampling. In Advances in Neural Information Processing Systems, 2013.
+
+Ian Osband, Benjamin Van Roy, and Zheng Wen. Generalization and exploration via randomized value functions. arXiv, 2014.
+
+Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped dqn. In Advances in Neural Information Processing Systems, 2016.
+
+Ian Osband, Daniel Russo, Zheng Wen, and Benjamin Van Roy. Deep exploration via randomized value functions. arXiv preprint arXiv:1703.07608, 2017.
+
+Yi Ouyang, Mukul Gagrani, Ashutosh Nayyar, and Rahul Jain. Learning unknown markov decision processes: A thompson sampling approach. In Advances in Neural Information Processing Systems, pp. 1333–1342, 2017.
+
+Carl Edward Rasmussen and Christopher KI Williams. Gaussian processes for machine learning, volume 1. MIT press Cambridge, 2006.
+
+Daniel Russo and Benjamin Van Roy. Learning to optimize via posterior sampling. Mathematics of Operations Research, 39(4):1221–1243, 2014.
+
+Daniel Russo, Benjamin Van Roy, Abbas Kazerouni, and Ian Osband. A tutorial on thompson sampling. arXiv preprint arXiv:1707.02038, 2017.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv, 2015.
+
+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), 2015.
+
+John Schulman, Pieter Abbeel, and Xi Chen. Equivalence between policy gradients and soft q-learning. arXiv, 2017.
+
+Shai Shalev-Shwartz, Shaked Shammah, and Amnon Shashua. Safe, multi-agent, reinforcement learning for autonomous driving. arXiv, 2016.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017.
+
+Jasper Snoek, Oren Rippel, Kevin Swersky, Ryan Kiros, Nadathur Satish, Narayanan Sundaram, Mostofa Patwary, Mr Prabhat, and Ryan Adams. Scalable bayesian optimization using deep neural networks. In International Conference on Machine Learning, pp. 2171–2180, 2015.
+
+Alexander L. Strehl, Lihong Li, and Michael L. Littman. Reinforcement learning in finite mdps: Pac analysis. J. Mach. Learn. Res., 2009.
+
+Malcolm Strens. A bayesian framework for reinforcement learning. In ICML, pp. 943–950, 2000.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998.
+
+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, 2000.
+
+Haoran Tang, Rein Houthooft, Davis Foote, Adam Stooke, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. # exploration: A study of count-based exploration for deep reinforcement learning. arXiv, 2016.
+
+Georgios Theocharous, Zheng Wen, Yasin Abbasi-Yadkori, and Nikos Vlassis. Posterior sampling for large scale reinforcement learning. arXiv preprint arXiv:1711.07979, 2017.
+
+William R Thompson. On the likelihood that one unknown probability exceeds another in view of the evidence of two samples. Biometrika, 1933.
+
+Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double q-learning. In AAAI, 2016.
+
+Ziyu Wang, Tom Schaul, Matteo Hessel, Hado Van Hasselt, Marc Lanctot, and Nando De Freitas. Dueling network architectures for deep reinforcement learning. arXiv, 2015.
+
+# A APPENDIX
+
+Learning rate: It is well known that DQN and DDQN are sensitive to the learning rate and change of learning rate can degrade the performance to even worse than random policy. We tried the same learning rate as BDQN, 0.0025, for DDQN and observed that its performance drops. Fig. 3 shows that the DDQN with higher learning rates learns as good as BDQN at the very beginning but it can not maintain the rate of improvement and degrade even worse than the original DDQN.
+
+![](images/31dc42fcfa19a93b955e649f0216400882de7b1e6a3e4dafd097d7be7e5ed169.jpg)  
+Figure 3: Effect of learning rate on DDQN
+
+Computational and sample cost comparison: For a given period of game time, the number of the backward pass in both BDQN and DQN are the same where for BDQN it is cheaper since it has one layer (the last layer) less than DQN. In the sense of fairness in sample usage, for example in duration of $1 0 \cdot T ^ { B a \dot { y } e s \ t a r g e t } = 1 0 0 k$ , all the layers of both BDQN and DQN, except the last layer, see the same number of samples, but the last layer of BDQN sees 16 times fewer samples compared to the last layer of DQN. The last layer of DQN for a duration of $1 0 0 k$ , observes $2 5 k = 1 0 0 k / 4$ (4 is back prob period) mini batches of size 32, which is $1 6 \cdot 1 0 0 k$ , where the last layer of BDQN just observes samples size of $B = 1 0 0 k$ . As it is mentioned in Alg. 1, to update the posterior distribution, BDQN draws $B$ samples from the replay buffer and needs to compute the feature vector of them. This step of BDQN gives a superiority to DQN in the sense of speed which is almost $7 0 \%$ faster than BDQN (DQN, on average, for the update does full forward and backward passes while BDQN does not do backward path on the last layer but needs an extra forward pass in order to compute the feature representation). One can easily relax this limitation by parallelizing this step with the main body of BDQN or deploying on-line posterior update methods.
+
+Thompson sampling frequency: The choice of TS update frequency can be crucial from domain to domain. If one chooses $T ^ { s a \dot { m } p l e }$ too short, then computed gradient for backpropagation of the feature representation is not going to be useful since the gradient get noisier and the loss function is changing too frequently. On the other hand, the network tries to find a feature representation which is suitable for a wide range of different weights of the last layer, results in improper use of model capacity. If the TS update frequency is too low, then it is far from being TS and losses randomized exploration property. The current choice of $T ^ { s a m p l e }$ is suitable for a variety of Atari games since the length of each episode is in range of $\mathcal { O } ( T ^ { s a m p l e } )$ and is infrequent enough to make the feature representation robust to big changes.
+
+For the RL problems with shorter horizon we suggest to introduce two more parameters, T˜sample and $\tilde { W }$ where $\tilde { T } ^ { s a m p l e }$ , the period that of $\tilde { W }$ is sampled our of posterior, is much smaller than $T ^ { s a m p l e }$ and $\tilde { W }$ is being used just for making TS actions while $W$ is used for backpropagation of feature representation. For game Assault, we tried using $\tilde { T } ^ { s a m p l e }$ and $\tilde { W }$ but did not observe much a difference, and set them to $\mathbf { \chi } _ { T } s a m p l e$ and $W$ . But for RL setting with a shorter horizon, we suggest using them.
+
+Further investigation in Atlantis: After removing the maximum episode length limit for the game Atlantis, BDQN gets the score of 62M. This episode is long enough to fill half of the replay buffer and make the model perfect for the later part of the game but losing the crafted skill for the beginning of the game. We observe in Fig. 4 that after losing the game in a long episode, the agent forgets a bit of its skill and loses few games but wraps up immediately and gets to score of $3 0 M$ . To overcome this issue, one can expand the replay buffer size, stochastically store samples in the reply buffer where the later samples get stored with lowers chance, or train new models for the later parts of the episode. There are many possible cures for this interesting observation and while we are comparing against DDQN, we do not want to advance BDQN structure-wise.
+
+![](images/d1bf647dc60e92f579a32a018f48a8523c1e357a548289efbfc73d61e5ed61ac.jpg)  
+Figure 4: BDQN on Atlantis after removing the limit on max of episode length

parse/train/Bk6qQGWRb/Bk6qQGWRb_content_list.json

@@ -0,0 +1,1633 @@
+[
+    {
+        "type": "text",
+        "text": "EFFICIENT EXPLORATION THROUGH BAYESIAN DEEPQ-NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            174,
+            398,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            238,
+            544,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose Bayesian Deep Q-Network (BDQN), a practical Thompson sampling based Reinforcement Learning (RL) Algorithm. Thompson sampling allows for targeted exploration in high dimensions through posterior sampling, but is usually computationally expensive. We address this limitation by introducing uncertainty only at the output layer of the network through a Bayesian Linear Regression (BLR) model, which can be trained with fast closed-form updates and its samples can be drawn efficiently through the Gaussian distribution. We apply our method to a wide range of Atari Arcade Learning Environments. Since BDQN carries out more efficient exploration, it is able to reach higher rewards substantially faster than a key baseline, DDQN. ",
+        "bbox": [
+            233,
+            270,
+            764,
+            410
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            467,
+            336,
+            483
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Designing algorithms that achieve an optimal trade-off between exploration and exploitation is one of the primary goal of reinforcement learning (RL). However, targeted exploration in high dimensional spaces is a challenging problem in RL. Recent advances in deep RL mostly deploy simple exploration strategies such as $\\varepsilon$ -greedy, where the agent chooses the optimistic action, the action with highest promising return, with probability $( 1 - \\varepsilon )$ , otherwise, uniformly at random picks one of the available actions. Due to this uniform sampling, the $\\varepsilon$ -greedy method scales poorly with the dimensionality of state and action spaces. Recent work has considered scaling exploration strategies to large domains (Bellemare et al., 2016; Tang et al., 2016). Several of these papers have focused on employing optimism-under-uncertainty approaches, which essentially rely on computing confidence bounds over different actions, and acting optimistically with respect to that uncertainty. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            638
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An alternative to optimism-under-uncertainty (Brafman & Tennenholtz, 2003) is Thompson Sampling (TS) (Thompson, 1933), one of the oldest heuristics for multi arm bandits. TS is a Bayesian approach where one starts with a prior distribution over the belief and compute the posterior beliefs based on the collected data through the interaction with the environment and then maximizes the expected return under the sampled belief. The TS based posterior sampling can provide more targeted exploration since it can trade off uncertainty with the expected return of actions. In contrast, the $\\varepsilon$ -greedy strategy is indifferent to uncertainty of the actions and the expected rewards of sub-optimistic ones (set of actions excluding the optimistic action). ",
+        "bbox": [
+            174,
+            645,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There has been relatively little work on scaling Thompson Sampling to large state spaces. The primary difficulty in implementing Thompson sampling is the difficulty of sampling from general posterior distributions. Prior efforts in this space have generally required extremely expensive computations (e.g. (Ghavamzadeh et al., 2015; Strens, 2000)) ",
+        "bbox": [
+            174,
+            763,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We derive a practical Thompson sampling framework, termed as Bayesian deep Q-networks (BDQN), where we approximate the posterior distribution on the set of Q-functions and sample from this approximated posterior. BDQN is computationally efficient since it incorporates uncertainty only at the output layer, in the form of a Bayesian linear regression model. Due to linearity and by choosing a Gaussian prior, we derive a closed-form analytical update to the approximated posterior distribution over Q functions. We can also draw samples efficiently from the Gaussian distribution. As addressed in Mnih et al. (2015), one of the major benefits of function approximation methods in deep RL is that the estimation of the Q-value, given a state-action pair, can generalize well to other state-action pairs, even if they are visited rarely. We expect this to hold in BDQN as well, but additionally, we also expect the uncertainty of state-action pairs to generalize well. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We test BDQN on a wide range of Arcade Learning Environment Atari games (Bellemare et al., 2013; Brockman et al., 2016) against a strong baseline DDQN (Van Hasselt et al., 2016). Aside from simplicity and popularity of DDQN, BDQN and DDQN share the same architecture, and follow same target objective. These are the main reasons we choose DDQN for our comparisons. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            208
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In table. 1 we see significant gains for BDQN over DDQN. BDQN is able to learn significantly faster and reach higher returns due to more efficient exploration. The evidence of this is further seen from the fact that we are able to train BDQN with much higher learning rates compared to DDQN. This suggests that BDQN is able to learn faster and reach better scores. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            271
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These promising results suggest that BDQN can further benefit from additional modifications that were done to DQN, e.g. Prioritized Experience Replay (Schaul et al., 2015), Dueling approach (Wang et al., 2015), A3C (Mnih et al., 2016), safe exploration (Lipton et al., 2016a), and etc. This is because BDQN only changes that exploration strategy of DQN, and can easily accommodate additional improvements to DQN. ",
+        "bbox": [
+            176,
+            279,
+            823,
+            348
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/1e9bda06eb0b12d805cf97aa37535974a759f8ba698e72b0459c8392d620a3c4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Game</td><td rowspan=1 colspan=1>BDQNDDQN</td><td rowspan=1 colspan=1>BDQNDDQNt</td><td rowspan=1 colspan=1>BDQNHUMAN</td><td rowspan=1 colspan=1>Step</td></tr><tr><td rowspan=1 colspan=1>Amidar</td><td rowspan=1 colspan=1>558%</td><td rowspan=1 colspan=1>788%</td><td rowspan=1 colspan=1>325%</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Alien</td><td rowspan=1 colspan=1>103%</td><td rowspan=1 colspan=1>103%</td><td rowspan=1 colspan=1>43%</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Assault</td><td rowspan=1 colspan=1>396%</td><td rowspan=1 colspan=1>176%</td><td rowspan=1 colspan=1>589%</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Asteroids</td><td rowspan=1 colspan=1>2517%</td><td rowspan=1 colspan=1>1516%</td><td rowspan=1 colspan=1>108%</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Asterix</td><td rowspan=1 colspan=1>531%</td><td rowspan=1 colspan=1>385%</td><td rowspan=1 colspan=1>687%</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>BeamRider</td><td rowspan=1 colspan=1>207%</td><td rowspan=1 colspan=1>114%</td><td rowspan=1 colspan=1>150%</td><td rowspan=1 colspan=1>70M</td></tr><tr><td rowspan=1 colspan=1>BattleZone</td><td rowspan=1 colspan=1>281%</td><td rowspan=1 colspan=1>253%</td><td rowspan=1 colspan=1>172%</td><td rowspan=1 colspan=1>50M</td></tr><tr><td rowspan=1 colspan=1>Atlantis</td><td rowspan=1 colspan=1>80604%</td><td rowspan=1 colspan=1>49413%</td><td rowspan=1 colspan=1>11172%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>DemonAttack</td><td rowspan=1 colspan=1>292%</td><td rowspan=1 colspan=1>114%</td><td rowspan=1 colspan=1>326%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>Centipede</td><td rowspan=1 colspan=1>114%</td><td rowspan=1 colspan=1>178%</td><td rowspan=1 colspan=1>61%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>BankHeist</td><td rowspan=1 colspan=1>211%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>CrazyClimber</td><td rowspan=1 colspan=1>148%k</td><td rowspan=1 colspan=1>122%</td><td rowspan=1 colspan=1>350%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>ChopperCommand</td><td rowspan=1 colspan=1>14500%</td><td rowspan=1 colspan=1>1576%</td><td rowspan=1 colspan=1>732%</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>Enduro</td><td rowspan=1 colspan=1>295%</td><td rowspan=1 colspan=1>350%</td><td rowspan=1 colspan=1>361%</td><td rowspan=1 colspan=1>30M</td></tr><tr><td rowspan=1 colspan=1>Pong</td><td rowspan=1 colspan=1>112%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>226%</td><td rowspan=1 colspan=1>5M</td></tr></table>",
+        "bbox": [
+            276,
+            364,
+            720,
+            654
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Table 1: The first column presents the score ratio after last column steps. The second column is the score ratio of BDQN after the number of steps in the last column compared to the score of $\\mathrm { D D Q N } ^ { \\dagger }$ , the reported scores of DDQN in Van Hasselt et al. (2016) after running for 200M samples during evaluation time, and the third column is with respect to Human score reported at Mnih et al. (2015). ",
+        "bbox": [
+            173,
+            670,
+            826,
+            727
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            344,
+            766
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The complexity of the exploration-exploitation trade-off has been vastly investigated in RL literature (Kearns & Singh, 2002; Brafman & Tennenholtz, 2003; Strehl et al., 2009; Bartlett & Tewari, 2009; Azar et al., 2017; Dann et al., 2017). Auer (2002) addresses this question for multi-armed bandit problems where regret guarantees are provided. Jaksch et al. (2010) investigates the regret analyses in MDPs where exploration happens through the optimal policy of optimistic model, a well-known Optimism in Face of Uncertainty (OFU) principle where a high probability regret upper bound is guaranteed. Azizzadenesheli et al. (2016a) deploys OFU in order to propose the high probability regret upper bound for Partially Observable MDPs (POMDPs) and finally, Bartók et al. (2014) tackles a general case of partial monitoring games and provides minimax regret guarantee which is polynomial in certain dimensions of the problem. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In multi arm bandit, there is compelling empirical evidence that Thompson Sampling can provide better results than optimism-under-uncertainty approaches (Chapelle & Li, 2011), while the state of the art performance bounds are preserved (Russo & Van Roy, 2014; Agrawal & Goyal, 2012; Gopalan & Mannor, 2015; Abeille & Lazaric, 2017). A natural adaptation of this algorithm to RL, posterior sampling RL (PSRL), first proposed by Strens (2000) also shown to have good frequentist and Bayesian performance guarantees (Osband et al., 2013; Gopalan & Mannor, 2015; Agrawal & Jia, 2017; Abbasi-Yadkori & Szepesvári, 2015; Ouyang et al., 2017; Theocharous et al., 2017; Russo et al., 2017). Even though the theoretical RL addresses the exploration and exploitation trade-offs, these problems are still prominent in empirical reinforcement learning research (Mnih et al., 2015; Jiang et al., 2016; Abel et al., 2016; Azizzadenesheli et al., 2016b). On the empirical side, the recent success in the video games has sparked a flurry of research interest. Following the success of Deep RL on Atari games (Mnih et al., 2015) and the board game Go (Silver et al., 2017), many researchers have begun exploring practical applications of deep reinforcement learning (DRL). Some investigated applications include, robotics (Levine et al., 2016), energy management (Night, 2016), and self-driving cars (Shalev-Shwartz et al., 2016). Among the mentioned literature, the prominent exploration strategy for Deep RL agent has been $\\varepsilon$ -greedy. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            325
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inevitably for PSRL, the act of posterior sampling for policy or value is computationally intractable with large systems, so PSRL can not be easily leveraged to high dimensional problems. To remedy these failings Osband et al. (2017) consider the use of randomized value functions to approximate posterior samples for the value function in a computationally efficient manner. They show that with a suitable linear value function approximation, using the approximated Bayesian linear regression for randomized least-squares value iteration method can remain statistically efficient (Osband et al., 2014) but still is not scalable to large scale RL with deep neural networks. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            430
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To combat these shortcomings, Osband et al. (2016) suggests a bootstrapped-ensemble approach that trains several models in parallel to approximate uncertainty. Other works suggest using a variational approximation to the Q-networks (Lipton et al., 2016b) or noisy network (Fortunato et al., 2017). However, most of these approaches significantly increase the computational cost of DQN and neither approaches produced much beyond modest gains on Atari games. Applying Bayesian regression in last layer of neural network was investigated in Snoek et al. (2015) for object recognition, image caption generation, and etc. where a significant advantage has been provided. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work we present another alternative approach that extends randomized least-squares value iteration method (Osband et al., 2014) to deep neural networks: we approximate the posterior by a Bayesian linear regression only on the last layer of the neural network. This approach has several benefits, e.g. simplicity, robustness, targeted exploration, and most importantly, we find that this method is much more effective than any of these predecessors in terms of sample complexity and final performance. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Concurrently, O’Donoghue et al. (2017) studies how to construct the frequentist confidence of the regression on the feature space of the neural network for RL problems by learning the uncertainties through a shallow network while Levine et al. (2017), similar to BDQN, suggests running linear regression on the representation layer of the deep network in order to learn the state-action value. Drop-out, as another randomized exploration method is proposed by Gal & Ghahramani (2016) but Osband et al. (2016) argues about its estimated uncertainty and hardness in driving a suitable exploitation of it. It is worth noting that most of proposed methods are based on $\\varepsilon$ -exploration. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THOMPSON SAMPLING VS ε−GREEDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            756,
+            521,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we enumerate a few benefits of TS over $\\varepsilon$ -greedy strategies. We show how TS strategies exploit the uncertainties and expected returns to design a randomized exploration while $\\varepsilon -$ greedy strategies disregard all these useful information for the exploration. ",
+        "bbox": [
+            173,
+            790,
+            823,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fig. 1(a) expresses the agent’s estimated values and uncertainties for the available actions at a given state $x$ . While $\\varepsilon -$ greedy strategy mostly focus on the action 1, the optimistic action, the TS based strategy randomizes, mostly, over actions 1 through 4, utilizing their approximated returns and uncertainties, and with low frequency tries actions 5, 6. Not only the $\\varepsilon -$ greedy strategy explores actions 5 and 6, where the RL agent is almost sure about low return of these actions, as frequent as other sub-optimistic actions, but also spends the network capacity to accurately estimate their values. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/44bda5713030c894fc2cad5c544c21705f3a46c15c61d88172fcc2dd85e2db1b.jpg",
+        "image_caption": [
+            "Figure 1: A cartoon representation of TS vs $\\varepsilon$ -greedy. The red crosses are the true Q-values, the diamonds are the mean of estimated Q-values with blue intervals as uncertainties (e.g. $c \\cdot$ variance) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            82,
+            794,
+            222
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A commonly used technique in deep RL is a moving window of replay buffer to store the recent experiences. The TS based agent, after a few tries of actions 5 and 6 builds a belief in low return of these actions given the current target values. Since the replay buffer is bounded moving window, lack of samples of these actions pushes the posterior belief of these actions to the prior, over time, and the agent tries them again in order to update its belief Fig. $1 ( b )$ . In general, TS based strategy advances the exploration-exploitation trade-off by making trade-off between the expected returns and the uncertainties, while $\\varepsilon -$ greedy strategy ignores all of this information. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            383
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Another superiority of TS over $\\varepsilon$ -greedy can be described using Fig. $1 ( c )$ . Consider an episodic maze-inspired deterministic game, with episode length $H$ of shortest pass from the start to the destination. The agent is placed to the start point at the beginning of each episode where the goal state is to reach the destination and receive a reward of 1 otherwise reward is 0. Consider an agent, which is given a hypothesis set of Q-functions where the true Q-function is within the set and is the most optimistic function in the set. In this situation, TS randomizes over the Q-functions with high promising returns and relatively high uncertainty, including the true Q-function. When it picks the true Q-function, it increases the posterior probability of this Q-function because it matches the likelihood. When TS chooses other functions, they predict deterministically wrong values and the posterior update of those functions set to zero, therefore, the agent will not choose them again, i.e. TS finds the true Q-function very fast. For $\\varepsilon$ -greedy agent, even though it chooses the true function at the beginning (it is the optimistic one), at each time step, it randomizes its action with the probability $\\varepsilon$ . Therefore, it takes exponentially many trials in order to get to the target in this game. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            598,
+            338,
+            613
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An infinite horizon $\\gamma$ -discounted MDP $M$ is a tuple $\\langle \\mathcal { X } , \\mathcal { A } , T , R \\rangle$ , with state space $\\mathcal { X }$ , action space $\\mathcal { A }$ , and the transition kernel $T$ , accompanied with reward function of $R$ where $0 < \\gamma \\leq 1$ . At each time step $t$ , the environment is at a state $x _ { t }$ , called current state, where the agent needs to make a decision $a _ { t }$ under its policy. Given the current state and action, the environment stochastically proceed to a successor state $x _ { t + 1 }$ under probability distribution $T ( X _ { t + 1 } | x _ { t } , a _ { t } ) : = \\mathbb { P } ( X _ { t + 1 } | x _ { t } , a _ { t } )$ and provides a stochastic reward $r _ { t }$ with mean of $\\mathbb { E } [ r | x = x _ { t } , a = a _ { t } ] = R ( x _ { t } , a _ { t } )$ . The agent objective is to optimize the overall expected discounted reward over its policy $\\pi : = \\mathcal { X }  \\mathcal { A }$ , a stochastic mapping from states to actions, ${ \\bar { \\pi } } ( a | x ) : = \\mathbb { P } ( a | x )$ . ",
+        "bbox": [
+            173,
+            631,
+            825,
+            744
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b2a5d1cbef10f01ee14f0d3e4b6efd83fbfd51b49d86791a041c7d9d227aec60.jpg",
+        "text": "$$\n\\eta ^ { * } = \\eta ( \\pi ^ { * } ) = \\operatorname* { m a x } _ { \\pi } \\eta ( \\pi ) = \\operatorname* { m a x } _ { \\pi } \\operatorname* { l i m } _ { N  \\infty } \\mathbb { E } _ { \\pi } [ \\sum _ { t = 0 } ^ { N } \\gamma ^ { t } r _ { t } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            756,
+            678,
+            800
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The expectation in Eq. 1 is with respect to the randomness in the distribution of initial state, transition probabilities, stochastic rewards, and policy, under stationary distribution, where $\\eta ^ { * } , \\pi ^ { * }$ are optimal return and optimal policy, respectively. Let $Q _ { \\pi } ( x , a )$ denote the average discounted reward under policy $\\pi$ starting off from state $x$ and taking action $a$ in the first place. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            867
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9f21ed4227a3f3f7335bebda8f5b4884554898913119fe7aef890035d34a5b74.jpg",
+        "text": "$$\nQ _ { \\pi } ( x , a ) : = \\operatorname* { l i m } _ { N \\to \\infty } \\mathbb { E } _ { \\pi } \\left[ \\sum _ { t = 0 } ^ { N } \\gamma ^ { t } r _ { t } | x _ { 0 } = x , a _ { 0 } = a \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            878,
+            665,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For a given policy $\\pi$ and Markovian assumption of the model, we can rewrite the equation for the Q functions as follows: ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/30f8da1a88be7c99481753da8c9b5581de786d8ffce616877c6b581d6baa5a3a.jpg",
+        "text": "$$\nQ _ { \\pi } ( x , a ) = R ( x , a ) + \\gamma \\sum _ { x ^ { \\prime } , a ^ { \\prime } } T ( x ^ { \\prime } | x , a ) \\pi ( a ^ { \\prime } | x ^ { \\prime } ) Q _ { \\pi } ( x ^ { \\prime } , a ^ { \\prime } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            133,
+            694,
+            169
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To find the optimal policy, one can solve the Linear Programing problem in Eq. 1 or follow the corresponding Bellman equation Eq. 2 where both of optimization methods turn to ",
+        "bbox": [
+            173,
+            174,
+            826,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/75cac72f5c3412907ad6d1b31fc9e87e52b30cf7ed67a57261af7d24f2193fd3.jpg",
+        "text": "$$\nQ ^ { * } ( x , a ) = R ( x , a ) + \\gamma \\sum _ { x ^ { \\prime } } T ( x ^ { \\prime } | x , a ) \\operatorname* { m a x } _ { a ^ { \\prime } } Q ^ { * } ( x ^ { \\prime } , a ^ { \\prime } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            207,
+            679,
+            241
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $Q ^ { * } ( x , a ) = Q _ { \\pi ^ { * } } ( x , a )$ and the optimal policy is a deterministic mapping from state to actions in $\\mathcal { A }$ , i.e. $x \\to a r g \\operatorname* { m a x } _ { a } Q ^ { * } ( x , a )$ . In RL, we do not know the transition kernel and the reward function in advance, therefore, we can not solve the posed Bellman equation directly. In order to tackle this problem, (Lagoudakis & Parr, 2003; Antos et al., 2008) studies the property of minimizing the Bellman residual of a given Q-function ",
+        "bbox": [
+            173,
+            244,
+            825,
+            315
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5e44356500f076565a4dc05b9b6c8c06d485f01f8cf8c4464140e0660722971e.jpg",
+        "text": "$$\n\\mathcal { L } ( Q ) = \\mathbb { E } _ { \\pi } \\left[ \\left( Q ( x , a ) - r - \\gamma Q ( x ^ { \\prime } , a ^ { \\prime } ) \\right) ^ { 2 } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            320,
+            642,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Where the tuple $( x , a , r , x ^ { \\prime } , a ^ { \\prime } )$ consists of consecutive samples under behavioral policy $\\pi$ . Furthermore, (Mnih et al., 2015) carries the same idea, and introduce Deep Q-Network (DQN) where the Q-functions are parameterized by a DNN. To improve the quality of Q function, they use back propagation on loss $\\mathcal { L } ( Q )$ using TD update (Sutton $\\&$ Barto, 1998). In the following we describe the setting used in DDQN. In order to reduce the bias of the estimator, they introduce target network ${ Q } ^ { t a r g e t }$ and target value $y = r + \\gamma Q ^ { t a r g e t } ( x ^ { \\prime } , \\hat { a } )$ where $\\hat { a } = \\arg \\operatorname* { m a x } _ { a ^ { \\prime } } Q ( x ^ { \\prime } , a ^ { \\prime } )$ with a new loss $\\mathcal { L } ( Q , Q ^ { t a r g e t } )$ ",
+        "bbox": [
+            173,
+            352,
+            825,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbb3170433cef290dd1823564976dbf2ee574dfa75cfc353ec9d2b859cfb279c.jpg",
+        "text": "$$\n\\mathcal { L } ( Q , Q ^ { t a r g e t } ) = \\mathbb { E } _ { \\boldsymbol \\pi } \\left[ \\left( Q ( \\boldsymbol x , a ) - y \\right) ^ { 2 } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            455,
+            627,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Minimizing this regression loss, and respectably its estimation $\\widehat { \\mathcal { L } } ( Q , Q ^ { t a r g e t } )$ , matches the $Q$ to the target $y$ . Once in a while, the algorithm sets ${ Q } ^ { t a r g e t }$ network to $Q$ network, peruses the regression with the new target value, and provides an biased estimator of the target. ",
+        "bbox": [
+            174,
+            489,
+            826,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 BAYESIAN DEEP Q-NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            553,
+            468,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We propose a Bayesian method to approximate the $Q$ -function and match it to the target value. We utilize the DQN architecture, remove its last layer, and build a Bayesian linear regression (BLR) (Rasmussen & Williams, 2006) on the feature representation layer, $\\dot { \\phi } _ { \\theta } ( x ) \\in \\mathbb { R } ^ { d }$ , parametrized by $\\theta$ . We deploy BLR to efficiently approximate the distribution over the Q-values where the uncertainty over the values is captured. A common assumption in DNN is that the feature representation is suitable for linear classification or regression (same assumption in DQN). ",
+        "bbox": [
+            173,
+            583,
+            825,
+            669
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The Q-functions can be approximated as a linear combination of features, i.e. for a given pair of state-action, $Q ( x , a ) = \\phi _ { \\boldsymbol { \\theta } } ( \\bar { x } ) ^ { \\top } w _ { a }$ . Therefore, by deploying BLR, we can approximate the generative model of the Q-function using its corresponding target value: $y = r + \\stackrel {  } { \\gamma } \\phi ^ { t a r g e t } w ^ { t a r g e \\acute { t } } \\hat { a }$ , where φtargetθ (x) ∈ Rd denotes the feature representation of target network, for any (x, a) as follows ",
+        "bbox": [
+            173,
+            674,
+            825,
+            733
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dde0f6b0e5175f2dc14af81ad9d27904c9b977eb73acb47e6a96c1f6bddc49a1.jpg",
+        "text": "$$\n\\boldsymbol { y } = \\boldsymbol { Q } ( \\boldsymbol { x } , \\boldsymbol { a } ) + \\epsilon = \\boldsymbol { w } _ { \\boldsymbol { a } } ^ { \\top } \\phi ( \\boldsymbol { x } ) + \\epsilon , \\quad \\forall \\boldsymbol { x } \\in \\mathcal { X } , \\boldsymbol { a } \\in \\mathcal { A }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            738,
+            671,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\epsilon \\sim \\mathcal { N } ( 0 , \\sigma _ { \\epsilon } ^ { 2 } )$ is an iid noise. Furthermore, we consider $w _ { a } \\in \\mathbb { R } ^ { d }$ for $a \\in { \\mathcal { A } }$ are drawn approximately from a Gaussian prior ${ \\mathcal { N } } ( 0 , \\sigma ^ { 2 } )$ . Therefore, $y | x , a , w _ { a } \\sim \\mathcal { N } ( \\phi ( x ) ^ { \\top } w _ { a } , \\sigma _ { \\epsilon } ^ { 2 } )$ . Moreover, the distribution of the target value $y$ is $\\begin{array} { r } { \\mathbb { P } \\left( y \\vert a \\right) = \\int _ { w _ { a } } \\mathbb { P } \\left( y \\vert w _ { a } \\right) \\mathbb { P } \\left( w _ { a } \\right) d w _ { a } } \\end{array}$ . Given a dataset $\\mathcal { D } = \\{ x _ { \\tau } , a _ { \\tau } , y _ { \\tau } \\} _ { \\tau = 1 } ^ { D }$ , we construct $| { \\cal A } |$ disjoint datasets for each action, $\\mathcal { D } _ { a }$ , where $\\mathcal { D } = \\cup _ { a \\in \\mathcal { A } } \\mathcal { D } _ { a }$ and $\\mathcal { D } _ { a }$ is a set of tuples $x _ { \\tau } , a _ { \\tau } , y _ { \\tau }$ with the action $a _ { \\tau } = a$ and size $D _ { a }$ . We are interested in $\\mathbb { P } ( w _ { a } | \\mathcal { D } _ { a } )$ and $\\mathbb { P } ( Q ( x , a ) | \\mathcal { D } _ { a } ) , \\forall x \\in \\mathcal { X }$ . We construct a matrix $\\Phi _ { a } \\in \\mathbb { R } ^ { d \\times D _ { a } }$ , a concatenation of feature column vectors distribu $\\{ \\phi ( x _ { i } ) \\} _ { i = 1 } ^ { D _ { a } }$ , and llow $\\mathbf { y } _ { a } \\in \\mathbb { R } ^ { D _ { a } }$ , a concatenation of target values in set $\\mathcal { D } _ { a }$ . Therefore the posterior ",
+        "bbox": [
+            173,
+            763,
+            826,
+            882
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0048d0214842bcda6057f39bfb6680e695cfc351402d89c52f7fc6b076c53f0a.jpg",
+        "text": "$$\nw _ { a } \\sim { \\mathcal { N } } \\left( { \\frac { 1 } { \\sigma _ { \\epsilon } ^ { 2 } } } \\Xi _ { a } \\Phi _ { a } \\mathbf { y } _ { a } , \\Xi _ { a } \\right) , w h e r e \\Xi _ { a } = \\left( { \\frac { 1 } { \\sigma _ { \\epsilon } ^ { 2 } } } \\Phi _ { a } \\Phi _ { a } ^ { \\top } + { \\frac { 1 } { \\sigma ^ { 2 } } } \\mathbb { 1 } \\right) ^ { - 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            885,
+            723,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 BDQN ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            308,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize parameter sets $\\theta$ , $\\theta ^ { t a r g e t }$ , $W$ , $W ^ { t a r g e t }$ , and $C o v$ using a normal distribution.   \n2: Initialize replay buffer and set counter $= ~ 0$   \n3: for episode $= 1$ to inf do   \n4: Initialize $x _ { 1 }$ to the initial state of the environment   \n5: for $t = \\mathrm { t o }$ the end of episode do   \n6: if count mod $T ^ { s a m p l e } = 0$ then   \n7: sample $W \\sim \\mathcal { N } \\left( W ^ { t a r g e t } , C o v \\right)$   \n8: end if   \n9: Select action $a _ { t } = a r g m a x _ { a ^ { \\prime } }$ $\\big [ W ^ { \\top } \\phi _ { \\theta } ( x _ { t } ) \\big ] _ { a ^ { \\prime } }$   \n10: Execute action $a _ { t }$ a in environment, observing reward $r _ { t }$ and successor state $x _ { t + 1 }$   \n11: Store transition $( x _ { t } , a _ { t } , r _ { t } , x _ { t + 1 } )$ in replay buffer   \n12: Sample a random minibatch of transitions $( x _ { \\tau } , a _ { \\tau } , r _ { \\tau } , x _ { \\tau + 1 } )$ from replay buffer   \n13: $\\begin{array} { l } { { y _ { \\tau } \\gets \\left\\{ \\begin{array} { l l } { { r _ { \\tau } , } } \\\\ { { r _ { \\tau } + \\left[ W ^ { t a r g e t } { } ^ { \\top } \\phi _ { \\theta ^ { t a r g e t } } ( x _ { \\tau + 1 } ) \\right] _ { \\hat { a } } ; \\hat { a } = a r g m a x _ { a ^ { \\prime } } \\left[ W ^ { \\top } \\phi _ { \\theta } ( x _ { \\tau + 1 } ) \\right] _ { a ^ { \\prime } } } } \\end{array} \\right. } } \\\\ { { \\theta \\gets \\theta - \\eta \\cdot \\nabla _ { \\theta } ( y _ { \\tau } - \\left[ W ^ { \\top } \\phi _ { \\theta } ( x _ { \\tau } ) \\right] _ { a _ { \\tau } } ) ^ { 2 } } } \\end{array}$ for non-terminal xτ+1 for terminal xτ+1   \n14:   \n15: if count mod $T ^ { t a r g e t } = 0$ then   \n16: set $\\theta ^ { t a r g e t }  \\theta$   \n17: end if   \n18: if count mod $T ^ { B a y e s ~ t a r g e t } = 0$ then   \n19: Update $W ^ { t a r g e t }$ and $C o v$   \n20: end if   \n21: count $=$ count + 1   \n22: end for   \n23: end for ",
+        "bbox": [
+            173,
+            122,
+            936,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbb { 1 } \\in \\mathbb { R } ^ { d }$ is a identity matrix, and $Q ( x , a ) | \\mathcal { D } _ { a } = w _ { a } ^ { \\top } \\phi ( x )$ . Since the prior and likelihood are conjugate of each other we have the posterior distribution over the discounted return approximated as ",
+        "bbox": [
+            173,
+            503,
+            825,
+            535
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dca7bfe95aa46411529524bb41a6374d57ea13b2a2c4a9f39655557d1952e1bb.jpg",
+        "text": "$$\n\\sum _ { t = 0 } ^ { N } \\gamma ^ { t } r _ { t } | x _ { 0 } = x , a _ { 0 } = a , \\mathcal { D } _ { a } \\sim \\mathcal { N } \\left( \\frac { 1 } { \\sigma _ { \\epsilon } ^ { 2 } } \\phi ( x ) ^ { \\top } \\Xi _ { a } \\Phi _ { a } \\mathbf { y } _ { a } , \\phi ( x ) ^ { \\top } \\Xi _ { a } \\phi ( x ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            540,
+            736,
+            584
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The expression in Eqs. 5 gives the posterior distribution over weights $w _ { a }$ and the function $Q$ . As TS suggests, for the exploration, we exploit the expression in Eq. 5. For all the actions, we set $w _ { a } ^ { t a r g e t }$ as the mean of posterior distribution over $w _ { a }$ . For each action, we sample a wight vector $w _ { a }$ in order to have samples of mean $\\mathrm { Q }$ -value. Then we act optimally with respect to the sampled means ",
+        "bbox": [
+            173,
+            590,
+            825,
+            647
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/939b11b44cffd4796d8fe9c4d94584b37e0a4f26502e57f239eb9e742fb5aa5c.jpg",
+        "text": "$$\na _ { \\mathrm { T S } } = \\arg \\operatorname* { m a x } _ { a } w _ { a } ^ { \\top } \\phi _ { \\theta } ( x ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            654,
+            589,
+            678
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Let $W = \\{ w _ { a } \\} _ { a = 1 } ^ { | \\mathcal { A } | }$ , respectively $W ^ { t a r g e t } = \\{ w _ { a } ^ { t a r g e t } \\} _ { a = 1 } ^ { | { \\cal A } | }$ , and $C o v = \\{ \\Xi _ { a } \\} _ { a = 1 } ^ { | { \\cal A } | }$ . In BDQN, the agent interacts with the environment through applying the actions proposed by TS, i.e. utilize a notion of experience replay buffer where the agent stores its recent experiences. The agent draws $W \\sim \\mathcal N \\left( W ^ { t { \\bar { a } } r g e t } , C o v \\right)$ (abbreviation for sampling of vector $w$ for each action separately) every $T ^ { s a m p l e }$ steps and act optimally with respect to the drawn weights. During the inner loop of the algorithm, we draw a minibatch of data from replay buffer and use loss ",
+        "bbox": [
+            173,
+            686,
+            825,
+            775
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91aaa48a7094a12b82287feaf08240a4dca095a43454e05726337e7601a54b97.jpg",
+        "text": "$$\n\\left( \\boldsymbol { y } _ { \\tau } - \\left[ \\boldsymbol { W } ^ { \\top } \\phi _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } _ { \\tau } ) \\right] _ { a _ { \\tau } } \\right) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            780,
+            581,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2f1bbe98cf8996ee44bb623fd8a7a745fd7a9814d688768616c6d7ff1ceca242.jpg",
+        "text": "$$\ny _ { \\tau } : = r _ { \\tau } + \\left[ { \\cal W } ^ { t a r g e t ^ { \\top } } \\phi _ { \\theta ^ { t a r g e t } } ( x _ { \\tau + 1 } ) \\right] _ { \\hat { a } } ; \\hat { a } = a r g m a x _ { a ^ { \\prime } } \\left[ { \\cal W } ^ { \\top } \\phi _ { \\theta } ( x _ { \\tau + 1 } ) \\right] _ { a ^ { \\prime } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            819,
+            774,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "and update the weights of network: $\\theta  \\theta - \\eta \\cdot \\nabla _ { \\theta } ( y _ { \\tau } - [ W ^ { \\top } \\phi _ { \\theta } ( x _ { \\tau } ) ] _ { a _ { \\tau } } ) ^ { 2 } .$ ",
+        "bbox": [
+            174,
+            854,
+            679,
+            873
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We update the target network every $T ^ { t a r g e t }$ steps and set $\\theta ^ { t a r g e t }$ to $\\theta$ . With the period of $T ^ { B a y e s }$ target the agent updates its posterior distribution using larger minibatch of data drawn from replay buffer and sample $W$ with respect to the updated posterior. Algorithm 1 gives the full description of BDQN. ",
+        "bbox": [
+            174,
+            880,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            326,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We apply BDQN on a variety of games in the OpenAiGym 1(Brockman et al., 2016). As a baseline2, we run DDQN algorithm and evaluate BDQN on the measures of sample complexity and score. ",
+        "bbox": [
+            173,
+            135,
+            826,
+            164
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e28849de6a30dd5651b659aeecf1240468e80b8a948672f5d16fc64e046559e.jpg",
+        "image_caption": [
+            "Figure 2: The fast targeted exploration of BDQN "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            179,
+            823,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Network architecture: The input to the network part of BDQN is $4 \\times 8 4 \\times 8 4$ tensor with a rescaled and averaged over channels of the last four observations. The first convolution layer has 32 filters of size 8 with a stride of 4. The second convolution layer has 64 filters of size 4 with stride 2. The last convolution layer has 64 filters of size 3 followed by a fully connected layers with size 512. We add a BLR layer on top of this. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            502
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Choice of hyper-parameters: For BDQN, we set the values of $W ^ { t a r g e t }$ to the mean of the posterior distribution over the weights of BLR with covariances $C o v$ and draw $W$ from this posterior. For the fixed $W$ and $W ^ { t a r g e t }$ , we randomly initialize the parameters of network part of BDQN, $\\theta$ , and train it using RMSProp, with learning rate of 0.0025, and a momentum of 0.95, inspired by (Mnih et al., 2015) where the discount factor is $\\gamma = 0 . 9 9$ , the number of steps between target updates $T ^ { t a r g e t } = 1 0 k$ steps, and weights $W$ are re-sampled from their posterior distribution every $\\hat { T } ^ { s a m p l e }$ step. We update the network part of BDQN every 4 steps by uniformly at random sampling a mini-batch of size 32 samples from the replay buffer. We update the posterior distribution of the weight set $W$ every $T ^ { B a y e s }$ target using mini-batch of size $B$ (if size of replay buffer is less than $B$ at the current step, we choose the minimum of these two ), with entries sampled uniformly form replay buffer. The experience replay contains the $1 M$ most recent transitions. Further hyper-parameters, are equivalent to ones in DQN setting. ",
+        "bbox": [
+            173,
+            521,
+            825,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Hyper-parameters tunning: For the BLR, we have noise variance $\\sigma _ { \\epsilon }$ , variance of prior over weights $\\sigma$ , sample size $B$ , posterior update period $T ^ { B a y e s ~ t a r g e t }$ , and the posterior sampling period $T ^ { s a \\overline { { m } } p l e }$ . To optimize for this set of hyper-parameters we set up a very simple, fast, and cheap hyper-parameter tunning procedure which proves the robustness of BDQN. To fine the first three, we set up a simple hyper-parameter search. We used a pretrained DQN model for the game of Assault, and removed the last fully connected layer in order to have access to its already trained feature representation. Then we tried combination of $B = \\{ T ^ { t a r g e t } , 1 0 \\cdot T ^ { t a r g e t } \\}$ , $\\sigma \\overset { \\cdot } { = } \\{ 1 , 0 . 1 , 0 . 0 0 1 \\}$ and $\\sigma _ { \\epsilon } = \\{ 1 , 1 0 \\}$ and test for 1000 episode of the game. We set these parameters to their best $B = 1 0 \\cdot T ^ { t a r g e t }$ , $\\sigma = 0 . 0 0 1 , \\sigma = 1$ . ",
+        "bbox": [
+            173,
+            705,
+            825,
+            830
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The above hyper-parameter tuning is cheap and fast since it requires only a few times $B$ number of forward passes. For the remaining parameter, we ran BDQN ( with weights randomly initialized) on the same game, Assault, for $5 M$ time steps, with a set of $T ^ { B a y e s t a r g e t } = \\{ T ^ { t a r g \\bar { e } t } , 1 0 \\cdot T ^ { t a r g e t } \\}$ and $\\begin{array} { r } { T ^ { s a m p l e } = \\{ \\frac { T ^ { t a r g e t } } { 1 0 } , \\frac { T ^ { t a r g e t } } { 1 0 0 } \\} } \\end{array}$ where BDQN performed better with choice of $T ^ { B a y e s ~ t a r g e t } =$ $1 0 \\cdot T ^ { t a r g e t }$ . For both choices of $T ^ { s a m p l e }$ , it performed almost equal where we choose the higher one. We started off with the learning rate of 0.0025 and did not tune for that. Thanks to the efficient TS exploration and closed form BLR, BDQN can learn a better policy in even shorter period of time. In contrast, it is well known for DQN based methods that changing the learning rate causes a major degradation in the performance, Apx. A. The proposed hyper-parameter search is very simple where the exhaustive hyper-parameter search is likely to provide even better performance. In order to compare the fairness in sample usage, we argue in Apx. A, that the network part of BDQN and its corresponding part in DDQN observe the same number of samples but the BLR part of BDQN uses 16 times less samples compared to its corresponding last layer in DDQN, Apx. A. All the implementations are coded in MXNet framework (Chen et al., 2015) and are available at ..... . ",
+        "bbox": [
+            173,
+            103,
+            825,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results: The results are provided in Fig. 2 and Table. 2. Mostly the focus of the experiments are on sample complexity in Deep-RL, even though, BDQN provides much larger scores compared to base line. For example, for the game Atlantis, DDQN† gives score of $6 4 . 6 7 k$ after $2 0 0 M$ samples during evaluation time, while BDQN reaches $3 . 2 4 M$ after $4 0 M$ samples. As it is been shown in Fig. 2, BDQN saturates for Atlantis after 20M samples. We realized that BDQN reaches the internal OpenAIGym limit of max_episode, where relaxing it improves score after $1 5 M$ steps to $6 2 M$ . ",
+        "bbox": [
+            173,
+            337,
+            825,
+            421
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We can observe that BDQN can immediately learn significantly better policies due to its targeted exploration in much shorter period of time. Since BDQN on game Atlantis promise a big jump around time step $2 0 M$ , we ran it five more times in order to make sure it was not just a coincidence. We did the same additional five experiments for the game Amidar as well. We observed that the improvements are consistent among the different runs. For the game Pong, we ran the experiment for a longer period but just plotted the beginning of it in order to observe the difference. For some games we did not run the experiment to $1 0 0 M$ samples since the reached their plateau. ",
+        "bbox": [
+            173,
+            428,
+            825,
+            526
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/49122ca506a3d45224800b07dd39179b5f44e3b8d50f06d3a5a5244da3a77867.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Game</td><td rowspan=1 colspan=1>BDQN</td><td rowspan=1 colspan=1>DDQN</td><td rowspan=1 colspan=1>DDQNt</td><td rowspan=1 colspan=1>Human</td><td rowspan=1 colspan=1>SC</td><td rowspan=1 colspan=1>SCt</td><td rowspan=1 colspan=1>Step</td></tr><tr><td rowspan=1 colspan=1>Amidar</td><td rowspan=1 colspan=1>5.52k</td><td rowspan=1 colspan=1>0.99k</td><td rowspan=1 colspan=1>0.7k</td><td rowspan=1 colspan=1>1.7k</td><td rowspan=1 colspan=1>22.9M</td><td rowspan=1 colspan=1>4.4M</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Alien</td><td rowspan=1 colspan=1>3k</td><td rowspan=1 colspan=1>2.9k</td><td rowspan=1 colspan=1>2.9k</td><td rowspan=1 colspan=1>6.9k</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>36.27M</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Assault</td><td rowspan=1 colspan=1>8.84k</td><td rowspan=1 colspan=1>2.23k</td><td rowspan=1 colspan=1>5.02k</td><td rowspan=1 colspan=1>1.5k</td><td rowspan=1 colspan=1>1.6M</td><td rowspan=1 colspan=1>24.3M</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Asteroids</td><td rowspan=1 colspan=1>14.1k</td><td rowspan=1 colspan=1>0.56k</td><td rowspan=1 colspan=1>0.93k</td><td rowspan=1 colspan=1>13.1k</td><td rowspan=1 colspan=1>58.2M</td><td rowspan=1 colspan=1>9.7M</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>Asterix</td><td rowspan=1 colspan=1>58.4k</td><td rowspan=1 colspan=1>11k</td><td rowspan=1 colspan=1>15.15k</td><td rowspan=1 colspan=1>8.5k</td><td rowspan=1 colspan=1>3.6M</td><td rowspan=1 colspan=1>5.7M</td><td rowspan=1 colspan=1>100M</td></tr><tr><td rowspan=1 colspan=1>BeamRider</td><td rowspan=1 colspan=1>8.7k</td><td rowspan=1 colspan=1>4.2k</td><td rowspan=1 colspan=1>7.6k</td><td rowspan=1 colspan=1>5.8k</td><td rowspan=1 colspan=1>4.0M</td><td rowspan=1 colspan=1>8.1M</td><td rowspan=1 colspan=1>70M</td></tr><tr><td rowspan=1 colspan=1>BattleZone</td><td rowspan=1 colspan=1>65.2k</td><td rowspan=1 colspan=1>23.2k</td><td rowspan=1 colspan=1>24.7k</td><td rowspan=1 colspan=1>38k</td><td rowspan=1 colspan=1>25.1M</td><td rowspan=1 colspan=1>14.9M</td><td rowspan=1 colspan=1>50M</td></tr><tr><td rowspan=1 colspan=1>Atlantis</td><td rowspan=1 colspan=1>3.24M</td><td rowspan=1 colspan=1>39.7k</td><td rowspan=1 colspan=1>64.76k</td><td rowspan=1 colspan=1>29.0k</td><td rowspan=1 colspan=1>3.3M</td><td rowspan=1 colspan=1>5.1M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>DemonAttack</td><td rowspan=1 colspan=1>11.1k</td><td rowspan=1 colspan=1>3.8k</td><td rowspan=1 colspan=1>9.7k</td><td rowspan=1 colspan=1>3.4k</td><td rowspan=1 colspan=1>2.0M</td><td rowspan=1 colspan=1>19.9M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>Centipede</td><td rowspan=1 colspan=1>7.3k</td><td rowspan=1 colspan=1>6.4k</td><td rowspan=1 colspan=1>4.1k</td><td rowspan=1 colspan=1>12.0k</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>4.2M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>BankHeist</td><td rowspan=1 colspan=1>0.72k</td><td rowspan=1 colspan=1>0.34k</td><td rowspan=1 colspan=1>0.72k</td><td rowspan=1 colspan=1>0.72k</td><td rowspan=1 colspan=1>2.1M</td><td rowspan=1 colspan=1>10.1M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>CrazyClimber</td><td rowspan=1 colspan=1>124k</td><td rowspan=1 colspan=1>84k</td><td rowspan=1 colspan=1>102k</td><td rowspan=1 colspan=1>35.4k</td><td rowspan=1 colspan=1>0.12M</td><td rowspan=1 colspan=1>2.1M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>ChopperCommand</td><td rowspan=1 colspan=1>72.5k</td><td rowspan=1 colspan=1>0.5k</td><td rowspan=1 colspan=1>4.6 k</td><td rowspan=1 colspan=1>9.9k</td><td rowspan=1 colspan=1>4.4M</td><td rowspan=1 colspan=1>2.2M</td><td rowspan=1 colspan=1>40M</td></tr><tr><td rowspan=1 colspan=1>Enduro</td><td rowspan=1 colspan=1>1.12k</td><td rowspan=1 colspan=1>0.38k</td><td rowspan=1 colspan=1>0.32k</td><td rowspan=1 colspan=1>0.31</td><td rowspan=1 colspan=1>0.82M</td><td rowspan=1 colspan=1>0.8M</td><td rowspan=1 colspan=1>30M</td></tr><tr><td rowspan=1 colspan=1>Pong</td><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>18.82</td><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>9.3</td><td rowspan=1 colspan=1>1.2M</td><td rowspan=1 colspan=1>2.4M</td><td rowspan=1 colspan=1>5M</td></tr></table>",
+        "bbox": [
+            191,
+            555,
+            808,
+            837
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Comparison of scores and sample complexities(scores in the first two columns are average of 100 consecutive episodes). $S C$ represents the number of samples the BDQN requires to bit the human score (Mnih et al., 2015)(“ − ” means BDQN could not bit) and $S C ^ { \\dagger }$ is the number number of samples the BDQN requires to bit the score of DDQN †. ",
+        "bbox": [
+            173,
+            853,
+            825,
+            910
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work we proposed BDQN, a practical TS based RL algorithm which provides targeted exploration in a computationally efficient manner. It involved making simple modifications to the DDQN architecture by replacing the last layer with a Bayesian linear regression. Under the Gaussian prior, we obtained fast closed-form updates for the posterior distribution. We demonstrated significantly faster training and enormously better rewards over a strong baseline DDQN. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            203
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This suggests that BDQN can benefit even more from further modifications to DQN such as e.g. Prioritized Experience Replay (Schaul et al., 2015), Dueling approach (Wang et al., 2015), A3C (Mnih et al., 2016), safe exploration (Lipton et al., 2016a), and etc. We plan to explore the benefit of these modifications up to small changes in the future. We also plan to combine strategies that incorporate uncertainty over model parameters with BDQN. In RL, policy gradient (Sutton et al., 2000; Kakade, 2002; Schulman et al., 2015) is another approach which directly learn the policy. In practical policy gradient, even though the optimal policy, given Markovian assumption, needs to be deterministic, the policy regularization is a dominant approach to make the policy stochastic and preserve the exploration thorough the stochasticity of the policy (Neu et al., 2017; Schulman et al., 2017). We plan to explore the advantage of TS based exploration instead of regularizing the policy and make it stochastic. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yasin Abbasi-Yadkori and Csaba Szepesvári. Bayesian optimal control of smoothly parameterized systems. In UAI, pp. 1–11, 2015. ",
+        "bbox": [
+            176,
+            125,
+            823,
+            151
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc Abeille and Alessandro Lazaric. Linear thompson sampling revisited. In AISTATS 2017-20th International Conference on Artificial Intelligence and Statistics, 2017. ",
+        "bbox": [
+            176,
+            161,
+            823,
+            188
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Abel, Alekh Agarwal, Fernando Diaz, Akshay Krishnamurthy, and Robert E Schapire. Exploratory gradient boosting for reinforcement learning in complex domains. arXiv, 2016. ",
+        "bbox": [
+            174,
+            196,
+            821,
+            224
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shipra Agrawal and Navin Goyal. Analysis of thompson sampling for the multi-armed bandit problem. In COLT, 2012. ",
+        "bbox": [
+            173,
+            232,
+            823,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shipra Agrawal and Randy Jia. Posterior sampling for reinforcement learning: worst-case regret bounds. arXiv, 2017. ",
+        "bbox": [
+            174,
+            268,
+            825,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "András Antos, Csaba Szepesvári, and Rémi Munos. Learning near-optimal policies with bellman-residual minimization based fitted policy iteration and a single sample path. Machine Learning, 2008. ",
+        "bbox": [
+            173,
+            305,
+            823,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Auer. Using confidence bounds for exploitation-exploration trade-offs. Journal of Machine Learning Research, 2002. ",
+        "bbox": [
+            173,
+            340,
+            823,
+            368
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Gheshlaghi Azar, Ian Osband, and Rémi Munos. Minimax regret bounds for reinforcement learning. arXiv preprint arXiv:1703.05449, 2017. ",
+        "bbox": [
+            173,
+            377,
+            825,
+            404
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kamyar Azizzadenesheli, Alessandro Lazaric, and Animashree Anandkumar. Reinforcement learning of pomdps using spectral methods. In Proceedings of the 29th Annual Conference on Learning Theory (COLT), 2016a. ",
+        "bbox": [
+            173,
+            414,
+            823,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kamyar Azizzadenesheli, Alessandro Lazaric, and Animashree Anandkumar. Reinforcement learning in rich-observation mdps using spectral methods. arXiv preprint arXiv:1611.03907, 2016b. ",
+        "bbox": [
+            174,
+            449,
+            821,
+            477
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter L. Bartlett and Ambuj Tewari. REGAL: A regularization based algorithm for reinforcement learning in weakly communicating MDPs. In Proceedings of the 25th Annual Conference on Uncertainty in Artificial Intelligence, 2009. ",
+        "bbox": [
+            173,
+            486,
+            823,
+            525
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gábor Bartók, Dean P Foster, Dávid Pál, Alexander Rakhlin, and Csaba Szepesvári. Partial monitoring—classification, regret bounds, and algorithms. Mathematics of Operations Research, 2014. ",
+        "bbox": [
+            173,
+            534,
+            823,
+            561
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, pp. 1471–1479, 2016. ",
+        "bbox": [
+            173,
+            570,
+            825,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 2013. ",
+        "bbox": [
+            171,
+            618,
+            823,
+            647
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ronen I Brafman and Moshe Tennenholtz. R-max-a general polynomial time algorithm for near-optimal reinforcement learning. The Journal of Machine Learning Research, 3:213–231, 2003. ",
+        "bbox": [
+            173,
+            655,
+            823,
+            683
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016. ",
+        "bbox": [
+            173,
+            690,
+            823,
+            718
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olivier Chapelle and Lihong Li. An empirical evaluation of thompson sampling. In Advances in neural information processing systems, pp. 2249–2257, 2011. ",
+        "bbox": [
+            171,
+            728,
+            823,
+            755
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. Mxnet: A flexible and efficient machine learning library for heterogeneous distributed systems. arXiv, 2015. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            803
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christoph Dann, Tor Lattimore, and Emma Brunskill. Ubev-a more practical algorithm for episodic rl with near-optimal pac and regret guarantees. arXiv preprint arXiv:1703.07710, 2017. ",
+        "bbox": [
+            173,
+            811,
+            823,
+            839
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, et al. Noisy networks for exploration. arXiv preprint arXiv:1706.10295, 2017. ",
+        "bbox": [
+            173,
+            848,
+            823,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In international conference on machine learning, 2016. ",
+        "bbox": [
+            171,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Ghavamzadeh, Shie Mannor, Joelle Pineau, Aviv Tamar, et al. Bayesian reinforcement learning: A survey. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Machine Learning, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            131
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aditya Gopalan and Shie Mannor. Thompson sampling for learning parameterized markov decision processes. In COLT, 2015. ",
+        "bbox": [
+            173,
+            138,
+            823,
+            166
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas Jaksch, Ronald Ortner, and Peter Auer. Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 2010. ",
+        "bbox": [
+            174,
+            174,
+            823,
+            202
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nan Jiang, Akshay Krishnamurthy, Alekh Agarwal, John Langford, and Robert E Schapire. Contextual decision processes with low bellman rank are pac-learnable. arXiv, 2016. ",
+        "bbox": [
+            174,
+            208,
+            821,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sham M Kakade. A natural policy gradient. In Advances in neural information processing systems, 2002. ",
+        "bbox": [
+            176,
+            243,
+            799,
+            258
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Kearns and Satinder Singh. Near-optimal reinforcement learning in polynomial time. Machine Learning, 49(2-3):209–232, 2002. ",
+        "bbox": [
+            173,
+            266,
+            825,
+            294
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michail G Lagoudakis and Ronald Parr. Least-squares policy iteration. Journal of machine learning research, 4 (Dec):1107–1149, 2003. ",
+        "bbox": [
+            174,
+            301,
+            823,
+            329
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nir Levine, Tom Zahavy, Daniel J Mankowitz, Aviv Tamar, and Shie Mannor. Shallow updates for deep reinforcement learning. arXiv preprint arXiv:1705.07461, 2017. ",
+        "bbox": [
+            173,
+            337,
+            823,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine et al. End-to-end training of deep visuomotor policies. JMLR, 2016. ",
+        "bbox": [
+            174,
+            371,
+            668,
+            386
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zachary C Lipton, Jianfeng Gao, Lihong Li, Jianshu Chen, and Li Deng. Combating reinforcement learning’s sisyphean curse with intrinsic fear. arXiv preprint arXiv:1611.01211, 2016a. ",
+        "bbox": [
+            173,
+            393,
+            823,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zachary C Lipton, Jianfeng Gao, Lihong Li, Xiujun Li, Faisal Ahmed, and Li Deng. Efficient exploration for dialogue policy learning with bbq networks & replay buffer spiking. arXiv preprint arXiv:1608.05081, 2016b. ",
+        "bbox": [
+            173,
+            429,
+            823,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 2015. ",
+        "bbox": [
+            176,
+            463,
+            825,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, 2016. ",
+        "bbox": [
+            174,
+            511,
+            823,
+            551
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gergely Neu, Anders Jonsson, and Vicenç Gómez. A unified view of entropy-regularized markov decision processes. arXiv, 2017. ",
+        "bbox": [
+            173,
+            559,
+            823,
+            587
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Will Night. The AI that cut google’s energy bill could soon help you. MIT Tech Review, 2016. ",
+        "bbox": [
+            173,
+            594,
+            732,
+            609
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brendan O’Donoghue, Ian Osband, Remi Munos, and Volodymyr Mnih. The uncertainty bellman equation and exploration. arXiv preprint arXiv:1709.05380, 2017. ",
+        "bbox": [
+            173,
+            617,
+            823,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Osband, Dan Russo, and Benjamin Van Roy. (more) efficient reinforcement learning via posterior sampling. In Advances in Neural Information Processing Systems, 2013. ",
+        "bbox": [
+            173,
+            651,
+            823,
+            679
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Osband, Benjamin Van Roy, and Zheng Wen. Generalization and exploration via randomized value functions. arXiv, 2014. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            714
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped dqn. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            174,
+            722,
+            823,
+            750
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Osband, Daniel Russo, Zheng Wen, and Benjamin Van Roy. Deep exploration via randomized value functions. arXiv preprint arXiv:1703.07608, 2017. ",
+        "bbox": [
+            173,
+            756,
+            823,
+            784
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yi Ouyang, Mukul Gagrani, Ashutosh Nayyar, and Rahul Jain. Learning unknown markov decision processes: A thompson sampling approach. In Advances in Neural Information Processing Systems, pp. 1333–1342, 2017. ",
+        "bbox": [
+            173,
+            791,
+            823,
+            819
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Carl Edward Rasmussen and Christopher KI Williams. Gaussian processes for machine learning, volume 1. MIT press Cambridge, 2006. ",
+        "bbox": [
+            171,
+            827,
+            823,
+            854
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Russo and Benjamin Van Roy. Learning to optimize via posterior sampling. Mathematics of Operations Research, 39(4):1221–1243, 2014. ",
+        "bbox": [
+            174,
+            862,
+            823,
+            888
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Russo, Benjamin Van Roy, Abbas Kazerouni, and Ian Osband. A tutorial on thompson sampling. arXiv preprint arXiv:1707.02038, 2017. ",
+        "bbox": [
+            171,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv, 2015. ",
+        "bbox": [
+            169,
+            103,
+            807,
+            119
+        ],
+        "page_idx": 11
+    },
+    {
+        "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), 2015. ",
+        "bbox": [
+            173,
+            127,
+            821,
+            154
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Pieter Abbeel, and Xi Chen. Equivalence between policy gradients and soft q-learning. arXiv, 2017. ",
+        "bbox": [
+            173,
+            161,
+            823,
+            189
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shai Shalev-Shwartz, Shaked Shammah, and Amnon Shashua. Safe, multi-agent, reinforcement learning for autonomous driving. arXiv, 2016. ",
+        "bbox": [
+            173,
+            196,
+            821,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017. ",
+        "bbox": [
+            173,
+            232,
+            823,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jasper Snoek, Oren Rippel, Kevin Swersky, Ryan Kiros, Nadathur Satish, Narayanan Sundaram, Mostofa Patwary, Mr Prabhat, and Ryan Adams. Scalable bayesian optimization using deep neural networks. In International Conference on Machine Learning, pp. 2171–2180, 2015. ",
+        "bbox": [
+            174,
+            280,
+            823,
+            320
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander L. Strehl, Lihong Li, and Michael L. Littman. Reinforcement learning in finite mdps: Pac analysis. J. Mach. Learn. Res., 2009. ",
+        "bbox": [
+            171,
+            328,
+            823,
+            354
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Malcolm Strens. A bayesian framework for reinforcement learning. In ICML, pp. 943–950, 2000. ",
+        "bbox": [
+            171,
+            363,
+            753,
+            377
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998. ",
+        "bbox": [
+            173,
+            386,
+            825,
+            412
+        ],
+        "page_idx": 11
+    },
+    {
+        "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, 2000. ",
+        "bbox": [
+            173,
+            420,
+            825,
+            460
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Haoran Tang, Rein Houthooft, Davis Foote, Adam Stooke, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. # exploration: A study of count-based exploration for deep reinforcement learning. arXiv, 2016. ",
+        "bbox": [
+            173,
+            468,
+            823,
+            507
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Georgios Theocharous, Zheng Wen, Yasin Abbasi-Yadkori, and Nikos Vlassis. Posterior sampling for large scale reinforcement learning. arXiv preprint arXiv:1711.07979, 2017. ",
+        "bbox": [
+            173,
+            517,
+            823,
+            544
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "William R Thompson. On the likelihood that one unknown probability exceeds another in view of the evidence of two samples. Biometrika, 1933. ",
+        "bbox": [
+            173,
+            551,
+            823,
+            579
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double q-learning. In AAAI, 2016. ",
+        "bbox": [
+            174,
+            587,
+            823,
+            614
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Tom Schaul, Matteo Hessel, Hado Van Hasselt, Marc Lanctot, and Nando De Freitas. Dueling network architectures for deep reinforcement learning. arXiv, 2015. ",
+        "bbox": [
+            173,
+            622,
+            823,
+            650
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Learning rate: It is well known that DQN and DDQN are sensitive to the learning rate and change of learning rate can degrade the performance to even worse than random policy. We tried the same learning rate as BDQN, 0.0025, for DDQN and observed that its performance drops. Fig. 3 shows that the DDQN with higher learning rates learns as good as BDQN at the very beginning but it can not maintain the rate of improvement and degrade even worse than the original DDQN. ",
+        "bbox": [
+            174,
+            132,
+            823,
+            202
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/31dc42fcfa19a93b955e649f0216400882de7b1e6a3e4dafd097d7be7e5ed169.jpg",
+        "image_caption": [
+            "Figure 3: Effect of learning rate on DDQN "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            339,
+            215,
+            656,
+            393
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Computational and sample cost comparison: For a given period of game time, the number of the backward pass in both BDQN and DQN are the same where for BDQN it is cheaper since it has one layer (the last layer) less than DQN. In the sense of fairness in sample usage, for example in duration of $1 0 \\cdot T ^ { B a \\dot { y } e s \\ t a r g e t } = 1 0 0 k$ , all the layers of both BDQN and DQN, except the last layer, see the same number of samples, but the last layer of BDQN sees 16 times fewer samples compared to the last layer of DQN. The last layer of DQN for a duration of $1 0 0 k$ , observes $2 5 k = 1 0 0 k / 4$ (4 is back prob period) mini batches of size 32, which is $1 6 \\cdot 1 0 0 k$ , where the last layer of BDQN just observes samples size of $B = 1 0 0 k$ . As it is mentioned in Alg. 1, to update the posterior distribution, BDQN draws $B$ samples from the replay buffer and needs to compute the feature vector of them. This step of BDQN gives a superiority to DQN in the sense of speed which is almost $7 0 \\%$ faster than BDQN (DQN, on average, for the update does full forward and backward passes while BDQN does not do backward path on the last layer but needs an extra forward pass in order to compute the feature representation). One can easily relax this limitation by parallelizing this step with the main body of BDQN or deploying on-line posterior update methods. ",
+        "bbox": [
+            173,
+            449,
+            826,
+            643
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Thompson sampling frequency: The choice of TS update frequency can be crucial from domain to domain. If one chooses $T ^ { s a \\dot { m } p l e }$ too short, then computed gradient for backpropagation of the feature representation is not going to be useful since the gradient get noisier and the loss function is changing too frequently. On the other hand, the network tries to find a feature representation which is suitable for a wide range of different weights of the last layer, results in improper use of model capacity. If the TS update frequency is too low, then it is far from being TS and losses randomized exploration property. The current choice of $T ^ { s a m p l e }$ is suitable for a variety of Atari games since the length of each episode is in range of $\\mathcal { O } ( T ^ { s a m p l e } )$ and is infrequent enough to make the feature representation robust to big changes. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            784
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the RL problems with shorter horizon we suggest to introduce two more parameters, T˜sample and $\\tilde { W }$ where $\\tilde { T } ^ { s a m p l e }$ , the period that of $\\tilde { W }$ is sampled our of posterior, is much smaller than $T ^ { s a m p l e }$ and $\\tilde { W }$ is being used just for making TS actions while $W$ is used for backpropagation of feature representation. For game Assault, we tried using $\\tilde { T } ^ { s a m p l e }$ and $\\tilde { W }$ but did not observe much a difference, and set them to $\\mathbf { \\chi } _ { T } s a m p l e$ and $W$ . But for RL setting with a shorter horizon, we suggest using them. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            881
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Further investigation in Atlantis: After removing the maximum episode length limit for the game Atlantis, BDQN gets the score of 62M. This episode is long enough to fill half of the replay buffer and make the model perfect for the later part of the game but losing the crafted skill for the beginning of the game. We observe in Fig. 4 that after losing the game in a long episode, the agent forgets a bit of its skill and loses few games but wraps up immediately and gets to score of $3 0 M$ . To overcome this issue, one can expand the replay buffer size, stochastically store samples in the reply buffer where the later samples get stored with lowers chance, or train new models for the later parts of the episode. There are many possible cures for this interesting observation and while we are comparing against DDQN, we do not want to advance BDQN structure-wise. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            826,
+            202
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1bf647dc60e92f579a32a018f48a8523c1e357a548289efbfc73d61e5ed61ac.jpg",
+        "image_caption": [
+            "Figure 4: BDQN on Atlantis after removing the limit on max of episode length "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            339,
+            217,
+            658,
+            398
+        ],
+        "page_idx": 13
+    }
+]

parse/train/SJl7DsR5YQ/SJl7DsR5YQ.md

@@ -0,0 +1,290 @@
+# RENEG AND BACKSEAT DRIVER: LEARNING FROMDEMONSTRATION WITH CONTINUOUS HUMAN FEED-BACK
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In autonomous vehicle (AV) control, requiring an agent to make mistakes, or even allowing mistakes, can be quite dangerous and costly in the real world. For this reason we investigate methods of training an AV without allowing the agent to explore and instead having a human explorer collect the data. Supervised learning has been explored for AV control, but it encounters the issue of the covariate shift. That is, training data collected from an optimal demonstration consists only of the states induced by the optimal control policy, but at runtime, the trained agent may encounter a vastly different state distribution and has seen little relevant training data. To mitigate this issue, we intentionally have our human explorer make sub-optimal decisions. In order to have our agent not replicate these suboptimal decisions, supervised learning requires that we either erase these actions, or replace these action with the correct action. Erasing these actions is wasteful and replacing these actions is difficult, since it is not easy to know the correct action without driving the car. Since supervised learning falls short, we introduce an alternate framework that includes continuous scalar feedback on each action, marking which actions we should replicate, which we should avoid, and how sure of this we are. Our framework, called “ReNeg”, learns from from human demonstration and human evaluative feedback, collected entirely before any training begins. Our agent learns continuous control from sub-optimal behavior, but sub-optimal behavior that is safely performed by a human. We find that a human demonstrator can explore sub-optimal states in a safe and controlled manner, while still getting enough gradation in the states to benefit learning. The way we collect data and the algorithm we use to compute feedback on the data we call “Backseat Driver.” Backseat Driver gives us state-action pairs matched with scalar values representing the score for those action in those states. We call the more general learning framework ReNeg, since it learns a regression from states to actions given negative as well as positive examples. We empirically validate several models in the ReNeg framework, testing on lane-following with limited data. We find that the best solution is a generalization of mean-squared error and outperforms supervised learning on the positive examples alone.
+
+# 1 PROBLEM FORMULATION
+
+We seek a way learn autonomous vehicle control using only RGB input from a front-facing camera. (Example input image in the appendix.) Specifically, we want to produce a policy network to map states to actions in order to follow a lane as close to center as possible. We would like the agent to behave optimally in dangerous situations, and recover to safe situations. For this to happen, the data the agent trains on must include these sub-optimal states. However, we do not want to leave the safety determination up to any machine. Thus, we require that a human explorer take all the actions. This is referred to as “Learning from Demonstration” or LfD. An expert human does the exploration and thus can limit the danger by controlling how dangerous the negative examples are (i.e. the human can swerve to show suboptimal driving but never drive off the road, as an RL agent likely would). Still, in order to get into sub-optimal states, the explorer will need to take sub-optimal actions. Ideally we could replace these sub-optimal actions with labels corresponding to the correct and optimal actions to take so we could perform supervised learning, which provides the strongest signal. However, it is notoriously difficult to assign supervised labels to driving data because it is hard to know the correct steering angle to control a vehicle when your steering has no effect on what happens to the vehicle (Ross et al., 2012). Instead of trying to enable humans to assign supervised labels by somehow showing the consequences of their actions, we focus on letting humans assign feedback that evaluates the sub-optimal actions, without actually representing the optimal action.
+
+Thus our goal is to learn a deterministic continuous control policy from demonstration, including both good and bad actions and continuous scores representing this valence. Our problem statement is somewhere in between supervised learning and RL: we focus on a general approach that is capable of mapping continuous sensor input to an arbitrary (differentiable) continuous policy output and capable of using feedback for singular predetermined actions. Our problem falls within the supervised setting since our agent cannot chose want actions to take, in order to avoid the agent exploring dangerous states, and all data collection is done prior to training. However, we also wish to incorporate evaluative scalar feedback given to each data point, which traditionally falls under the RL framework. We refer to this problem setting as the ReNeg framework, since we are essentially performing a regression with scalar weights attached to each data point, that can be positive and negative. For the demonstration, a human demonstrator drives, yielding state-action pairs the agent can learn from. In order to teach the agent which actions are good or bad, an expert critic, or “backseat driver,” labels the actions with a continuous scalar.
+
+For a viable solution to this problem, we need to define a loss function that induces an effective and robust policy. We also need to choose what driving data to collect to expose the agent to a variety of good and bad states, and in particular show the agent how to get out of bad states where an accident is imminent. What data to collect is non-obvious: we want to explore a range of good and bad states so the agent learns a reasonable policy for how to act in all kinds of states. However, to make this feasible in the real world, we want to avoid exploring dangerous states. Finally, we need to carefully choose a way to collect human feedback that contains signal from which the agent can learn, but is not too hard to collect. We will discuss the choices we made for these three parts of the problem in the Loss Function, Driving Data, and Feedback sections respectively. Although we validate in simulation, specifically Unity, for the sake of ease, the algorithms we test could be easily trained in the real world.
+
+# 2 RELATED WORK
+
+Learning from demonstration has mostly been studied in the supervised learning framework and the Markov Decision Process (MDP) framework. In the former, it is generally known as imitation learning (or behavioral cloning in the AV setting), and in the latter, it is generally known as apprenticeship learning. There are other relevant RL algorithms, but none for LfD in our problem setting, as we will show.
+
+The supervised learning in this area has focused on a least squares regression that maps from an input state to action. The easiest approach to take here is to have an expert perform an optimal demonstration, and then simply use that as training data. The main issue here is that the runtime and training distributions can be vastly different. That is, once the trained agent is acting on its own after training and encounters states it has not seen, it does not know how to act, and strays further from the intended behavior. This problem is known as the Covariate Shift and the widely accepted solution generally follow the approach laid out in DAgger Ross et al. (2010). DAgger allows the agent to explore and then uses the expert to label the new dataset, then training on all of the combined data. Such an approach has even been improved upon both to address scalar feeddback by incorporating experts that can label $Q$ values with the AggreVaTeD algorithm (Ross & Bagnell, 2014), and to and to address deep neural networks by finding a policy gradient with the Deeply AggreVaTeD algorithm (Sun et al., 2017). However, these DAgger based policies require the agent to ex-plore and make mistakes.
+
+The MDP research on apprenticeship learning has largely been on inverse reinforcement learning, or IRL (Abbeel & $\mathrm { N g }$ , 2004), in which a reward function is estimated given the demonstration of an expert. However, often in this framework, the reward function is restricted to the class of linear combinations of the discrete features of the state, and the framework only allows for positive examples. In addition, there has been work on inverse reinforcement learning from failure (Shiarlis et al., 2016), which allows for a sequence of positive or a sequence of negative examples. There is also distance minimization for reward learning from scored trajectories (Burchfiel et al., 2016), which allows for gradation in the scores, but does not allow for an arbitrary reward function on continuous inputs or labels for atomic actions as opposed to a trajectory or sequence of actions. Moreover, these IRL methods are not a candidate for our problem, since they require an exact MDP solution with a tractable transition function and exploration to find the optimal policy. The issue we have is not that we don’t have the reward function, but that even with the more informative feedback, we cannot use exploration to learn the optimal policy.
+
+It is interesting to note that there are off-policy RL algorithms as well, but we would like to highlight that this is not the same thing as LfD. LfD, as we use it, means that we have collected all of our data before training. This could be thought of as on-policy only if our policy and start state never changes. Whereas, off-policy RL (e.g. Off-Policy Actor-Critic(Degris et al., 2012), Q-Learning(Watkins & Dayan, 1992), Retrace(Munos et al., 2016)) generally requires agents to have a non-zero probability of choosing any action in any state, in order for the algorithm to converge. (Moreover, it is the somewhat parenthetical opinion of at least one of authors of this paper that in the off-policy policy gradient RL framework, using importance sampling to calculate an expectation over a different action distribution is fine, but changing the objective function from an expectation over the learned policy state-visitation distribution to an expectation over the behavior (exploratory) state-visitation distribution, as in (Degris et al., 2012), is an unsatisfactory answer that does not give the optimal policy for the agent when running on the learned policy, as we will want to do.) Normalized Actor Critic (NAC) does attempt to bridge the gap between off-policy and LfD, and works with bad as well as good demonstration, however, NAC does not allow for restricted exploration either, since it adds entropy to the objective function to encourage exploration (Gao et al., 2018). NAC has also only been done for discrete action control, not continuous as we want to do.
+
+Finally, there are many RL algorithms that use human evaluative feedback, but none for LfD. One RL algorithm with human feedback of note is COACH (MacGlashan et al., 2017), which is based on the stochastic policy gradient. COACH is an on-policy RL algorithm that uses human-feedback to label the agent’s actions while exploring. COACH’s view on human feedback helps us to draw connections to RL, as we will discuss later. However, COACH was designed for on-policy exploration and uses discrete feedback values of 1 and -1, whereas we generalize to continuous values in $[ - 1 , 1 ]$ . We cannot use a stochastic policy gradient in a justified manner, since we do not explore with a stochastic policy.
+
+Out of all the LfD work in the AV context, the most notable has either been on behavioral cloning (Bojarski et al., 2016) (Pan et al., 2017) or using IRL to solve sub-tasks such as driving preferences that act on top of a safely functioning trajectory planner (Kuderer et al., 2015). To the best of our knowledge, no research so far has focused on using any kind of evaluative scalar feedback provided by a human in the context of AV control with LfD. That is, no one has solved how to take states, actions, and continuous feedback with respect to those actions, and convert them into a control policy for an AV, without having the AV explore. We believe that this is a major oversight: many AV research groups are investing huge amounts of time into collecting driving data; if they used our model, they could improve performance simply by having an expert labeler sit in the car with the driver for no additional real time.
+
+# 3 OUR APPROACH
+
+# 3.1 LOSS FUNCTION
+
+Let $\theta$ be the steering angle in the demonstrated example; $\hat { \theta }$ the steering angle predicted by the policy network (or PNet); $D$ the absolute difference between $\theta$ and $\hat { \theta }$ , $| \theta - \hat { \theta } |$ ; and $f _ { \theta }$ , or $f$ , the feedback for the demonstrated angle. We collect $f \in [ - 1 , 1 ]$ . The loss function we choose should have the following 3 properties:
+
+1. Minimizing the loss should minimize the $\mathrm { D }$ for positive examples. That is, when $f > 0$ , $\begin{array} { r } { \frac { \partial L o s s } { \partial D } \geq 0 } \end{array}$ .   
+2. Minimizing the loss should maximize the distance between $\theta$ and $\hat { \theta }$ for negative examples. That is, when $f < 0$ ∂Loss ≤ 0.
+
+3. The rate at which the loss is minimized should be determined by the magnitude of the feedback. That is, when $f > 0$ , $\frac { \partial | L o s s | } { \partial f } > 0$ , and when $f < 0$ , $\frac { \partial | L o s s | } { \partial f } < 0$
+
+These three properties together ensure that the network avoids the worst negative examples as much as possible, while seeking the best examples. Given an input state $s$ , the first loss function that comes to mind is what we term “scalar loss”:
+
+$$
+L o s s _ { s c a l a r } = f _ { s } * ( \theta _ { s } - \hat { \theta } ( s ) ) ^ { 2 }
+$$
+
+This loss function is notable for several reasons. First, it is a generalization of mean squared error, the standard behavioral cloning loss function:
+
+$$
+L o s s _ { M S E } = ( \theta _ { s } - \hat { \theta } ( s ) ) ^ { 2 }
+$$
+
+Mean squared error is a well-principled loss function if you assume Gaussian noise in your training data. That is, you assume the probability of your data can be given by Gaussian noise around some mean and you learn to predict $\hat { \theta }$ as that mean. Given this assumption, you can derive MSE as the loss that produces a maximum likelihood estimate for your parameters. Let the parameters of the model be represented by $p$ and probability be $P r$ . $\hat { \theta }$ is parameterized by $p$ and will be used interchangeably with $\hat { \theta } _ { p }$ , when clarity is needed. Please note that $\theta$ refers to the angle label, and not the model parameters:
+
+$$
+\begin{array} { r l } & { \quad \mathrm { a g m a x } _ { p } \gamma ^ { n } \left( \ell \mathrm { d } t \right) d t } \\ & { \quad \mathrm { ~ u p p r o v e ~ } \displaystyle \prod _ { \ell = 0 < \ell \in \mathcal { N } _ { \ell } } \mathrm { e r } ( \theta | \hat { \theta } _ { \ell } ^ { ( \ell ) } ) } \\ & { \quad \mathrm { a f ~ a n d ~ } \displaystyle \sum _ { \ell = 0 } ^ { \infty } \mathrm { e r } ( \theta | P _ { \ell } ^ { \ell } ( \ell \hat { \theta } _ { \ell } ^ { ( \ell ) } ) ) } \\ & { \quad \mathrm { a f ~ a n d ~ } \displaystyle \sum _ { \ell = 0 } ^ { \infty } \mathrm { e l } ( P r ( \ell \hat { \theta } _ { \ell } ^ { ( \ell ) } ) ) } \\ & { \quad \mathrm { a f ~ a n d ~ } \displaystyle \sum _ { \ell = 0 } ^ { \infty } \mathrm { e l } ( \theta | P r ( \ell \hat { \theta } _ { \ell } ^ { ( \ell ) } ) ) } \\ & { \quad \mathrm { a f ~ a n d ~ } \displaystyle \sum _ { \ell = 0 < \ell \in \mathcal { N } _ { \ell } } \mathrm { e r f } ( P \ell ) ( \theta | \hat { \theta } _ { \ell } ^ { ( \ell ) } ) } \\ & { \quad \mathrm { a f ~ a n d ~ } \displaystyle \sum _ { \ell = 0 < \ell \in \mathcal { N } _ { \ell } } \mathrm { e r f } ( P \ell ( \theta | \hat { \theta } _ { \ell } ^ { ( \ell ) } ) ) } \\ & { \quad \quad \mathrm { L o s s } - l o g ( P r ( \ell \hat { \theta } _ { \ell } ^ { ( \ell ) } ) ) } \\ & { \quad \quad \mathrm { L o s s } - l o g ( P r ^ { \ell } ( \ell \hat { \theta } _ { \ell } ^ { ( \ell ) } ) ) } \\ & { \quad \quad \mathrm { L o s s } - l o g ( P r ^ { \ell } ) } \\ & { \quad \quad \mathrm { R e t s } - l o g ( P r ^ { \ell } ) } \\ & { \quad \mathrm { o r s s } - \frac { ( \theta - l ) ^ { 2 } + ( l - 1 ) ! } { 2 } \mathrm { e r f } ( P \ell ) ^ { 2 } } \\ & { \quad \mathrm { o r s } - \frac { ( \theta - l ) ^ { 2 } + ( l - 1 ) ! } { 2 } \mathrm { e r f } ( P \ell ) ^ { 2 } } \end{array}
+$$
+
+Generally, $l o g ( \sqrt { 2 \pi \sigma ^ { 2 } } )$ is left out since it is a constant w.r.t. our parameters and so will go away when the gradient is taken, leaving:
+
+$$
+L o s s = \frac { ( \theta - \hat { \theta } ) ^ { 2 } } { 2 \sigma ^ { 2 } }
+$$
+
+Generally, $2 \sigma ^ { 2 }$ is also left out, since it only acts to scale the gradient, and can be accounted for by adjusting the learning rate of gradient descent, leaving:
+
+$$
+L o s s = ( \theta - \hat { \theta } _ { p } ) ^ { 2 }
+$$
+
+However, we note that, if we interpret $| f |$ , the magnitude of our feedback, as $\scriptstyle { \frac { 1 } { 2 \sigma ^ { 2 } } }$ , we can view $| f |$ as a measure of certainty. This certainly applies to a Gaussian distribution with a variance of at least $\frac { 1 } { 2 }$ , since $f \in ( 0 , 1 ]$ for positive examples. For negative examples, we generalize further by removing the magnitude calculation, and allowing our feedback to be negative. This enforces that we minimize the probability of negative data:
+
+$$
+L o s s = f * ( \theta - { \hat { \theta } } _ { p } ) ^ { 2 }
+$$
+
+To be able to easily recover behavioral cloning, we introduce two hyperparameters. The first such parameter is the ability to threshold feedback values. If we threshold, we simply replace every $f$ with $s i g n ( f )$ . Thresholding eliminates gradations in positive and negative data. Additionally, we introduced the parameter $\alpha$ , which scales down all our negative examples’ feedback: $f : =$ $m a x ( f , \alpha f )$ . This trades off between behavioral cloning and avoiding negative examples. We apply $m a x ( f , \alpha f )$ after we threshold, so if we threshold with and set $\alpha$ to 0.0, we recover behavioral cloning.
+
+Our scalar loss is also notable since it closely resembles a loss that induces a stochastic policy gradient. In a standard RL policy network such as REINFORCE, the gradient would be $\nabla _ { p } =$ $\nabla _ { p } ( Q ^ { \pi } ( \theta ) * - l o g ( P r ( \theta ) ) )$ (Williams, 1992). The loss then, that would induce this gradient is $\dot { L o s s } = Q ^ { \pi } ( \theta ) * - l o g ( P r ( \theta ) ) .$ $R$ , the return, or a sample contributing to $Q ^ { \pi } ( \theta )$ , is generally used. In continuous control, one could instead predict a mean $\hat { \theta }$ for a normal distribution and then sample your action $\theta$ from that normal distribution. As demonstrated above, if you replace $l o g ( P r ( \theta ) )$ with the probability density function for a normal distribution, the loss you wind up with is precisely MSE scaled by $R$ . Substituting this scalar into the derivation above at every step, you get:
+
+$$
+L o s s = R * ( \theta - \hat { \theta } ) ^ { 2 }
+$$
+
+A full derivation of this loss given the stochastic policy gradient and Gaussian policy can be found in the appendix. Clearly if we view $f _ { \theta }$ , our feedback, as $R _ { \hat { \theta } }$ and assume a Gaussian policy, we get our scalar loss function. COACH in fact points out that you can view online feedback given for the current policy, $f _ { \hat { \theta } }$ as a sample from $Q ^ { \pi } ( { \hat { \theta } } )$ , or $A ^ { \pi } ( { \hat { \theta } } )$ , the advantage function, and empirically verifies that this works for on-line RL with discrete feedback (MacGlashan et al., 2017). This similarity was useful for inspiration and ideation, but actually falls short of rigorous justification for two reasons. Since we are training off-policy, and, more specifically, on a pre-determined policy that does not explore stochastically and does not vary depending on the current predicted policy, we run into major issues justifying our loss this way.
+
+First, the main “off-policy” issue here is that for the stochastic policy gradient to hold, the exploration must be stochastic. However, in our case, the data is drawn from a pre-determined, deterministic policy. We can illuminate the intuition for why the stochastic policy gradient no longer works by considering a simple example. Consider the network attempting to learn the correct predicted $\hat { \theta }$ for a given state. Consider that there is only one demonstrated $\theta , - 1$ , with a feedback of $^ { - 1 }$ . Now, no matter what $\hat { \theta }$ the network predicts, the $\theta$ action that is taken during training will always be $^ { - 1 }$ , and the feedback will always be -1. Moreover, consider that the actual optimum is $\hat { \theta } = 1$ , and the network is currently predicting $\hat { \theta } = - 2$ . Using our scalar loss, the network will increase distance between $\theta$ and $\hat { \theta }$ by decreasing $\hat { \theta }$ , making the policy worse and worse. This would not happen when using a stochastic RL policy, since the network can explore states around the current predicted $\hat { \theta }$ by choosing appropriate actions.
+
+Using a stochastic RL policy, given enough samples on either side of $\hat { \theta }$ , the network will have larger and larger gradients, the more negative $\hat { \theta }$ is. But these gradients will not keeping “pushing” the prediction to the left of $^ { - 1 }$ , but rather will randomly cause $\hat { \theta }$ to move around, gradually moving to the right as it finds better feedback, and eventually converging at the optimum of $\hat { \theta } = 1$ . The network will move less “violently” and more “stably” the closer $\hat { \theta }$ gets to 0. And when the network eventually reaches the positive numbers, it might get “pulled” to the left a bit when it happens to sample a worse action, but it will not get pulled as strongly as when it samples a better action to the right. We can now intuitively see the issue: the neural network cannot not influence the probability of seeing an example again, which can lead to problems with learning the policy. In RL, a policy network can try a bad action, and then move the policy away from that action and not revisit it. On the other hand, if we have a bad example in our training set for a given state, on every epoch of training, our neural net will encounter this example and take a step away from it, thus pushing our network as far away from it as possible. Taking these steps is not necessarily helpful since the network may not have favored taking the bad action before.
+
+We could use some sort of importance sampling (Silver et al., 2014) (Degris et al., 2012), as is done with stochastic off-policy exploration, to scale down the loss for examples we are far away from. However, this would make our update have almost no effect when we are far away from positive examples, and with the deterministic exploration of ReNeg, the distinction between positive and negative examples now matters. We can’t have it both ways just by multiplying by the probability of $\hat { \theta }$ given our model. (This happens since the Gaussian PDF decreases exponentially with difference $| \theta - \hat { \theta } |$ , but the loss only increases quadratically with the difference, due to the logarithm. Thus the gradient tends toward 0 due to the differing rates of growth, as the difference gets large.) Moreover, importance sampling consistently reduced performance for learning from demonstration in the NAC paper (Gao et al., 2018).
+
+Another, perhaps less significant issue, is that our feedback represents $Q *$ , and not $Q \pi$ . Even if the human critic could re-assigned labels as the agent trains, he/she would have no way to sample the return from $Q \pi$ , without letting the agent explore freely. This is significant because an action that is optimal for the expert may be a dangerous and poor decision for a non-optimal policy. This is perhaps less significant than the other issue, since there are no actions in our data that could be considered both good and risky. What is good for one policy (i.e. steering back to the middle of the road) is generally good for all policies, and so can act rather greedily with respect to $Q *$ , even though it will not always be following the optimal policy.
+
+For these reasons, we find the comparison to stochastic policy gradients useful, but ultimately uncompelling. Applying RL losses to supervised learning does not provide the mathematical justification we need. The stochastic policy gradient is no longer computing the gradient of the current policy at all. Thus, we focus primarily on extending and generalizing MSE. Yet, we can still learn from the policy gradient comparison. In particular, we acknowledge that the sign of our feedback is far more significant than it was in the RL context (which is one of the reasons we introduce the $\alpha$ parameter, which scales down the importance of negative examples, in the event that we collect too many negative examples). In RL, using the stochastic policy gradient, it did not matter if negative examples “pulled” $\hat { \theta }$ closer to them, so long as the positive examples pulled $\hat { \theta }$ more, since you would eventually try one of those actions, if it is a nearby optimum. However, since actions are no longer sampled dependent on the current policy, suddenly the sign matters very much. In fact, even if we have a positive example for a state, if we have more negative examples than positive examples, we may wind up ignoring our positive examples entirely in an effort to get away from our negative examples. This case highlights the trouble inherent in using negative examples: It is hard to know how and when to take into account the negative examples.
+
+![](images/fb2ebe93034a8728e91f71cf7b05a5a5d1ec491f956ee488e95c1d04b1a52cd2.jpg)  
+Figure 1: Potential outcomes of regression with negative examples
+
+Now, let us consider negative examples in the ReNeg framework. For example, as shown in Figure 1, if we perform a regression on positive and negative examples with more negative examples than positive in one state, we may wind up in a case where our loss is minimized by a prediction of positive or negative infinity, and thus our regression is “overwhelmed” by the negative examples. This led us to our second “exponential” loss:
+
+$$
+L o s s _ { e x p } = | \theta ( s ) - \hat { \theta } ( s ) | ^ { 2 f }
+$$
+
+Using this loss, negative examples will have infinite loss at distance 0, and then drop off exponentially with distance. We hope that this will create regressions more akin to the second image in Figure 1. In this image, adding more negative points will still nudge the regression away more and more, but one positive point not too close by should be enough to prevent it from diverging to positive or negative infinity. It should be noted that the loss in a particular state still could only have negative examples, especially in a continuous state-space like ours where states are unlikely to be revisited. However, the reduction in loss caused by diverging to infinity would be so small that it should not happen simply due to continuity with nearby states enforced by the structure of the network. In addition, one concern with this loss could be that for positive fractional differences, and negative non-fractional differences, the desired property 3) of loss functions no longer holds. That is, our positive loss will not grow with $f$ if the difference being exponentiated is a fraction. And for negative exponents, the loss will only grow if the difference is a fraction that shrinks as it is raised to increasing powers of $f$ . However, we hope that for negative examples, distances that are more than 1 unit away will not occur often (since 1 unit is half the distance range). We discuss a potential future solution in the appendix to patch this loss function.
+
+Our final loss function should produce regressions more like the final image in Figure 1: We propose directly modelling the feedback with another neural network (which we call the FNet) for use as a loss function for our PNet. If this FNet is correctly able to learn to copy how we label data with feedback, it could be used as a loss function for regression with our PNet. Thus, in order to maximize feedback, our loss function would be as follows:
+
+$$
+L o s s _ { F N e t } = - F N e t ( s , \hat { \theta } )
+$$
+
+After learning this FNet, we can either use it as a loss function to train a policy network or, every time we want to run inference, we can run a computationally expensive gradient descent optimization to pick the best action. Because the latter does not depend on the training distribution (so we do not have the issue of the runtime and training distributions being different), and it is more efficient, we choose an even easier version of the latter: we pick the best action out of a list of discrete options according to the FNet’s predictions. One feature of the FNet is that adding more negative points will not “push” our regression further away from this point, but rather just make our FNet more confident of the negative feedback there. This may not be the desired effect for all applications. Moreover, the FNet cannot operate on purely positive points with no gradation. That is, behavioral cloning cannot be recovered from it.
+
+# 3.2 DRIVING DATA
+
+We recorded 20 minutes of optimal driving and labeled all of this data with a feedback of 1.0. Choosing the suboptimal data and how to label it was a bit more tricky. One reason that we are not using reinforcement learning is that letting the car explore actions is dangerous. In this vein, we wanted to collect data only on “safe” driving. However, the neural network needs data that will teach it about bad actions well as good actions that recover the car from bad states. In order to explore these types of states and actions, we collected two types of bad driving: “swerving” and “lane changing”. The first image in Figure 2 is swerving. In swerving, the car was driving in a “sine wave” pattern on either side of the road. We collected 10 minutes of this data on the right side of the road and 10 minutes on the left. The second image is lane changing. For this, we drove to the right side of the road, straightened out, stayed there, and then returned to the middle. We repeated this for 10 minutes, and then collected 10 minutes on the left-hand side as well.
+
+![](images/76638594e8208c5c80fa3207610f2c272ae96ecfca3d5ca19113bcec62dcfb5b.jpg)  
+Figure 2: Types of driving: swerving (left), lane change (right)
+
+# 3.3 “BACKSEAT DRIVER” FEEDBACK
+
+Backseat Driver is the framework we use to compute and collect   
+feedback in the AV context. Our feedback includes much more information than just a reward (as is used in RL): we take our label to directly measure how “good” an action is relative to other possible actions. We use this approach instead of labeling rewards for actions both because we found it an easy way to label data with feedback, and because it contains more signal. How exactly to label the data with feedback, however, is non-obvious. At first, we considered labeling using a slider from -1 to 1. However, using a slider can be non-intuitive in many cases and there would be discontinuities in feedback you would want to give. For example, if the demonstrator is driving straight off the road and then starts to turn left back onto the road, there would be a large discontinuity in the very negative and then slightly positive feedback.
+
+In order to circumvent these issues, and to make the labeling process more intuitive, we decided to collect feedback using the steering wheel. We found that it is easier for people to focus on the steering angle, since that is how we are used to controlling cars. Our first thought was to just turn the steering wheel to the correct angle. However, this is very difficult to estimate, especially on turns, when you cannot see the actual effects your steering is having on the car. (Note that if we did this, our algorithm would turn into behavioral cloning.) Instead, we decided to label the differential. That is, we turned the wheel to the left if the car should steer more left. This signal shows where the error is (i.e. “You should be turning more” or “You’re turning the wrong way”). Note that the label does not need to be the exact correct angle; it just needs to show in which direction the current action is erring, and proportionally how much. We call this method of human feedback collection “Backseat Driver.” In order to process the angle labels into a feedback value in $[ - 1 , 1 ]$ , we used the equation below:
+
+$$
+\begin{array} { r l } & { \Xi \mathrm { E D B A C K } ( c , \theta ) } \\ & { \quad \mathrm { i f ~ s i g n } ( c ) = = \mathrm { s i g n } ( \theta ) \mathrm { o r } \left| c \right| \le \epsilon } \\ & { \qquad \mathrm { r e t u r n } \ 1 - \left| c \right| } \\ & { \quad \mathrm { e l s e } } \\ & { \qquad \mathrm { r e t u r n } - \left| c \right| } \end{array}
+$$
+
+Note: We first normalize all of our corrections by dividing by the greatest collected correction $c$ , so all of our $c$ values fall in $[ - 1 , 1 ]$ . In line 1 above, if we are turning the steering wheel in the same direction as the car (with some $\epsilon$ of error), then the feedback should be positive. (We set epsilon to $\frac { 5 } { \theta _ { m a x } }$ so that it allows up to 5 degrees of tolerance.) Since $c$ represents a delta in steering, a greater delta should result in a less positive signal. Therefore, the feedback should be proportional to $- | c |$ . We add 1 to ensure all $c$ in the same direction as $\theta$ are positive. If $c$ is in a different direction than we were steering (line 3), then the feedback should be negative, so we just return $- | c |$ as the feedback. Thus the greater the delta, the more negative the feedback will be. If $c$ is in the same direction, on the other hand, we chose to scale these feedbacks up so that the feedback is positive, but less positive for a greater differential. This makes sense since if, for example, the car is steering left and we tell it to steer more left, this is not as bad as if the car is steering the wrong way. Thus, slow actions back to the center of the road will be rewarded less than quick actions back to the center of the road.
+
+# 3.4 ARCHITECTURE
+
+We chose to use only an hour of data because we wanted to see how far we could get with limited data. While our feedback is relatively easy to collect compared to other options, it still takes up human hours, so we would like to limit its necessity. We sampled states at a rate of approximately two frames per second, since states that are close in time tend to look very similar. We augmented our data by flipping it left-right, inverting the angle label, and leaving the feedback the same. After this augmentation, we had 17,918 training images and 3,162 validation images (a 85:15 split).
+
+We chose to learn our policy with an end-to-end optimization of a neural network to approximate a continuous control function. Such networks are capable of tackling a wide array of general problems and end-to-end learning has the potential to better optimize all aspects of the pipeline for the task at hand. Given the option to use separate (differentiable) modules for sub-tasks such as computer vision, or to connect these modules in a way that is differentiable for the specific task, the latter will always perform better, since the end-to-end model always has the ability to simply not update the sub-module if it will not help training loss.
+
+We used transfer learning to help bootstrap learning with limited data for both the PNet and Fnet. We decided to start with a pretrained Inception v3 since it has relatively few parameters, but has been trained to have strong performance on ImageNet, giving us a head start on any related computer vision task. We kept some early layers of Inception and added several of our own, followed by a tanh activation for the output. We tried splitting the network at various layers and found that one about halfway through the network (called mixed 2) worked best. The layers we added after the split were fully connected layers of sizes 100, 300, and 20. For the FNet, the angle input is concatenated onto the first fully-connected layer. (Find an architecture diagram in the appendix.)
+
+# 4 EXPERIMENTS
+
+We tested our trained models by running them in our Unity simulator and recording the time until the car crashed or all four tires left the road. (Note: We designed the ReNeg framework so it need not be run in a simulator. This would work just as well in the real world. We only used a simulator because it was all we had access to.) We first tested our PNet with the scalar loss, our PNet with the exponential loss, and our FNet. We plotted their mean times over the eight runs with standard deviation. See Figure 3 below. (All of these were on the default hyperparameters listed in the appendix, except for the exponential loss model, for which we set $\alpha$ to 0.1 since otherwise we could not get it to converge.) Based on the predicted angles, the FNet seemed to primarily predict feedback based on state, not angle; this makes sense given that the feedback in “bad” states is generally “bad”, except for the split second when the “good” action takes place.
+
+![](images/e6c81d1b329d1c1800c41a758b57a19d4606971f26d91202ad45f70625d3a5b4.jpg)  
+Figure 4: Scalar loss function performance including negative examples vs. only positive examples
+
+![](images/a4e94a51bb957022aaf910655fd4b9663adfd310b87c2c4ab9f6847a48e1dd3e.jpg)  
+Figure 3: Initial comparison of loss functions.
+
+Given that the scalar loss performed best (and was training correctly), we spent more time tuning the hyperparameters for this model. This can be seen in Figure 4. We note several interesting things from figure 4 exploring the scalar loss. First, the pink group is identical to the solid blue group except that all the $\alpha$ values are 0, meaning that negative-feedback examples are zeroed out and effectively ignored in training. The blue bars are much higher than their pink counterparts, indicating that the negative data is useful. Second, we can see that thresholding the feedback to -1 and 1 (the blue crosshatch pattern) increased the scalar performance to about 30 seconds (compared to 6 seconds with the default hyperparameters). At first this could be taken to indicate that having gradations in positive and negative data could be harmful to training. However, we see that the same performance is achieved (and surpassed) by increasing the learning rate instead of thresholding, by looking to the 2 rightmost blue bars. The reason for this is likely that we tuned the learning rate to work well on thresholded data, and so, when we don’t threshold/clone our data, the scalars on the loss drop significantly, forcing the network to take smaller steps, and effectively decreasing the learning rate. Increasing the learning rate instead of thresholding yields much better performance, indicating that gradations in the data (with a high learning rate) do help training.
+
+![](images/80ed7413c16f799d08a30677f69455a3c2f52c8881dd301471c8643c39e1115c.jpg)  
+Figure 5: Over 3 training runs, our scalar loss model performed over 1.5 times as well as the behavioral cloning benchmark, with significantly less variance.
+
+Note, $\alpha$ can in fact be in $[ 0 , \infty ]$ , however we focused on $\alpha = 0$ and $\alpha = 1$ , since this corresponds to no negative examples and an equal weighting between positive and negative examples. It it difficult to tune independently due its relationship with the learning rate.
+
+Moreover, all we are trying to show is that using negative examples, with some relative importance to the positive examples, can be beneficial.
+
+After selecting the best learning rate for each model, we then trained new versions of each network 2 more times, for a total of 3 models each, to account for stochasticity in SGD. (The best learning rate for both turned out to be 1e-5; see the appendix for more details on tuning.) Each time, we let the model drive the car for 8 trials and calculated the performance as the mean time before crashing over these 8 trials. We then calculated the mean performance for each over the 3 training sessions. Figure 5 shows the results.
+
+# 5 CONCLUSION
+
+We hypothesized that for the task of learning lane following for autonomous vehicles from demonstration, adding in negative examples would improve model performance. Our scalar loss model performed over 1.5 times as well as the behavioral cloning baseline, showing our hypothesis to be true. The specific method of regression with negative examples we used allows for learning deterministic continuous control problems from demonstration from any range of good and bad behavior. Moreover, the loss function that empirically worked the best in this domain does not require an additional neural network to model it, and it induces a stochastic policy gradient that could be used for fine-tuning with RL. We also introduced a novel way of collecting continuous human feedback for autonomous vehicles intuitively and efficiently, called Backseat Driver. We thus believe our work could be extremely useful in the autonomous control industry: with no additional real world time, we can increase performance over supervised learning by simply having a backseat driver.
+
+# REFERENCES
+
+Pieter Abbeel and Andrew Y. Ng. Apprenticeship learning via inverse reinforcement learning. In In Proceedings of the Twenty-first International Conference on Machine Learning. ACM Press, 2004.
+
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D. Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, Xin Zhang, Jake Zhao, and Karol Zieba. End to end learning for self-driving cars. CoRR, abs/1604.07316, 2016. URL http://arxiv.org/abs/1604.07316.
+
+Benjamin Burchfiel, Carlo Tomasi, and Ronald Parr. Distance minimization for reward learning from scored trajectories. In AAAI, 2016.
+
+Thomas Degris, Martha White, and Richard S. Sutton. Off-policy actor-critic. CoRR, abs/1205.4839, 2012. URL http://arxiv.org/abs/1205.4839.
+
+Yang Gao, Huazhe Xu, Ji Lin, Fisher Yu, Sergey Levine, and Trevor Darrell. Reinforcement learning from imperfect demonstrations. CoRR, abs/1802.05313, 2018. URL http://arxiv.org/ abs/1802.05313.
+
+Markus Kuderer, Shilpa Gulati, and Wolfram Burgard. Learning driving styles for autonomous vehicles from demonstration. 2015 IEEE International Conference on Robotics and Automation (ICRA), pp. 2641–2646, 2015.
+
+James MacGlashan, Mark K. Ho, Robert Tyler Loftin, Bei Peng, David L. Roberts, Matthew E. Taylor, and Michael L. Littman. Interactive learning from policy-dependent human feedback. CoRR, abs/1701.06049, 2017. URL http://arxiv.org/abs/1701.06049.
+
+Remi Munos, Tom Stepleton, Anna Harutyunyan, and Marc G. Bellemare. Safe and efficient off- ´ policy reinforcement learning. CoRR, abs/1606.02647, 2016. URL http://arxiv.org/ abs/1606.02647.
+
+Yunpeng Pan, Ching-An Cheng, Kamil Saigol, Keuntaek Lee, Xinyan Yan, Evangelos Theodorou, and Byron Boots. Agile off-road autonomous driving using end-to-end deep imitation learning. CoRR, abs/1709.07174, 2017. URL http://arxiv.org/abs/1709.07174.
+
+Stephane Ross and J. Andrew Bagnell. Reinforcement and imitation learning via interactive no- ´ regret learning. CoRR, abs/1406.5979, 2014. URL http://arxiv.org/abs/1406.5979.
+
+Stephane Ross, Geoffrey J. Gordon, and J. Andrew Bagnell. No-regret reductions for imitation ´ learning and structured prediction. CoRR, abs/1011.0686, 2010. URL http://arxiv.org/ abs/1011.0686.
+
+Stephane Ross, Narek Melik-Barkhudarov, Kumar Shaurya Shankar, Andreas Wendel, Debadeepta ´ Dey, J. Andrew Bagnell, and Martial Hebert. Learning monocular reactive UAV control in cluttered natural environments. CoRR, abs/1211.1690, 2012. URL http://arxiv.org/abs/ 1211.1690.
+
+Kyriacos Shiarlis, Joao Messias, and Shimon Whiteson. Inverse reinforcement learning from failure. In Proceedings of the 2016 International Conference on Autonomous Agents &#38; Multiagent Systems, AAMAS ’16, pp. 1060–1068, Richland, SC, 2016. International Foundation for Autonomous Agents and Multiagent Systems. ISBN 978-1-4503-4239-1. URL http://dl.acm.org/citation.cfm?id=2936924.2937079.
+
+David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic policy gradient algorithms. In Proceedings of the 31st International Conference on International Conference on Machine Learning - Volume 32, ICML’14, pp. I–387– I–395. JMLR.org, 2014. URL http://dl.acm.org/citation.cfm?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ 3044805. 3044850.
+
+Wen Sun, Arun Venkatraman, Geoffrey J. Gordon, Byron Boots, and J. Andrew Bagnell. Deeply aggrevated: Differentiable imitation learning for sequential prediction. CoRR, abs/1703.01030, 2017. URL http://arxiv.org/abs/1703.01030.
+
+Christopher J. C. H. Watkins and Peter Dayan. Q-learning. In Machine Learning, pp. 279–292, 1992.
+
+Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 8(3):229–256, May 1992. ISSN 1573-0565. doi: 10.1007/ BF00992696. URL https://doi.org/10.1007/BF00992696.
+
+# 6 APPENDIX
+
+# 6.1 EXAMPLE INPUT
+
+![](images/ae4ddc473622f9106c7c7de15d1dbedcf83084b17a0ae968aeb1653e842b8a04.jpg)
+
+# 6.2 ARCHITECTURE
+
+![](images/0fcf20935e9c02f4077575941137816218716348efe565708a0357916d1057a6.jpg)
+
+The architecture of our model, based on Inception v3. After the split, the branch on the right is the branch used for our PNet or FNet, while the left branch is ignored. The new layers we added were 3 fully connected layers of sizes 100, 300, and 20. The final activation is Tanh to ensure the output range of (-1,1). For the FNet, the angle input is concatenated onto the first fully-connected layer.
+
+# 6.3 HYPERPARAMETERS
+
+Our batch size was 100 and we trained for 5 epochs. Unless otherwise specified for a given model in the experiments, we used an $\alpha$ value of 1.0, we did not threshold, and we used a learning rate of 1e-6. As in the Inception model we were using, our input was bilinearly sampled to match the
+
+resolution $2 9 9 \mathrm { x } 2 9 9$ . Likewise, we subtracted off an assumed mean of $2 5 6 . 0 / 2 . 0$ and divided by an assumed standard deviation of $2 5 6 . 0 / 2 . 0$ .
+
+# 6.4 TRAINING METRICS
+
+During training, we kept track of two validation metrics: the loss for the model being trained, and the average absolute error on just the positive data multiplied by 50. The first we refer to as “loss” and the second we refer to as “cloning error” (since it is the 50 times the square root of the cloning error) or just “error”. The reason we multiplied by 50 is that this is how Unity converts the $^ { - 1 }$ to 1 number to a steering angle, so the error is the average angle our model is off by on the positive data. (This is true with the maximum angle set to 50.)
+
+During training, these two metrics generally behaved very similarly, however, in the models for which we increased the learning rate, these eventually start to diverge. In this case, the error on the positive data started to increase, but the loss was still decreasing. For this reason, we tried varying the learning rate on several models, to see if the loss was more important than the “cloning” error. It is clear that the behavioral cloning models (thresholded with $\alpha = 0 . 0$ ) should in general do better on the “cloning” error, since they are very closely related. Whereas for non-thresholded data, it was trained with examples weighted differently. And for the negative data, it was trained to also get “away” from negative examples. We hope that even though the cloning error may increase, this means that it is because the model is choosing something better than (yet further away from) the positive examples. We still use the cloning error, however, because it is a useful intuitive metric for training and comparison.
+
+# 6.5 LEARNING RATE TUNING
+
+We tried several learning rates for both behavioral cloning and ReNeg. We compared the performance, shown in figures 6 and 7, and found that 1e-5 worked best for both.
+
+![](images/c45c2497c1279cabe104018c5f963449b671bfe70068e419c29c4b088dbd5963.jpg)  
+Figure 6: The scalar loss performed best with a learning rate of 1e-5.
+
+# 6.6 GAUSSIAN POLICY GRADIENT DERIVATION
+
+Here is the derivation from the stochastic policy gradient to the loss that induces it, which is very similar to our scalar loss:
+
+$$
+\begin{array} { r l } & { \nabla L o s s = \nabla ( R * - l o g ( P r ( \theta ) ) ) } \\ & { \nabla L o s s = \nabla ( R * - l o g ( \frac { e ^ { - \frac { ( \theta - \hat { \theta } ) ^ { 2 } } { 2 \sigma ^ { 2 } } } } { \sqrt { 2 \pi \sigma ^ { 2 } } } ) ) } \end{array}
+$$
+
+![](images/c4cac38d402176c404918773499bd6846b5fd70915feaed836b671772501f706.jpg)  
+Figure 7: The behavioral cloning loss performed best with a learning rate of 1e-5.
+
+$$
+\begin{array} { c } { { \nabla L o s s = \nabla ( R * - ( l o g ( e ^ { - \frac { ( \theta - \hat { \theta } ) ^ { 2 } } { 2 \sigma ^ { 2 } } } ) - l o g ( \sqrt { 2 \pi \sigma ^ { 2 } } ) ) ) } } \\ { { \nabla L o s s = \nabla ( R * - ( l o g ( e ^ { - \frac { ( \theta - \hat { \theta } ) ^ { 2 } } { 2 \sigma ^ { 2 } } } ) ) } } \\ { { \nabla L o s s = \nabla ( R * \frac { ( \theta - \hat { \theta } ) ^ { 2 } } { 2 \sigma ^ { 2 } } ) } } \\ { { \nabla L o s s \propto \nabla ( R * ( \theta - \hat { \theta } ) ^ { 2 } ) } } \\ { { L o s s \propto R * ( \theta - \hat { \theta } ) ^ { 2 } } } \end{array}
+$$
+
+# 6.7 FUTURE RESEARCH
+
+Future research involving human feedback should focus on 2 things: the loss function and enforcing continuity. These will be briefly explored in the next two sections.
+
+Note, before we discuss potential extensions of this work, that fine-tuning the policy once it is acceptably safe is a separate but also interesting problem. Supervised approaches involving a safety driver taking over control, and retraining on this data a la DAgger, should probably be explored. Additionally, instead of aggregating the new data with the old, active learning approaches could be explored, where the model is not entirely retrained. we point the reader to (Pan et al., 2017) for an AV application of DAgger.
+
+# 6.7.1 LOSS FUNCTION
+
+Immediate next steps should likely focus on alterations to the loss function. Here we introduce a fourth desired property that can ensure our negative examples have less or the same “impact” as they get farther away, and positive examples have more of an impact as they get farther away. In other words, for positive examples, as $\mathbf { D }$ increases, the update (derivative) is always the same or greater in magnitude, and for negative examples, the same is true as $\mathbf { D }$ decreases.
+
+4. Concavity:
+
+The loss is concave up with respect to $\mathrm { D }$ i.e . ∂2Loss >= 0.
+
+For positive examples, when $f > 0$ : This enforces that $| \frac { \partial L o s s } { \partial D } |$ has have a minimum at $D = 0$ (the optimum), since it must be positive and increasing. Ideally, $\frac { \partial L o s s } { \partial D }$ would equal 0 at $D = 0$ , and nowhere else.
+
+For negative examples, when $f < 0$ : This enforces that $| \frac { \partial L o s s } { \partial D } |$ has have a minimum a $D = \infty$ (the optimum), since it must be negative and increasing. Ideally, $\frac { \partial L o s s } { \partial D }$ would approach 0 as $D \to \infty$ , and be 0 nowhere else.
+
+We propose two loss functions that meet properties 1-4:
+
+1. We can accomplish this exponential decay by modifying our scalar function in a very easy way: Move the “sign” of f into the exponent:
+
+$$
+L o s s _ { i n v e r s e } = | f | * ( \theta ( s ) - \hat { \theta } ( s ) ) ^ { 2 * s i g n ( f ) }
+$$
+
+Using this loss function we have all three properties satisfied. That is, positive examples encourage moving towards them, negative examples encourage moving away from them, and the amount of this movement increases with the magnitude of f. Moreover, we also have the property that, in negative examples, loss drops off exponentially with the distance from the negative example (because we are dividing by it).
+
+2. If we want our scalar loss function to have neither an exponential decay nor an exponential increase with the distance from the negative points, we can simply use the following loss:
+
+$$
+L o s s _ { a b s o l u t e } = f * | \theta ( s ) - \hat { \theta } ( s ) |
+$$
+
+This has the not-so-nice property that, in the positive example, it allows outliers much more easily than the traditional squared loss. However, it has the very nice property that, given a single state input, as long as you have more positive examples than negative examples, your loss will always be minimized in that state by a value between your positive examples. This is because, as soon as you get to your greatest or least positive example, every step away from your positive examples will cost you 1 loss, for each positive example you have, and you will only lose 1 loss for each negative example you have. (Note, if you are not thresholding, then this translates to more total $| f |$ for positive examples than negative examples.)
+
+# 6.7.2 CONTINUITY
+
+Because in both our scalar and exponential loss, our loss function at a given state with just a negative example is minimized by moving away from the negative example, our regression in that state will tend toward positive or negative infinity. Certainly having a cost on negative examples that drops of exponentially will help, but it may not be enough. Moreover, we may not want to rely on the structure of neural networks to discourage this discontinuity. Therefore, research could be done on adding a regularization term to the loss that penalizes discontinuity. That is, we would add some small loss based on how dissimilar the answers for nearby states are. Of course, this implies a distance metric over states, but using consecutive frames may suffice.

parse/train/SJl7DsR5YQ/SJl7DsR5YQ_content_list.json

@@ -0,0 +1,1558 @@
+[
+    {
+        "type": "text",
+        "text": "RENEG AND BACKSEAT DRIVER: LEARNING FROMDEMONSTRATION WITH CONTINUOUS HUMAN FEED-BACK",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            260,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In autonomous vehicle (AV) control, requiring an agent to make mistakes, or even allowing mistakes, can be quite dangerous and costly in the real world. For this reason we investigate methods of training an AV without allowing the agent to explore and instead having a human explorer collect the data. Supervised learning has been explored for AV control, but it encounters the issue of the covariate shift. That is, training data collected from an optimal demonstration consists only of the states induced by the optimal control policy, but at runtime, the trained agent may encounter a vastly different state distribution and has seen little relevant training data. To mitigate this issue, we intentionally have our human explorer make sub-optimal decisions. In order to have our agent not replicate these suboptimal decisions, supervised learning requires that we either erase these actions, or replace these action with the correct action. Erasing these actions is wasteful and replacing these actions is difficult, since it is not easy to know the correct action without driving the car. Since supervised learning falls short, we introduce an alternate framework that includes continuous scalar feedback on each action, marking which actions we should replicate, which we should avoid, and how sure of this we are. Our framework, called “ReNeg”, learns from from human demonstration and human evaluative feedback, collected entirely before any training begins. Our agent learns continuous control from sub-optimal behavior, but sub-optimal behavior that is safely performed by a human. We find that a human demonstrator can explore sub-optimal states in a safe and controlled manner, while still getting enough gradation in the states to benefit learning. The way we collect data and the algorithm we use to compute feedback on the data we call “Backseat Driver.” Backseat Driver gives us state-action pairs matched with scalar values representing the score for those action in those states. We call the more general learning framework ReNeg, since it learns a regression from states to actions given negative as well as positive examples. We empirically validate several models in the ReNeg framework, testing on lane-following with limited data. We find that the best solution is a generalization of mean-squared error and outperforms supervised learning on the positive examples alone. ",
+        "bbox": [
+            233,
+            292,
+            764,
+            708
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 PROBLEM FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            738,
+            416,
+            753
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We seek a way learn autonomous vehicle control using only RGB input from a front-facing camera. (Example input image in the appendix.) Specifically, we want to produce a policy network to map states to actions in order to follow a lane as close to center as possible. We would like the agent to behave optimally in dangerous situations, and recover to safe situations. For this to happen, the data the agent trains on must include these sub-optimal states. However, we do not want to leave the safety determination up to any machine. Thus, we require that a human explorer take all the actions. This is referred to as “Learning from Demonstration” or LfD. An expert human does the exploration and thus can limit the danger by controlling how dangerous the negative examples are (i.e. the human can swerve to show suboptimal driving but never drive off the road, as an RL agent likely would). Still, in order to get into sub-optimal states, the explorer will need to take sub-optimal actions. Ideally we could replace these sub-optimal actions with labels corresponding to the correct and optimal actions to take so we could perform supervised learning, which provides the strongest signal. However, it is notoriously difficult to assign supervised labels to driving data because it is hard to know the correct steering angle to control a vehicle when your steering has no effect on what happens to the vehicle (Ross et al., 2012). Instead of trying to enable humans to assign supervised labels by somehow showing the consequences of their actions, we focus on letting humans assign feedback that evaluates the sub-optimal actions, without actually representing the optimal action. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            186
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Thus our goal is to learn a deterministic continuous control policy from demonstration, including both good and bad actions and continuous scores representing this valence. Our problem statement is somewhere in between supervised learning and RL: we focus on a general approach that is capable of mapping continuous sensor input to an arbitrary (differentiable) continuous policy output and capable of using feedback for singular predetermined actions. Our problem falls within the supervised setting since our agent cannot chose want actions to take, in order to avoid the agent exploring dangerous states, and all data collection is done prior to training. However, we also wish to incorporate evaluative scalar feedback given to each data point, which traditionally falls under the RL framework. We refer to this problem setting as the ReNeg framework, since we are essentially performing a regression with scalar weights attached to each data point, that can be positive and negative. For the demonstration, a human demonstrator drives, yielding state-action pairs the agent can learn from. In order to teach the agent which actions are good or bad, an expert critic, or “backseat driver,” labels the actions with a continuous scalar. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For a viable solution to this problem, we need to define a loss function that induces an effective and robust policy. We also need to choose what driving data to collect to expose the agent to a variety of good and bad states, and in particular show the agent how to get out of bad states where an accident is imminent. What data to collect is non-obvious: we want to explore a range of good and bad states so the agent learns a reasonable policy for how to act in all kinds of states. However, to make this feasible in the real world, we want to avoid exploring dangerous states. Finally, we need to carefully choose a way to collect human feedback that contains signal from which the agent can learn, but is not too hard to collect. We will discuss the choices we made for these three parts of the problem in the Loss Function, Driving Data, and Feedback sections respectively. Although we validate in simulation, specifically Unity, for the sake of ease, the algorithms we test could be easily trained in the real world. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            344,
+            573
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning from demonstration has mostly been studied in the supervised learning framework and the Markov Decision Process (MDP) framework. In the former, it is generally known as imitation learning (or behavioral cloning in the AV setting), and in the latter, it is generally known as apprenticeship learning. There are other relevant RL algorithms, but none for LfD in our problem setting, as we will show. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            659
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The supervised learning in this area has focused on a least squares regression that maps from an input state to action. The easiest approach to take here is to have an expert perform an optimal demonstration, and then simply use that as training data. The main issue here is that the runtime and training distributions can be vastly different. That is, once the trained agent is acting on its own after training and encounters states it has not seen, it does not know how to act, and strays further from the intended behavior. This problem is known as the Covariate Shift and the widely accepted solution generally follow the approach laid out in DAgger Ross et al. (2010). DAgger allows the agent to explore and then uses the expert to label the new dataset, then training on all of the combined data. Such an approach has even been improved upon both to address scalar feeddback by incorporating experts that can label $Q$ values with the AggreVaTeD algorithm (Ross & Bagnell, 2014), and to and to address deep neural networks by finding a policy gradient with the Deeply AggreVaTeD algorithm (Sun et al., 2017). However, these DAgger based policies require the agent to ex-plore and make mistakes. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The MDP research on apprenticeship learning has largely been on inverse reinforcement learning, or IRL (Abbeel & $\\mathrm { N g }$ , 2004), in which a reward function is estimated given the demonstration of an expert. However, often in this framework, the reward function is restricted to the class of linear combinations of the discrete features of the state, and the framework only allows for positive examples. In addition, there has been work on inverse reinforcement learning from failure (Shiarlis et al., 2016), which allows for a sequence of positive or a sequence of negative examples. There is also distance minimization for reward learning from scored trajectories (Burchfiel et al., 2016), which allows for gradation in the scores, but does not allow for an arbitrary reward function on continuous inputs or labels for atomic actions as opposed to a trajectory or sequence of actions. Moreover, these IRL methods are not a candidate for our problem, since they require an exact MDP solution with a tractable transition function and exploration to find the optimal policy. The issue we have is not that we don’t have the reward function, but that even with the more informative feedback, we cannot use exploration to learn the optimal policy. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is interesting to note that there are off-policy RL algorithms as well, but we would like to highlight that this is not the same thing as LfD. LfD, as we use it, means that we have collected all of our data before training. This could be thought of as on-policy only if our policy and start state never changes. Whereas, off-policy RL (e.g. Off-Policy Actor-Critic(Degris et al., 2012), Q-Learning(Watkins & Dayan, 1992), Retrace(Munos et al., 2016)) generally requires agents to have a non-zero probability of choosing any action in any state, in order for the algorithm to converge. (Moreover, it is the somewhat parenthetical opinion of at least one of authors of this paper that in the off-policy policy gradient RL framework, using importance sampling to calculate an expectation over a different action distribution is fine, but changing the objective function from an expectation over the learned policy state-visitation distribution to an expectation over the behavior (exploratory) state-visitation distribution, as in (Degris et al., 2012), is an unsatisfactory answer that does not give the optimal policy for the agent when running on the learned policy, as we will want to do.) Normalized Actor Critic (NAC) does attempt to bridge the gap between off-policy and LfD, and works with bad as well as good demonstration, however, NAC does not allow for restricted exploration either, since it adds entropy to the objective function to encourage exploration (Gao et al., 2018). NAC has also only been done for discrete action control, not continuous as we want to do. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, there are many RL algorithms that use human evaluative feedback, but none for LfD. One RL algorithm with human feedback of note is COACH (MacGlashan et al., 2017), which is based on the stochastic policy gradient. COACH is an on-policy RL algorithm that uses human-feedback to label the agent’s actions while exploring. COACH’s view on human feedback helps us to draw connections to RL, as we will discuss later. However, COACH was designed for on-policy exploration and uses discrete feedback values of 1 and -1, whereas we generalize to continuous values in $[ - 1 , 1 ]$ . We cannot use a stochastic policy gradient in a justified manner, since we do not explore with a stochastic policy. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            563
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Out of all the LfD work in the AV context, the most notable has either been on behavioral cloning (Bojarski et al., 2016) (Pan et al., 2017) or using IRL to solve sub-tasks such as driving preferences that act on top of a safely functioning trajectory planner (Kuderer et al., 2015). To the best of our knowledge, no research so far has focused on using any kind of evaluative scalar feedback provided by a human in the context of AV control with LfD. That is, no one has solved how to take states, actions, and continuous feedback with respect to those actions, and convert them into a control policy for an AV, without having the AV explore. We believe that this is a major oversight: many AV research groups are investing huge amounts of time into collecting driving data; if they used our model, they could improve performance simply by having an expert labeler sit in the car with the driver for no additional real time. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 OUR APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            728,
+            341,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 LOSS FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            761,
+            331,
+            775
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\theta$ be the steering angle in the demonstrated example; $\\hat { \\theta }$ the steering angle predicted by the policy network (or PNet); $D$ the absolute difference between $\\theta$ and $\\hat { \\theta }$ , $| \\theta - \\hat { \\theta } |$ ; and $f _ { \\theta }$ , or $f$ , the feedback for the demonstrated angle. We collect $f \\in [ - 1 , 1 ]$ . The loss function we choose should have the following 3 properties: ",
+        "bbox": [
+            174,
+            786,
+            825,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Minimizing the loss should minimize the $\\mathrm { D }$ for positive examples. That is, when $f > 0$ , $\\begin{array} { r } { \\frac { \\partial L o s s } { \\partial D } \\geq 0 } \\end{array}$ .   \n2. Minimizing the loss should maximize the distance between $\\theta$ and $\\hat { \\theta }$ for negative examples. That is, when $f < 0$ ∂Loss ≤ 0. ",
+        "bbox": [
+            212,
+            858,
+            825,
+            926
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3. The rate at which the loss is minimized should be determined by the magnitude of the feedback. That is, when $f > 0$ , $\\frac { \\partial | L o s s | } { \\partial f } > 0$ , and when $f < 0$ , $\\frac { \\partial | L o s s | } { \\partial f } < 0$ ",
+        "bbox": [
+            210,
+            103,
+            823,
+            138
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "These three properties together ensure that the network avoids the worst negative examples as much as possible, while seeking the best examples. Given an input state $s$ , the first loss function that comes to mind is what we term “scalar loss”: ",
+        "bbox": [
+            174,
+            150,
+            826,
+            191
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/89112c1151d51f69a7e7d4b9621e9550f0ecae9a370bf33cb7d4524e64cd2c28.jpg",
+        "text": "$$\nL o s s _ { s c a l a r } = f _ { s } * ( \\theta _ { s } - \\hat { \\theta } ( s ) ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            195,
+            604,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This loss function is notable for several reasons. First, it is a generalization of mean squared error, the standard behavioral cloning loss function: ",
+        "bbox": [
+            174,
+            222,
+            823,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/beb311b8981005357f73f341246d489a836bd4743699d182566de2bbc5f77a67.jpg",
+        "text": "$$\nL o s s _ { M S E } = ( \\theta _ { s } - \\hat { \\theta } ( s ) ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            256,
+            586,
+            276
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Mean squared error is a well-principled loss function if you assume Gaussian noise in your training data. That is, you assume the probability of your data can be given by Gaussian noise around some mean and you learn to predict $\\hat { \\theta }$ as that mean. Given this assumption, you can derive MSE as the loss that produces a maximum likelihood estimate for your parameters. Let the parameters of the model be represented by $p$ and probability be $P r$ . $\\hat { \\theta }$ is parameterized by $p$ and will be used interchangeably with $\\hat { \\theta } _ { p }$ , when clarity is needed. Please note that $\\theta$ refers to the angle label, and not the model parameters: ",
+        "bbox": [
+            173,
+            289,
+            826,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/302ccf2a157b4321709bce6ac3b1fba4bf3031f2e4219b5519e42925f485540c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad \\mathrm { a g m a x } _ { p } \\gamma ^ { n } \\left( \\ell \\mathrm { d } t \\right) d t } \\\\ & { \\quad \\mathrm { ~ u p p r o v e ~ } \\displaystyle \\prod _ { \\ell = 0 < \\ell \\in \\mathcal { N } _ { \\ell } } \\mathrm { e r } ( \\theta | \\hat { \\theta } _ { \\ell } ^ { ( \\ell ) } ) } \\\\ & { \\quad \\mathrm { a f ~ a n d ~ } \\displaystyle \\sum _ { \\ell = 0 } ^ { \\infty } \\mathrm { e r } ( \\theta | P _ { \\ell } ^ { \\ell } ( \\ell \\hat { \\theta } _ { \\ell } ^ { ( \\ell ) } ) ) } \\\\ & { \\quad \\mathrm { a f ~ a n d ~ } \\displaystyle \\sum _ { \\ell = 0 } ^ { \\infty } \\mathrm { e l } ( P r ( \\ell \\hat { \\theta } _ { \\ell } ^ { ( \\ell ) } ) ) } \\\\ & { \\quad \\mathrm { a f ~ a n d ~ } \\displaystyle \\sum _ { \\ell = 0 } ^ { \\infty } \\mathrm { e l } ( \\theta | P r ( \\ell \\hat { \\theta } _ { \\ell } ^ { ( \\ell ) } ) ) } \\\\ & { \\quad \\mathrm { a f ~ a n d ~ } \\displaystyle \\sum _ { \\ell = 0 < \\ell \\in \\mathcal { N } _ { \\ell } } \\mathrm { e r f } ( P \\ell ) ( \\theta | \\hat { \\theta } _ { \\ell } ^ { ( \\ell ) } ) } \\\\ & { \\quad \\mathrm { a f ~ a n d ~ } \\displaystyle \\sum _ { \\ell = 0 < \\ell \\in \\mathcal { N } _ { \\ell } } \\mathrm { e r f } ( P \\ell ( \\theta | \\hat { \\theta } _ { \\ell } ^ { ( \\ell ) } ) ) } \\\\ & { \\quad \\quad \\mathrm { L o s s } - l o g ( P r ( \\ell \\hat { \\theta } _ { \\ell } ^ { ( \\ell ) } ) ) } \\\\ & { \\quad \\quad \\mathrm { L o s s } - l o g ( P r ^ { \\ell } ( \\ell \\hat { \\theta } _ { \\ell } ^ { ( \\ell ) } ) ) } \\\\ & { \\quad \\quad \\mathrm { L o s s } - l o g ( P r ^ { \\ell } ) } \\\\ & { \\quad \\quad \\mathrm { R e t s } - l o g ( P r ^ { \\ell } ) } \\\\ & { \\quad \\mathrm { o r s s } - \\frac { ( \\theta - l ) ^ { 2 } + ( l - 1 ) ! } { 2 } \\mathrm { e r f } ( P \\ell ) ^ { 2 } } \\\\ & { \\quad \\mathrm { o r s } - \\frac { ( \\theta - l ) ^ { 2 } + ( l - 1 ) ! } { 2 } \\mathrm { e r f } ( P \\ell ) ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            390,
+            609,
+            657
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generally, $l o g ( \\sqrt { 2 \\pi \\sigma ^ { 2 } } )$ is left out since it is a constant w.r.t. our parameters and so will go away when the gradient is taken, leaving: ",
+        "bbox": [
+            173,
+            660,
+            823,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d089b65b6f637043d2aa9c460598d324cdd2576efa449eb2cdff321cf74c8a80.jpg",
+        "text": "$$\nL o s s = \\frac { ( \\theta - \\hat { \\theta } ) ^ { 2 } } { 2 \\sigma ^ { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            686,
+            558,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generally, $2 \\sigma ^ { 2 }$ is also left out, since it only acts to scale the gradient, and can be accounted for by adjusting the learning rate of gradient descent, leaving: ",
+        "bbox": [
+            173,
+            724,
+            825,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e695464367c395a558619f121057945eb992e8cfe19b4f1ea28aa01e8453b94f.jpg",
+        "text": "$$\nL o s s = ( \\theta - \\hat { \\theta } _ { p } ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            758,
+            560,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, we note that, if we interpret $| f |$ , the magnitude of our feedback, as $\\scriptstyle { \\frac { 1 } { 2 \\sigma ^ { 2 } } }$ , we can view $| f |$ as a measure of certainty. This certainly applies to a Gaussian distribution with a variance of at least $\\frac { 1 } { 2 }$ , since $f \\in ( 0 , 1 ]$ for positive examples. For negative examples, we generalize further by removing the magnitude calculation, and allowing our feedback to be negative. This enforces that we minimize the probability of negative data: ",
+        "bbox": [
+            173,
+            785,
+            825,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/39123b6ce689a7bc7cc9a3c84fb1e614603de8ada1a6e2c0bff7051fd4883a2e.jpg",
+        "text": "$$\nL o s s = f * ( \\theta - { \\hat { \\theta } } _ { p } ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            862,
+            573,
+            882
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To be able to easily recover behavioral cloning, we introduce two hyperparameters. The first such parameter is the ability to threshold feedback values. If we threshold, we simply replace every $f$ with $s i g n ( f )$ . Thresholding eliminates gradations in positive and negative data. Additionally, we introduced the parameter $\\alpha$ , which scales down all our negative examples’ feedback: $f : =$ $m a x ( f , \\alpha f )$ . This trades off between behavioral cloning and avoiding negative examples. We apply $m a x ( f , \\alpha f )$ after we threshold, so if we threshold with and set $\\alpha$ to 0.0, we recover behavioral cloning. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our scalar loss is also notable since it closely resembles a loss that induces a stochastic policy gradient. In a standard RL policy network such as REINFORCE, the gradient would be $\\nabla _ { p } =$ $\\nabla _ { p } ( Q ^ { \\pi } ( \\theta ) * - l o g ( P r ( \\theta ) ) )$ (Williams, 1992). The loss then, that would induce this gradient is $\\dot { L o s s } = Q ^ { \\pi } ( \\theta ) * - l o g ( P r ( \\theta ) ) .$ $R$ , the return, or a sample contributing to $Q ^ { \\pi } ( \\theta )$ , is generally used. In continuous control, one could instead predict a mean $\\hat { \\theta }$ for a normal distribution and then sample your action $\\theta$ from that normal distribution. As demonstrated above, if you replace $l o g ( P r ( \\theta ) )$ with the probability density function for a normal distribution, the loss you wind up with is precisely MSE scaled by $R$ . Substituting this scalar into the derivation above at every step, you get: ",
+        "bbox": [
+            173,
+            180,
+            825,
+            295
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/953199cf43bf38b6b0ef280f007b7c27dd47f87d08d6ec33d8b7315e1e66dff4.jpg",
+        "text": "$$\nL o s s = R * ( \\theta - \\hat { \\theta } ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            297,
+            570,
+            316
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A full derivation of this loss given the stochastic policy gradient and Gaussian policy can be found in the appendix. Clearly if we view $f _ { \\theta }$ , our feedback, as $R _ { \\hat { \\theta } }$ and assume a Gaussian policy, we get our scalar loss function. COACH in fact points out that you can view online feedback given for the current policy, $f _ { \\hat { \\theta } }$ as a sample from $Q ^ { \\pi } ( { \\hat { \\theta } } )$ , or $A ^ { \\pi } ( { \\hat { \\theta } } )$ , the advantage function, and empirically verifies that this works for on-line RL with discrete feedback (MacGlashan et al., 2017). This similarity was useful for inspiration and ideation, but actually falls short of rigorous justification for two reasons. Since we are training off-policy, and, more specifically, on a pre-determined policy that does not explore stochastically and does not vary depending on the current predicted policy, we run into major issues justifying our loss this way. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First, the main “off-policy” issue here is that for the stochastic policy gradient to hold, the exploration must be stochastic. However, in our case, the data is drawn from a pre-determined, deterministic policy. We can illuminate the intuition for why the stochastic policy gradient no longer works by considering a simple example. Consider the network attempting to learn the correct predicted $\\hat { \\theta }$ for a given state. Consider that there is only one demonstrated $\\theta , - 1$ , with a feedback of $^ { - 1 }$ . Now, no matter what $\\hat { \\theta }$ the network predicts, the $\\theta$ action that is taken during training will always be $^ { - 1 }$ , and the feedback will always be -1. Moreover, consider that the actual optimum is $\\hat { \\theta } = 1$ , and the network is currently predicting $\\hat { \\theta } = - 2$ . Using our scalar loss, the network will increase distance between $\\theta$ and $\\hat { \\theta }$ by decreasing $\\hat { \\theta }$ , making the policy worse and worse. This would not happen when using a stochastic RL policy, since the network can explore states around the current predicted $\\hat { \\theta }$ by choosing appropriate actions. ",
+        "bbox": [
+            173,
+            452,
+            825,
+            618
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using a stochastic RL policy, given enough samples on either side of $\\hat { \\theta }$ , the network will have larger and larger gradients, the more negative $\\hat { \\theta }$ is. But these gradients will not keeping “pushing” the prediction to the left of $^ { - 1 }$ , but rather will randomly cause $\\hat { \\theta }$ to move around, gradually moving to the right as it finds better feedback, and eventually converging at the optimum of $\\hat { \\theta } = 1$ . The network will move less “violently” and more “stably” the closer $\\hat { \\theta }$ gets to 0. And when the network eventually reaches the positive numbers, it might get “pulled” to the left a bit when it happens to sample a worse action, but it will not get pulled as strongly as when it samples a better action to the right. We can now intuitively see the issue: the neural network cannot not influence the probability of seeing an example again, which can lead to problems with learning the policy. In RL, a policy network can try a bad action, and then move the policy away from that action and not revisit it. On the other hand, if we have a bad example in our training set for a given state, on every epoch of training, our neural net will encounter this example and take a step away from it, thus pushing our network as far away from it as possible. Taking these steps is not necessarily helpful since the network may not have favored taking the bad action before. ",
+        "bbox": [
+            174,
+            627,
+            825,
+            830
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We could use some sort of importance sampling (Silver et al., 2014) (Degris et al., 2012), as is done with stochastic off-policy exploration, to scale down the loss for examples we are far away from. However, this would make our update have almost no effect when we are far away from positive examples, and with the deterministic exploration of ReNeg, the distinction between positive and negative examples now matters. We can’t have it both ways just by multiplying by the probability of $\\hat { \\theta }$ given our model. (This happens since the Gaussian PDF decreases exponentially with difference $| \\theta - \\hat { \\theta } |$ , but the loss only increases quadratically with the difference, due to the logarithm. Thus the gradient tends toward 0 due to the differing rates of growth, as the difference gets large.) Moreover, importance sampling consistently reduced performance for learning from demonstration in the NAC paper (Gao et al., 2018). ",
+        "bbox": [
+            174,
+            837,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Another, perhaps less significant issue, is that our feedback represents $Q *$ , and not $Q \\pi$ . Even if the human critic could re-assigned labels as the agent trains, he/she would have no way to sample the return from $Q \\pi$ , without letting the agent explore freely. This is significant because an action that is optimal for the expert may be a dangerous and poor decision for a non-optimal policy. This is perhaps less significant than the other issue, since there are no actions in our data that could be considered both good and risky. What is good for one policy (i.e. steering back to the middle of the road) is generally good for all policies, and so can act rather greedily with respect to $Q *$ , even though it will not always be following the optimal policy. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            279
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For these reasons, we find the comparison to stochastic policy gradients useful, but ultimately uncompelling. Applying RL losses to supervised learning does not provide the mathematical justification we need. The stochastic policy gradient is no longer computing the gradient of the current policy at all. Thus, we focus primarily on extending and generalizing MSE. Yet, we can still learn from the policy gradient comparison. In particular, we acknowledge that the sign of our feedback is far more significant than it was in the RL context (which is one of the reasons we introduce the $\\alpha$ parameter, which scales down the importance of negative examples, in the event that we collect too many negative examples). In RL, using the stochastic policy gradient, it did not matter if negative examples “pulled” $\\hat { \\theta }$ closer to them, so long as the positive examples pulled $\\hat { \\theta }$ more, since you would eventually try one of those actions, if it is a nearby optimum. However, since actions are no longer sampled dependent on the current policy, suddenly the sign matters very much. In fact, even if we have a positive example for a state, if we have more negative examples than positive examples, we may wind up ignoring our positive examples entirely in an effort to get away from our negative examples. This case highlights the trouble inherent in using negative examples: It is hard to know how and when to take into account the negative examples. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            496
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb2ebe93034a8728e91f71cf7b05a5a5d1ec491f956ee488e95c1d04b1a52cd2.jpg",
+        "image_caption": [
+            "Figure 1: Potential outcomes of regression with negative examples "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            520,
+            759,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Now, let us consider negative examples in the ReNeg framework. For example, as shown in Figure 1, if we perform a regression on positive and negative examples with more negative examples than positive in one state, we may wind up in a case where our loss is minimized by a prediction of positive or negative infinity, and thus our regression is “overwhelmed” by the negative examples. This led us to our second “exponential” loss: ",
+        "bbox": [
+            173,
+            683,
+            825,
+            752
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4eb286dc347f90057ba08ccb3fc94dc33af2a7e9034ce9eacbacb8067be00e7b.jpg",
+        "text": "$$\nL o s s _ { e x p } = | \\theta ( s ) - \\hat { \\theta } ( s ) | ^ { 2 f }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            758,
+            589,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Using this loss, negative examples will have infinite loss at distance 0, and then drop off exponentially with distance. We hope that this will create regressions more akin to the second image in Figure 1. In this image, adding more negative points will still nudge the regression away more and more, but one positive point not too close by should be enough to prevent it from diverging to positive or negative infinity. It should be noted that the loss in a particular state still could only have negative examples, especially in a continuous state-space like ours where states are unlikely to be revisited. However, the reduction in loss caused by diverging to infinity would be so small that it should not happen simply due to continuity with nearby states enforced by the structure of the network. In addition, one concern with this loss could be that for positive fractional differences, and negative non-fractional differences, the desired property 3) of loss functions no longer holds. That is, our positive loss will not grow with $f$ if the difference being exponentiated is a fraction. And for negative exponents, the loss will only grow if the difference is a fraction that shrinks as it is raised to increasing powers of $f$ . However, we hope that for negative examples, distances that are more than 1 unit away will not occur often (since 1 unit is half the distance range). We discuss a potential future solution in the appendix to patch this loss function. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our final loss function should produce regressions more like the final image in Figure 1: We propose directly modelling the feedback with another neural network (which we call the FNet) for use as a loss function for our PNet. If this FNet is correctly able to learn to copy how we label data with feedback, it could be used as a loss function for regression with our PNet. Thus, in order to maximize feedback, our loss function would be as follows: ",
+        "bbox": [
+            173,
+            180,
+            825,
+            250
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91175d7c9238d2a1506f9dc884e30e05fba84f07427805b6f4028ce7ada88e82.jpg",
+        "text": "$$\nL o s s _ { F N e t } = - F N e t ( s , \\hat { \\theta } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            252,
+            589,
+            272
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "After learning this FNet, we can either use it as a loss function to train a policy network or, every time we want to run inference, we can run a computationally expensive gradient descent optimization to pick the best action. Because the latter does not depend on the training distribution (so we do not have the issue of the runtime and training distributions being different), and it is more efficient, we choose an even easier version of the latter: we pick the best action out of a list of discrete options according to the FNet’s predictions. One feature of the FNet is that adding more negative points will not “push” our regression further away from this point, but rather just make our FNet more confident of the negative feedback there. This may not be the desired effect for all applications. Moreover, the FNet cannot operate on purely positive points with no gradation. That is, behavioral cloning cannot be recovered from it. ",
+        "bbox": [
+            174,
+            275,
+            825,
+            415
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 DRIVING DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            431,
+            320,
+            445
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We recorded 20 minutes of optimal driving and labeled all of this data with a feedback of 1.0. Choosing the suboptimal data and how to label it was a bit more tricky. One reason that we are not using reinforcement learning is that letting the car explore actions is dangerous. In this vein, we wanted to collect data only on “safe” driving. However, the neural network needs data that will teach it about bad actions well as good actions that recover the car from bad states. In order to explore these types of states and actions, we collected two types of bad driving: “swerving” and “lane changing”. The first image in Figure 2 is swerving. In swerving, the car was driving in a “sine wave” pattern on either side of the road. We collected 10 minutes of this data on the right side of the road and 10 minutes on the left. The second image is lane changing. For this, we drove to the right side of the road, straightened out, stayed there, and then returned to the middle. We repeated this for 10 minutes, and then collected 10 minutes on the left-hand side as well. ",
+        "bbox": [
+            174,
+            458,
+            614,
+            678
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/76638594e8208c5c80fa3207610f2c272ae96ecfca3d5ca19113bcec62dcfb5b.jpg",
+        "image_caption": [
+            "Figure 2: Types of driving: swerving (left), lane change (right) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            651,
+            474,
+            797,
+            637
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 “BACKSEAT DRIVER” FEEDBACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            695,
+            444,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Backseat Driver is the framework we use to compute and collect   \nfeedback in the AV context. Our feedback includes much more information than just a reward (as is used in RL): we take our label to directly measure how “good” an action is relative to other possible actions. We use this approach instead of labeling rewards for actions both because we found it an easy way to label data with feedback, and because it contains more signal. How exactly to label the data with feedback, however, is non-obvious. At first, we considered labeling using a slider from -1 to 1. However, using a slider can be non-intuitive in many cases and there would be discontinuities in feedback you would want to give. For example, if the demonstrator is driving straight off the road and then starts to turn left back onto the road, there would be a large discontinuity in the very negative and then slightly positive feedback. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to circumvent these issues, and to make the labeling process more intuitive, we decided to collect feedback using the steering wheel. We found that it is easier for people to focus on the steering angle, since that is how we are used to controlling cars. Our first thought was to just turn the steering wheel to the correct angle. However, this is very difficult to estimate, especially on turns, when you cannot see the actual effects your steering is having on the car. (Note that if we did this, our algorithm would turn into behavioral cloning.) Instead, we decided to label the differential. That is, we turned the wheel to the left if the car should steer more left. This signal shows where the error is (i.e. “You should be turning more” or “You’re turning the wrong way”). Note that the label does not need to be the exact correct angle; it just needs to show in which direction the current action is erring, and proportionally how much. We call this method of human feedback collection “Backseat Driver.” In order to process the angle labels into a feedback value in $[ - 1 , 1 ]$ , we used the equation below: ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/733133fb513edbefa67ef0f411a58a4ae8bf46c9fc8abe72ac92a84866be2597.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\Xi \\mathrm { E D B A C K } ( c , \\theta ) } \\\\ & { \\quad \\mathrm { i f ~ s i g n } ( c ) = = \\mathrm { s i g n } ( \\theta ) \\mathrm { o r } \\left| c \\right| \\le \\epsilon } \\\\ & { \\qquad \\mathrm { r e t u r n } \\ 1 - \\left| c \\right| } \\\\ & { \\quad \\mathrm { e l s e } } \\\\ & { \\qquad \\mathrm { r e t u r n } - \\left| c \\right| } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            231,
+            400,
+            308
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Note: We first normalize all of our corrections by dividing by the greatest collected correction $c$ , so all of our $c$ values fall in $[ - 1 , 1 ]$ . In line 1 above, if we are turning the steering wheel in the same direction as the car (with some $\\epsilon$ of error), then the feedback should be positive. (We set epsilon to $\\frac { 5 } { \\theta _ { m a x } }$ so that it allows up to 5 degrees of tolerance.) Since $c$ represents a delta in steering, a greater delta should result in a less positive signal. Therefore, the feedback should be proportional to $- | c |$ . We add 1 to ensure all $c$ in the same direction as $\\theta$ are positive. If $c$ is in a different direction than we were steering (line 3), then the feedback should be negative, so we just return $- | c |$ as the feedback. Thus the greater the delta, the more negative the feedback will be. If $c$ is in the same direction, on the other hand, we chose to scale these feedbacks up so that the feedback is positive, but less positive for a greater differential. This makes sense since if, for example, the car is steering left and we tell it to steer more left, this is not as bad as if the car is steering the wrong way. Thus, slow actions back to the center of the road will be rewarded less than quick actions back to the center of the road. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.4 ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            326,
+            523
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We chose to use only an hour of data because we wanted to see how far we could get with limited data. While our feedback is relatively easy to collect compared to other options, it still takes up human hours, so we would like to limit its necessity. We sampled states at a rate of approximately two frames per second, since states that are close in time tend to look very similar. We augmented our data by flipping it left-right, inverting the angle label, and leaving the feedback the same. After this augmentation, we had 17,918 training images and 3,162 validation images (a 85:15 split). ",
+        "bbox": [
+            174,
+            536,
+            825,
+            619
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We chose to learn our policy with an end-to-end optimization of a neural network to approximate a continuous control function. Such networks are capable of tackling a wide array of general problems and end-to-end learning has the potential to better optimize all aspects of the pipeline for the task at hand. Given the option to use separate (differentiable) modules for sub-tasks such as computer vision, or to connect these modules in a way that is differentiable for the specific task, the latter will always perform better, since the end-to-end model always has the ability to simply not update the sub-module if it will not help training loss. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            724
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We used transfer learning to help bootstrap learning with limited data for both the PNet and Fnet. We decided to start with a pretrained Inception v3 since it has relatively few parameters, but has been trained to have strong performance on ImageNet, giving us a head start on any related computer vision task. We kept some early layers of Inception and added several of our own, followed by a tanh activation for the output. We tried splitting the network at various layers and found that one about halfway through the network (called mixed 2) worked best. The layers we added after the split were fully connected layers of sizes 100, 300, and 20. For the FNet, the angle input is concatenated onto the first fully-connected layer. (Find an architecture diagram in the appendix.) ",
+        "bbox": [
+            174,
+            731,
+            825,
+            843
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            863,
+            326,
+            878
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We tested our trained models by running them in our Unity simulator and recording the time until the car crashed or all four tires left the road. (Note: We designed the ReNeg framework so it need not be run in a simulator. This would work just as well in the real world. We only used a simulator because it was all we had access to.) We first tested our PNet with the scalar loss, our PNet with the exponential loss, and our FNet. We plotted their mean times over the eight runs with standard deviation. See Figure 3 below. (All of these were on the default hyperparameters listed in the appendix, except for the exponential loss model, for which we set $\\alpha$ to 0.1 since otherwise we could not get it to converge.) Based on the predicted angles, the FNet seemed to primarily predict feedback based on state, not angle; this makes sense given that the feedback in “bad” states is generally “bad”, except for the split second when the “good” action takes place. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e6c81d1b329d1c1800c41a758b57a19d4606971f26d91202ad45f70625d3a5b4.jpg",
+        "image_caption": [
+            "Figure 4: Scalar loss function performance including negative examples vs. only positive examples "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            104,
+            833,
+            369
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4e94a51bb957022aaf910655fd4b9663adfd310b87c2c4ab9f6847a48e1dd3e.jpg",
+        "image_caption": [
+            "Figure 3: Initial comparison of loss functions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            108,
+            428,
+            391
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            450,
+            825,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Given that the scalar loss performed best (and was training correctly), we spent more time tuning the hyperparameters for this model. This can be seen in Figure 4. We note several interesting things from figure 4 exploring the scalar loss. First, the pink group is identical to the solid blue group except that all the $\\alpha$ values are 0, meaning that negative-feedback examples are zeroed out and effectively ignored in training. The blue bars are much higher than their pink counterparts, indicating that the negative data is useful. Second, we can see that thresholding the feedback to -1 and 1 (the blue crosshatch pattern) increased the scalar performance to about 30 seconds (compared to 6 seconds with the default hyperparameters). At first this could be taken to indicate that having gradations in positive and negative data could be harmful to training. However, we see that the same performance is achieved (and surpassed) by increasing the learning rate instead of thresholding, by looking to the 2 rightmost blue bars. The reason for this is likely that we tuned the learning rate to work well on thresholded data, and so, when we don’t threshold/clone our data, the scalars on the loss drop significantly, forcing the network to take smaller steps, and effectively decreasing the learning rate. Increasing the learning rate instead of thresholding yields much better performance, indicating that gradations in the data (with a high learning rate) do help training. ",
+        "bbox": [
+            173,
+            569,
+            614,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/80ed7413c16f799d08a30677f69455a3c2f52c8881dd301471c8643c39e1115c.jpg",
+        "image_caption": [
+            "Figure 5: Over 3 training runs, our scalar loss model performed over 1.5 times as well as the behavioral cloning benchmark, with significantly less variance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            633,
+            590,
+            828,
+            777
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Note, $\\alpha$ can in fact be in $[ 0 , \\infty ]$ , however we focused on $\\alpha = 0$ and $\\alpha = 1$ , since this corresponds to no negative examples and an equal weighting between positive and negative examples. It it difficult to tune independently due its relationship with the learning rate. ",
+        "bbox": [
+            173,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Moreover, all we are trying to show is that using negative examples, with some relative importance to the positive examples, can be beneficial. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "After selecting the best learning rate for each model, we then trained new versions of each network 2 more times, for a total of 3 models each, to account for stochasticity in SGD. (The best learning rate for both turned out to be 1e-5; see the appendix for more details on tuning.) Each time, we let the model drive the car for 8 trials and calculated the performance as the mean time before crashing over these 8 trials. We then calculated the mean performance for each over the 3 training sessions. Figure 5 shows the results. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            242,
+            341,
+            258
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We hypothesized that for the task of learning lane following for autonomous vehicles from demonstration, adding in negative examples would improve model performance. Our scalar loss model performed over 1.5 times as well as the behavioral cloning baseline, showing our hypothesis to be true. The specific method of regression with negative examples we used allows for learning deterministic continuous control problems from demonstration from any range of good and bad behavior. Moreover, the loss function that empirically worked the best in this domain does not require an additional neural network to model it, and it induces a stochastic policy gradient that could be used for fine-tuning with RL. We also introduced a novel way of collecting continuous human feedback for autonomous vehicles intuitively and efficiently, called Backseat Driver. We thus believe our work could be extremely useful in the autonomous control industry: with no additional real world time, we can increase performance over supervised learning by simply having a backseat driver. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            428
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pieter Abbeel and Andrew Y. Ng. Apprenticeship learning via inverse reinforcement learning. In In Proceedings of the Twenty-first International Conference on Machine Learning. ACM Press, 2004. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D. Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, Xin Zhang, Jake Zhao, and Karol Zieba. End to end learning for self-driving cars. CoRR, abs/1604.07316, 2016. URL http://arxiv.org/abs/1604.07316. ",
+        "bbox": [
+            173,
+            176,
+            825,
+            233
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Burchfiel, Carlo Tomasi, and Ronald Parr. Distance minimization for reward learning from scored trajectories. In AAAI, 2016. ",
+        "bbox": [
+            171,
+            241,
+            823,
+            270
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas Degris, Martha White, and Richard S. Sutton. Off-policy actor-critic. CoRR, abs/1205.4839, 2012. URL http://arxiv.org/abs/1205.4839. ",
+        "bbox": [
+            171,
+            279,
+            823,
+            308
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yang Gao, Huazhe Xu, Ji Lin, Fisher Yu, Sergey Levine, and Trevor Darrell. Reinforcement learning from imperfect demonstrations. CoRR, abs/1802.05313, 2018. URL http://arxiv.org/ abs/1802.05313. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            358
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Markus Kuderer, Shilpa Gulati, and Wolfram Burgard. Learning driving styles for autonomous vehicles from demonstration. 2015 IEEE International Conference on Robotics and Automation (ICRA), pp. 2641–2646, 2015. ",
+        "bbox": [
+            173,
+            366,
+            823,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James MacGlashan, Mark K. Ho, Robert Tyler Loftin, Bei Peng, David L. Roberts, Matthew E. Taylor, and Michael L. Littman. Interactive learning from policy-dependent human feedback. CoRR, abs/1701.06049, 2017. URL http://arxiv.org/abs/1701.06049. ",
+        "bbox": [
+            176,
+            417,
+            823,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Remi Munos, Tom Stepleton, Anna Harutyunyan, and Marc G. Bellemare. Safe and efficient off- ´ policy reinforcement learning. CoRR, abs/1606.02647, 2016. URL http://arxiv.org/ abs/1606.02647. ",
+        "bbox": [
+            173,
+            468,
+            823,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yunpeng Pan, Ching-An Cheng, Kamil Saigol, Keuntaek Lee, Xinyan Yan, Evangelos Theodorou, and Byron Boots. Agile off-road autonomous driving using end-to-end deep imitation learning. CoRR, abs/1709.07174, 2017. URL http://arxiv.org/abs/1709.07174. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            563
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross and J. Andrew Bagnell. Reinforcement and imitation learning via interactive no- ´ regret learning. CoRR, abs/1406.5979, 2014. URL http://arxiv.org/abs/1406.5979. ",
+        "bbox": [
+            173,
+            570,
+            821,
+            599
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey J. Gordon, and J. Andrew Bagnell. No-regret reductions for imitation ´ learning and structured prediction. CoRR, abs/1011.0686, 2010. URL http://arxiv.org/ abs/1011.0686. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            650
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Narek Melik-Barkhudarov, Kumar Shaurya Shankar, Andreas Wendel, Debadeepta ´ Dey, J. Andrew Bagnell, and Martial Hebert. Learning monocular reactive UAV control in cluttered natural environments. CoRR, abs/1211.1690, 2012. URL http://arxiv.org/abs/ 1211.1690. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            715
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyriacos Shiarlis, Joao Messias, and Shimon Whiteson. Inverse reinforcement learning from failure. In Proceedings of the 2016 International Conference on Autonomous Agents &#38; Multiagent Systems, AAMAS ’16, pp. 1060–1068, Richland, SC, 2016. International Foundation for Autonomous Agents and Multiagent Systems. ISBN 978-1-4503-4239-1. URL http://dl.acm.org/citation.cfm?id=2936924.2937079. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            795
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic policy gradient algorithms. In Proceedings of the 31st International Conference on International Conference on Machine Learning - Volume 32, ICML’14, pp. I–387– I–395. JMLR.org, 2014. URL http://dl.acm.org/citation.cfm?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ 3044805. 3044850. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wen Sun, Arun Venkatraman, Geoffrey J. Gordon, Byron Boots, and J. Andrew Bagnell. Deeply aggrevated: Differentiable imitation learning for sequential prediction. CoRR, abs/1703.01030, 2017. URL http://arxiv.org/abs/1703.01030. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher J. C. H. Watkins and Peter Dayan. Q-learning. In Machine Learning, pp. 279–292, 1992. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 8(3):229–256, May 1992. ISSN 1573-0565. doi: 10.1007/ BF00992696. URL https://doi.org/10.1007/BF00992696. ",
+        "bbox": [
+            176,
+            141,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            294,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.1 EXAMPLE INPUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            135,
+            333,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae4ddc473622f9106c7c7de15d1dbedcf83084b17a0ae968aeb1653e842b8a04.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            159,
+            437,
+            262
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.2 ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            284,
+            326,
+            296
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/0fcf20935e9c02f4077575941137816218716348efe565708a0357916d1057a6.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            320,
+            352,
+            757
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The architecture of our model, based on Inception v3. After the split, the branch on the right is the branch used for our PNet or FNet, while the left branch is ignored. The new layers we added were 3 fully connected layers of sizes 100, 300, and 20. The final activation is Tanh to ensure the output range of (-1,1). For the FNet, the angle input is concatenated onto the first fully-connected layer. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            837
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.3 HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            854,
+            356,
+            869
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Our batch size was 100 and we trained for 5 epochs. Unless otherwise specified for a given model in the experiments, we used an $\\alpha$ value of 1.0, we did not threshold, and we used a learning rate of 1e-6. As in the Inception model we were using, our input was bilinearly sampled to match the ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "resolution $2 9 9 \\mathrm { x } 2 9 9$ . Likewise, we subtracted off an assumed mean of $2 5 6 . 0 / 2 . 0$ and divided by an assumed standard deviation of $2 5 6 . 0 / 2 . 0$ . ",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.4 TRAINING METRICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            352,
+            162
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "During training, we kept track of two validation metrics: the loss for the model being trained, and the average absolute error on just the positive data multiplied by 50. The first we refer to as “loss” and the second we refer to as “cloning error” (since it is the 50 times the square root of the cloning error) or just “error”. The reason we multiplied by 50 is that this is how Unity converts the $^ { - 1 }$ to 1 number to a steering angle, so the error is the average angle our model is off by on the positive data. (This is true with the maximum angle set to 50.) ",
+        "bbox": [
+            173,
+            174,
+            825,
+            258
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "During training, these two metrics generally behaved very similarly, however, in the models for which we increased the learning rate, these eventually start to diverge. In this case, the error on the positive data started to increase, but the loss was still decreasing. For this reason, we tried varying the learning rate on several models, to see if the loss was more important than the “cloning” error. It is clear that the behavioral cloning models (thresholded with $\\alpha = 0 . 0$ ) should in general do better on the “cloning” error, since they are very closely related. Whereas for non-thresholded data, it was trained with examples weighted differently. And for the negative data, it was trained to also get “away” from negative examples. We hope that even though the cloning error may increase, this means that it is because the model is choosing something better than (yet further away from) the positive examples. We still use the cloning error, however, because it is a useful intuitive metric for training and comparison. ",
+        "bbox": [
+            173,
+            265,
+            825,
+            417
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.5 LEARNING RATE TUNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            434,
+            393,
+            449
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We tried several learning rates for both behavioral cloning and ReNeg. We compared the performance, shown in figures 6 and 7, and found that 1e-5 worked best for both. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            489
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/c45c2497c1279cabe104018c5f963449b671bfe70068e419c29c4b088dbd5963.jpg",
+        "image_caption": [
+            "Figure 6: The scalar loss performed best with a learning rate of 1e-5. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            379,
+            506,
+            622,
+            767
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.6 GAUSSIAN POLICY GRADIENT DERIVATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            816,
+            516,
+            830
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Here is the derivation from the stochastic policy gradient to the loss that induces it, which is very similar to our scalar loss: ",
+        "bbox": [
+            176,
+            842,
+            823,
+            869
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/164ee026e7bbc04890d89d3255d3c63320958edea7bdf44b3d1c181fdb368bbe.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla L o s s = \\nabla ( R * - l o g ( P r ( \\theta ) ) ) } \\\\ & { \\nabla L o s s = \\nabla ( R * - l o g ( \\frac { e ^ { - \\frac { ( \\theta - \\hat { \\theta } ) ^ { 2 } } { 2 \\sigma ^ { 2 } } } } { \\sqrt { 2 \\pi \\sigma ^ { 2 } } } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            867,
+            616,
+            930
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/c4cac38d402176c404918773499bd6846b5fd70915feaed836b671772501f706.jpg",
+        "image_caption": [
+            "Figure 7: The behavioral cloning loss performed best with a learning rate of 1e-5. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            382,
+            104,
+            622,
+            366
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c791deed41f34a82c0b60e957f5bc684447c5c4dd69344edf6ab29d330752923.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\nabla L o s s = \\nabla ( R * - ( l o g ( e ^ { - \\frac { ( \\theta - \\hat { \\theta } ) ^ { 2 } } { 2 \\sigma ^ { 2 } } } ) - l o g ( \\sqrt { 2 \\pi \\sigma ^ { 2 } } ) ) ) } } \\\\ { { \\nabla L o s s = \\nabla ( R * - ( l o g ( e ^ { - \\frac { ( \\theta - \\hat { \\theta } ) ^ { 2 } } { 2 \\sigma ^ { 2 } } } ) ) } } \\\\ { { \\nabla L o s s = \\nabla ( R * \\frac { ( \\theta - \\hat { \\theta } ) ^ { 2 } } { 2 \\sigma ^ { 2 } } ) } } \\\\ { { \\nabla L o s s \\propto \\nabla ( R * ( \\theta - \\hat { \\theta } ) ^ { 2 } ) } } \\\\ { { L o s s \\propto R * ( \\theta - \\hat { \\theta } ) ^ { 2 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            415,
+            673,
+            555
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "6.7 FUTURE RESEARCH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            571,
+            352,
+            587
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Future research involving human feedback should focus on 2 things: the loss function and enforcing continuity. These will be briefly explored in the next two sections. ",
+        "bbox": [
+            173,
+            598,
+            823,
+            627
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Note, before we discuss potential extensions of this work, that fine-tuning the policy once it is acceptably safe is a separate but also interesting problem. Supervised approaches involving a safety driver taking over control, and retraining on this data a la DAgger, should probably be explored. Additionally, instead of aggregating the new data with the old, active learning approaches could be explored, where the model is not entirely retrained. we point the reader to (Pan et al., 2017) for an AV application of DAgger. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            718
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "6.7.1 LOSS FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            733,
+            344,
+            748
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Immediate next steps should likely focus on alterations to the loss function. Here we introduce a fourth desired property that can ensure our negative examples have less or the same “impact” as they get farther away, and positive examples have more of an impact as they get farther away. In other words, for positive examples, as $\\mathbf { D }$ increases, the update (derivative) is always the same or greater in magnitude, and for negative examples, the same is true as $\\mathbf { D }$ decreases. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            829
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4. Concavity: ",
+        "bbox": [
+            214,
+            843,
+            305,
+            856
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The loss is concave up with respect to $\\mathrm { D }$ i.e . ∂2Loss >= 0. ",
+        "bbox": [
+            232,
+            857,
+            619,
+            876
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For positive examples, when $f > 0$ : This enforces that $| \\frac { \\partial L o s s } { \\partial D } |$ has have a minimum at $D = 0$ (the optimum), since it must be positive and increasing. Ideally, $\\frac { \\partial L o s s } { \\partial D }$ would equal 0 at $D = 0$ , and nowhere else. ",
+        "bbox": [
+            232,
+            878,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For negative examples, when $f < 0$ : This enforces that $| \\frac { \\partial L o s s } { \\partial D } |$ has have a minimum a $D = \\infty$ (the optimum), since it must be negative and increasing. Ideally, $\\frac { \\partial L o s s } { \\partial D }$ would approach 0 as $D \\to \\infty$ , and be 0 nowhere else. ",
+        "bbox": [
+            230,
+            102,
+            825,
+            148
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We propose two loss functions that meet properties 1-4: ",
+        "bbox": [
+            174,
+            161,
+            539,
+            176
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "1. We can accomplish this exponential decay by modifying our scalar function in a very easy way: Move the “sign” of f into the exponent: ",
+        "bbox": [
+            174,
+            183,
+            823,
+            212
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a6c7e7d810aec057b78f7d4d8172029fc42546de2ea98f032cb400f9e514ca72.jpg",
+        "text": "$$\nL o s s _ { i n v e r s e } = | f | * ( \\theta ( s ) - \\hat { \\theta } ( s ) ) ^ { 2 * s i g n ( f ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            218,
+            642,
+            238
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Using this loss function we have all three properties satisfied. That is, positive examples encourage moving towards them, negative examples encourage moving away from them, and the amount of this movement increases with the magnitude of f. Moreover, we also have the property that, in negative examples, loss drops off exponentially with the distance from the negative example (because we are dividing by it). ",
+        "bbox": [
+            173,
+            251,
+            825,
+            321
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "2. If we want our scalar loss function to have neither an exponential decay nor an exponential increase with the distance from the negative points, we can simply use the following loss: ",
+        "bbox": [
+            169,
+            328,
+            823,
+            358
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/13ddf535e59a8a8fa7eb51aa30f9241c94f279909b8bb822116cafe49de2212e.jpg",
+        "text": "$$\nL o s s _ { a b s o l u t e } = f * | \\theta ( s ) - \\hat { \\theta } ( s ) |\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            363,
+            609,
+            383
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "This has the not-so-nice property that, in the positive example, it allows outliers much more easily than the traditional squared loss. However, it has the very nice property that, given a single state input, as long as you have more positive examples than negative examples, your loss will always be minimized in that state by a value between your positive examples. This is because, as soon as you get to your greatest or least positive example, every step away from your positive examples will cost you 1 loss, for each positive example you have, and you will only lose 1 loss for each negative example you have. (Note, if you are not thresholding, then this translates to more total $| f |$ for positive examples than negative examples.) ",
+        "bbox": [
+            173,
+            397,
+            825,
+            510
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "6.7.2 CONTINUITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            523,
+            318,
+            539
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Because in both our scalar and exponential loss, our loss function at a given state with just a negative example is minimized by moving away from the negative example, our regression in that state will tend toward positive or negative infinity. Certainly having a cost on negative examples that drops of exponentially will help, but it may not be enough. Moreover, we may not want to rely on the structure of neural networks to discourage this discontinuity. Therefore, research could be done on adding a regularization term to the loss that penalizes discontinuity. That is, we would add some small loss based on how dissimilar the answers for nearby states are. Of course, this implies a distance metric over states, but using consecutive frames may suffice. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            660
+        ],
+        "page_idx": 15
+    }
+]

parse/train/r1lyTjAqYX/r1lyTjAqYX.md

@@ -0,0 +1,290 @@
+# RECURRENT EXPERIENCE REPLAY IN DISTRIBUTED REINFORCEMENT LEARNING
+
+Steven Kapturowski, Georg Ostrovski, John Quan, Remi Munos, Will Dabney ´ DeepMind, London, UK {skapturowski,ostrovski,johnquan,munos,wdabney}@google.com
+
+# ABSTRACT
+
+Building on the recent successes of distributed training of RL agents, in this paper we investigate the training of RNN-based RL agents from distributed prioritized experience replay. We study the effects of parameter lag resulting in representational drift and recurrent state staleness and empirically derive an improved training strategy. Using a single network architecture and fixed set of hyperparameters, the resulting agent, Recurrent Replay Distributed DQN, quadruples the previous state of the art on Atari-57, and matches the state of the art on DMLab-30. It is the first agent to exceed human-level performance in 52 of the 57 Atari games.
+
+# 1 INTRODUCTION
+
+Reinforcement Learning (RL) has seen a rejuvenation of research interest recently due to repeated successes in solving challenging problems such as reaching human-level play on Atari 2600 games (Mnih et al., 2015), beating the world champion in the game of Go (Silver et al., 2017), and playing competitive 5-player DOTA (OpenAI, 2018b). The earliest of these successes leveraged experience replay for data efficiency and stacked a fixed number of consecutive frames to overcome the partial observability in Atari 2600 games. However, with progress towards increasingly difficult, partially observable domains, the need for more advanced memory-based representations increases, necessitating more principled solutions such as recurrent neural networks (RNNs). The use of LSTMs (Hochreiter & Schmidhuber, 1997) within RL has been widely adopted to overcome partial observability (Hausknecht & Stone, 2015; Mnih et al., 2016; Espeholt et al., 2018; Gruslys et al., 2018).
+
+In this paper we investigate the training of RNNs with experience replay. We have three primary contributions. First, we demonstrate the effect of experience replay on parameter lag, leading to representational drift and recurrent state staleness. This is potentially exacerbated in the distributed training setting, and ultimately results in diminished training stability and performance. Second, we perform an empirical study into the effects of several approaches to RNN training with experience replay, mitigating the aforementioned effects. Third, we present an agent that integrates these findings to achieve significant advances in the state of the art on Atari-57 (Bellemare et al., 2013) and matches the state of the art on DMLab-30 (Beattie et al., 2016). To the best of our knowledge, our agent, Recurrent Replay Distributed DQN (R2D2), is the first to achieve this using a single network architecture and fixed set of hyper-parameters.
+
+# 2 BACKGROUND
+
+# 2.1 REINFORCEMENT LEARNING
+
+Our work is set within the Reinforcement Learning (RL) framework (Sutton & Barto, 1998), in which an agent interacts with an environment to maximize the sum of discounted, $\gamma \in [ 0 , 1 )$ , rewards. We model the environment as a Partially Observable Markov Decision Process (POMDP) given by the tuple $( S , \mathcal { A } , T , R , \Omega , \mathcal { O } )$ (Monahan, 1982; Jaakkola et al., 1995; Kaelbling et al., 1998). The underlying Markov Decision Process (MDP) is defined by $( S , { \mathcal { A } } , T , R )$ , where $s$ is the set of states, $\mathcal { A }$ the set of actions, $T$ a transition function mapping state-actions to probability distributions over next states, and $R : S \times \mathcal { A }  \mathbb { R }$ is the reward function. Finally, $\Omega$ gives the set of observations potentially received by the agent and $\mathcal { O }$ is the observation function mapping (unobserved) states to probability distributions over observations.
+
+Within this framework, the agent receives an observation $o \in \Omega$ , which may only contain partial information about the underlying state $s \in S$ . When the agent takes an action $a \in { \mathcal { A } }$ the environment responds by transitioning to state $s ^ { \prime } \sim T ( \cdot | s , a )$ and giving the agent a new observation $o ^ { \prime } \sim \Omega ( \cdot | s ^ { \prime } )$ and reward $r \sim R ( s , a )$ .
+
+Although there are many approaches to RL in POMDPs, we focus on using recurrent neural networks (RNNs) with backpropagation through time (BPTT) (Werbos, 1990) to learn a representation that disambiguates the true state of the POMDP.
+
+The Deep Q-Network agent (DQN) (Mnih et al., 2015) learns to play games from the Atari-57 benchmark by using frame-stacking of 4 consecutive frames as observations, and training a convolutional network to represent a value function with Q-learning (Watkins & Dayan, 1992), from data continuously collected in a replay buffer (Lin, 1993). Other algorithms like the A3C (Mnih et al., 2016), use an LSTM and are trained directly on the online stream of experience without using a replay buffer. Hausknecht & Stone (2015) combined DQN with an LSTM by storing sequences in replay and initializing the recurrent state to zero during training.
+
+# 2.2 DISTRIBUTED REINFORCEMENT LEARNING
+
+Recent advances in reinforcement learning have achieved significantly improved performance by leveraging distributed training architectures which separate learning from acting, collecting data from many actors running in parallel on separate environment instances (Horgan et al., 2018; Espeholt et al., 2018; Gruslys et al., 2018; OpenAI, 2018b;a; Jaderberg et al., 2018).
+
+Distributed replay allows the Ape-X agent (Horgan et al., 2018) to decouple learning from acting, with actors feeding experience into the distributed replay buffer and the learner receiving (randomized) training batches from it. In addition to distributed replay with prioritized sampling (Schaul et al., 2016), Ape-X uses $n$ -step return targets (Sutton, 1988), the double Q-learning algorithm (van Hasselt et al., 2016), the dueling DQN network architecture (Wang et al., 2016) and 4-framestacking. Ape-X achieved state-of-the-art performance on Atari-57, significantly out-performing the best single-actor algorithms. It has also been used in continuous control domains and again showed state-of-the-art results, further demonstrating the performance benefits of distributed training in RL.
+
+IMPALA (Espeholt et al., 2018) is a distributed reinforcement learning architecture which uses a first-in-first-out queue with a novel off-policy correction algorithm called V-trace, to learn sequentially from the stream of experience generated by a large number of independent actors. IMPALA stores sequences of transitions along with an initial recurrent state in the experience queue, and since experience is trained on exactly once, this data generally stays very close to the learner parameters. Espeholt et al. (2018) showed that IMPALA could achieve strong performance in the Atari-57 and DMLab-30 benchmark suites, and furthermore was able to use a single large network to learn all tasks in a benchmark simultaneously while maintaining human-level performance.
+
+# 2.3 THE RECURRENT REPLAY DISTRIBUTED DQN AGENT
+
+We propose a new agent, the Recurrent Replay Distributed DQN (R2D2), and use it to study the interplay between recurrent state, experience replay, and distributed training. R2D2 is most similar to Ape-X, built upon prioritized distributed replay and $n$ -step double Q-learning (with $n \ : = \ : 5$ ), generating experience by a large number of actors (typically 256) and learning from batches of replayed experience by a single learner. Like Ape-X, we use the dueling network architecture of Wang et al. (2016), but provide an LSTM layer after the convolutional stack, similarly to Gruslys et al. (2018).
+
+Instead of regular $( s , a , r , s ^ { \prime } )$ transition tuples, we store fixed-length ( $m = 8 0$ ) sequences of $( s , a , r )$ in replay, with adjacent sequences overlapping each other by 40 time steps, and never crossing episode boundaries. When training, we unroll both online and target networks (Mnih et al., 2015) on the same sequence of states to generate value estimates and targets. We leave details of our exact treatment of recurrent states in replay for the next sections.
+
+Like Ape-X, we use 4-frame-stacks and the full 18-action set when training on Atari. On DMLab, we use single RGB frames as observations, and the same action set discretization as Hessel et al. (2018b). Following the modified Ape-X version in Pohlen et al. (2018), we do not clip rewards, but instead use an invertible value function rescaling of the form $h ( x ) = \mathrm { s i g n } ( x ) ( \sqrt { | x | + 1 } - 1 ) + \epsilon x$ which results in the following $n$ -step targets for the Q-value function:
+
+$$
+\hat { y } _ { t } = h \left( \sum _ { k = 0 } ^ { n - 1 } r _ { t + k } \gamma ^ { k } + \gamma ^ { n } h ^ { - 1 } \left( Q ( s _ { t + n } , a ^ { * } ; \theta ^ { - } ) \right) \right) , \quad a ^ { * } = \arg \operatorname* { m a x } _ { a } Q ( s _ { t + n } , a ; \theta ) .
+$$
+
+Here, $\theta ^ { - }$ denotes the target network parameters which are copied from the online network parameters $\theta$ every 2500 learner steps.
+
+Our replay prioritization differs from that of Ape- $\mathbf { X }$ in that we use a mixture of max and mean absolute $n$ -step TD-errors $\delta _ { i }$ over the sequence: $\begin{array} { r } { p = \eta \operatorname* { m a x } _ { i } \delta _ { i } + ( 1 - \eta ) \bar { \delta } } \end{array}$ . We set $\eta$ and the priority exponent to 0.9. This more aggressive scheme is motivated by our observation that averaging over long sequences tends to wash out large errors, thereby compressing the range of priorities and limiting the ability of prioritization to pick out useful experience.
+
+Finally, compared to Ape-X, we used the slightly higher discount of $\gamma = 0 . 9 9 7$ , and disabled the loss-of-life-as-episode-end heuristic that has been used in Atari agents in some of the work since (Mnih et al., 2015). A full list of hyper-parameters is provided in the Appendix.
+
+We train the R2D2 agent with a single GPU-based learner, performing approximately 5 network updates per second (each update on a mini-batch of 64 length-80 sequences), and each actor performing $\sim 2 6 0$ environment steps per second on Atari $\sim 1 3 0$ per second on DMLab).
+
+# 3 TRAINING RECURRENT RL AGENTS WITH EXPERIENCE REPLAY
+
+In order to achieve good performance in a partially observed environment, an RL agent requires a state representation that encodes information about its state-action trajectory in addition to its current observation. The most common way to achieve this is by using an RNN, typically an LSTM (Hochreiter & Schmidhuber, 1997), as part of the agent’s state encoding. To train an RNN from replay and enable it to learn meaningful long-term dependencies, whole state-action trajectories need to be stored in replay and used for training the network. Hausknecht & Stone (2015) compared two strategies of training an LSTM from replayed experience:
+
+• Using a zero start state to initialize the network at the beginning of sampled sequences.   
+• Replaying whole episode trajectories.
+
+The zero start state strategy’s appeal lies in its simplicity, and it allows independent decorrelated sampling of relatively short sequences, which is important for robust optimization of a neural network. On the other hand, it forces the RNN to learn to recover meaningful predictions from an atypical initial recurrent state (‘initial recurrent state mismatch’), which may limit its ability to fully rely on its recurrent state and learn to exploit long temporal correlations. The second strategy on the other hand avoids the problem of finding a suitable initial state, but creates a number of practical, computational, and algorithmic issues due to varying and potentially environment-dependent sequence length, and higher variance of network updates because of the highly correlated nature of states in a trajectory when compared to training on randomly sampled batches of experience tuples.
+
+Hausknecht & Stone (2015) observed little difference between the two strategies for empirical agent performance on a set of Atari games, and therefore opted for the simpler zero start state strategy. One possible explanation for this is that in some cases, an RNN tends to converge to a more ‘typical’ state if allowed a certain number of ‘burn-in’ steps, and so recovers from a bad initial recurrent state on a sufficiently long sequence. We also hypothesize that while the zero start state strategy may suffice in the mostly fully observable Atari domain, it prevents a recurrent network from learning actual long-term dependencies in more memory-critical domains (e.g. on DMLab).
+
+To fix these issues, we propose and evaluate two strategies for training a recurrent neural network from randomly sampled replay sequences, that can be used individually or in combination:
+
+![](images/93782f93fa31b63533252d9f01f85b216b622ea3625af6020a7ac9a7a3d1994d.jpg)  
+Figure 1: Top row shows $\mathrm { Q }$ -value discrepancy $\Delta Q$ as a measure for recurrent state staleness. (a) Diagram of how $\Delta Q$ is computed, with green box indicating a whole sequence sampled from replay. For simplicity, $l = 0$ (no burn-in). (b) $\Delta Q$ measured at first state and last state of replay sequences, for agents training on a selection of DMLab levels (indicated by initials) with different training strategies. Bars are averages over seeds and through time indicated by bold line on $\mathbf { X }$ -axis in bottom row. (c) Learning curves on the same levels, varying the training strategy, and averaged over 3 seeds.
+
+• Stored state: Storing the recurrent state in replay and using it to initialize the network at training time. This partially remedies the weakness of the zero start state strategy, however it may suffer from the effect of ‘representational drift’ leading to ‘recurrent state staleness’, as the stored recurrent state generated by a sufficiently old network could differ significantly from a typical state produced by a more recent version.
+
+• Burn-in: Allow the network a ‘burn-in period’ by using a portion of the replay sequence only for unrolling the network and producing a start state, and update the network only on the remaining part of the sequence. We hypothesize that this allows the network to partially recover from a poor start state (zero, or stored but stale) and find itself in a better initial state before being required to produce accurate outputs.
+
+In all our experiments we will be using the proposed agent architecture from Section 2.3 with replay sequences of length $m = 8 0$ , with an optional burn-in prefix of $l = 4 0$ or 20 steps. Our aim is to assess the negative effects of representational drift and recurrent state staleness on network training and how they are mitigated by the different training strategies. For that, we will compare the Qvalues produced by the network on sampled replay sequences when unrolled using one of these strategies and the Q-values produced when using the true stored recurrent states at each step (see Figure 1a, showing different sources for the hidden state).
+
+More formally, let $O _ { t } , \ldots , O _ { t + m }$ and $h _ { t } , \ldots , h _ { t + m }$ denote the replay sequence of observations and stored recurrent states, and denote by $h _ { t + 1 } = h ( o _ { t } , h _ { t } ; \theta )$ and $q ( h _ { t } ; \theta )$ the recurrent state and Qvalue vector output by the recurrent neural network with parameter vector $\theta$ , respectively. We write $\hat { h } _ { t }$ for the hidden state, used during training and initialized under one of the above strategies (either $\hat { h } _ { t } = 0$ or $\hat { h } _ { t } = h _ { t } ,$ ). Then $\hat { h } _ { t + i } \ = \ h ( o _ { t + i - 1 } , \hat { h } _ { t + i - 1 } ; \hat { \theta } )$ is computed by unrolling the network with parameters $\hat { \theta }$ on the sequence $O _ { t } , \ldots , O _ { t + l + m - 1 }$ . We estimate the impact of representational drift and recurrent state staleness by their effect on the Q-value estimates, by measuring $Q$ -value discrepancy
+
+$$
+\Delta Q = \frac { | | q ( \hat { h } _ { t + i } ; \hat { \theta } ) - q ( h _ { t + i } ; \hat { \theta } ) | | _ { 2 } } { | \operatorname* { m a x } _ { a , j } ( q ( \hat { h } _ { t + j } ; \hat { \theta } ) ) _ { a } | }
+$$
+
+for the first $( i = l )$ and last $( i = l + m - 1 )$ states of the non-burn-in part of the replay sequence (see Figure 1a for an illustration). The normalization by the maximal $\mathrm { Q }$ -value helps comparability between different environments and training stages, as the $\mathbf { Q }$ -value range of an agent can vary drastically between these. Note that we are not directly comparing the Q-values produced at acting and training time, $q ( h _ { t } ; \theta )$ and $q ( \hat { h } _ { t } ; \hat { \theta } )$ , as these can naturally be expected to be distinct as the agent is being trained. Instead we focus on the difference that results from applying the same network (parameterized by $\hat { \theta }$ ) to the distinct recurrent states.
+
+In Figure 1b, we are comparing agents trained with the different strategies on several DMLab environments in terms of this proposed metric. It can be seen that the zero start state heuristic results in a significantly more severe effect of recurrent state staleness on the outputs of the network. As hypothesized above, this effect is greatly reduced for the last sequence states compared to the first ones, after the RNN has had time to recover from the atypical start state, but the effect of staleness is still substantially worse here for the zero state than the stored state strategy. Another potential downside of the pure zero state heuristic is that it prevents the agent from strongly relying on its recurrent state and exploit long-term temporal dependencies, see Section 5.
+
+We observe that the burn-in strategy on its own partially mitigates the staleness problem on the initial part of replayed sequences, while not showing a significant effect on the Q-value discrepancy for later sequence states. Empirically, this translates into noticeable performance improvements, as can be seen in Figure 1c. This itself is noteworthy, as the only difference between the pure zero state and the burn-in strategy lies in the fact that the latter unrolls the network over a prefix of states on which the network does not receive updates. In informal experiments (not shown here) we observed that this is not due to the different unroll lengths themselves (i.e., the zero state strategy without burn-in, on sequences of length $l + m$ , performed worse overall). We hypothesize that the beneficial effect of burn-in lies in the fact that it prevents ‘destructive updates’ to the RNN parameters resulting from highly inaccurate initial outputs on the first few time steps after a zero state initialization.
+
+The stored state strategy, on the other hand, proves to be overall much more effective at mitigating state staleness in terms of the Q-value discrepancy, which also leads to clearer and more consistent improvements in empirical performance. Finally, the combination of both methods consistently yields the smallest discrepancy on the last sequence states and the most robust performance gains.
+
+We conclude the section with the observation that both stored state and burn-in strategy provide substantial advantages over the naive zero state training strategy, in terms of (indirect) measures of the effect of representation drift and recurrent state staleness, and empirical performance. Since they combine beneficially, we use both of these strategies (with burn-in length of $l = 4 0$ ) in the empirical evaluation of our proposed agent in Section 4. Additional results on the effects of distributed training on representation drift and Q-value discrepancy are given in the Appendix.
+
+# 4 EXPERIMENTAL EVALUATION
+
+In this section we evaluate the empirical performance of R2D2 on two challenging benchmark suites for deep reinforcement learning: Atari-57 (Bellemare et al., 2013) and DMLab-30 (Beattie et al., 2016). One of the fundamental contributions of Deep Q-Networks (DQN) (Mnih et al., 2015) was to set as standard practice the use of a single network architecture and set of hyper-parameters across the entire suite of 57 Atari games. Unfortunately, expanding past Atari this standard has not been maintained and, to the best of our knowledge, at present there is no algorithm applied to both Atari57 and DMLab-30 under this standard. In particular, we will compare performance with Ape-X and IMPALA for which hyper-parameters are tuned separately for each benchmark.
+
+For R2D2, we use a single neural network architecture and a single set of hyper-parameters across all experiments. This demonstrates greater robustness and generality than has been previously observed in deep RL. It is also in pursuit of this generality, that we decided to disable the (Atari-specific) heuristic of treating life losses as episode ends, and did not apply reward clipping. Despite this, we observe state-of-the-art performance in both Atari and DMLab, validating the intuitions derived from our empirical study. A more detailed ablation study of the effects of these modifications is presented in the Appendix.
+
+# 4.1 ATARI-57
+
+The Atari-57 benchmark is built upon the Arcade Learning Environment (ALE) (Bellemare et al., 2013), and consists of 57 classic Atari 2600 video games. Initial human-level performance was achieved by DQN (Mnih et al., 2015), and since then RL agents have improved significantly through both algorithmic and architectural advances. Currently, state of the art for a single actor is achieved by the recent distributional reinforcement learning algorithms IQN (Dabney et al., 2018) and Rainbow (Hessel et al., 2018a), and for multi-actor results, Ape-X (Horgan et al., 2018).
+
+![](images/1934bb75b4b558b48d67caf70bb2970a64002d2b68bb09884ed49d7dfc6f46d8.jpg)  
+Figure 2: Atari-57 results. Left: median human-normalized scores and training times of various agent architectures. Diagram reproduced and extended from (Horgan et al., 2018). Right: Example individual learning curves of R2D2, averaged over 3 seeds, and Ape-X, single seed.
+
+Figure 2 (left) shows the median human-normalized scores across all games for R2D2 and related methods (see Appendix for full Atari-57 scores and learning curves). R2D2 achieves an order of magnitude higher performance than all single-actor agents and quadruples the previous state-ofthe-art performance of Ape-X using fewer actors (256 instead of 360), resulting in higher sampleand time-efficiency. Table 1 lists mean and median human-normalized scores for R2D2 and other algorithms, highlighting these improvements.
+
+In addition to achieving state-of-the-art results on the entire task suite, R2D2 also achieves the highest ever reported agent scores on a large fraction of the individual Atari games, in many cases ‘solving’ the respective games by achieving the highest attainable score. In Figure 2 (right) we highlight some of these individual learning curves of R2D2. As an example, notice the performance on MS.PACMAN is even greater than that of the agent reported in (van Seijen et al., 2017), which was engineered specifically for this game. Furthermore, we notice that Ape-X achieves super-human performance for the same number of games as Rainbow (49), and that its improvements came from improving already strong scores. R2D2 on the other hand is super-human on 52 out of 57 games. Of those remaining, we anecdotally observed that three (SKIING, SOLARIS, and PRIVATE EYE) can reach super-human performance with higher discount rates and faster target network updates. The other two (MONTEZUMA’S REVENGE and PITFALL) are known hard exploration problems, and solving these with a general-purpose algorithm will likely require new algorithmic insights.
+
+# 4.2 DMLAB-30
+
+DMLab-30 is a suite of 30 problems set in a 3D first-person game engine, testing for a wide range of different challenges (Beattie et al., 2016). While Atari can largely be approached with only frame-stacking, DMLab-30 requires long-term memory to achieve reasonable performance. Perhaps because of this, and the difficulty of integrating recurrent state with experience replay, topperforming agents have, to date, always come in the form of actor-critic algorithms trained in (near) on-policy settings. For the first time we show state-of-the-art performance on DMLab-30 using a value-function-based agent. We stress that, different from the state-of-the-art IMPALA architecture (Espeholt et al., 2018), the R2D2 agent uses the same set of hyper-parameters here as on Atari.
+
+Here we are mainly interested in comparing to the IMPALA ‘experts’, not to its multi-task variant. Since the original IMPALA experts were trained on a smaller amount of data (approximately 333M environment frames) and since R2D2 uses the improved action set introduced in (Hessel et al., 2018b), we decided to re-run the IMPALA agent with improved action set and for a comparable training time (10B environment frames) for a fairer comparison, resulting in substantially improved scores for the IMPALA agent compared to the original in (Espeholt et al., 2018), see Table 1.
+
+![](images/e957f23a3a12aa20add90ddbd8e73df1ac0e4afa6bd32a4ea273b3308164c260.jpg)  
+Figure 3: DMLab-30 comparison of R2D2 and $\mathrm { R } 2 \mathrm { D } 2 +$ with our re-run of IMPALA shallow and deep in terms of mean-capped human-normalized score (Espeholt et al., 2018).
+
+Table 1: Comparison of Atari-57 and DMLab-30 results. R2D2 average final score over 3 seeds (1 seed for feed-forward variant), IMPALA final score over 1 seed, Ape-X best training score with 1 seed. Our re-run of IMPALA uses the same improved action set from (Hessel et al., 2018b) as R2D2, and is trained for a comparable number of environment frames (10B frames; the original IMPALA experts in (Espeholt et al., 2018) were only trained for approximately 333M frames). $\mathrm { R } 2 \mathrm { D } 2 +$ refers to the adapted R2D2 variant matching deep IMPALA’s 15-layer ResNet architecture and asymmetric reward clipping, as well as using a shorter target update period of 400.   
+
+<table><tr><td rowspan="2">Human-Normalized Score</td><td colspan="2">Atari-57</td><td colspan="2">DMLab-30</td></tr><tr><td>Median</td><td>Mean</td><td>Median</td><td>Mean-Capped</td></tr><tr><td>Ape-X (Horgan et al., 2018)</td><td>434.1%</td><td>1695.6%</td><td>1</td><td>1</td></tr><tr><td>Reactor (Gruslys et al., 2018)</td><td>187.0%</td><td>1</td><td>1</td><td>1</td></tr><tr><td>IMPALA, deep (Espeholt et al., 2018)</td><td>191.8%</td><td>957.6%</td><td>49.0%</td><td>45.8%</td></tr><tr><td>IMPALA, shallow (re-run)</td><td>1</td><td>1</td><td>89.7%</td><td>73.6%</td></tr><tr><td>IMPALA, deep (re-run)</td><td>1</td><td>1</td><td>107.5%</td><td>85.1%</td></tr><tr><td>R2D2+</td><td></td><td>1</td><td>99.5%</td><td>85.7%</td></tr><tr><td>R2D2,feed-forward</td><td>589.2%</td><td>1974.4%</td><td>二</td><td>二</td></tr><tr><td>R2D2</td><td>1920.6%</td><td>4024.9%</td><td>96.9%</td><td>78.3%</td></tr></table>
+
+Figure 3 compares R2D2 with IMPALA. We note that R2D2 exceeds the performance of the (shallow) IMPALA version, despite using the exact same set of hyper-parameters and architecture as the variant trained on Atari, and in particular not using the ‘optimistic asymmetric reward clipping’ used by all IMPALA agents1.
+
+To demonstrate the potential of our agent, we also devise a somewhat adapted R2D2 version for DMLab only $( \mathsf { R } 2 \mathsf { D } 2 + )$ by adding asymmetric reward clipping, using the 15-layer ResNet from IMPALA (deep), and reducing the target update frequency from 2500 to 400 for better sample efficiency. To fit the larger model in GPU memory, we reduced the batch size from 64 to 32 in these runs only. We observe that this modified version yields further substantial improvements over standard R2D2 and matches deep IMPALA in terms of sample efficiency as well as asymptotic performance. Both our re-run of deep IMPALA and $\mathrm { R } 2 \mathrm { D } 2 +$ are setting new state-of-the-art scores on the DMLab-30 benchmark.
+
+![](images/a1515cd5aa97fe9970c1fcd0104f77bbfe2ecafed39017d2e3de5af6a71b5c0a.jpg)  
+Figure 4: Ablations with reward clipping instead of value function rescaling (Clipped), smaller discount factor of $\gamma = 0 . 9 9$ (Discount), and feed-forward (Feed-Forward) variants of R2D2.
+
+![](images/3ef23cc25165d66718031f98b4459f4ad07f7d9268997d80c946842ec1eb0cd0.jpg)  
+Figure 5: Effect of restricting R2D2’s policy’s memory on MS.PACMAN and EMSTM WATERMAZE.
+
+# 5 ANALYSIS OF AGENT PERFORMANCE
+
+Atari-57 is a class of environments which are almost fully observable (given 4-frame-stack observations), and agents trained on it are not necessarily expected to strongly benefit from a memoryaugmented representation. The main algorithmic difference between R2D2 and its predecessor, Ape-X, is the use of a recurrent neural network, and it is therefore surprising by how large a margin R2D2 surpasses the previous state of the art on Atari. In this section we analyze the role of the LSTM network and other algorithmic choices for the high performance of the R2D2 agent.
+
+Since the performance of asynchronous or distributed RL agents can depend on subtle implementational details and even factors such as precise hardware setup, it is impractical to perform a direct comparison to the Ape-X agent as reported in (Horgan et al., 2018). Instead, here we verify that the LSTM and its training strategy play a crucial role for the success of R2D2 by a comparison of the R2D2 agent with a purely feed-forward variant, all other parameters held fixed. Similarly, we consider the performance of R2D2 using reward clipping without value rescaling (Clipped) and using a smaller discount factor of $\gamma = 0 . 9 9$ (Discount). The ablation results in Figure 4 show very clearly that the LSTM component is crucial for boosting the agent’s peak performance as well as learning speed, explaining much of the performance difference to Ape-X. Other design choices have more mixed effects, improving in some games and hurting performance in others. Full ablation results (in particular, an ablation over the full Atari-57 suite of the feed-forward agent variant, as well as an ablation of the use of the life-loss-as-episode-termination heuristic) are presented in the Appendix.
+
+In our next experiment we test to what extent the R2D2 agent relies on its memory, and how this is impacted by the different training strategies. For this we select the Atari game MS.PACMAN, on which R2D2 shows state-of-the-art performance despite the game being virtually fully observable, and the DMLab task EMSTM WATERMAZE, which strongly requires the use of memory. We train two agents on each game, using the zero and stored state strategies, respectively. We then evaluate these agents by restricting their policy to a fixed history length: at time step $t$ , their policy uses an LSTM unrolled over time steps $O _ { t - k + 1 } , \ldots , O _ { t }$ , with the hidden state $h _ { t - k }$ replaced by zero instead of the actual hidden state (note this is only done for evaluation, not at training time of the agents).
+
+In Figure 5 (left) we decrease the history length $k$ from $\infty$ (full history) down to 0 and show the degradation of agent performance (measured as mean score over 10 episodes) as a function of $k$ We additionally show the difference of max-Q-values and the percentage of correct greedy actions (where the unconstrained variant is taken as ground truth).
+
+We observe that restricting the agent’s memory gradually decreases its performance, indicating its nontrivial use of memory on both domains. Crucially, while the agent trained with stored state shows higher performance when using the full history, its performance decays much more rapidly than for the agent trained with zero start states. This is evidence that the zero start state strategy, used in past RNN-based agents with replay, limits the agent’s ability to learn to make use of its memory. While this doesn’t necessarily translate into a performance difference (like in MS.PACMAN), it does so whenever the task requires an effective use of memory (like EMSTM WATERMAZE). This advantage of the stored state compared to the zero state strategy may explain the large performance difference between R2D2 and its close cousin Reactor (Gruslys et al., 2018), which trains its LSTM policy from replay with the zero state strategy.
+
+Finally, the right and middle columns of Figure 5 show a monotonic decrease of the quality of Qvalues and the resulting greedy policy as the available history length $k$ is decreased to 0, providing a simple causal link between the constraint and the empirical agent performance.
+
+For a qualitative comparison of different behaviours learned by R2D2 and its feed-forward variant, we provide several agent videos at https://bit.ly/r2d2600.
+
+# 6 CONCLUSIONS
+
+Here we take a step back from evaluating performance and discuss our empirical findings in a broader context. There are two surprising findings in our results.
+
+First, although zero state initialization was often used in previous works (Hausknecht & Stone, 2015; Gruslys et al., 2018), we have found that it leads to misestimated action-values, especially in the early states of replayed sequences. Moreover, without burn-in, updates through BPTT to these early time steps with poorly estimated outputs seem to give rise to destructive updates and hinder the network’s ability to recover from sub-optimal initial recurrent states. This suggests that either the context-dependent recurrent state should be stored along with the trajectory in replay, or an initial part of replayed sequences should be reserved for burn-in, to allow the RNN to rely on its recurrent state and exploit long-term temporal dependencies, and the two techniques can also be combined beneficially. We have also observed that the underlying problems of representational drift and recurrent state staleness are potentially exacerbated in the distributed setting (see Appendix), highlighting the importance of robustness to these effects through an adequate training strategy of the RNN.
+
+Second, we found that the impact of RNN training goes beyond providing the agent with memory. Instead, RNN training also serves a role not previously studied in RL, potentially by enabling better representation learning, and thereby improves performance even on domains that are fully observable and do not obviously require memory (cf. BREAKOUT results in the feed-forward ablation).
+
+Finally, taking a broader view on our empirical results, we note that scaling up of RL agents through parallelization and distributed training allows them to benefit from huge experience throughput and achieve ever-increasing results over broad simulated task suites such as Atari-57 and DMLab-30. Impressive as these results are in terms of raw performance, they come at the price of high sample complexity, consuming billions of simulated time steps in hours or days of wall-clock time. One widely open avenue for future work lies in improving the sample efficiency of these agents, to allow applications to domains that do not easily allow fast simulation at similar scales. Another remaining challenge, very apparent in our results on Atari-57, is exploration: Save for the hardest-exploration games from Atari-57, R2D2 surpasses human-level performance on this task suite significantly, essentially ‘solving’ many of the games therein.
+
+# ACKNOWLEDGMENTS
+
+We are tremendously grateful to our colleagues at DeepMind and Google for their contributions to this work, as well as to the anonymous reviewers for their feedback. We thank Hado van Hasselt, Tom Schaul, and David Silver for feedback on an earlier draft of the paper. We thank Toby Pohlen, Bilal Piot, Tom Stepleton, and Mohammad Gheshlaghi Azar for helpful conversations and advice during development and writing.
+
+We want to thank John Aslanides for many engineering contributions to the underlying agent infrastructure, and Gabriel Barth-Maron, Manuel Kroiss, David Budden, Jackie Kay, Matt Hoffman for library and training infrastructure support.
+
+Sean Silva provided an incredibly comprehensive analysis of our initial submission results that made several novel observations about the benefits of memory in Atari. Finally, for generously providing raw data of previous agents, we wish to thank Hubert Soyer, Dan Horgan, Matteo Hessel, Simon Schmitt, Lasse Espeholt, and Audrunas Gruslys.
+
+# REFERENCES
+
+Charles Beattie, Joel Z Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Kuttler,¨ Andrew Lefrancq, Simon Green, V´ıctor Valdes, Amir Sadik, et al. DeepMind Lab. ´ arXiv preprint arXiv:1612.03801, 2016.
+
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The Arcade Learning Environment: an evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.
+
+Will Dabney, Georg Ostrovski, David Silver, and Remi Munos. Implicit quantile networks for distributional reinforcement learning. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1096–1105, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. PMLR.
+
+Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymir Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al. Impala: Scalable distributed deep-rl with importance weighted actor-learner architectures. arXiv preprint arXiv:1802.01561, 2018.
+
+Audrunas Gruslys, Will Dabney, Mohammad Gheshlaghi Azar, Bilal Piot, Marc Bellemare, and Remi Munos. The reactor: A fast and sample-efficient actor-critic agent for reinforcement learning. In International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id ${ . } = { }$ rkHVZWZAZ.
+
+Matthew Hausknecht and Peter Stone. Deep recurrent Q-learning for partially observable MDPs. CoRR, abs/1507.06527, 7(1), 2015.
+
+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. In Proceedings of the AAAI Conference on Artificial Intelligence, 2018a.
+
+Matteo Hessel, Hubert Soyer, Lasse Espeholt, Wojciech Czarnecki, Simon Schmitt, and Hado van Hasselt. Multi-task deep reinforcement learning with popart. arXiv preprint arXiv:1809.04474, 2018b.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado Van Hasselt, and David Silver. Distributed prioritized experience replay. arXiv preprint arXiv:1803.00933, 2018.
+
+Tommi Jaakkola, Satinder P Singh, and Michael I Jordan. Reinforcement learning algorithm for partially observable markov decision problems. In Advances in neural information processing systems, pp. 345–352, 1995.
+
+Max Jaderberg, Wojciech M Czarnecki, Iain Dunning, Luke Marris, Guy Lever, Antonio Garcia Castaneda, Charles Beattie, Neil C Rabinowitz, Ari S Morcos, Avraham Ruderman, et al. Humanlevel performance in first-person multiplayer games with population-based deep reinforcement learning. arXiv preprint arXiv:1807.01281, 2018.
+
+Leslie Pack Kaelbling, Michael L Littman, and Anthony R Cassandra. Planning and acting in partially observable stochastic domains. Artificial intelligence, 101(1-2):99–134, 1998.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Long-Ji Lin. Reinforcement learning for robots using neural networks. Technical report, CarnegieMellon Univ Pittsburgh PA School of Computer Science, 1993.
+
+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, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International conference on machine learning, pp. 1928–1937, 2016.
+
+George E Monahan. State of the arta survey of partially observable markov decision processes: theory, models, and algorithms. Management Science, 28(1):1–16, 1982.
+
+OpenAI. Learning dexterous in-hand manipulation. arXiv preprint: arxiv:1808.00177, 2018a.
+
+OpenAI. OpenAI Five. https://blog.openai.com/openai-five/, 2018b.
+
+Tobias Pohlen, Bilal Piot, Todd Hester, Mohammad Gheshlaghi, Dan Horgan, David Budden, Gabriel Barth-Maron, Hado Van Hasselt, John Quan, Mel Vecerik, Matteo Hessel, Remi Munos, and Olivier Pietquin. Observe and look further: Achieving consistent performance on atari. arXiv preprint: arxiv:1805.11593, 2018.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. In Proceedings of the International Conference on Learning Representations (ICLR), 2016.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017.
+
+Richard S. Sutton. Learning to predict by the methods of temporal differences. Machine Learning, 3(1):9–44, 1988.
+
+Richard S. Sutton and Andrew G. Barto. Reinforcement Learning: An Introduction. MIT Press, 1998.
+
+Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double Qlearning. In Proceedings of the AAAI Conference on Artificial Intelligence, 2016.
+
+Harm van Seijen, Mehdi Fatemi, Joshua Romoff, Romain Laroche, Tavian Barnes, and Jeffrey Tsang. Hybrid reward architecture for reinforcement learning. In Advances in Neural Information Processing Systems, pp. 5392–5402, 2017.
+
+Ziyu Wang, Tom Schaul, Matteo Hessel, Hado van Hasselt, Marc Lanctot, and Nando de Freitas. Dueling network architectures for deep reinforcement learning. In Proceedings of the International Conference on Machine Learning (ICML), 2016.
+
+Christopher JCH Watkins and Peter Dayan. Q-learning. Machine Learning, 8(3):279–292, 1992.
+
+Paul J Werbos. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78(10):1550–1560, 1990.
+
+![](images/1111d81331b5fc4644ae04c08acf714dee0b1322dad6001bfafa3885191d0594.jpg)  
+Figure 6: Left: Parameter lag experienced with distributed prioritized replay with (top) 256 and (bottom) 64 actors on four DMLab levels: explore obstructed goals large (eogl), explore object rewards many (eorm), lasertag three opponents small (lots), rooms watermaze (rw). Center: initialstate and Right: final-state Q-value discrepancy for the same set of experiments.
+
+# APPENDIX
+
+EFFECT OF DISTRIBUTED RL AGENT TRAINING
+
+In this section, we investigate the effects of distributed training of an agent using a recurrent neural network, where a large number of actors feed their experience into a replay buffer for a single learner.
+
+On the one hand, the distributed setting typically presents a less severe problem of representational drift than the single-actor case, such as the one studied in (Hausknecht & Stone, 2015). This is because in relative terms, the large amount of generated experience is replayed less frequently (on average, an experience sample is replayed less than once in the Ape-X agent, compared to eight times in DQN), and so distributed agent training tends to give rise to a smaller degree of ‘parameter lag’ (the mean age, in parameter updates, of the network parameters used to generate an experience, at the time it is being replayed).
+
+On the other hand, the distributed setting allows for easy scaling of computational resources according to hardware or time constraints. An ideal distributed agent should therefore be robust to changes in, e.g., the number of actors, without careful parameter re-tuning. As we have seen in the previous section, RNN training from replay is sensitive to the issue of representational drift, the severity of which can depend on exactly these parameters.
+
+To investigate these effects, we train the R2D2 agent with a substantially smaller number of actors. This has a direct (inversely proportional) effect on the parameter lag (see Figure 6(left)). Specifically, in our experiments, as the number of actors is changed from 256 to 64, the mean parameter lag goes from 1500 to approximately 5500 parameter updates, which in turn impacts the magnitude of representation drift and recurrent state staleness, as measured by $\Delta Q$ in Section 3.
+
+The right two columns in Figure 6 show an overall increase of the average $\Delta Q$ for the smaller number of actors, both for first and last states of replayed sequences. This supports the above intuitions and highlights the increased importance of an improved training strategy (compared to the zero state strategy) in the distributed training setting, if a certain level of empirical agent performance is to be maintained across ranges of extrinsic and potentially hardware dependent parameters.
+
+![](images/f371d5ed047681192f65e894bf59a054052e1bafdca205328c7c40a14def41b6.jpg)  
+Figure 7: Ablation results with standard deviations shown by shading (3 seeds). ‘Clipped’ refers to the agent variant using clipped rewards (instead of value function rescaling), ‘discount’ refers to the use of a discount value of 0.99 (instead of 0.997).
+
+![](images/2386f41e8e77bfc9b787e43594d986418a2863e65ae227f234e70d4fbb86cd7e.jpg)  
+Figure 8: Ablation results for the use of life loss as episode termination on Atari, with standard deviations shown by shading (3 seeds). ‘reset’ refers to the agent variant using life losses as full episode terminations (preventing value function bootstrapping across life loss events, as well as resetting the LSTM state), whereas ‘roll’ only prevents value function bootstrapping, but unrolls the LSTM for the duration of a full episode (potentially spanning multiple life losses).
+
+EXTENDED RESULTS
+
+In this section we give additional experimental results supporting our empirical study in the main text. Figure 7 gives a more in-depth view of the ablation results from Figure 4. We see that, with the exception of the feed-forward ablation, there are always games in which the ablated choice performs better. Our choice of architecture and configuration optimizes for overall performance and general (cross-domain) applicability, but for individual games there are different configurations that would yield improved performance.
+
+Additionally, in Figure 8 we compare R2D2 with variants using the life loss signal as episode termination. Both ablation variants interrupt value function bootstrapping past the life loss events, but differ in that one (‘reset’) also resets the LSTM state at these events, whereas the other (‘roll’) only resets the LSTM state at actual episode boundaries, like regular R2D2. Despite the fact that the life loss heuristic is generally helpful to speed up learning in Atari, we did not use it in our main R2D2 agent for the sake of generality of the algorithm.
+
+![](images/e458fb9919f564eb3a5c7c494d797fc303f2dfd5d752515ad9c085b378d64392.jpg)  
+Figure 9: Comparing sample efficiency between state-of-the-art agents on Atari-57. We observe a general trend of increasing final performance being negatively correlated with sample efficiency, which holds for all four algorithms compared.
+
+In Figure 9 we compare the sample efficiency of R2D2 with recent state-of-the-art agents on Atari-57 in terms of human-normalized median score. As expected, the more distributed agents have worse sample efficiency early on, but also much improved long-term performance. This is an interesting correlation on its own, but we add that R2D2 appears to achieve a qualitatively different performance curve than any of the other algorithms.
+
+Note that, while Ape-X has a larger number of actors than R2D2 (360 compared to 256), its learner processes approximately 20 batches of size 512 per second, whereas R2D2 performs updates on batches of $6 4 \times 8 0$ observations (batch size $\times$ sequence length), at a rate of approximately 5 per second. This results in a reduced ‘replay ratio’ (effective number of times each experienced observation is being replayed): On average, Ape-X replays each observation approximately 1.3 times, whereas this number is only about 0.8 for R2D2, which explains the initial sample efficiency advantage of Ape-X.
+
+# HYPER-PARAMETERS
+
+R2D2 uses the same 3-layer convolutional network as DQN (Mnih et al., 2015), followed by an LSTM with 512 hidden units, which feeds into the advantage and value heads of a dueling network (Wang et al., 2016), each with a hidden layer of size 512. Additionally, the LSTM receives as input the reward and one-hot action vector from the previous time step. On the four language tasks in the DMLab suite, we are using the same additional language-LSTM with 64 hidden units as IMPALA (Espeholt et al., 2018).
+
+Table 2: Hyper-parameters values used in R2D2. All missing parameters follow the ones in Ape-X (Horgan et al., 2018).   
+
+<table><tr><td>Number of actors Actor parameter update interval</td><td>256 400 environment steps</td></tr><tr><td>Sequence length m Replay buffer size Priority exponent</td><td>80 (+ prefix of l = 40 in burn-in experiments) 4 × 106 observations (lo5 part-overlapping sequences) 0.9</td></tr><tr><td>Importance sampling exponent Discount y</td><td>0.6 0.997</td></tr><tr><td>Minibatch size</td><td>64 (32 for R2D2+ on DMLab)</td></tr><tr><td>Optimizer</td><td>Adam (Kingma&amp;Ba,2014)</td></tr><tr><td>Optimizer settings Target network update interval</td><td>learning rate = 10-4,ε = 10-3</td></tr><tr><td>Value function rescaling</td><td>2500 updates</td></tr><tr><td></td><td>h(𝑥)= sign(𝑥)(√|x|+1-1) + ∈x,∈= 10-3</td></tr></table>
+
+As is usual for agent training on Atari since (Mnih et al., 2015), we cap all (training and evaluation) episodes at 30 minutes (108, 000 environment frames). All reported scores are (undiscounted)
+
+episode returns. For the R2D2 agent we always report final scores (as opposed to some of the comparison agents that use best score attained during training).
+
+FULL RESULTS   
+Table 3: Performance of R2D2 and $\mathrm { R } 2 \mathrm { D } 2 +$ , averaged over 3 seeds, compared to our own singleseed re-run of IMPALA (shallow/deep) with improved action-set and trained on the same amount of data (10B environment frames). Compared to standard R2D2, the $\mathrm { R } 2 \mathrm { D } 2 +$ variant uses a shorter target network update frequency (400 compared to 2500), as well as the substantially larger 15-layer ResNet and the custom ‘optimistic asymmetric reward clipping’ from (Espeholt et al., 2018).   
+
+<table><tr><td>GAMES</td><td>IMPALA(S)</td><td>IMPALA(D)</td><td>R2D2</td><td>R2D2+</td></tr><tr><td>rooms_collect_good_objects_test</td><td>10.0</td><td>10.0</td><td>9.8</td><td>9.9</td></tr><tr><td>rooms_exploit_deferred_effects_test</td><td>46.0</td><td>62.2</td><td>39.9</td><td>38.1</td></tr><tr><td>rooms_select_nonmatching_object</td><td>11.0</td><td>39.0</td><td>2.3</td><td>63.6</td></tr><tr><td>rooms_watermaze</td><td>48.4</td><td>47.0</td><td>45.9</td><td>49.0</td></tr><tr><td>rooms_keys_doors_puzzle</td><td>43.8</td><td>54.6</td><td>52.0</td><td>46.2</td></tr><tr><td>language_select_described_object</td><td>638.0</td><td>664.0</td><td>445.9</td><td>617.6</td></tr><tr><td>language_select_located_object</td><td>534.8</td><td>731.4</td><td>555.4</td><td>772.8</td></tr><tr><td>language_execute_random_task</td><td>515.2</td><td>465.4</td><td>363.1</td><td>497.4</td></tr><tr><td>language_answer_quantitative_question</td><td>18.0</td><td>362.0</td><td>258.0</td><td>344.4</td></tr><tr><td>lasertag_one_opponent_large</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>lasertag_three_opponents_large</td><td>0.0</td><td>32.2</td><td>22.9</td><td>28.6</td></tr><tr><td>lasertag_one_opponent_small</td><td>0.0</td><td>0.0</td><td>0.0</td><td>31.8</td></tr><tr><td>lasertag_three_opponents_small</td><td>53.8</td><td>57.2</td><td>42.8</td><td>49.0</td></tr><tr><td>natlab_fixed_large_map</td><td>57.0</td><td>63.4</td><td>48.9</td><td>60.6</td></tr><tr><td>natlab_varying_map_regrowth</td><td>22.4</td><td>34.0</td><td>25.7</td><td>24.6</td></tr><tr><td>natlab_varying_map_randomized</td><td>48.6</td><td>47.0</td><td>40.8</td><td>42.4</td></tr><tr><td>skymaze_irreversible_path_hard</td><td>80.0</td><td>80.0</td><td>84.0</td><td>76.0</td></tr><tr><td>skymaze_irreversible_path_varied</td><td>80.0</td><td>100.0</td><td>80.0</td><td>76.0</td></tr><tr><td>psychlab_arbitrary_visuomotor_mapping</td><td>37.0</td><td>38.4</td><td>34.2</td><td>33.1</td></tr><tr><td>psychlab_continuous_recognition</td><td>30.2</td><td>28.6</td><td>29.4</td><td>30.0</td></tr><tr><td>psychlab_sequential_comparison</td><td>30.8</td><td>29.6</td><td>30.8</td><td>30.0</td></tr><tr><td>psychlab_visual_search</td><td>80.0</td><td>80.0</td><td>79.6</td><td>79.9</td></tr><tr><td>explore_object_locations_small</td><td>104.0</td><td>100.4</td><td>82.9</td><td>83.7</td></tr><tr><td>explore_object_locations_large</td><td>78.8</td><td>91.0</td><td>52.4</td><td>60.6</td></tr><tr><td>explore_obstructed_goals_small</td><td>324.0</td><td>372.0</td><td>357.6</td><td>311.9</td></tr><tr><td>explore_obstructed_goals_large</td><td>150.0</td><td>102.0</td><td>63.2</td><td>95.5</td></tr><tr><td>explore_goal_locations_small</td><td>566.0</td><td>482.0</td><td>459.6</td><td>460.7</td></tr><tr><td>explore_goal_locations_large</td><td>386.0</td><td>316.0</td><td>328.0</td><td>174.7</td></tr><tr><td>explore_object_rewards_few</td><td>39.0</td><td>92.6</td><td>76.5</td><td>80.7</td></tr><tr><td>explore_object_rewards_many</td><td>79.8</td><td>89.4</td><td>59.7</td><td>75.8</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+<table><tr><td rowspan=1 colspan=8>GAMES</td><td rowspan=1 colspan=2>HUMAN</td><td rowspan=1 colspan=1>REACTOR</td><td rowspan=1 colspan=1>IMPALA(S/D)</td><td rowspan=1 colspan=1>APE-X</td><td rowspan=1 colspan=1>R2D2</td></tr><tr><td rowspan=1 colspan=8>alienamidar</td><td rowspan=1 colspan=2>7127.81719.5</td><td rowspan=1 colspan=1>6482.1833.0</td><td rowspan=1 colspan=1>1536.0/15962.1497.6/1554.8</td><td rowspan=1 colspan=1>40804.98659.2</td><td rowspan=1 colspan=1>229496.929321.4</td></tr><tr><td rowspan=1 colspan=8>assault</td><td rowspan=1 colspan=2>742.0</td><td rowspan=1 colspan=1>11013.5</td><td rowspan=1 colspan=1>12086.9/19148.5</td><td rowspan=1 colspan=1>24559.4</td><td rowspan=1 colspan=1>108197.0</td></tr><tr><td rowspan=1 colspan=8>asterix</td><td rowspan=1 colspan=2>8503.3</td><td rowspan=1 colspan=1>36238.5</td><td rowspan=1 colspan=1>29692.5/300732.0</td><td rowspan=1 colspan=1>313305.0</td><td rowspan=1 colspan=1>999153.3</td></tr><tr><td rowspan=3 colspan=8>asteroidsatlantisbank_heist</td><td rowspan=2 colspan=2>asteroidsatlantis</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>473</td></tr><tr><td rowspan=1 colspan=6></td><td rowspan=1 colspan=2>29028.1</td><td rowspan=1 colspan=1>308257.5</td><td rowspan=1 colspan=1>773355.5/849967.5</td><td rowspan=1 colspan=1>944497.5</td><td rowspan=1 colspan=1>1620764.0</td></tr><tr><td rowspan=1 colspan=2>753.1</td><td rowspan=1 colspan=1>988.7</td><td rowspan=1 colspan=1>1200.3/1223.2</td><td rowspan=1 colspan=1>1716.4</td><td rowspan=1 colspan=1>24235.9</td></tr><tr><td rowspan=1 colspan=8>battle_zone</td><td rowspan=1 colspan=2>37187.5</td><td rowspan=1 colspan=1>61220.0</td><td rowspan=1 colspan=1>13015.0/20885.0</td><td rowspan=1 colspan=1>98895.0</td><td rowspan=1 colspan=1>751880.0</td></tr><tr><td rowspan=2 colspan=8>beam_riderberzerk</td><td rowspan=2 colspan=2>16926.52630.4</td><td rowspan=1 colspan=1>8566.5</td><td rowspan=1 colspan=1>8219.9/32463.5</td><td rowspan=1 colspan=1>63305.2</td><td rowspan=1 colspan=1>188257.4</td></tr><tr><td rowspan=1 colspan=1>1641.4</td><td rowspan=1 colspan=1>888.3/1852.7</td><td rowspan=1 colspan=1>57196.7</td><td rowspan=1 colspan=1>53318.7</td></tr><tr><td rowspan=1 colspan=6>bowling</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>160.7</td><td rowspan=1 colspan=1>75.4</td><td rowspan=2 colspan=1>35.7/59.996.3/100.0</td><td rowspan=2 colspan=1>17.6100.0</td><td rowspan=2 colspan=1>219.598.5</td></tr><tr><td rowspan=1 colspan=8>boxing</td><td rowspan=1 colspan=2>12.1</td><td rowspan=1 colspan=1>99.4</td></tr><tr><td rowspan=1 colspan=8>breakout</td><td rowspan=1 colspan=2>30.5</td><td rowspan=1 colspan=1>518.4</td><td rowspan=1 colspan=1>640.4/787.3</td><td rowspan=1 colspan=1>800.9</td><td rowspan=1 colspan=1>837.7</td></tr><tr><td rowspan=2 colspan=8>centipedechopper_command</td><td rowspan=1 colspan=2>12017.0</td><td rowspan=1 colspan=1>3402.8</td><td rowspan=1 colspan=1>5528.1/11049.8</td><td rowspan=1 colspan=1>12974.0</td><td rowspan=1 colspan=1>599140.3</td></tr><tr><td rowspan=1 colspan=2>7387.8</td><td rowspan=1 colspan=1>37568.0</td><td rowspan=1 colspan=1>5012.0/28255.0</td><td rowspan=1 colspan=1>721851.0</td><td rowspan=1 colspan=1>986652.0</td></tr><tr><td rowspan=1 colspan=8>crazy_climber</td><td rowspan=1 colspan=2>35829.4</td><td rowspan=1 colspan=1>194347.0</td><td rowspan=1 colspan=1>136211.5/136950.0</td><td rowspan=1 colspan=1>320426.0</td><td rowspan=1 colspan=1>366690.7</td></tr><tr><td rowspan=1 colspan=8>defender</td><td rowspan=1 colspan=2>18688.9</td><td rowspan=1 colspan=1>113127.8</td><td rowspan=1 colspan=1>58718.3/185203.0</td><td rowspan=1 colspan=1>411943.5</td><td rowspan=1 colspan=1>665792.0</td></tr><tr><td rowspan=1 colspan=8>demon_attack</td><td rowspan=1 colspan=2>1971.0</td><td rowspan=1 colspan=1>100188.5</td><td rowspan=1 colspan=1>107264.7/132827.0</td><td rowspan=1 colspan=1>133086.4</td><td rowspan=1 colspan=1>140002.3</td></tr><tr><td rowspan=1 colspan=6>double_dunk</td><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>-16.4</td><td rowspan=1 colspan=1>11.4</td><td rowspan=1 colspan=1>-0.4/-0.3</td><td rowspan=2 colspan=1>12.82177.4</td><td rowspan=2 colspan=1>23.72372.7</td></tr><tr><td rowspan=1 colspan=8>enduro</td><td rowspan=1 colspan=2>860.5</td><td rowspan=1 colspan=1>2230.1</td><td rowspan=1 colspan=1>0.0/0.0</td></tr><tr><td rowspan=1 colspan=8>fishing_derby</td><td rowspan=1 colspan=2>-38.8</td><td rowspan=1 colspan=1>23.2</td><td rowspan=1 colspan=1>32.1/44.9</td><td rowspan=1 colspan=1>44.4</td><td rowspan=1 colspan=1>85.8</td></tr><tr><td rowspan=1 colspan=8>freeway</td><td rowspan=1 colspan=2>29.6</td><td rowspan=1 colspan=1>31.4</td><td rowspan=1 colspan=1>0.0/0.0</td><td rowspan=1 colspan=1>33.7</td><td rowspan=1 colspan=1>32.5</td></tr><tr><td rowspan=1 colspan=8>frostbite</td><td rowspan=1 colspan=2>4334.7</td><td rowspan=1 colspan=1>8042.1</td><td rowspan=1 colspan=1>269.6/317.8</td><td rowspan=1 colspan=1>9328.6</td><td rowspan=1 colspan=1>315456.4</td></tr><tr><td rowspan=1 colspan=8>gopher</td><td rowspan=1 colspan=2>2412.5</td><td rowspan=1 colspan=1>69135.1</td><td rowspan=1 colspan=1>1002.4/66782.3</td><td rowspan=1 colspan=1>120500.9</td><td rowspan=1 colspan=1>124776.3</td></tr><tr><td rowspan=1 colspan=8>gravitar</td><td rowspan=1 colspan=2>3351.4</td><td rowspan=1 colspan=1>1073.8</td><td rowspan=1 colspan=1>211.5/359.5</td><td rowspan=1 colspan=1>1598.5</td><td rowspan=1 colspan=1>15680.7</td></tr><tr><td rowspan=1 colspan=8>hero</td><td rowspan=1 colspan=2>30826.4</td><td rowspan=1 colspan=1>35542.2</td><td rowspan=1 colspan=1>33853.2/33730.6</td><td rowspan=1 colspan=1>31655.9</td><td rowspan=1 colspan=1>39537.1</td></tr><tr><td rowspan=1 colspan=8>ice_hockey</td><td rowspan=1 colspan=2>0.9</td><td rowspan=1 colspan=1>3.4</td><td rowspan=1 colspan=1>-5.3/3.5</td><td rowspan=1 colspan=1>33.0</td><td rowspan=1 colspan=1>79.3</td></tr><tr><td rowspan=1 colspan=8>jamesbond</td><td rowspan=1 colspan=2>302.8</td><td rowspan=1 colspan=1>7869.3</td><td rowspan=1 colspan=1>440.0/601.5</td><td rowspan=1 colspan=1>21322.5</td><td rowspan=1 colspan=1>25354.0</td></tr><tr><td rowspan=1 colspan=8>kangaroo</td><td rowspan=1 colspan=2>3035.0</td><td rowspan=1 colspan=1>10484.5</td><td rowspan=1 colspan=1>47.0/1632.0</td><td rowspan=1 colspan=1>1416.0</td><td rowspan=1 colspan=1>14130.7</td></tr><tr><td rowspan=1 colspan=8>krull</td><td rowspan=1 colspan=2>2665.5</td><td rowspan=1 colspan=1>9930.9</td><td rowspan=1 colspan=1>9247.6/8147.4</td><td rowspan=1 colspan=1>11741.4</td><td rowspan=1 colspan=1>218448.1</td></tr><tr><td rowspan=1 colspan=8>kung_fu_master</td><td rowspan=1 colspan=2>22736.3</td><td rowspan=1 colspan=1>59799.5</td><td rowspan=1 colspan=1>42259.0/43375.5</td><td rowspan=1 colspan=1>97829.5</td><td rowspan=1 colspan=1>233413.3</td></tr><tr><td rowspan=1 colspan=8>montezuma_revenge</td><td rowspan=1 colspan=2>4753.3</td><td rowspan=1 colspan=1>2643.5</td><td rowspan=1 colspan=1>0.0/0.0</td><td rowspan=1 colspan=1>2500.0</td><td rowspan=1 colspan=1>2061.3</td></tr><tr><td rowspan=1 colspan=8>ms_pacman</td><td rowspan=1 colspan=2>6951.6</td><td rowspan=1 colspan=1>2724.3</td><td rowspan=1 colspan=1>6501.7/7342.3</td><td rowspan=1 colspan=1>11255.2</td><td rowspan=1 colspan=1>42281.7</td></tr><tr><td rowspan=2 colspan=8>name_this_gamephoenix</td><td rowspan=2 colspan=2>8049.07242.6</td><td rowspan=1 colspan=1>9907.1</td><td rowspan=1 colspan=1>6049.6/21537.2</td><td rowspan=1 colspan=1>25783.3</td><td rowspan=1 colspan=1>58182.7</td></tr><tr><td rowspan=1 colspan=1>40092.3</td><td rowspan=1 colspan=1>33068.2/210996.5</td><td rowspan=1 colspan=1>224491.1</td><td rowspan=1 colspan=1>864020.0</td></tr><tr><td rowspan=1 colspan=8>pitfall</td><td rowspan=1 colspan=2>6463.7</td><td rowspan=1 colspan=1>-3.5</td><td rowspan=1 colspan=1>-11.1/-1.7</td><td rowspan=1 colspan=1>-0.6</td><td rowspan=1 colspan=1>0.0</td></tr><tr><td rowspan=1 colspan=8>pong</td><td rowspan=1 colspan=2>14.6</td><td rowspan=1 colspan=1>20.7</td><td rowspan=1 colspan=1>20.4/21.0</td><td rowspan=1 colspan=1>20.9</td><td rowspan=1 colspan=1>21.0</td></tr><tr><td rowspan=1 colspan=6>private_eye</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>69571.3</td><td rowspan=1 colspan=1>15177.1</td><td rowspan=1 colspan=1>92.4/98.5</td><td rowspan=1 colspan=1>49.8</td><td rowspan=1 colspan=1>5322.7</td></tr><tr><td rowspan=1 colspan=5>qbert</td><td></td><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>13455.0</td><td rowspan=1 colspan=1>22956.5</td><td rowspan=1 colspan=1>18901.3/351200.1</td><td rowspan=1 colspan=1>302391.3</td><td rowspan=1 colspan=1>408850.0</td></tr><tr><td rowspan=1 colspan=8>riverraid</td><td rowspan=1 colspan=2>17118.0</td><td rowspan=1 colspan=1>16608.3</td><td rowspan=1 colspan=1>17401.9/29608.0</td><td rowspan=1 colspan=1>63864.4</td><td rowspan=1 colspan=1>45632.1</td></tr><tr><td rowspan=1 colspan=8>road_runner</td><td rowspan=1 colspan=2>7845.0</td><td rowspan=1 colspan=1>71168.0</td><td rowspan=1 colspan=1>37505.0/57121.0</td><td rowspan=1 colspan=1>222234.5</td><td rowspan=1 colspan=1>599246.7</td></tr><tr><td rowspan=1 colspan=8>robotank</td><td rowspan=1 colspan=2>11.9</td><td rowspan=1 colspan=1>68.5</td><td rowspan=1 colspan=1>2.3/13.0</td><td rowspan=1 colspan=1>73.8</td><td rowspan=1 colspan=1>100.4</td></tr><tr><td rowspan=1 colspan=8>seaquest</td><td rowspan=1 colspan=2>42054.7</td><td rowspan=1 colspan=1>8425.8</td><td rowspan=1 colspan=1>1716.9/1753.2</td><td rowspan=1 colspan=1>392952.3</td><td rowspan=1 colspan=1>999996.7</td></tr><tr><td rowspan=1 colspan=6>skiing</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>-4336.9</td><td rowspan=1 colspan=1>-10753.4</td><td rowspan=1 colspan=1>-29975.0/-10180.4</td><td rowspan=1 colspan=1>-10789.9</td><td rowspan=2 colspan=1>-30021.73787.2</td></tr><tr><td rowspan=1 colspan=8>solaris</td><td rowspan=1 colspan=2>12326.7</td><td rowspan=1 colspan=1>2165.2</td><td rowspan=1 colspan=1>2368.4/2365.0</td><td rowspan=1 colspan=1>2892.9</td></tr><tr><td rowspan=1 colspan=8>space_invaders</td><td rowspan=1 colspan=2>1668.7</td><td rowspan=1 colspan=1>2448.6</td><td rowspan=1 colspan=1>1726.3/43595.8</td><td rowspan=1 colspan=1>54681.0</td><td rowspan=1 colspan=1>43223.4</td></tr><tr><td rowspan=1 colspan=8>star-gunner</td><td rowspan=1 colspan=2>10250.0</td><td rowspan=1 colspan=1>70038.0</td><td rowspan=1 colspan=1>69139.0/200625.0</td><td rowspan=1 colspan=1>434342.5</td><td rowspan=1 colspan=1>717344.0</td></tr><tr><td rowspan=1 colspan=8>surround</td><td rowspan=3 colspan=3>surroundtennistime_pilot</td><td rowspan=3 colspan=1>6.5-8.35229.1</td><td rowspan=1 colspan=1>6.7</td><td rowspan=1 colspan=1>-8.1/7.6</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td rowspan=1 colspan=1>23.3</td><td rowspan=1 colspan=1>-1.9/0.5</td><td rowspan=1 colspan=1>23.9</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td rowspan=1 colspan=1>19401.0</td><td rowspan=1 colspan=1>6617.5/48481.5</td><td rowspan=1 colspan=1>87085.0</td><td></td></tr><tr><td rowspan=1 colspan=8>tutankham</td><td rowspan=1 colspan=2>167.6</td><td rowspan=1 colspan=1>272.6</td><td rowspan=1 colspan=1>267.8/292.1</td><td rowspan=1 colspan=1>272.6</td><td rowspan=1 colspan=1>395.3</td></tr><tr><td rowspan=1 colspan=8>up_n_down</td><td rowspan=1 colspan=2>11693.2</td><td rowspan=1 colspan=1>64354.3</td><td rowspan=1 colspan=1>273058.1/332546.8</td><td rowspan=1 colspan=1>401884.3</td><td rowspan=1 colspan=1>589226.9</td></tr><tr><td rowspan=1 colspan=6>venture</td><td rowspan=1 colspan=1></td><td></td><td rowspan=1 colspan=2>1187.5</td><td rowspan=1 colspan=1>1597.5</td><td rowspan=1 colspan=1>0.0/0.0</td><td rowspan=1 colspan=1>1773.5</td><td rowspan=1 colspan=1>1970.7</td></tr><tr><td rowspan=1 colspan=8>video_pinball</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>17667.9</td><td rowspan=1 colspan=1>469365.8</td><td rowspan=1 colspan=1>228642.5/572898.3</td><td rowspan=1 colspan=1>546197.4</td><td rowspan=1 colspan=1>999383.2</td></tr><tr><td rowspan=1 colspan=8>wizard_of_wor</td><td rowspan=1 colspan=2>4756.5</td><td rowspan=1 colspan=1>13170.5</td><td rowspan=1 colspan=1>4203.0/9157.5</td><td rowspan=1 colspan=1>46204.0</td><td rowspan=2 colspan=1>144362.7995048.4</td></tr><tr><td rowspan=2 colspan=8>yars_-revengezaxxon</td><td rowspan=1 colspan=2>54576.9</td><td rowspan=1 colspan=1>102759.8</td><td rowspan=1 colspan=1>80530.1/84231.1</td><td rowspan=1 colspan=1>148594.8</td></tr><tr><td rowspan=1 colspan=2>9173.3</td><td rowspan=1 colspan=1>25215.5</td><td rowspan=1 colspan=1>1148.5/32935.5</td><td rowspan=1 colspan=1>42285.5</td><td rowspan=1 colspan=1>224910.7</td></tr></table>
+
+Table 4: Performance of R2D2 (averaged over 3 seeds) compared to Reactor, IMPALA (shallow and deep expert variants), and Ape-X, with 30 random no-op starts. Ape-X uses best score attained during training, whereas all other agents use final scores.
+
+![](images/8b77cc9221f28d61dae01ea71ed3f45cbc039974bbeb9c87c5287a0977f9f499.jpg)  
+Figure 10: Learning curves on 57 Atari games: R2D2 (3 seeds), Ape-X and R2D2-feed-forward (1 seed each).
+
+![](images/ec1bf6b781e279ec65d4a02ec11d45701ddbb3e082e4ccc442bbf22f98fccd00.jpg)  
+Figure 11: Per-level breakdown of DMLab-30 performance. Comparison between R2D2 and IMPALA trained for the same number of environment frames. The shallow-network and deep-network versions are overlaid for each algorithm.

parse/train/r1lyTjAqYX/r1lyTjAqYX_content_list.json

@@ -0,0 +1,1595 @@
+[
+    {
+        "type": "text",
+        "text": "RECURRENT EXPERIENCE REPLAY IN DISTRIBUTED REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            704,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Steven Kapturowski, Georg Ostrovski, John Quan, Remi Munos, Will Dabney ´ DeepMind, London, UK {skapturowski,ostrovski,johnquan,munos,wdabney}@google.com ",
+        "bbox": [
+            183,
+            169,
+            748,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            248,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Building on the recent successes of distributed training of RL agents, in this paper we investigate the training of RNN-based RL agents from distributed prioritized experience replay. We study the effects of parameter lag resulting in representational drift and recurrent state staleness and empirically derive an improved training strategy. Using a single network architecture and fixed set of hyperparameters, the resulting agent, Recurrent Replay Distributed DQN, quadruples the previous state of the art on Atari-57, and matches the state of the art on DMLab-30. It is the first agent to exceed human-level performance in 52 of the 57 Atari games. ",
+        "bbox": [
+            233,
+            280,
+            764,
+            405
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            431,
+            336,
+            448
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement Learning (RL) has seen a rejuvenation of research interest recently due to repeated successes in solving challenging problems such as reaching human-level play on Atari 2600 games (Mnih et al., 2015), beating the world champion in the game of Go (Silver et al., 2017), and playing competitive 5-player DOTA (OpenAI, 2018b). The earliest of these successes leveraged experience replay for data efficiency and stacked a fixed number of consecutive frames to overcome the partial observability in Atari 2600 games. However, with progress towards increasingly difficult, partially observable domains, the need for more advanced memory-based representations increases, necessitating more principled solutions such as recurrent neural networks (RNNs). The use of LSTMs (Hochreiter & Schmidhuber, 1997) within RL has been widely adopted to overcome partial observability (Hausknecht & Stone, 2015; Mnih et al., 2016; Espeholt et al., 2018; Gruslys et al., 2018). ",
+        "bbox": [
+            174,
+            463,
+            825,
+            602
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we investigate the training of RNNs with experience replay. We have three primary contributions. First, we demonstrate the effect of experience replay on parameter lag, leading to representational drift and recurrent state staleness. This is potentially exacerbated in the distributed training setting, and ultimately results in diminished training stability and performance. Second, we perform an empirical study into the effects of several approaches to RNN training with experience replay, mitigating the aforementioned effects. Third, we present an agent that integrates these findings to achieve significant advances in the state of the art on Atari-57 (Bellemare et al., 2013) and matches the state of the art on DMLab-30 (Beattie et al., 2016). To the best of our knowledge, our agent, Recurrent Replay Distributed DQN (R2D2), is the first to achieve this using a single network architecture and fixed set of hyper-parameters. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            748
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            768,
+            326,
+            785
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2.1 REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            800,
+            415,
+            814
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our work is set within the Reinforcement Learning (RL) framework (Sutton & Barto, 1998), in which an agent interacts with an environment to maximize the sum of discounted, $\\gamma \\in [ 0 , 1 )$ , rewards. We model the environment as a Partially Observable Markov Decision Process (POMDP) given by the tuple $( S , \\mathcal { A } , T , R , \\Omega , \\mathcal { O } )$ (Monahan, 1982; Jaakkola et al., 1995; Kaelbling et al., 1998). The underlying Markov Decision Process (MDP) is defined by $( S , { \\mathcal { A } } , T , R )$ , where $s$ is the set of states, $\\mathcal { A }$ the set of actions, $T$ a transition function mapping state-actions to probability distributions over next states, and $R : S \\times \\mathcal { A }  \\mathbb { R }$ is the reward function. Finally, $\\Omega$ gives the set of observations potentially received by the agent and $\\mathcal { O }$ is the observation function mapping (unobserved) states to probability distributions over observations. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Within this framework, the agent receives an observation $o \\in \\Omega$ , which may only contain partial information about the underlying state $s \\in S$ . When the agent takes an action $a \\in { \\mathcal { A } }$ the environment responds by transitioning to state $s ^ { \\prime } \\sim T ( \\cdot | s , a )$ and giving the agent a new observation $o ^ { \\prime } \\sim \\Omega ( \\cdot | s ^ { \\prime } )$ and reward $r \\sim R ( s , a )$ . ",
+        "bbox": [
+            176,
+            138,
+            825,
+            195
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Although there are many approaches to RL in POMDPs, we focus on using recurrent neural networks (RNNs) with backpropagation through time (BPTT) (Werbos, 1990) to learn a representation that disambiguates the true state of the POMDP. ",
+        "bbox": [
+            176,
+            202,
+            821,
+            243
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Deep Q-Network agent (DQN) (Mnih et al., 2015) learns to play games from the Atari-57 benchmark by using frame-stacking of 4 consecutive frames as observations, and training a convolutional network to represent a value function with Q-learning (Watkins & Dayan, 1992), from data continuously collected in a replay buffer (Lin, 1993). Other algorithms like the A3C (Mnih et al., 2016), use an LSTM and are trained directly on the online stream of experience without using a replay buffer. Hausknecht & Stone (2015) combined DQN with an LSTM by storing sequences in replay and initializing the recurrent state to zero during training. ",
+        "bbox": [
+            174,
+            251,
+            825,
+            348
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 DISTRIBUTED REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            373,
+            516,
+            387
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recent advances in reinforcement learning have achieved significantly improved performance by leveraging distributed training architectures which separate learning from acting, collecting data from many actors running in parallel on separate environment instances (Horgan et al., 2018; Espeholt et al., 2018; Gruslys et al., 2018; OpenAI, 2018b;a; Jaderberg et al., 2018). ",
+        "bbox": [
+            174,
+            402,
+            823,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Distributed replay allows the Ape-X agent (Horgan et al., 2018) to decouple learning from acting, with actors feeding experience into the distributed replay buffer and the learner receiving (randomized) training batches from it. In addition to distributed replay with prioritized sampling (Schaul et al., 2016), Ape-X uses $n$ -step return targets (Sutton, 1988), the double Q-learning algorithm (van Hasselt et al., 2016), the dueling DQN network architecture (Wang et al., 2016) and 4-framestacking. Ape-X achieved state-of-the-art performance on Atari-57, significantly out-performing the best single-actor algorithms. It has also been used in continuous control domains and again showed state-of-the-art results, further demonstrating the performance benefits of distributed training in RL. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            577
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "IMPALA (Espeholt et al., 2018) is a distributed reinforcement learning architecture which uses a first-in-first-out queue with a novel off-policy correction algorithm called V-trace, to learn sequentially from the stream of experience generated by a large number of independent actors. IMPALA stores sequences of transitions along with an initial recurrent state in the experience queue, and since experience is trained on exactly once, this data generally stays very close to the learner parameters. Espeholt et al. (2018) showed that IMPALA could achieve strong performance in the Atari-57 and DMLab-30 benchmark suites, and furthermore was able to use a single large network to learn all tasks in a benchmark simultaneously while maintaining human-level performance. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.3 THE RECURRENT REPLAY DISTRIBUTED DQN AGENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            720,
+            591,
+            734
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose a new agent, the Recurrent Replay Distributed DQN (R2D2), and use it to study the interplay between recurrent state, experience replay, and distributed training. R2D2 is most similar to Ape-X, built upon prioritized distributed replay and $n$ -step double Q-learning (with $n \\ : = \\ : 5$ ), generating experience by a large number of actors (typically 256) and learning from batches of replayed experience by a single learner. Like Ape-X, we use the dueling network architecture of Wang et al. (2016), but provide an LSTM layer after the convolutional stack, similarly to Gruslys et al. (2018). ",
+        "bbox": [
+            174,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Instead of regular $( s , a , r , s ^ { \\prime } )$ transition tuples, we store fixed-length ( $m = 8 0$ ) sequences of $( s , a , r )$ in replay, with adjacent sequences overlapping each other by 40 time steps, and never crossing episode boundaries. When training, we unroll both online and target networks (Mnih et al., 2015) on the same sequence of states to generate value estimates and targets. We leave details of our exact treatment of recurrent states in replay for the next sections. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Like Ape-X, we use 4-frame-stacks and the full 18-action set when training on Atari. On DMLab, we use single RGB frames as observations, and the same action set discretization as Hessel et al. (2018b). Following the modified Ape-X version in Pohlen et al. (2018), we do not clip rewards, but instead use an invertible value function rescaling of the form $h ( x ) = \\mathrm { s i g n } ( x ) ( \\sqrt { | x | + 1 } - 1 ) + \\epsilon x$ which results in the following $n$ -step targets for the Q-value function: ",
+        "bbox": [
+            174,
+            103,
+            825,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6b47006e8f1623670bf16a41d05aadc0ff928433986013f78e7c02208a60c580.jpg",
+        "text": "$$\n\\hat { y } _ { t } = h \\left( \\sum _ { k = 0 } ^ { n - 1 } r _ { t + k } \\gamma ^ { k } + \\gamma ^ { n } h ^ { - 1 } \\left( Q ( s _ { t + n } , a ^ { * } ; \\theta ^ { - } ) \\right) \\right) , \\quad a ^ { * } = \\arg \\operatorname* { m a x } _ { a } Q ( s _ { t + n } , a ; \\theta ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            184,
+            779,
+            228
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\theta ^ { - }$ denotes the target network parameters which are copied from the online network parameters $\\theta$ every 2500 learner steps. ",
+        "bbox": [
+            171,
+            238,
+            821,
+            267
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our replay prioritization differs from that of Ape- $\\mathbf { X }$ in that we use a mixture of max and mean absolute $n$ -step TD-errors $\\delta _ { i }$ over the sequence: $\\begin{array} { r } { p = \\eta \\operatorname* { m a x } _ { i } \\delta _ { i } + ( 1 - \\eta ) \\bar { \\delta } } \\end{array}$ . We set $\\eta$ and the priority exponent to 0.9. This more aggressive scheme is motivated by our observation that averaging over long sequences tends to wash out large errors, thereby compressing the range of priorities and limiting the ability of prioritization to pick out useful experience. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            344
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, compared to Ape-X, we used the slightly higher discount of $\\gamma = 0 . 9 9 7$ , and disabled the loss-of-life-as-episode-end heuristic that has been used in Atari agents in some of the work since (Mnih et al., 2015). A full list of hyper-parameters is provided in the Appendix. ",
+        "bbox": [
+            174,
+            349,
+            825,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We train the R2D2 agent with a single GPU-based learner, performing approximately 5 network updates per second (each update on a mini-batch of 64 length-80 sequences), and each actor performing $\\sim 2 6 0$ environment steps per second on Atari $\\sim 1 3 0$ per second on DMLab). ",
+        "bbox": [
+            174,
+            398,
+            825,
+            441
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 TRAINING RECURRENT RL AGENTS WITH EXPERIENCE REPLAY",
+        "text_level": 1,
+        "bbox": [
+            176,
+            464,
+            740,
+            481
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to achieve good performance in a partially observed environment, an RL agent requires a state representation that encodes information about its state-action trajectory in addition to its current observation. The most common way to achieve this is by using an RNN, typically an LSTM (Hochreiter & Schmidhuber, 1997), as part of the agent’s state encoding. To train an RNN from replay and enable it to learn meaningful long-term dependencies, whole state-action trajectories need to be stored in replay and used for training the network. Hausknecht & Stone (2015) compared two strategies of training an LSTM from replayed experience: ",
+        "bbox": [
+            174,
+            498,
+            825,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Using a zero start state to initialize the network at the beginning of sampled sequences.   \n• Replaying whole episode trajectories. ",
+        "bbox": [
+            214,
+            609,
+            802,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The zero start state strategy’s appeal lies in its simplicity, and it allows independent decorrelated sampling of relatively short sequences, which is important for robust optimization of a neural network. On the other hand, it forces the RNN to learn to recover meaningful predictions from an atypical initial recurrent state (‘initial recurrent state mismatch’), which may limit its ability to fully rely on its recurrent state and learn to exploit long temporal correlations. The second strategy on the other hand avoids the problem of finding a suitable initial state, but creates a number of practical, computational, and algorithmic issues due to varying and potentially environment-dependent sequence length, and higher variance of network updates because of the highly correlated nature of states in a trajectory when compared to training on randomly sampled batches of experience tuples. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            785
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hausknecht & Stone (2015) observed little difference between the two strategies for empirical agent performance on a set of Atari games, and therefore opted for the simpler zero start state strategy. One possible explanation for this is that in some cases, an RNN tends to converge to a more ‘typical’ state if allowed a certain number of ‘burn-in’ steps, and so recovers from a bad initial recurrent state on a sufficiently long sequence. We also hypothesize that while the zero start state strategy may suffice in the mostly fully observable Atari domain, it prevents a recurrent network from learning actual long-term dependencies in more memory-critical domains (e.g. on DMLab). ",
+        "bbox": [
+            174,
+            790,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To fix these issues, we propose and evaluate two strategies for training a recurrent neural network from randomly sampled replay sequences, that can be used individually or in combination: ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/93782f93fa31b63533252d9f01f85b216b622ea3625af6020a7ac9a7a3d1994d.jpg",
+        "image_caption": [
+            "Figure 1: Top row shows $\\mathrm { Q }$ -value discrepancy $\\Delta Q$ as a measure for recurrent state staleness. (a) Diagram of how $\\Delta Q$ is computed, with green box indicating a whole sequence sampled from replay. For simplicity, $l = 0$ (no burn-in). (b) $\\Delta Q$ measured at first state and last state of replay sequences, for agents training on a selection of DMLab levels (indicated by initials) with different training strategies. Bars are averages over seeds and through time indicated by bold line on $\\mathbf { X }$ -axis in bottom row. (c) Learning curves on the same levels, varying the training strategy, and averaged over 3 seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            103,
+            826,
+            333
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Stored state: Storing the recurrent state in replay and using it to initialize the network at training time. This partially remedies the weakness of the zero start state strategy, however it may suffer from the effect of ‘representational drift’ leading to ‘recurrent state staleness’, as the stored recurrent state generated by a sufficiently old network could differ significantly from a typical state produced by a more recent version. ",
+        "bbox": [
+            215,
+            464,
+            825,
+            534
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Burn-in: Allow the network a ‘burn-in period’ by using a portion of the replay sequence only for unrolling the network and producing a start state, and update the network only on the remaining part of the sequence. We hypothesize that this allows the network to partially recover from a poor start state (zero, or stored but stale) and find itself in a better initial state before being required to produce accurate outputs. ",
+        "bbox": [
+            215,
+            537,
+            825,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In all our experiments we will be using the proposed agent architecture from Section 2.3 with replay sequences of length $m = 8 0$ , with an optional burn-in prefix of $l = 4 0$ or 20 steps. Our aim is to assess the negative effects of representational drift and recurrent state staleness on network training and how they are mitigated by the different training strategies. For that, we will compare the Qvalues produced by the network on sampled replay sequences when unrolled using one of these strategies and the Q-values produced when using the true stored recurrent states at each step (see Figure 1a, showing different sources for the hidden state). ",
+        "bbox": [
+            173,
+            619,
+            825,
+            718
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "More formally, let $O _ { t } , \\ldots , O _ { t + m }$ and $h _ { t } , \\ldots , h _ { t + m }$ denote the replay sequence of observations and stored recurrent states, and denote by $h _ { t + 1 } = h ( o _ { t } , h _ { t } ; \\theta )$ and $q ( h _ { t } ; \\theta )$ the recurrent state and Qvalue vector output by the recurrent neural network with parameter vector $\\theta$ , respectively. We write $\\hat { h } _ { t }$ for the hidden state, used during training and initialized under one of the above strategies (either $\\hat { h } _ { t } = 0$ or $\\hat { h } _ { t } = h _ { t } ,$ ). Then $\\hat { h } _ { t + i } \\ = \\ h ( o _ { t + i - 1 } , \\hat { h } _ { t + i - 1 } ; \\hat { \\theta } )$ is computed by unrolling the network with parameters $\\hat { \\theta }$ on the sequence $O _ { t } , \\ldots , O _ { t + l + m - 1 }$ . We estimate the impact of representational drift and recurrent state staleness by their effect on the Q-value estimates, by measuring $Q$ -value discrepancy ",
+        "bbox": [
+            173,
+            723,
+            825,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/437e66e8b04826c4c82ea138d7f7f4aa8de9c41f28fe4c3891fb7f8c557a4bd3.jpg",
+        "text": "$$\n\\Delta Q = \\frac { | | q ( \\hat { h } _ { t + i } ; \\hat { \\theta } ) - q ( h _ { t + i } ; \\hat { \\theta } ) | | _ { 2 } } { | \\operatorname* { m a x } _ { a , j } ( q ( \\hat { h } _ { t + j } ; \\hat { \\theta } ) ) _ { a } | }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            840,
+            612,
+            880
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for the first $( i = l )$ and last $( i = l + m - 1 )$ states of the non-burn-in part of the replay sequence (see Figure 1a for an illustration). The normalization by the maximal $\\mathrm { Q }$ -value helps comparability between different environments and training stages, as the $\\mathbf { Q }$ -value range of an agent can vary drastically between these. Note that we are not directly comparing the Q-values produced at acting and training time, $q ( h _ { t } ; \\theta )$ and $q ( \\hat { h } _ { t } ; \\hat { \\theta } )$ , as these can naturally be expected to be distinct as the agent is being trained. Instead we focus on the difference that results from applying the same network (parameterized by $\\hat { \\theta }$ ) to the distinct recurrent states. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Figure 1b, we are comparing agents trained with the different strategies on several DMLab environments in terms of this proposed metric. It can be seen that the zero start state heuristic results in a significantly more severe effect of recurrent state staleness on the outputs of the network. As hypothesized above, this effect is greatly reduced for the last sequence states compared to the first ones, after the RNN has had time to recover from the atypical start state, but the effect of staleness is still substantially worse here for the zero state than the stored state strategy. Another potential downside of the pure zero state heuristic is that it prevents the agent from strongly relying on its recurrent state and exploit long-term temporal dependencies, see Section 5. ",
+        "bbox": [
+            174,
+            170,
+            825,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We observe that the burn-in strategy on its own partially mitigates the staleness problem on the initial part of replayed sequences, while not showing a significant effect on the Q-value discrepancy for later sequence states. Empirically, this translates into noticeable performance improvements, as can be seen in Figure 1c. This itself is noteworthy, as the only difference between the pure zero state and the burn-in strategy lies in the fact that the latter unrolls the network over a prefix of states on which the network does not receive updates. In informal experiments (not shown here) we observed that this is not due to the different unroll lengths themselves (i.e., the zero state strategy without burn-in, on sequences of length $l + m$ , performed worse overall). We hypothesize that the beneficial effect of burn-in lies in the fact that it prevents ‘destructive updates’ to the RNN parameters resulting from highly inaccurate initial outputs on the first few time steps after a zero state initialization. ",
+        "bbox": [
+            174,
+            289,
+            825,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The stored state strategy, on the other hand, proves to be overall much more effective at mitigating state staleness in terms of the Q-value discrepancy, which also leads to clearer and more consistent improvements in empirical performance. Finally, the combination of both methods consistently yields the smallest discrepancy on the last sequence states and the most robust performance gains. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We conclude the section with the observation that both stored state and burn-in strategy provide substantial advantages over the naive zero state training strategy, in terms of (indirect) measures of the effect of representation drift and recurrent state staleness, and empirical performance. Since they combine beneficially, we use both of these strategies (with burn-in length of $l = 4 0$ ) in the empirical evaluation of our proposed agent in Section 4. Additional results on the effects of distributed training on representation drift and Q-value discrepancy are given in the Appendix. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            603,
+            450,
+            619
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section we evaluate the empirical performance of R2D2 on two challenging benchmark suites for deep reinforcement learning: Atari-57 (Bellemare et al., 2013) and DMLab-30 (Beattie et al., 2016). One of the fundamental contributions of Deep Q-Networks (DQN) (Mnih et al., 2015) was to set as standard practice the use of a single network architecture and set of hyper-parameters across the entire suite of 57 Atari games. Unfortunately, expanding past Atari this standard has not been maintained and, to the best of our knowledge, at present there is no algorithm applied to both Atari57 and DMLab-30 under this standard. In particular, we will compare performance with Ape-X and IMPALA for which hyper-parameters are tuned separately for each benchmark. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            747
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For R2D2, we use a single neural network architecture and a single set of hyper-parameters across all experiments. This demonstrates greater robustness and generality than has been previously observed in deep RL. It is also in pursuit of this generality, that we decided to disable the (Atari-specific) heuristic of treating life losses as episode ends, and did not apply reward clipping. Despite this, we observe state-of-the-art performance in both Atari and DMLab, validating the intuitions derived from our empirical study. A more detailed ablation study of the effects of these modifications is presented in the Appendix. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            851
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 ATARI-57 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            281,
+            882
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The Atari-57 benchmark is built upon the Arcade Learning Environment (ALE) (Bellemare et al., 2013), and consists of 57 classic Atari 2600 video games. Initial human-level performance was achieved by DQN (Mnih et al., 2015), and since then RL agents have improved significantly through both algorithmic and architectural advances. Currently, state of the art for a single actor is achieved by the recent distributional reinforcement learning algorithms IQN (Dabney et al., 2018) and Rainbow (Hessel et al., 2018a), and for multi-actor results, Ape-X (Horgan et al., 2018). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/1934bb75b4b558b48d67caf70bb2970a64002d2b68bb09884ed49d7dfc6f46d8.jpg",
+        "image_caption": [
+            "Figure 2: Atari-57 results. Left: median human-normalized scores and training times of various agent architectures. Diagram reproduced and extended from (Horgan et al., 2018). Right: Example individual learning curves of R2D2, averaged over 3 seeds, and Ape-X, single seed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            101,
+            820,
+            321
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            412,
+            825,
+            469
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 (left) shows the median human-normalized scores across all games for R2D2 and related methods (see Appendix for full Atari-57 scores and learning curves). R2D2 achieves an order of magnitude higher performance than all single-actor agents and quadruples the previous state-ofthe-art performance of Ape-X using fewer actors (256 instead of 360), resulting in higher sampleand time-efficiency. Table 1 lists mean and median human-normalized scores for R2D2 and other algorithms, highlighting these improvements. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            560
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In addition to achieving state-of-the-art results on the entire task suite, R2D2 also achieves the highest ever reported agent scores on a large fraction of the individual Atari games, in many cases ‘solving’ the respective games by achieving the highest attainable score. In Figure 2 (right) we highlight some of these individual learning curves of R2D2. As an example, notice the performance on MS.PACMAN is even greater than that of the agent reported in (van Seijen et al., 2017), which was engineered specifically for this game. Furthermore, we notice that Ape-X achieves super-human performance for the same number of games as Rainbow (49), and that its improvements came from improving already strong scores. R2D2 on the other hand is super-human on 52 out of 57 games. Of those remaining, we anecdotally observed that three (SKIING, SOLARIS, and PRIVATE EYE) can reach super-human performance with higher discount rates and faster target network updates. The other two (MONTEZUMA’S REVENGE and PITFALL) are known hard exploration problems, and solving these with a general-purpose algorithm will likely require new algorithmic insights. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            733
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 DMLAB-30 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            297,
+            765
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "DMLab-30 is a suite of 30 problems set in a 3D first-person game engine, testing for a wide range of different challenges (Beattie et al., 2016). While Atari can largely be approached with only frame-stacking, DMLab-30 requires long-term memory to achieve reasonable performance. Perhaps because of this, and the difficulty of integrating recurrent state with experience replay, topperforming agents have, to date, always come in the form of actor-critic algorithms trained in (near) on-policy settings. For the first time we show state-of-the-art performance on DMLab-30 using a value-function-based agent. We stress that, different from the state-of-the-art IMPALA architecture (Espeholt et al., 2018), the R2D2 agent uses the same set of hyper-parameters here as on Atari. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here we are mainly interested in comparing to the IMPALA ‘experts’, not to its multi-task variant. Since the original IMPALA experts were trained on a smaller amount of data (approximately 333M environment frames) and since R2D2 uses the improved action set introduced in (Hessel et al., 2018b), we decided to re-run the IMPALA agent with improved action set and for a comparable training time (10B environment frames) for a fairer comparison, resulting in substantially improved scores for the IMPALA agent compared to the original in (Espeholt et al., 2018), see Table 1. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e957f23a3a12aa20add90ddbd8e73df1ac0e4afa6bd32a4ea273b3308164c260.jpg",
+        "image_caption": [
+            "Figure 3: DMLab-30 comparison of R2D2 and $\\mathrm { R } 2 \\mathrm { D } 2 +$ with our re-run of IMPALA shallow and deep in terms of mean-capped human-normalized score (Espeholt et al., 2018). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            820,
+            301
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/959bfd921175d060428b3c86a0127f61ff317e7364be71cf543dae2058d7126d.jpg",
+        "table_caption": [
+            "Table 1: Comparison of Atari-57 and DMLab-30 results. R2D2 average final score over 3 seeds (1 seed for feed-forward variant), IMPALA final score over 1 seed, Ape-X best training score with 1 seed. Our re-run of IMPALA uses the same improved action set from (Hessel et al., 2018b) as R2D2, and is trained for a comparable number of environment frames (10B frames; the original IMPALA experts in (Espeholt et al., 2018) were only trained for approximately 333M frames). $\\mathrm { R } 2 \\mathrm { D } 2 +$ refers to the adapted R2D2 variant matching deep IMPALA’s 15-layer ResNet architecture and asymmetric reward clipping, as well as using a shorter target update period of 400. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Human-Normalized Score</td><td colspan=\"2\">Atari-57</td><td colspan=\"2\">DMLab-30</td></tr><tr><td>Median</td><td>Mean</td><td>Median</td><td>Mean-Capped</td></tr><tr><td>Ape-X (Horgan et al., 2018)</td><td>434.1%</td><td>1695.6%</td><td>1</td><td>1</td></tr><tr><td>Reactor (Gruslys et al., 2018)</td><td>187.0%</td><td>1</td><td>1</td><td>1</td></tr><tr><td>IMPALA, deep (Espeholt et al., 2018)</td><td>191.8%</td><td>957.6%</td><td>49.0%</td><td>45.8%</td></tr><tr><td>IMPALA, shallow (re-run)</td><td>1</td><td>1</td><td>89.7%</td><td>73.6%</td></tr><tr><td>IMPALA, deep (re-run)</td><td>1</td><td>1</td><td>107.5%</td><td>85.1%</td></tr><tr><td>R2D2+</td><td></td><td>1</td><td>99.5%</td><td>85.7%</td></tr><tr><td>R2D2,feed-forward</td><td>589.2%</td><td>1974.4%</td><td>二</td><td>二</td></tr><tr><td>R2D2</td><td>1920.6%</td><td>4024.9%</td><td>96.9%</td><td>78.3%</td></tr></table>",
+        "bbox": [
+            192,
+            369,
+            805,
+            515
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            654,
+            825,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 compares R2D2 with IMPALA. We note that R2D2 exceeds the performance of the (shallow) IMPALA version, despite using the exact same set of hyper-parameters and architecture as the variant trained on Atari, and in particular not using the ‘optimistic asymmetric reward clipping’ used by all IMPALA agents1. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            773
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the potential of our agent, we also devise a somewhat adapted R2D2 version for DMLab only $( \\mathsf { R } 2 \\mathsf { D } 2 + )$ by adding asymmetric reward clipping, using the 15-layer ResNet from IMPALA (deep), and reducing the target update frequency from 2500 to 400 for better sample efficiency. To fit the larger model in GPU memory, we reduced the batch size from 64 to 32 in these runs only. We observe that this modified version yields further substantial improvements over standard R2D2 and matches deep IMPALA in terms of sample efficiency as well as asymptotic performance. Both our re-run of deep IMPALA and $\\mathrm { R } 2 \\mathrm { D } 2 +$ are setting new state-of-the-art scores on the DMLab-30 benchmark. ",
+        "bbox": [
+            173,
+            780,
+            825,
+            891
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a1515cd5aa97fe9970c1fcd0104f77bbfe2ecafed39017d2e3de5af6a71b5c0a.jpg",
+        "image_caption": [
+            "Figure 4: Ablations with reward clipping instead of value function rescaling (Clipped), smaller discount factor of $\\gamma = 0 . 9 9$ (Discount), and feed-forward (Feed-Forward) variants of R2D2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            820,
+            209
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/3ef23cc25165d66718031f98b4459f4ad07f7d9268997d80c946842ec1eb0cd0.jpg",
+        "image_caption": [
+            "Figure 5: Effect of restricting R2D2’s policy’s memory on MS.PACMAN and EMSTM WATERMAZE. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            280,
+            756,
+            440
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 ANALYSIS OF AGENT PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            516,
+            527
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Atari-57 is a class of environments which are almost fully observable (given 4-frame-stack observations), and agents trained on it are not necessarily expected to strongly benefit from a memoryaugmented representation. The main algorithmic difference between R2D2 and its predecessor, Ape-X, is the use of a recurrent neural network, and it is therefore surprising by how large a margin R2D2 surpasses the previous state of the art on Atari. In this section we analyze the role of the LSTM network and other algorithmic choices for the high performance of the R2D2 agent. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            632
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Since the performance of asynchronous or distributed RL agents can depend on subtle implementational details and even factors such as precise hardware setup, it is impractical to perform a direct comparison to the Ape-X agent as reported in (Horgan et al., 2018). Instead, here we verify that the LSTM and its training strategy play a crucial role for the success of R2D2 by a comparison of the R2D2 agent with a purely feed-forward variant, all other parameters held fixed. Similarly, we consider the performance of R2D2 using reward clipping without value rescaling (Clipped) and using a smaller discount factor of $\\gamma = 0 . 9 9$ (Discount). The ablation results in Figure 4 show very clearly that the LSTM component is crucial for boosting the agent’s peak performance as well as learning speed, explaining much of the performance difference to Ape-X. Other design choices have more mixed effects, improving in some games and hurting performance in others. Full ablation results (in particular, an ablation over the full Atari-57 suite of the feed-forward agent variant, as well as an ablation of the use of the life-loss-as-episode-termination heuristic) are presented in the Appendix. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            805
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our next experiment we test to what extent the R2D2 agent relies on its memory, and how this is impacted by the different training strategies. For this we select the Atari game MS.PACMAN, on which R2D2 shows state-of-the-art performance despite the game being virtually fully observable, and the DMLab task EMSTM WATERMAZE, which strongly requires the use of memory. We train two agents on each game, using the zero and stored state strategies, respectively. We then evaluate these agents by restricting their policy to a fixed history length: at time step $t$ , their policy uses an LSTM unrolled over time steps $O _ { t - k + 1 } , \\ldots , O _ { t }$ , with the hidden state $h _ { t - k }$ replaced by zero instead of the actual hidden state (note this is only done for evaluation, not at training time of the agents). ",
+        "bbox": [
+            174,
+            813,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5 (left) we decrease the history length $k$ from $\\infty$ (full history) down to 0 and show the degradation of agent performance (measured as mean score over 10 episodes) as a function of $k$ We additionally show the difference of max-Q-values and the percentage of correct greedy actions (where the unconstrained variant is taken as ground truth). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We observe that restricting the agent’s memory gradually decreases its performance, indicating its nontrivial use of memory on both domains. Crucially, while the agent trained with stored state shows higher performance when using the full history, its performance decays much more rapidly than for the agent trained with zero start states. This is evidence that the zero start state strategy, used in past RNN-based agents with replay, limits the agent’s ability to learn to make use of its memory. While this doesn’t necessarily translate into a performance difference (like in MS.PACMAN), it does so whenever the task requires an effective use of memory (like EMSTM WATERMAZE). This advantage of the stored state compared to the zero state strategy may explain the large performance difference between R2D2 and its close cousin Reactor (Gruslys et al., 2018), which trains its LSTM policy from replay with the zero state strategy. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            305
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, the right and middle columns of Figure 5 show a monotonic decrease of the quality of Qvalues and the resulting greedy policy as the available history length $k$ is decreased to 0, providing a simple causal link between the constraint and the empirical agent performance. ",
+        "bbox": [
+            176,
+            313,
+            825,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For a qualitative comparison of different behaviours learned by R2D2 and its feed-forward variant, we provide several agent videos at https://bit.ly/r2d2600. ",
+        "bbox": [
+            174,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            445,
+            328,
+            460
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Here we take a step back from evaluating performance and discuss our empirical findings in a broader context. There are two surprising findings in our results. ",
+        "bbox": [
+            176,
+            497,
+            823,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "First, although zero state initialization was often used in previous works (Hausknecht & Stone, 2015; Gruslys et al., 2018), we have found that it leads to misestimated action-values, especially in the early states of replayed sequences. Moreover, without burn-in, updates through BPTT to these early time steps with poorly estimated outputs seem to give rise to destructive updates and hinder the network’s ability to recover from sub-optimal initial recurrent states. This suggests that either the context-dependent recurrent state should be stored along with the trajectory in replay, or an initial part of replayed sequences should be reserved for burn-in, to allow the RNN to rely on its recurrent state and exploit long-term temporal dependencies, and the two techniques can also be combined beneficially. We have also observed that the underlying problems of representational drift and recurrent state staleness are potentially exacerbated in the distributed setting (see Appendix), highlighting the importance of robustness to these effects through an adequate training strategy of the RNN. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            699
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Second, we found that the impact of RNN training goes beyond providing the agent with memory. Instead, RNN training also serves a role not previously studied in RL, potentially by enabling better representation learning, and thereby improves performance even on domains that are fully observable and do not obviously require memory (cf. BREAKOUT results in the feed-forward ablation). ",
+        "bbox": [
+            174,
+            705,
+            823,
+            762
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, taking a broader view on our empirical results, we note that scaling up of RL agents through parallelization and distributed training allows them to benefit from huge experience throughput and achieve ever-increasing results over broad simulated task suites such as Atari-57 and DMLab-30. Impressive as these results are in terms of raw performance, they come at the price of high sample complexity, consuming billions of simulated time steps in hours or days of wall-clock time. One widely open avenue for future work lies in improving the sample efficiency of these agents, to allow applications to domains that do not easily allow fast simulation at similar scales. Another remaining challenge, very apparent in our results on Atari-57, is exploration: Save for the hardest-exploration games from Atari-57, R2D2 surpasses human-level performance on this task suite significantly, essentially ‘solving’ many of the games therein. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            909
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            326,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We are tremendously grateful to our colleagues at DeepMind and Google for their contributions to this work, as well as to the anonymous reviewers for their feedback. We thank Hado van Hasselt, Tom Schaul, and David Silver for feedback on an earlier draft of the paper. We thank Toby Pohlen, Bilal Piot, Tom Stepleton, and Mohammad Gheshlaghi Azar for helpful conversations and advice during development and writing. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We want to thank John Aslanides for many engineering contributions to the underlying agent infrastructure, and Gabriel Barth-Maron, Manuel Kroiss, David Budden, Jackie Kay, Matt Hoffman for library and training infrastructure support. ",
+        "bbox": [
+            176,
+            204,
+            821,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sean Silva provided an incredibly comprehensive analysis of our initial submission results that made several novel observations about the benefits of memory in Atari. Finally, for generously providing raw data of previous agents, we wish to thank Hubert Soyer, Dan Horgan, Matteo Hessel, Simon Schmitt, Lasse Espeholt, and Audrunas Gruslys. ",
+        "bbox": [
+            174,
+            253,
+            825,
+            309
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            330,
+            285,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Charles Beattie, Joel Z Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Kuttler,¨ Andrew Lefrancq, Simon Green, V´ıctor Valdes, Amir Sadik, et al. DeepMind Lab. ´ arXiv preprint arXiv:1612.03801, 2016. ",
+        "bbox": [
+            174,
+            352,
+            823,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The Arcade Learning Environment: an evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013. ",
+        "bbox": [
+            173,
+            401,
+            821,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Will Dabney, Georg Ostrovski, David Silver, and Remi Munos. Implicit quantile networks for distributional reinforcement learning. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1096–1105, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. PMLR. ",
+        "bbox": [
+            173,
+            452,
+            825,
+            522
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymir Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al. Impala: Scalable distributed deep-rl with importance weighted actor-learner architectures. arXiv preprint arXiv:1802.01561, 2018. ",
+        "bbox": [
+            176,
+            530,
+            821,
+            573
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Audrunas Gruslys, Will Dabney, Mohammad Gheshlaghi Azar, Bilal Piot, Marc Bellemare, and Remi Munos. The reactor: A fast and sample-efficient actor-critic agent for reinforcement learning. In International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id ${ . } = { }$ rkHVZWZAZ. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            637
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew Hausknecht and Peter Stone. Deep recurrent Q-learning for partially observable MDPs. CoRR, abs/1507.06527, 7(1), 2015. ",
+        "bbox": [
+            176,
+            645,
+            821,
+            674
+        ],
+        "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. In Proceedings of the AAAI Conference on Artificial Intelligence, 2018a. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            737
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matteo Hessel, Hubert Soyer, Lasse Espeholt, Wojciech Czarnecki, Simon Schmitt, and Hado van Hasselt. Multi-task deep reinforcement learning with popart. arXiv preprint arXiv:1809.04474, 2018b. ",
+        "bbox": [
+            173,
+            744,
+            825,
+            787
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            795,
+            823,
+            824
+        ],
+        "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. arXiv preprint arXiv:1803.00933, 2018. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            873
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tommi Jaakkola, Satinder P Singh, and Michael I Jordan. Reinforcement learning algorithm for partially observable markov decision problems. In Advances in neural information processing systems, pp. 345–352, 1995. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Wojciech M Czarnecki, Iain Dunning, Luke Marris, Guy Lever, Antonio Garcia Castaneda, Charles Beattie, Neil C Rabinowitz, Ari S Morcos, Avraham Ruderman, et al. Humanlevel performance in first-person multiplayer games with population-based deep reinforcement learning. arXiv preprint arXiv:1807.01281, 2018. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Leslie Pack Kaelbling, Michael L Littman, and Anthony R Cassandra. Planning and acting in partially observable stochastic domains. Artificial intelligence, 101(1-2):99–134, 1998. ",
+        "bbox": [
+            169,
+            169,
+            823,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            207,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Long-Ji Lin. Reinforcement learning for robots using neural networks. Technical report, CarnegieMellon Univ Pittsburgh PA School of Computer Science, 1993. ",
+        "bbox": [
+            174,
+            244,
+            821,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International conference on machine learning, pp. 1928–1937, 2016. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "George E Monahan. State of the arta survey of partially observable markov decision processes: theory, models, and algorithms. Management Science, 28(1):1–16, 1982. ",
+        "bbox": [
+            173,
+            385,
+            821,
+            414
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "OpenAI. Learning dexterous in-hand manipulation. arXiv preprint: arxiv:1808.00177, 2018a. ",
+        "bbox": [
+            174,
+            422,
+            790,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "OpenAI. OpenAI Five. https://blog.openai.com/openai-five/, 2018b. ",
+        "bbox": [
+            169,
+            446,
+            740,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tobias Pohlen, Bilal Piot, Todd Hester, Mohammad Gheshlaghi, Dan Horgan, David Budden, Gabriel Barth-Maron, Hado Van Hasselt, John Quan, Mel Vecerik, Matteo Hessel, Remi Munos, and Olivier Pietquin. Observe and look further: Achieving consistent performance on atari. arXiv preprint: arxiv:1805.11593, 2018. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            526
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. In Proceedings of the International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            565
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017. ",
+        "bbox": [
+            173,
+            573,
+            826,
+            616
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton. Learning to predict by the methods of temporal differences. Machine Learning, 3(1):9–44, 1988. ",
+        "bbox": [
+            173,
+            626,
+            823,
+            654
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton and Andrew G. Barto. Reinforcement Learning: An Introduction. MIT Press, 1998. ",
+        "bbox": [
+            173,
+            662,
+            823,
+            691
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double Qlearning. In Proceedings of the AAAI Conference on Artificial Intelligence, 2016. ",
+        "bbox": [
+            169,
+            700,
+            821,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Harm van Seijen, Mehdi Fatemi, Joshua Romoff, Romain Laroche, Tavian Barnes, and Jeffrey Tsang. Hybrid reward architecture for reinforcement learning. In Advances in Neural Information Processing Systems, pp. 5392–5402, 2017. ",
+        "bbox": [
+            176,
+            738,
+            823,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Tom Schaul, Matteo Hessel, Hado van Hasselt, Marc Lanctot, and Nando de Freitas. Dueling network architectures for deep reinforcement learning. In Proceedings of the International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            174,
+            790,
+            823,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher JCH Watkins and Peter Dayan. Q-learning. Machine Learning, 8(3):279–292, 1992. ",
+        "bbox": [
+            171,
+            842,
+            808,
+            858
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Paul J Werbos. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78(10):1550–1560, 1990. ",
+        "bbox": [
+            171,
+            866,
+            823,
+            895
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/1111d81331b5fc4644ae04c08acf714dee0b1322dad6001bfafa3885191d0594.jpg",
+        "image_caption": [
+            "Figure 6: Left: Parameter lag experienced with distributed prioritized replay with (top) 256 and (bottom) 64 actors on four DMLab levels: explore obstructed goals large (eogl), explore object rewards many (eorm), lasertag three opponents small (lots), rooms watermaze (rw). Center: initialstate and Right: final-state Q-value discrepancy for the same set of experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            826,
+            356
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            479,
+            263,
+            494
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "EFFECT OF DISTRIBUTED RL AGENT TRAINING ",
+        "bbox": [
+            174,
+            525,
+            508,
+            539
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this section, we investigate the effects of distributed training of an agent using a recurrent neural network, where a large number of actors feed their experience into a replay buffer for a single learner. ",
+        "bbox": [
+            174,
+            560,
+            823,
+            588
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "On the one hand, the distributed setting typically presents a less severe problem of representational drift than the single-actor case, such as the one studied in (Hausknecht & Stone, 2015). This is because in relative terms, the large amount of generated experience is replayed less frequently (on average, an experience sample is replayed less than once in the Ape-X agent, compared to eight times in DQN), and so distributed agent training tends to give rise to a smaller degree of ‘parameter lag’ (the mean age, in parameter updates, of the network parameters used to generate an experience, at the time it is being replayed). ",
+        "bbox": [
+            174,
+            595,
+            825,
+            694
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, the distributed setting allows for easy scaling of computational resources according to hardware or time constraints. An ideal distributed agent should therefore be robust to changes in, e.g., the number of actors, without careful parameter re-tuning. As we have seen in the previous section, RNN training from replay is sensitive to the issue of representational drift, the severity of which can depend on exactly these parameters. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            770
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To investigate these effects, we train the R2D2 agent with a substantially smaller number of actors. This has a direct (inversely proportional) effect on the parameter lag (see Figure 6(left)). Specifically, in our experiments, as the number of actors is changed from 256 to 64, the mean parameter lag goes from 1500 to approximately 5500 parameter updates, which in turn impacts the magnitude of representation drift and recurrent state staleness, as measured by $\\Delta Q$ in Section 3. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The right two columns in Figure 6 show an overall increase of the average $\\Delta Q$ for the smaller number of actors, both for first and last states of replayed sequences. This supports the above intuitions and highlights the increased importance of an improved training strategy (compared to the zero state strategy) in the distributed training setting, if a certain level of empirical agent performance is to be maintained across ranges of extrinsic and potentially hardware dependent parameters. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/f371d5ed047681192f65e894bf59a054052e1bafdca205328c7c40a14def41b6.jpg",
+        "image_caption": [
+            "Figure 7: Ablation results with standard deviations shown by shading (3 seeds). ‘Clipped’ refers to the agent variant using clipped rewards (instead of value function rescaling), ‘discount’ refers to the use of a discount value of 0.99 (instead of 0.997). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            820,
+            397
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/2386f41e8e77bfc9b787e43594d986418a2863e65ae227f234e70d4fbb86cd7e.jpg",
+        "image_caption": [
+            "Figure 8: Ablation results for the use of life loss as episode termination on Atari, with standard deviations shown by shading (3 seeds). ‘reset’ refers to the agent variant using life losses as full episode terminations (preventing value function bootstrapping across life loss events, as well as resetting the LSTM state), whereas ‘roll’ only prevents value function bootstrapping, but unrolls the LSTM for the duration of a full episode (potentially spanning multiple life losses). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            481,
+            820,
+            589
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "EXTENDED RESULTS ",
+        "bbox": [
+            174,
+            718,
+            320,
+            732
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section we give additional experimental results supporting our empirical study in the main text. Figure 7 gives a more in-depth view of the ablation results from Figure 4. We see that, with the exception of the feed-forward ablation, there are always games in which the ablated choice performs better. Our choice of architecture and configuration optimizes for overall performance and general (cross-domain) applicability, but for individual games there are different configurations that would yield improved performance. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Additionally, in Figure 8 we compare R2D2 with variants using the life loss signal as episode termination. Both ablation variants interrupt value function bootstrapping past the life loss events, but differ in that one (‘reset’) also resets the LSTM state at these events, whereas the other (‘roll’) only resets the LSTM state at actual episode boundaries, like regular R2D2. Despite the fact that the life loss heuristic is generally helpful to speed up learning in Atari, we did not use it in our main R2D2 agent for the sake of generality of the algorithm. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/e458fb9919f564eb3a5c7c494d797fc303f2dfd5d752515ad9c085b378d64392.jpg",
+        "image_caption": [
+            "Figure 9: Comparing sample efficiency between state-of-the-art agents on Atari-57. We observe a general trend of increasing final performance being negatively correlated with sample efficiency, which holds for all four algorithms compared. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            343,
+            104,
+            630,
+            258
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Figure 9 we compare the sample efficiency of R2D2 with recent state-of-the-art agents on Atari-57 in terms of human-normalized median score. As expected, the more distributed agents have worse sample efficiency early on, but also much improved long-term performance. This is an interesting correlation on its own, but we add that R2D2 appears to achieve a qualitatively different performance curve than any of the other algorithms. ",
+        "bbox": [
+            174,
+            349,
+            825,
+            419
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Note that, while Ape-X has a larger number of actors than R2D2 (360 compared to 256), its learner processes approximately 20 batches of size 512 per second, whereas R2D2 performs updates on batches of $6 4 \\times 8 0$ observations (batch size $\\times$ sequence length), at a rate of approximately 5 per second. This results in a reduced ‘replay ratio’ (effective number of times each experienced observation is being replayed): On average, Ape-X replays each observation approximately 1.3 times, whereas this number is only about 0.8 for R2D2, which explains the initial sample efficiency advantage of Ape-X. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            523
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "HYPER-PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            544,
+            323,
+            556
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "R2D2 uses the same 3-layer convolutional network as DQN (Mnih et al., 2015), followed by an LSTM with 512 hidden units, which feeds into the advantage and value heads of a dueling network (Wang et al., 2016), each with a hidden layer of size 512. Additionally, the LSTM receives as input the reward and one-hot action vector from the previous time step. On the four language tasks in the DMLab suite, we are using the same additional language-LSTM with 64 hidden units as IMPALA (Espeholt et al., 2018). ",
+        "bbox": [
+            173,
+            569,
+            825,
+            654
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/528b369f5948015921b105af44b26417aed3ebab47bffd429113a5f593173d5d.jpg",
+        "table_caption": [
+            "Table 2: Hyper-parameters values used in R2D2. All missing parameters follow the ones in Ape-X (Horgan et al., 2018). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Number of actors Actor parameter update interval</td><td>256 400 environment steps</td></tr><tr><td>Sequence length m Replay buffer size Priority exponent</td><td>80 (+ prefix of l = 40 in burn-in experiments) 4 × 106 observations (lo5 part-overlapping sequences) 0.9</td></tr><tr><td>Importance sampling exponent Discount y</td><td>0.6 0.997</td></tr><tr><td>Minibatch size</td><td>64 (32 for R2D2+ on DMLab)</td></tr><tr><td>Optimizer</td><td>Adam (Kingma&amp;Ba,2014)</td></tr><tr><td>Optimizer settings Target network update interval</td><td>learning rate = 10-4,ε = 10-3</td></tr><tr><td>Value function rescaling</td><td>2500 updates</td></tr><tr><td></td><td>h(𝑥)= sign(𝑥)(√|x|+1-1) + ∈x,∈= 10-3</td></tr></table>",
+        "bbox": [
+            194,
+            667,
+            803,
+            842
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As is usual for agent training on Atari since (Mnih et al., 2015), we cap all (training and evaluation) episodes at 30 minutes (108, 000 environment frames). All reported scores are (undiscounted) ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "episode returns. For the R2D2 agent we always report final scores (as opposed to some of the comparison agents that use best score attained during training). ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/3ce07075af6f4044a2f2275c5ae7f65856e02b8502e41eb0326798e5c3c335cc.jpg",
+        "table_caption": [
+            "FULL RESULTS ",
+            "Table 3: Performance of R2D2 and $\\mathrm { R } 2 \\mathrm { D } 2 +$ , averaged over 3 seeds, compared to our own singleseed re-run of IMPALA (shallow/deep) with improved action-set and trained on the same amount of data (10B environment frames). Compared to standard R2D2, the $\\mathrm { R } 2 \\mathrm { D } 2 +$ variant uses a shorter target network update frequency (400 compared to 2500), as well as the substantially larger 15-layer ResNet and the custom ‘optimistic asymmetric reward clipping’ from (Espeholt et al., 2018). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>GAMES</td><td>IMPALA(S)</td><td>IMPALA(D)</td><td>R2D2</td><td>R2D2+</td></tr><tr><td>rooms_collect_good_objects_test</td><td>10.0</td><td>10.0</td><td>9.8</td><td>9.9</td></tr><tr><td>rooms_exploit_deferred_effects_test</td><td>46.0</td><td>62.2</td><td>39.9</td><td>38.1</td></tr><tr><td>rooms_select_nonmatching_object</td><td>11.0</td><td>39.0</td><td>2.3</td><td>63.6</td></tr><tr><td>rooms_watermaze</td><td>48.4</td><td>47.0</td><td>45.9</td><td>49.0</td></tr><tr><td>rooms_keys_doors_puzzle</td><td>43.8</td><td>54.6</td><td>52.0</td><td>46.2</td></tr><tr><td>language_select_described_object</td><td>638.0</td><td>664.0</td><td>445.9</td><td>617.6</td></tr><tr><td>language_select_located_object</td><td>534.8</td><td>731.4</td><td>555.4</td><td>772.8</td></tr><tr><td>language_execute_random_task</td><td>515.2</td><td>465.4</td><td>363.1</td><td>497.4</td></tr><tr><td>language_answer_quantitative_question</td><td>18.0</td><td>362.0</td><td>258.0</td><td>344.4</td></tr><tr><td>lasertag_one_opponent_large</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>lasertag_three_opponents_large</td><td>0.0</td><td>32.2</td><td>22.9</td><td>28.6</td></tr><tr><td>lasertag_one_opponent_small</td><td>0.0</td><td>0.0</td><td>0.0</td><td>31.8</td></tr><tr><td>lasertag_three_opponents_small</td><td>53.8</td><td>57.2</td><td>42.8</td><td>49.0</td></tr><tr><td>natlab_fixed_large_map</td><td>57.0</td><td>63.4</td><td>48.9</td><td>60.6</td></tr><tr><td>natlab_varying_map_regrowth</td><td>22.4</td><td>34.0</td><td>25.7</td><td>24.6</td></tr><tr><td>natlab_varying_map_randomized</td><td>48.6</td><td>47.0</td><td>40.8</td><td>42.4</td></tr><tr><td>skymaze_irreversible_path_hard</td><td>80.0</td><td>80.0</td><td>84.0</td><td>76.0</td></tr><tr><td>skymaze_irreversible_path_varied</td><td>80.0</td><td>100.0</td><td>80.0</td><td>76.0</td></tr><tr><td>psychlab_arbitrary_visuomotor_mapping</td><td>37.0</td><td>38.4</td><td>34.2</td><td>33.1</td></tr><tr><td>psychlab_continuous_recognition</td><td>30.2</td><td>28.6</td><td>29.4</td><td>30.0</td></tr><tr><td>psychlab_sequential_comparison</td><td>30.8</td><td>29.6</td><td>30.8</td><td>30.0</td></tr><tr><td>psychlab_visual_search</td><td>80.0</td><td>80.0</td><td>79.6</td><td>79.9</td></tr><tr><td>explore_object_locations_small</td><td>104.0</td><td>100.4</td><td>82.9</td><td>83.7</td></tr><tr><td>explore_object_locations_large</td><td>78.8</td><td>91.0</td><td>52.4</td><td>60.6</td></tr><tr><td>explore_obstructed_goals_small</td><td>324.0</td><td>372.0</td><td>357.6</td><td>311.9</td></tr><tr><td>explore_obstructed_goals_large</td><td>150.0</td><td>102.0</td><td>63.2</td><td>95.5</td></tr><tr><td>explore_goal_locations_small</td><td>566.0</td><td>482.0</td><td>459.6</td><td>460.7</td></tr><tr><td>explore_goal_locations_large</td><td>386.0</td><td>316.0</td><td>328.0</td><td>174.7</td></tr><tr><td>explore_object_rewards_few</td><td>39.0</td><td>92.6</td><td>76.5</td><td>80.7</td></tr><tr><td>explore_object_rewards_many</td><td>79.8</td><td>89.4</td><td>59.7</td><td>75.8</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            192,
+            130,
+            803,
+            565
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/ce589b078b0c3c307703aa147b3590e4c9fc73a469a5288f46beaa00438b35b9.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 4: Performance of R2D2 (averaged over 3 seeds) compared to Reactor, IMPALA (shallow and deep expert variants), and Ape-X, with 30 random no-op starts. Ape-X uses best score attained during training, whereas all other agents use final scores. "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=8>GAMES</td><td rowspan=1 colspan=2>HUMAN</td><td rowspan=1 colspan=1>REACTOR</td><td rowspan=1 colspan=1>IMPALA(S/D)</td><td rowspan=1 colspan=1>APE-X</td><td rowspan=1 colspan=1>R2D2</td></tr><tr><td rowspan=1 colspan=8>alienamidar</td><td rowspan=1 colspan=2>7127.81719.5</td><td rowspan=1 colspan=1>6482.1833.0</td><td rowspan=1 colspan=1>1536.0/15962.1497.6/1554.8</td><td rowspan=1 colspan=1>40804.98659.2</td><td rowspan=1 colspan=1>229496.929321.4</td></tr><tr><td rowspan=1 colspan=8>assault</td><td rowspan=1 colspan=2>742.0</td><td rowspan=1 colspan=1>11013.5</td><td rowspan=1 colspan=1>12086.9/19148.5</td><td rowspan=1 colspan=1>24559.4</td><td rowspan=1 colspan=1>108197.0</td></tr><tr><td rowspan=1 colspan=8>asterix</td><td rowspan=1 colspan=2>8503.3</td><td rowspan=1 colspan=1>36238.5</td><td rowspan=1 colspan=1>29692.5/300732.0</td><td rowspan=1 colspan=1>313305.0</td><td rowspan=1 colspan=1>999153.3</td></tr><tr><td rowspan=3 colspan=8>asteroidsatlantisbank_heist</td><td rowspan=2 colspan=2>asteroidsatlantis</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>473</td></tr><tr><td rowspan=1 colspan=6></td><td rowspan=1 colspan=2>29028.1</td><td rowspan=1 colspan=1>308257.5</td><td rowspan=1 colspan=1>773355.5/849967.5</td><td rowspan=1 colspan=1>944497.5</td><td rowspan=1 colspan=1>1620764.0</td></tr><tr><td rowspan=1 colspan=2>753.1</td><td rowspan=1 colspan=1>988.7</td><td rowspan=1 colspan=1>1200.3/1223.2</td><td rowspan=1 colspan=1>1716.4</td><td rowspan=1 colspan=1>24235.9</td></tr><tr><td rowspan=1 colspan=8>battle_zone</td><td rowspan=1 colspan=2>37187.5</td><td rowspan=1 colspan=1>61220.0</td><td rowspan=1 colspan=1>13015.0/20885.0</td><td rowspan=1 colspan=1>98895.0</td><td rowspan=1 colspan=1>751880.0</td></tr><tr><td rowspan=2 colspan=8>beam_riderberzerk</td><td rowspan=2 colspan=2>16926.52630.4</td><td rowspan=1 colspan=1>8566.5</td><td rowspan=1 colspan=1>8219.9/32463.5</td><td rowspan=1 colspan=1>63305.2</td><td rowspan=1 colspan=1>188257.4</td></tr><tr><td rowspan=1 colspan=1>1641.4</td><td rowspan=1 colspan=1>888.3/1852.7</td><td rowspan=1 colspan=1>57196.7</td><td rowspan=1 colspan=1>53318.7</td></tr><tr><td rowspan=1 colspan=6>bowling</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>160.7</td><td rowspan=1 colspan=1>75.4</td><td rowspan=2 colspan=1>35.7/59.996.3/100.0</td><td rowspan=2 colspan=1>17.6100.0</td><td rowspan=2 colspan=1>219.598.5</td></tr><tr><td rowspan=1 colspan=8>boxing</td><td rowspan=1 colspan=2>12.1</td><td rowspan=1 colspan=1>99.4</td></tr><tr><td rowspan=1 colspan=8>breakout</td><td rowspan=1 colspan=2>30.5</td><td rowspan=1 colspan=1>518.4</td><td rowspan=1 colspan=1>640.4/787.3</td><td rowspan=1 colspan=1>800.9</td><td rowspan=1 colspan=1>837.7</td></tr><tr><td rowspan=2 colspan=8>centipedechopper_command</td><td rowspan=1 colspan=2>12017.0</td><td rowspan=1 colspan=1>3402.8</td><td rowspan=1 colspan=1>5528.1/11049.8</td><td rowspan=1 colspan=1>12974.0</td><td rowspan=1 colspan=1>599140.3</td></tr><tr><td rowspan=1 colspan=2>7387.8</td><td rowspan=1 colspan=1>37568.0</td><td rowspan=1 colspan=1>5012.0/28255.0</td><td rowspan=1 colspan=1>721851.0</td><td rowspan=1 colspan=1>986652.0</td></tr><tr><td rowspan=1 colspan=8>crazy_climber</td><td rowspan=1 colspan=2>35829.4</td><td rowspan=1 colspan=1>194347.0</td><td rowspan=1 colspan=1>136211.5/136950.0</td><td rowspan=1 colspan=1>320426.0</td><td rowspan=1 colspan=1>366690.7</td></tr><tr><td rowspan=1 colspan=8>defender</td><td rowspan=1 colspan=2>18688.9</td><td rowspan=1 colspan=1>113127.8</td><td rowspan=1 colspan=1>58718.3/185203.0</td><td rowspan=1 colspan=1>411943.5</td><td rowspan=1 colspan=1>665792.0</td></tr><tr><td rowspan=1 colspan=8>demon_attack</td><td rowspan=1 colspan=2>1971.0</td><td rowspan=1 colspan=1>100188.5</td><td rowspan=1 colspan=1>107264.7/132827.0</td><td rowspan=1 colspan=1>133086.4</td><td rowspan=1 colspan=1>140002.3</td></tr><tr><td rowspan=1 colspan=6>double_dunk</td><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>-16.4</td><td rowspan=1 colspan=1>11.4</td><td rowspan=1 colspan=1>-0.4/-0.3</td><td rowspan=2 colspan=1>12.82177.4</td><td rowspan=2 colspan=1>23.72372.7</td></tr><tr><td rowspan=1 colspan=8>enduro</td><td rowspan=1 colspan=2>860.5</td><td rowspan=1 colspan=1>2230.1</td><td rowspan=1 colspan=1>0.0/0.0</td></tr><tr><td rowspan=1 colspan=8>fishing_derby</td><td rowspan=1 colspan=2>-38.8</td><td rowspan=1 colspan=1>23.2</td><td rowspan=1 colspan=1>32.1/44.9</td><td rowspan=1 colspan=1>44.4</td><td rowspan=1 colspan=1>85.8</td></tr><tr><td rowspan=1 colspan=8>freeway</td><td rowspan=1 colspan=2>29.6</td><td rowspan=1 colspan=1>31.4</td><td rowspan=1 colspan=1>0.0/0.0</td><td rowspan=1 colspan=1>33.7</td><td rowspan=1 colspan=1>32.5</td></tr><tr><td rowspan=1 colspan=8>frostbite</td><td rowspan=1 colspan=2>4334.7</td><td rowspan=1 colspan=1>8042.1</td><td rowspan=1 colspan=1>269.6/317.8</td><td rowspan=1 colspan=1>9328.6</td><td rowspan=1 colspan=1>315456.4</td></tr><tr><td rowspan=1 colspan=8>gopher</td><td rowspan=1 colspan=2>2412.5</td><td rowspan=1 colspan=1>69135.1</td><td rowspan=1 colspan=1>1002.4/66782.3</td><td rowspan=1 colspan=1>120500.9</td><td rowspan=1 colspan=1>124776.3</td></tr><tr><td rowspan=1 colspan=8>gravitar</td><td rowspan=1 colspan=2>3351.4</td><td rowspan=1 colspan=1>1073.8</td><td rowspan=1 colspan=1>211.5/359.5</td><td rowspan=1 colspan=1>1598.5</td><td rowspan=1 colspan=1>15680.7</td></tr><tr><td rowspan=1 colspan=8>hero</td><td rowspan=1 colspan=2>30826.4</td><td rowspan=1 colspan=1>35542.2</td><td rowspan=1 colspan=1>33853.2/33730.6</td><td rowspan=1 colspan=1>31655.9</td><td rowspan=1 colspan=1>39537.1</td></tr><tr><td rowspan=1 colspan=8>ice_hockey</td><td rowspan=1 colspan=2>0.9</td><td rowspan=1 colspan=1>3.4</td><td rowspan=1 colspan=1>-5.3/3.5</td><td rowspan=1 colspan=1>33.0</td><td rowspan=1 colspan=1>79.3</td></tr><tr><td rowspan=1 colspan=8>jamesbond</td><td rowspan=1 colspan=2>302.8</td><td rowspan=1 colspan=1>7869.3</td><td rowspan=1 colspan=1>440.0/601.5</td><td rowspan=1 colspan=1>21322.5</td><td rowspan=1 colspan=1>25354.0</td></tr><tr><td rowspan=1 colspan=8>kangaroo</td><td rowspan=1 colspan=2>3035.0</td><td rowspan=1 colspan=1>10484.5</td><td rowspan=1 colspan=1>47.0/1632.0</td><td rowspan=1 colspan=1>1416.0</td><td rowspan=1 colspan=1>14130.7</td></tr><tr><td rowspan=1 colspan=8>krull</td><td rowspan=1 colspan=2>2665.5</td><td rowspan=1 colspan=1>9930.9</td><td rowspan=1 colspan=1>9247.6/8147.4</td><td rowspan=1 colspan=1>11741.4</td><td rowspan=1 colspan=1>218448.1</td></tr><tr><td rowspan=1 colspan=8>kung_fu_master</td><td rowspan=1 colspan=2>22736.3</td><td rowspan=1 colspan=1>59799.5</td><td rowspan=1 colspan=1>42259.0/43375.5</td><td rowspan=1 colspan=1>97829.5</td><td rowspan=1 colspan=1>233413.3</td></tr><tr><td rowspan=1 colspan=8>montezuma_revenge</td><td rowspan=1 colspan=2>4753.3</td><td rowspan=1 colspan=1>2643.5</td><td rowspan=1 colspan=1>0.0/0.0</td><td rowspan=1 colspan=1>2500.0</td><td rowspan=1 colspan=1>2061.3</td></tr><tr><td rowspan=1 colspan=8>ms_pacman</td><td rowspan=1 colspan=2>6951.6</td><td rowspan=1 colspan=1>2724.3</td><td rowspan=1 colspan=1>6501.7/7342.3</td><td rowspan=1 colspan=1>11255.2</td><td rowspan=1 colspan=1>42281.7</td></tr><tr><td rowspan=2 colspan=8>name_this_gamephoenix</td><td rowspan=2 colspan=2>8049.07242.6</td><td rowspan=1 colspan=1>9907.1</td><td rowspan=1 colspan=1>6049.6/21537.2</td><td rowspan=1 colspan=1>25783.3</td><td rowspan=1 colspan=1>58182.7</td></tr><tr><td rowspan=1 colspan=1>40092.3</td><td rowspan=1 colspan=1>33068.2/210996.5</td><td rowspan=1 colspan=1>224491.1</td><td rowspan=1 colspan=1>864020.0</td></tr><tr><td rowspan=1 colspan=8>pitfall</td><td rowspan=1 colspan=2>6463.7</td><td rowspan=1 colspan=1>-3.5</td><td rowspan=1 colspan=1>-11.1/-1.7</td><td rowspan=1 colspan=1>-0.6</td><td rowspan=1 colspan=1>0.0</td></tr><tr><td rowspan=1 colspan=8>pong</td><td rowspan=1 colspan=2>14.6</td><td rowspan=1 colspan=1>20.7</td><td rowspan=1 colspan=1>20.4/21.0</td><td rowspan=1 colspan=1>20.9</td><td rowspan=1 colspan=1>21.0</td></tr><tr><td rowspan=1 colspan=6>private_eye</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>69571.3</td><td rowspan=1 colspan=1>15177.1</td><td rowspan=1 colspan=1>92.4/98.5</td><td rowspan=1 colspan=1>49.8</td><td rowspan=1 colspan=1>5322.7</td></tr><tr><td rowspan=1 colspan=5>qbert</td><td></td><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>13455.0</td><td rowspan=1 colspan=1>22956.5</td><td rowspan=1 colspan=1>18901.3/351200.1</td><td rowspan=1 colspan=1>302391.3</td><td rowspan=1 colspan=1>408850.0</td></tr><tr><td rowspan=1 colspan=8>riverraid</td><td rowspan=1 colspan=2>17118.0</td><td rowspan=1 colspan=1>16608.3</td><td rowspan=1 colspan=1>17401.9/29608.0</td><td rowspan=1 colspan=1>63864.4</td><td rowspan=1 colspan=1>45632.1</td></tr><tr><td rowspan=1 colspan=8>road_runner</td><td rowspan=1 colspan=2>7845.0</td><td rowspan=1 colspan=1>71168.0</td><td rowspan=1 colspan=1>37505.0/57121.0</td><td rowspan=1 colspan=1>222234.5</td><td rowspan=1 colspan=1>599246.7</td></tr><tr><td rowspan=1 colspan=8>robotank</td><td rowspan=1 colspan=2>11.9</td><td rowspan=1 colspan=1>68.5</td><td rowspan=1 colspan=1>2.3/13.0</td><td rowspan=1 colspan=1>73.8</td><td rowspan=1 colspan=1>100.4</td></tr><tr><td rowspan=1 colspan=8>seaquest</td><td rowspan=1 colspan=2>42054.7</td><td rowspan=1 colspan=1>8425.8</td><td rowspan=1 colspan=1>1716.9/1753.2</td><td rowspan=1 colspan=1>392952.3</td><td rowspan=1 colspan=1>999996.7</td></tr><tr><td rowspan=1 colspan=6>skiing</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>-4336.9</td><td rowspan=1 colspan=1>-10753.4</td><td rowspan=1 colspan=1>-29975.0/-10180.4</td><td rowspan=1 colspan=1>-10789.9</td><td rowspan=2 colspan=1>-30021.73787.2</td></tr><tr><td rowspan=1 colspan=8>solaris</td><td rowspan=1 colspan=2>12326.7</td><td rowspan=1 colspan=1>2165.2</td><td rowspan=1 colspan=1>2368.4/2365.0</td><td rowspan=1 colspan=1>2892.9</td></tr><tr><td rowspan=1 colspan=8>space_invaders</td><td rowspan=1 colspan=2>1668.7</td><td rowspan=1 colspan=1>2448.6</td><td rowspan=1 colspan=1>1726.3/43595.8</td><td rowspan=1 colspan=1>54681.0</td><td rowspan=1 colspan=1>43223.4</td></tr><tr><td rowspan=1 colspan=8>star-gunner</td><td rowspan=1 colspan=2>10250.0</td><td rowspan=1 colspan=1>70038.0</td><td rowspan=1 colspan=1>69139.0/200625.0</td><td rowspan=1 colspan=1>434342.5</td><td rowspan=1 colspan=1>717344.0</td></tr><tr><td rowspan=1 colspan=8>surround</td><td rowspan=3 colspan=3>surroundtennistime_pilot</td><td rowspan=3 colspan=1>6.5-8.35229.1</td><td rowspan=1 colspan=1>6.7</td><td rowspan=1 colspan=1>-8.1/7.6</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td rowspan=1 colspan=1>23.3</td><td rowspan=1 colspan=1>-1.9/0.5</td><td rowspan=1 colspan=1>23.9</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td rowspan=1 colspan=1>19401.0</td><td rowspan=1 colspan=1>6617.5/48481.5</td><td rowspan=1 colspan=1>87085.0</td><td></td></tr><tr><td rowspan=1 colspan=8>tutankham</td><td rowspan=1 colspan=2>167.6</td><td rowspan=1 colspan=1>272.6</td><td rowspan=1 colspan=1>267.8/292.1</td><td rowspan=1 colspan=1>272.6</td><td rowspan=1 colspan=1>395.3</td></tr><tr><td rowspan=1 colspan=8>up_n_down</td><td rowspan=1 colspan=2>11693.2</td><td rowspan=1 colspan=1>64354.3</td><td rowspan=1 colspan=1>273058.1/332546.8</td><td rowspan=1 colspan=1>401884.3</td><td rowspan=1 colspan=1>589226.9</td></tr><tr><td rowspan=1 colspan=6>venture</td><td rowspan=1 colspan=1></td><td></td><td rowspan=1 colspan=2>1187.5</td><td rowspan=1 colspan=1>1597.5</td><td rowspan=1 colspan=1>0.0/0.0</td><td rowspan=1 colspan=1>1773.5</td><td rowspan=1 colspan=1>1970.7</td></tr><tr><td rowspan=1 colspan=8>video_pinball</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>17667.9</td><td rowspan=1 colspan=1>469365.8</td><td rowspan=1 colspan=1>228642.5/572898.3</td><td rowspan=1 colspan=1>546197.4</td><td rowspan=1 colspan=1>999383.2</td></tr><tr><td rowspan=1 colspan=8>wizard_of_wor</td><td rowspan=1 colspan=2>4756.5</td><td rowspan=1 colspan=1>13170.5</td><td rowspan=1 colspan=1>4203.0/9157.5</td><td rowspan=1 colspan=1>46204.0</td><td rowspan=2 colspan=1>144362.7995048.4</td></tr><tr><td rowspan=2 colspan=8>yars_-revengezaxxon</td><td rowspan=1 colspan=2>54576.9</td><td rowspan=1 colspan=1>102759.8</td><td rowspan=1 colspan=1>80530.1/84231.1</td><td rowspan=1 colspan=1>148594.8</td></tr><tr><td rowspan=1 colspan=2>9173.3</td><td rowspan=1 colspan=1>25215.5</td><td rowspan=1 colspan=1>1148.5/32935.5</td><td rowspan=1 colspan=1>42285.5</td><td rowspan=1 colspan=1>224910.7</td></tr></table>",
+        "bbox": [
+            189,
+            102,
+            812,
+            906
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/8b77cc9221f28d61dae01ea71ed3f45cbc039974bbeb9c87c5287a0977f9f499.jpg",
+        "image_caption": [
+            "Figure 10: Learning curves on 57 Atari games: R2D2 (3 seeds), Ape-X and R2D2-feed-forward (1 seed each). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            77,
+            802,
+            898
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec1bf6b781e279ec65d4a02ec11d45701ddbb3e082e4ccc442bbf22f98fccd00.jpg",
+        "image_caption": [
+            "Figure 11: Per-level breakdown of DMLab-30 performance. Comparison between R2D2 and IMPALA trained for the same number of environment frames. The shallow-network and deep-network versions are overlaid for each algorithm. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            125,
+            789,
+            847
+        ],
+        "page_idx": 18
+    }
+]