Add files using upload-large-folder tool

parse/train/BJ5UeU9xx/BJ5UeU9xx_content_list.json

@@ -0,0 +1,1284 @@
+[
+    {
+        "type": "text",
+        "text": "VISUALIZING DEEP NEURAL NETWORK DECISIONS: PREDICTION DIFFERENCE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            803,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Luisa M Zintgraf1,3, Taco S Cohen1, Tameem Adel1, Max Welling1,2 1University of Amsterdam, 2Canadian Institute of Advanced Research, 3Vrije Universiteit Brussel {lmzintgraf,tameem.hesham}@gmail.com, {t.s.cohen, m.welling}@uva.nl ",
+        "bbox": [
+            183,
+            167,
+            828,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This article presents the prediction difference analysis method for visualizing the response of a deep neural network to a specific input. When classifying images, the method highlights areas in a given input image that provide evidence for or against a certain class. It overcomes several shortcoming of previous methods and provides great additional insight into the decision making process of classifiers. Making neural network decisions interpretable through visualization is important both to improve models and to accelerate the adoption of black-box classifiers in application areas such as medicine. We illustrate the method in experiments on natural images (ImageNet data), as well as medical images (MRI brain scans). ",
+        "bbox": [
+            233,
+            282,
+            766,
+            407
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            439,
+            336,
+            454
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Over the last few years, deep neural networks (DNNs) have emerged as the method of choice for perceptual tasks such as speech recognition and image classification. In essence, a DNN is a highly complex non-linear function, which makes it hard to understand how a particular classification comes about. This lack of transparency is a significant impediment to the adoption of deep learning in areas of industry, government and healthcare where the cost of errors is high. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            541
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In order to realize the societal promise of deep learning - e.g., through self-driving cars or personalized medicine - it is imperative that classifiers learn to explain their decisions, whether it is in the lab, the clinic, or the courtroom. In scientific applications, a better understanding of the complex dependencies learned by deep networks could lead to new insights and theories in poorly understood domains. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            604
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a new, probabilistically sound methodology for explaining classification decisions made by deep neural networks. The method can be used to produce a saliency map for each (instance, node) pair that highlights the parts (features) of the input that constitute most evidence for or against the activation of the given (internal or output) node. See figure 1 for an example. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            666
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the following two sections, we review related work and then present our approach. In section 4 we provide several demonstrations of our technique for deep convolutional neural networks (DCNNs) trained on ImageNet data, and further how the method can be applied when classifying MRI brain scans of HIV patients with neurodegenerative disease. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            729
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/5ced911aed2598832e28ff23d1a96c2876006712933b86acb08f35ad61dec9e2.jpg",
+        "image_caption": [
+            "Figure 1: Example of our visualization method: explains why the DCNN (GoogLeNet) predicts \"cockatoo\". Shown is the evidence for (red) and against (blue) the prediction. We see that the facial features of the cockatoo are most supportive for the decision, and parts of the body seem to constitute evidence against it. In fact, the classifier most likely considers them evidence for the second-highest scoring class, white wolf. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            367,
+            756,
+            625,
+            854
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            118
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Broadly speaking, there are two approaches for understanding DCNNs through visualization investigated in the literature: find an input image that maximally activates a given unit or class score to visualize what the network is looking for (Erhan et al., 2009; Simonyan et al., 2013; Yosinski et al., 2015), or visualize how the network responds to a specific input image in order to explain a particular classification made by the network. The latter will be the subject of this paper. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            203
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One such instance-specific method is class saliency visualization proposed by Simonyan et al. (2013) who measure how sensitive the classification score is to small changes in pixel values, by computing the partial derivative of the class score with respect to the input features using standard backpropagation. They also show that there is a close connection to using deconvolutional networks for visualization, proposed by Zeiler & Fergus (2014). Other methods include Shrikumar et al. (2016), who compare the activation of a unit when a specific input is fed forward through the net to a reference activation for that unit. Zhou et al. (2016) and Bach et al. (2015) also generate interesting visualization results for individual inputs, but are both not as closely related to our method as the two papers mentioned above. The idea of our method is similar to another analysis Zeiler & Fergus (2014) make: they estimate the importance of input pixels by visualizing the probability of the (correct) class as a function of a gray patch occluding parts of the image. In this paper, we take a more rigorous approach at both removing information from the image and evaluating the effect of this. ",
+        "bbox": [
+            174,
+            209,
+            825,
+            377
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the field of medical image classification specifically, a widely used method for visualizing feature importances is to simply plot the weights of a linear classifier (Klöppel et al., 2008; Ecker et al., 2010), or the p-values of these weights (determined by permutation testing) (Mourao-Miranda et al., 2005; Wang et al., 2007). These are independent of the input image, and, as argued by Gaonkar & Davatzikos (2013) and Haufe et al. (2014), interpreting these weights can be misleading in general. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            454
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The work presented in this paper is based on an instance-specific method by Robnik-Šikonja & Kononenko (2008), the prediction difference analysis, which is reviewed in the next section. Our main contributions are three substantial improvements of this method: conditional sampling (section 3.1), multivariate analysis (section 3.2), and deep visualization (section 3.3). ",
+        "bbox": [
+            174,
+            462,
+            825,
+            517
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            537,
+            297,
+            554
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our method is based on the technique presented by Robnik-Šikonja & Kononenko (2008), which we will now review. For a given prediction, the method assigns a relevance value to each input feature with respect to a class $c$ . The basic idea is that the relevance of a feature $x _ { i }$ can be estimated by measuring how the prediction changes if the feature is unknown, i.e., the difference between $p ( c | \\mathbf { x } )$ and $p ( c | \\mathbf { x } _ { \\backslash i } )$ , where $\\mathbf { x } _ { \\backslash i }$ denotes the set of all input features except $x _ { i }$ . ",
+        "bbox": [
+            174,
+            568,
+            825,
+            640
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To find $p ( c | \\mathbf { x } _ { \\backslash i } )$ , i.e., evaluate the prediction when a feature is unknown, the authors propose three strategies. The first is to label the feature as unknown (which only few classifiers allow). The second is to re-train the classifier with the feature left out (which is clearly infeasible for DNNs and high-dimensional data like images). The third approach is to simulate the absence of a feature by marginalizing the feature: ",
+        "bbox": [
+            173,
+            647,
+            825,
+            717
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb86c0c5946cb7e95a002ce9c94b3b507b7574f3418d6bada2d72028dbebc6b4.jpg",
+        "text": "$$\np ( c | \\mathbf { x } _ { \\backslash i } ) = \\sum _ { x _ { i } } p ( x _ { i } | \\mathbf { x } _ { \\backslash i } ) p ( c | \\mathbf { x } _ { \\backslash i } , x _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            723,
+            619,
+            757
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(with the sum running over all possible values for $x _ { i }$ ). However, modeling $p ( x _ { i } | \\mathbf { x } _ { \\backslash i } )$ can easily become infeasible with a large number of features. Therefore, the authors approximate equation (1) by assuming that feature $x _ { i }$ is independent of the other features, $\\mathbf { x } _ { \\backslash i }$ : ",
+        "bbox": [
+            173,
+            762,
+            825,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d281ab3e39a82be40e5ae0bb453d9429c74d6dd6c3de3e3f94b1905c45e13bf2.jpg",
+        "text": "$$\np ( c | \\mathbf { x } _ { \\backslash i } ) \\approx \\sum _ { x _ { i } } p ( x _ { i } ) p ( c | \\mathbf { x } _ { \\backslash i } , x _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            813,
+            612,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The prior probability $p ( x _ { i } )$ is usually approximated by the empirical distribution for that feature. ",
+        "bbox": [
+            174,
+            852,
+            803,
+            868
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Once the class probability $p ( c | \\mathbf { x } _ { \\backslash i } )$ is estimated, it can be compared to $p ( c | \\mathbf { x } )$ . We stick to an evaluation proposed by the authors referred to as weight of evidence, given by ",
+        "bbox": [
+            173,
+            873,
+            825,
+            902
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e846122a21bbb1cce5ea30283eaab8a224e353d5e8f29ae6801ebcc7b0a7ede4.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { W E } _ { i } ( c | \\mathbf { x } ) = \\log _ { 2 } \\left( \\operatorname { o d d s } ( c | \\mathbf { x } ) \\right) - \\log _ { 2 } \\left( \\operatorname { o d d s } ( c | \\mathbf { x } _ { \\backslash i } ) \\right) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            907,
+            673,
+            926
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/2d3615626674c157c6eefb119008f778803ca19b3e3f4b0516ad65688ee3ec04.jpg",
+        "image_caption": [
+            "Figure 2: Simple illustration of the sampling procedure in algorithm 1. Given the input image $x$ , we select every possible patch $x _ { w }$ (in a sliding window fashion) of size $k \\times k$ and place a larger patch $\\hat { x } _ { w }$ of size $l \\times l$ around it. We can then conditionally sample $x _ { w }$ by conditioning on the surrounding patch $\\hat { x } _ { w }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            364,
+            99,
+            629,
+            172
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Evaluating the prediction difference using conditional and multivariate sampling Input: classifier with outputs $\\mathsf { p } ( \\mathsf { c } | \\mathbf { x } )$ , input image $\\mathbf { x }$ of size $n \\times n$ , inner patch size $k$ , outer patch size $l > k$ , class of interest $c$ , probabilistic model over patches of size $l \\times l$ , number of samples $S$ Initialization: $\\mathrm { W E = z e r o s ( n ^ { * } n ) }$ , counts $\\mathbf { \\mu } _ { \\mathrm { : } } = \\mathbf { Z } \\mathbf { e }$ ros $( \\mathfrak { n } ^ { * } \\mathfrak { n } )$ for every patch $\\mathbf { x } _ { w }$ of size $k \\times k$ in $\\mathbf { x }$ do $\\mathbf { x } ^ { \\prime } = { \\bar { \\mathrm { c o p y } } } ( \\mathbf { x } )$ $\\mathrm { s u m } _ { w } = 0$ define patch $\\hat { \\mathbf { x } } _ { w }$ of size $l \\times l$ that contains $\\mathbf { x } _ { w }$ for $s = 1$ to $S$ do $\\mathbf { x } _ { w } ^ { \\prime } \\gets \\mathbf { x } _ { w }$ sampled from $p ( \\mathbf { x } _ { w } | \\hat { \\mathbf { x } } _ { w } \\backslash \\mathbf { x } _ { w } )$ $\\mathrm { s u m } _ { w } \\mathrel { + { = } } p ( c | \\mathbf { x } ^ { \\prime } )$ . evaluate classifier end for $p ( c | \\mathbf x \\backslash \\mathbf x _ { w } ) : = \\mathtt { s u m } _ { w } / S$ WE[coordinates of $\\mathbf { x } _ { w } ] + = \\log _ { 2 } ( \\operatorname { o d d s } ( c | \\mathbf { x } ) ) - \\log _ { 2 } ( \\operatorname { o d d s } ( c | \\mathbf { x } \\backslash \\mathbf { x } _ { w } ) )$ counts[coordinates of $\\mathbf { x } _ { w } ] + = 1$ end for Output: WE / counts . point-wise division where $\\mathrm { o d d s } ( c | \\mathbf { x } ) = p ( c | \\mathbf { x } ) / ( 1 - p ( c | \\mathbf { x } ) )$ . To avoid problems with zero probabilities, Laplace correction $p \\gets ( p N + 1 ) / ( N + K )$ is used, where $N$ is the number of training instances and $K$ the number of classes. ",
+        "bbox": [
+            176,
+            239,
+            826,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            512,
+            825,
+            554
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The method produces a relevance vector $( \\mathrm { W E } _ { i } ) _ { i = 1 \\dots m }$ ( $\\textbar { m }$ being the number of features) of the same size as the input, which reflects the relative importance of all features. A large prediction difference means that the feature contributed substantially to the classification, whereas a small difference indicates that the feature was not important for the decision. A positive value $\\mathrm { W E } _ { i }$ means that the feature has contributed evidence for the class of interest: removing it would decrease the confidence of the classifier in the given class. A negative value on the other hand indicates that the feature displays evidence against the class: removing it also removes potentially conflicting or irritating information and the classifier becomes more certain in the investigated class. ",
+        "bbox": [
+            173,
+            560,
+            825,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 CONDITIONAL SAMPLING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            690,
+            395,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In equation (3), the conditional probability $p ( x _ { i } | \\mathbf { x } _ { \\backslash i } )$ of a feature $x _ { i }$ is approximated using the marginal distribution $p ( x _ { i } )$ . This is a very crude approximation. In images for example, a pixel’s value is highly dependent on other pixels. We propose a much more accurate approximation, based on the following two observations: a pixel depends most strongly on a small neighborhood around it, and the conditional of a pixel given its neighborhood does not depend on the position of the pixel in the image. For a pixel $x _ { i }$ , we can therefore find a patch $\\hat { \\mathbf { x } } _ { i }$ of size $l \\times l$ that contains $x _ { i }$ , and condition on the remaining pixels in that patch: ",
+        "bbox": [
+            173,
+            715,
+            825,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e1abe31ac1abc3bc8a19906ea2895e22abd4c4574fe6cc34c055617a96bcd3bc.jpg",
+        "text": "$$\np ( x _ { i } | \\mathbf { x } _ { \\backslash i } ) \\approx p ( x _ { i } | \\hat { \\mathbf { x } } _ { \\backslash i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            821,
+            578,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This greatly improves the approximation while remaining completely tractable. ",
+        "bbox": [
+            173,
+            847,
+            692,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For a feature to become relevant when using conditional sampling, it now has to satisfy two conditions: being relevant to predict the class of interest, and be hard to predict from the neighboring pixels. Relative to the marginal method, we therefore downweight the pixels that can easily be predicted and are thus redundant in this sense. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 MULTIVARIATE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            397,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Robnik-Šikonja & Kononenko (2008) take a univariate approach: only one feature at a time is removed. However, we would expect that a neural network is relatively robust to just one feature of a high-dimensional input being unknown, like a pixel in an image. Therefore, we will remove several features at once by again making use of our knowledge about images by strategically choosing these feature sets: patches of connected pixels. Instead of going through all individual pixels, we go through all patches of size $k \\times k$ in the image ( $k \\times k \\times 3$ for RGB images and $k \\times k \\times k$ for 3D images like MRI scans), implemented in a sliding window fashion. The patches are overlapping, so that ultimately an individual pixel’s relevance is obtained by taking the average relevance obtained from the different patches it was in. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            255
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 and figure 2 illustrate how the method can be implemented, incorporating the proposed improvements. ",
+        "bbox": [
+            176,
+            262,
+            823,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 DEEP VISUALIZATION OF HIDDEN LAYERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            306,
+            513,
+            321
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When trying to understand neural networks and how they make decisions, it is not only interesting to analyze the input-output relation of the classifier, but also to look at what is going on inside the hidden layers of the network. We can adapt the method to see how the units of any layer of the network influence a node from a deeper layer. Mathematically, we can formulate this as follows. Let h be the vector representation of the values in a layer $H$ in the network (after forward-propagating the input up to this layer). Further, let $z = z ( \\mathbf { h } )$ be the value of a node that depends on $\\mathbf { h }$ , i.e., a node in a subsequent layer. Then the analog of equation (2) is given by the expectation: ",
+        "bbox": [
+            173,
+            333,
+            825,
+            431
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/50ea593e2838adfdab10938b3ec38b13238f6811b9445daef6fb52ed24182967.jpg",
+        "text": "$$\ng ( z | \\mathbf { h } _ { \\setminus i } ) \\equiv \\mathbb { E } _ { p ( h _ { i } | \\mathbf { h } _ { \\setminus i } ) } \\left[ z ( \\mathbf { h } ) \\right] = \\sum _ { h _ { i } } p ( h _ { i } | \\mathbf { h } _ { \\setminus i } ) z ( \\mathbf { h } _ { \\setminus i } , h _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            436,
+            684,
+            472
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which expresses the distribution of $z$ when unit $h _ { i }$ in layer $H$ is unobserved. The equation now works for arbitrary layer/unit combinations, and evaluates to the same as equation (1) when the input-output relation is analyzed. To evaluate the difference between $g ( z | \\mathbf { h } )$ and $g ( z | \\mathbf { h } _ { \\backslash i } )$ , we will in general use the activation difference, $\\mathrm { A D } _ { i } ( z | \\mathbf { h } ) = g ( z | \\mathbf { h } ) - g ( z | \\mathbf { h } _ { \\backslash i } )$ , for the case when we are not dealing with probabilities (and equation (3) is not applicable). ",
+        "bbox": [
+            174,
+            478,
+            825,
+            550
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            569,
+            326,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we illustrate how the proposed visualization method can be applied, on the ImageNet dataset of natural images when using DCNNs (section 4.1), and on a medical imaging dataset of MRI scans when using a logistic regression classifier (section 4.2). For marginal sampling we always use the empirical distribution, i.e., we replace a feature (patch) with samples taken directly from other images, at the same location. For conditional sampling we use a multivariate normal distribution. For both sampling methods we use 10 samples to estimate $p ( c | \\mathbf { x } _ { \\backslash i } )$ (since no significant difference was observed with more samples). Note that all images are best viewed digital and in color. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our implementation is available at github.com/lmzintgraf/DeepVis-PredDiff. ",
+        "bbox": [
+            176,
+            705,
+            781,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 IMAGENET: UNDERSTANDING HOW A DCNN MAKES DECISIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            736,
+            663,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use images from the ILSVRC challenge (Russakovsky et al., 2015) (a large dataset of natural images from 1000 categories) and three DCNNs: the AlexNet (Krizhevsky et al., 2012), the GoogLeNet (Szegedy et al., 2015) and the (16-layer) VGG network (Simonyan & Zisserman, 2014). We used the publicly available pre-trained models that were implemented using the deep learning framework caffe (Jia et al., 2014). Analyzing one image took us on average 20, 30 and 70 minutes for the respective classifiers AlexNet, GoogLeNet and VGG (using the GPU implementation of caffe and mini-batches with the standard settings of 10 samples and a window size of $k = 1 0$ ). ",
+        "bbox": [
+            174,
+            762,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The results shown here are chosen from among a small set of images in order to show a range of behavior of the algorithm. The shown images are quite representative of the performance of the method in general. Examples on randomly selected images, including a comparison to the sensitivity analysis of Simonyan et al. (2013), can be seen in appendix A. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/06d03ab00e42b16d0dc1187d88a9d265f3ce56aff123688d917d4d208fc132ae.jpg",
+        "image_caption": [
+            "Figure 3: Visualization of the effects of marginal versus conditional sampling using the GoogLeNet classifier. The classifier makes correct predictions (ostrich and saxophone), and we show the evidence for (red) and against (blue) this decision at the output layer. We can see that conditional sampling gives more targeted explanations compared to marginal sampling. Also, marginal sampling assigns too much importance on pixels that are easily predictable conditioned on their neighboring pixels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            103,
+            802,
+            188
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6455e925ac116e0d784784daf0f8afd0f43f4ad88880d94d1d98f4fa761d3377.jpg",
+        "image_caption": [
+            "Figure 4: Visualization of how different window sizes influence the visualization result. We used the conditional sampling method and the AlexNet classifier with $l = k + 4$ and varying $k$ . We can see that even when removing single pixels $k = 1 ,$ ), this has a noticeable effect on the classifier and more important pixels get a higher score. By increasing the window size we can get a more easily interpretable, smooth result until the image gets blurry for very large window sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            289,
+            807,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We start this section by demonstrating our proposed improvements (sections 3.1 - 3.3). ",
+        "bbox": [
+            176,
+            455,
+            738,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Marginal vs Conditional Sampling ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            483,
+            401,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows visualizations of the spatial support for the highest scoring class, using marginal and conditional sampling (with $k = 1 0$ and $l = 1 4$ ). We can see that conditional sampling leads to results that are more refined in the sense that they concentrate more around the object. We can also see that marginal sampling leads to pixels being declared as important that are very easily predictable conditioned on their neighboring pixels (like in the saxophone example). Throughout our experiments, we have found that conditional sampling tends to give more specific and fine-grained results than marginal sampling. For the rest of our experiments, we therefore show results using conditional sampling only. ",
+        "bbox": [
+            173,
+            505,
+            825,
+            616
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Multivariate Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            316,
+            645
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For ImageNet data, we have observed that setting $k = 1 0$ gives a good trade-off between sharp results and a smooth appearance. Figure 4 shows how different window sizes influence the resolution of the visualization. Surprisingly, removing only one pixel does have a measurable effect on the prediction, and the largest effect comes from sensitive pixels. We expected that removing only one pixel does not have any effect on the classification outcome, but apparently the classifier is sensitive even to these small changes. However when using such a small window size, it is difficult to make sense of the sign information in the visualization. If we want to get a good impression of which parts in the image are evidence for/against a class, it is therefore better to use larger windows. If $k$ is chosen too large however, the results tend to get blurry. Note that these results are not just simple averages of one another, but a multivariate approach is indeed necessary to observe the presented results. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Deep Visualization of Hidden Network Layers ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            805,
+            473,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our third main contribution is the extension of the method to neural networks; to understand the role of hidden layers in a DNN. Figure 5 shows how different feature maps in three different layers of the GoogLeNet react to the input of a tabby cat (see figure 6, middle image). For each feature map in a convolutional layer, we first compute the relevance of the input image for each hidden unit in that map. To estimate what the feature map as a whole is doing, we show the average of the relevance vectors over all units in that feature map. The first convolutional layer works with different types of simple image filters (e.g., edge detectors), and what we see is which parts of the input image respond positively or negatively to these filters. The layer we picked from somewhere in the middle of the network is specialized to higher level features (like facial features of the cat). The activations of the last convolutional layer are very sparse across feature channels, indicating that these units are highly specialized. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9aa2911fd8a20fff6a6cd4bba440ba720e6df920436632ccf296d971d05fc662.jpg",
+        "image_caption": [
+            "Figure 5: Visualization of feature maps from thee different layers of the GoogLeNet (l.t.r.: ”conv $1 / 7 \\mathrm { x } 7 \\_ \\mathrm { s } 2 ^ { \\cdot \\prime }$ , ”inception_3a/output”, ”inception_5b/output”), using conditional sampling and patch sizes $k = 1 0$ and $l = 1 4$ (see alg. 1). For each feature map in the convolutional layer, we first evaluate the relevance for every single unit, and then average the results over all the units in one feature map to get a sense of what the unit is doing as a whole. Red pixels activate a unit, blue pixels decreased the activation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            818,
+            226
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/fcc833d94084792a985ed7f2b47caa4c514cc946c9f6110859c390c1249dbbb6.jpg",
+        "image_caption": [
+            "Figure 6: Visualization of three different feature maps, taken from the ”inception_ $3 \\mathrm { a } I$ output” layer of the GoogLeNet (from the middle of the network). Shown is the average relevance of the input features over all activations of the feature map. We used patch sizes $k = 1 0$ and $l = 1 4$ (see alg. 1). Red pixels activate a unit, blue pixels decreased the activation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            267,
+            323,
+            723,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            574,
+            825,
+            631
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To get a sense of what single feature maps in convolutional layers are doing, we can look at their visualization for different input images and look for patterns in their behavior. Figure 6 shows this for four different feature maps from a layer from the middle of the GoogLeNet network. We can directly see which kind of features the model has learned at this stage in the network. For example, one feature map is mostly activated by the eyes of animals (third row), and another is looking mostly at the background (last row). ",
+        "bbox": [
+            174,
+            637,
+            825,
+            722
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Penultimate vs Output Layer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            736,
+            362,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "If we visualize the influence of the input features on the penultimate (pre-softmax) layer, we show only the evidence for/against this particular class, without taking other classes into consideration. After the softmax operation however, the values of the nodes are all interdependent: a drop in the probability for one class could be due to less evidence for it, or because a different class becomes more likely. Figure 7 compares visualizations for the last two layers. By looking at the top three scoring classes, we can see that the visualizations in the penultimate layer look very similar if the classes are similar (like different dog breeds). When looking at the output layer however, they look rather different. Consider the case of the elephants: the top three classes are different elephant subspecies, and the visualizations of the penultimate layer look similar since every subspecies can be identified by similar characteristics. But in the output layer, we can see how the classifier decides for one of the three types of elephants and against the others: the ears in this case are the crucial difference. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/482164df5c34ceee133e9014c442da8bd23bc4dbcb0b6b265127f97c1db9629a.jpg",
+        "image_caption": [
+            "Figure 7: Visualization of the support for the top-three scoring classes in the penultimate- and output layer. Next to the input image, the first row shows the results with respect to the penultimate layer; the second row with respect to the output layer. For each image, we additionally report the values of the units. We used the AlexNet with conditional sampling and patch sizes $k = 1 0$ and $l = 1 4$ (see alg. 1). Red pixels are evidence for a class, and blue against it. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            818,
+            247
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8082c60373251d3deb98376d94efd6c054cce69550e78b6f91354800c5bb442.jpg",
+        "image_caption": [
+            "Figure 8: Comparison of the prediction visualization of different DCNN architectures. For two input images, we show the results of the prediction difference analysis when using different neural networks - the AlexNet, GoogLeNet and VGG network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            353,
+            815,
+            420
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Network Comparison ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            520,
+            315,
+            534
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When analyzing how neural networks make decisions, we can also compare how different network architectures influence the visualization. Here, we tested our method on the AlexNet, the GoogLeNet and the VGG network. Figure 8 shows the results for the three different networks, on two input images. The AlexNet seems to more on contextual information (the sky in the balloon image), which could be attributed to it having the least complex architecture compared to the other two networks. It is also interesting to see that the VGG network deems the basket of the balloon as very important compared to all other pixels. The second highest scoring class in this case was a parachute - presumably, the network learned to not confuse a balloon with a parachute by detecting a square basket (and not a human). ",
+        "bbox": [
+            173,
+            540,
+            825,
+            665
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 MRI DATA: EXPLAINING CLASSIFIER DECISIONS IN MEDICAL IMAGING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            693,
+            715,
+            707
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To illustrate how our visualization method can also be useful in a medical domain, we show some experimental results on an MRI dataset of HIV and healthy patients. In such settings, it is crucial that the practitioner has some insight into the algorithm’s decision when classifying a patient, to weigh this information and incorporate it in the overall diagnosis process. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The dataset used here is referred to as the COBRA dataset. It contains 3D MRIs from $1 0 0 \\ \\mathrm { H I V }$ patients and 70 healthy individuals, included in the Academic Medical Center (AMC) in Amsterdam, The Netherlands. Of these subjects, diffusion weighted MRI data were acquired. Preprocessing of the data was performed with software developed in-house, using the HPCN-UvA Neuroscience Gateway and using resources of the Dutch e-Science Grid Shahand et al. (2015). As a result, Fractional Anisotropy (FA) maps were computed. FA is sensitive to microstructural damage and therefore expected to be, on average, decreased in patients. Subjects were scanned on two 3.0 Tesla scanner systems, 121 subjects on a Philips Intera system and 39 on a Philips Ingenia system. Patients and controls were evenly distributed. FA images were spatially normalized to standard space Andersson et al. (2007), resulting in volumes with $9 1 \\times 1 0 9 \\times 9 1 = 9 0 2 , 6 2 9$ voxels. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We trained an L2-regularized Logistic Regression classifier on a subset of the MRI slices (slices 29-40 along the first axis) and on a balanced version of the dataset (by taking the first 70 samples of the HIV class) to achieve an accuracy of $6 9 . 3 \\%$ in a 10-fold cross-validation test. Analyzing one image took around half an hour (on a CPU, with $k = 3$ and $l = 7$ , see algorithm 1). For conditional sampling, we also tried adding location information in equation (2), i.e., we split up the 3D image into a $2 0 \\times 2 0 \\times 2 0$ grid and also condition on the index in that grid. We found that this slightly improved the interpretability of the results, since the pixel values in the special case of MRI scans does depend on spacial location as well. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 9 (first row) shows one way via which the prediction difference results could be presented to a physician, for an HIV sample. By overlapping the prediction difference and the MRI image, the exact regions can be pointed out that are evidence for (red parts) or against (blue parts) the classifier’s decision. The second row shows the results using the weights of the logistic regression classifier, which is a commonly used method in neuroscientific literature. We can see that they are considerably noisier (in the sense that, compared to our method, the voxels relevant for the classification decisions are more scattered), and also, they are not specific to the given image. Figure 10 shows the visualization results for four healthy, and four HIV samples. We can clearly see that the patterns for the two classes are distinct, and there is some pattern to the decision of the classifier, but which is still specific to the input image. Figure 11 shows the same (HIV) sample as in figure 9 along different axes, and figure 12 shows how the visualization changes with different patch sizes. We believe that both varying the slice and patch size can give different insights to a clinician, and in clinical practice, a 3D animation where these parameters can be adjusted would be very useful for analyzing the visualization result. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            416
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In general we can assume that the better the classifier, the closer the explanations for its decisions are to the true class difference. For clinical practice it is therefore crucial to have very good classifiers. This will increase computation time, but in many medical settings, longer waiting times for test results are common and worth the wait if the patient is not in an acute life threatening condition (e.g., when predicting HIV or Alzheimer from MRI scans, or the field of cancer diagnosis and detection). The presented results here are for demonstration purposes of the visualization method, and we claim no medical validity. A thorough qualitative analysis incorporating expert knowledge was outside the scope of this paper. ",
+        "bbox": [
+            174,
+            422,
+            826,
+            535
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            554,
+            331,
+            570
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we used a simple multivariate normal distribution for conditional sampling. We can imagine that using more sophisticated generative models will lead to better results: pixels that are easily predictable by their surrounding are downweighted even more. However this will also significantly increase the computational resources needed to produce the explanations. Similarly, we could try to modify equation (4) to get an even better approximation by using a conditional distribution that takes more information about the whole image into account (like adding spatial information for the MRI scans). ",
+        "bbox": [
+            174,
+            585,
+            825,
+            684
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To make the method applicable for clinical analysis and practice, a better classification algorithm is required. Also, software that visualizes the results as an interactive 3D model will improve the usability of the system. ",
+        "bbox": [
+            176,
+            690,
+            821,
+            733
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            752,
+            318,
+            770
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We presented a new method for visualizing deep neural networks that improves on previous methods by using a more powerful conditional, multivariate model. The visualization method shows which pixels of a specific input image are evidence for or against a node in the network. The signed information offers new insights - for research on the networks, as well as the acceptance and usability in domains like healthcare. While our method requires significant computational resources, real-time 3D visualization is possible when visualizations are pre-computed. With further optimization and powerful GPUs, pre-computation time can be reduced a lot further. In our experiments, we have presented several ways in which the visualization method can be put into use for analyzing how DCNNs make decisions. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            910
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a85509f7394141043b2a833c061d51d93e6f419f4ea44470573238dd279a77ee.jpg",
+        "image_caption": [
+            "Figure 9: Visualization of the support for the correct classification ”HIV”, using the Prediction Difference method and Logistic Regression Weights. For an HIV sample, we show the results with the prediction difference (first row), and using the weights of the logistic regression classifier (second row), for slices 29 and 40 (along the first axis). Red are positive values, and blue negative. For each slice, the left image shows the original image, overlaid with the relevance values. The right image shows the original image with reversed colors and the relevance values. Relevance values are shown only for voxels with (absolute) relevance value above $1 5 \\%$ of the (absolute) maximum value. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            282,
+            99,
+            709,
+            294
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/95924f4010f91217380b1bc9eb550b78acaba90e69477baca5ed190bd7d9cf28.jpg",
+        "image_caption": [
+            "Figure 10: Prediction difference visualization for different samples. The first four samples are of the class ”healthy”; the last four of the class ”HIV”. All images show slice 39 (along the first axis). All samples are correctly classified, and the results show evidence for (red) and against (blue) this decision. Prediction differences are shown only for voxels with (absolute) relevance value above $1 5 \\%$ of the (absolute) maximum value. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            406,
+            787,
+            545
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/20456acef76521d1fe14e977d7395f11d399ffa099efda55adcbe4c412677c10.jpg",
+        "image_caption": [
+            "Figure 11: Visualization results across different slices of the MRI image, using the same input image as shown in 9. Prediction differences are shown only for voxels with (absolute) relevance value above $1 5 \\%$ of the (absolute) maximum value. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            619,
+            758,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/58c146db5b6150e3d5cdfc12aaa56836d4ba0d268953eea18fd7e26b54b572a3.jpg",
+        "image_caption": [
+            "Figure 12: How the patch size influences the visualization. For the input image (HIV sample, slice 39 along the first axis) we show the visualization with different patch sizes $k$ in alg. 1). Prediction differences are shown only for voxels with (absolute) relevance value above $1 5 \\%$ of the (absolute) maximum (for $k = 2$ it is $10 \\%$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            775,
+            756,
+            867
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            326,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by AWS in Education Grant award. We thank Facebook and Google for financial support, and our reviewers for their time and valuable, constructive feedback. ",
+        "bbox": [
+            173,
+            128,
+            821,
+            154
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was also in part supported by: Innoviris, the Brussels Institute for Research and Innovation, Brussels, Belgium; the Nuts-OHRA Foundation (grant no. 1003-026), Amsterdam, The Netherlands; The Netherlands Organization for Health Research and Development (ZonMW) together with AIDS Fonds (grant no 300020007 and 2009063). Additional unrestricted scientific grants were received from Gilead Sciences, ViiV Healthcare, Janssen Pharmaceutica N.V., Bristol-Myers Squibb, Boehringer Ingelheim, and Merck&Co. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            224
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Barbara Elsenga, Jane Berkel, Sandra Moll, Maja Totté, and Marjolein Martens for running the AGEhIV study program and capturing our data with such care and passion. We thank Yolanda Ruijs-Tiggelman, Lia Veenenberg-Benschop, Sima Zaheri, and Mariska Hillebregt at the HIV Monitoring Foundation for their contributions to data management. We thank Aafien Henderiks and Hans-Erik Nobel for their advice on logistics and organization at the Academic Medical Center. We thank all HIV-physicians and HIV-nurses at the Academic Medical Center for their efforts to include the HIV-infected participants into the AGEhIV Cohort Study, and the Municipal Health Service Amsterdam personnel for their efforts to include the HIV-uninfected participants into the AGEhIV Cohort Study. We thank all study participants without whom this research would not be possible. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "AGEhIV Cohort Study Group. Scientific oversight and coordination: P. Reiss (principal investigator), F.W.N.M. Wit, M. van der Valk, J. Schouten, K.W. Kooij, R.A. van Zoest, E. Verheij, B.C. Elsenga (Academic Medical Center (AMC), Department of Global Health and Amsterdam Institute for Global Health and Development (AIGHD)). M. Prins (co-principal investigator), M.F. Schim van der Loeff, M. Martens, S. Moll, J. Berkel, M. Totté, G.R. Visser, L. May, S. Kovalev, A. Newsum, M. Dijkstra (Public Health Service of Amsterdam, Department of Infectious Diseases). Datamanagement: S. Zaheri, M.M.J. Hillebregt, Y.M.C. Ruijs, D.P. Benschop, A. el Berkaoui (HIV Monitoring Foundation). Central laboratory support: N.A. Kootstra, A.M. Harskamp-Holwerda, I. Maurer, T. Booiman, M.M. Mangas Ruiz, A.F. Girigorie, B. Boeser-Nunnink (AMC, Laboratory for Viral Immune Pathogenesis and Department of Experimental Immunology). Project management and administrative support: W. Zikkenheiner, F.R. Janssen (AIGHD). Participating HIV physicians and nurses: S.E. Geerlings, M.H. Godfried, A. Goorhuis, J.W.R. Hovius, J.T.M. van der Meer, F.J.B. Nellen, T. van der Poll, J.M. Prins, P. Reiss, M. van der Valk, W.J. Wiersinga, M. van Vugt, G. de Bree, F.W.N.M. Wit; J. van Eden, A.M.H. van Hes, M. Mutschelknauss , H.E. Nobel, F.J.J. Pijnappel, M. Bijsterveld, A. Weijsenfeld, S. Smalhout (AMC, Division of Infectious Diseases). Other collaborators: J. de Jong, P.G. Postema (AMC, Department of Cardiology); P.H.L.T. Bisschop, M.J.M. Serlie (AMC, Division of Endocrinology and Metabolism); P. Lips (Free University Medical Center Amsterdam); E. Dekker (AMC, Department of Gastroenterology); N. van der Velde (AMC, Division of Geriatric Medicine); J.M.R. Willemsen, L. Vogt (AMC, Division of Nephrology); J. Schouten, P. Portegies, B.A. Schmand, G.J. Geurtsen (AMC, Department of Neurology); F.D. Verbraak, N. Demirkaya (AMC, Department of Ophthalmology); I. Visser (AMC, Department of Psychiatry); A. Schadé (Free University Medical Center Amsterdam, Department of Psychiatry); P.T. Nieuwkerk, N. Langebeek (AMC, Department of Medical Psychology); R.P. van Steenwijk, E. Dijkers (AMC, Department of Pulmonary medicine); C.B.L.M. Majoie, M.W.A. Caan, T. Su (AMC, Department of Radiology); H.W. van Lunsen, M.A.F. Nievaard (AMC, Department of Gynaecology); B.J.H. van den Born, E.S.G. Stroes, (AMC, Division of Vascular Medicine); W.M.C. Mulder (HIV Vereniging Nederland). ",
+        "bbox": [
+            173,
+            338,
+            826,
+            642
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            665,
+            285,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jesper LR Andersson, Mark Jenkinson, and Stephen Smith. Non-linear optimisation. fmrib technical report tr07ja1. University of Oxford FMRIB Centre: Oxford, UK, 2007. ",
+        "bbox": [
+            173,
+            688,
+            823,
+            713
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Bach, Alexander Binder, Grégoire Montavon, Frederick Klauschen, Klaus-Robert Müller, and Wojciech Samek. On pixel-wise explanations for non-linear classifier decisions by layer-wise relevance propagation. PloS one, 10(7):e0130140, 2015. ",
+        "bbox": [
+            176,
+            727,
+            821,
+            766
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christine Ecker, Andre Marquand, Janaina Mourão-Miranda, Patrick Johnston, Eileen M Daly, Michael J Brammer, Stefanos Maltezos, Clodagh M Murphy, Dene Robertson, Steven C Williams, et al. Describing the brain in autism in five dimensions—magnetic resonance imaging-assisted diagnosis of autism spectrum disorder using a multiparameter classification approach. The Journal of Neuroscience, 30(32):10612–10623, 2010. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            843
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dumitru Erhan, Yoshua Bengio, Aaron Courville, and Pascal Vincent. Visualizing higher-layer features of a deep network. Dept. IRO, Université de Montréal, Tech. Rep, 4323, 2009. ",
+        "bbox": [
+            173,
+            858,
+            823,
+            883
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bilwaj Gaonkar and Christos Davatzikos. Analytic estimation of statistical significance maps for support vector machine based multi-variate image analysis and classification. NeuroImage, 78:270–283, 2013. ",
+        "bbox": [
+            176,
+            897,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stefan Haufe, Frank Meinecke, Kai Görgen, Sven Dähne, John-Dylan Haynes, Benjamin Blankertz, and Felix Bießmann. On the interpretation of weight vectors of linear models in multivariate neuroimaging. Neuroimage, 87:96–110, 2014. ",
+        "bbox": [
+            174,
+            104,
+            823,
+            143
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embedding. arXiv preprint arXiv:1408.5093, 2014. ",
+        "bbox": [
+            174,
+            151,
+            821,
+            191
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stefan Klöppel, Cynthia M Stonnington, Carlton Chu, Bogdan Draganski, Rachael I Scahill, Jonathan D Rohrer, Nick C Fox, Clifford R Jack, John Ashburner, and Richard SJ Frackowiak. Automatic classification of mr scans in alzheimer’s disease. Brain, 131(3):681–689, 2008. ",
+        "bbox": [
+            173,
+            199,
+            825,
+            239
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            173,
+            247,
+            821,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Janaina Mourao-Miranda, Arun LW Bokde, Christine Born, Harald Hampel, and Martin Stetter. Classifying brain states and determining the discriminating activation patterns: Support vector machine on functional mri data. NeuroImage, 28(4):980–995, 2005. ",
+        "bbox": [
+            171,
+            282,
+            823,
+            321
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marko Robnik-Šikonja and Igor Kononenko. Explaining classifications for individual instances. Knowledge and Data Engineering, IEEE Transactions on, 20(5):589–600, 2008. ",
+        "bbox": [
+            168,
+            330,
+            823,
+            358
+        ],
+        "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 Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y. ",
+        "bbox": [
+            174,
+            366,
+            826,
+            417
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shayan Shahand, Ammar Benabdelkader, Mohammad Mahdi Jaghoori, Mostapha al Mourabit, Jordi Huguet, Matthan WA Caan, Antoine HC Kampen, and Sílvia D Olabarriaga. A data-centric neuroscience gateway: design, implementation, and experiences. Concurrency and Computation: Practice and Experience, 27(2): 489–506, 2015. ",
+        "bbox": [
+            173,
+            426,
+            826,
+            478
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Avanti Shrikumar, Peyton Greenside, Anna Shcherbina, and Anshul Kundaje. Not just a black box: Learning important features through propagating activation differences. arXiv preprint arXiv:1605.01713, 2016. ",
+        "bbox": [
+            173,
+            486,
+            821,
+            513
+        ],
+        "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,
+            521,
+            823,
+            549
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013. ",
+        "bbox": [
+            171,
+            556,
+            823,
+            584
+        ],
+        "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,
+            592,
+            825,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ze Wang, Anna R Childress, Jiongjiong Wang, and John A Detre. Support vector machine learning-based fmri data group analysis. NeuroImage, 36(4):1139–1151, 2007. ",
+        "bbox": [
+            173,
+            640,
+            823,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Yosinski, Jeff Clune, Anh Nguyen, Thomas Fuchs, and Hod Lipson. Understanding neural networks through deep visualization. arXiv preprint arXiv:1506.06579, 2015. ",
+        "bbox": [
+            173,
+            675,
+            823,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In Computer vision–ECCV 2014, pp. 818–833. Springer, 2014. ",
+        "bbox": [
+            173,
+            710,
+            821,
+            738
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2921–2929, 2016. ",
+        "bbox": [
+            173,
+            746,
+            823,
+            785
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A RANDOM RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            369,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/56046904ef7dc7617dbe0e10eb3d4bc0cf57ee2e68dd29905815aada30679ce8.jpg",
+        "image_caption": [
+            "Figure 13: Results on 34 randomly chosen ImageNet images. Middle columns: original image; left columns: sensitivity maps (Simonyan et al., 2013) where the red pixels indicate high sensitivity, and white pixels mean no sensitivity (note that we show the absolute values of the partial derivatives, since the sign cannot be interpreted like in our method); right columns: results from our method. For both methods, we visualize the results with respect to the correct class which is given above the image. In brackets we see how the classifier ranks this class, i.e., a (1) means it was correctly classified, whereas a (4) means that it was misclassified, and the correct class was ranked fourth. For our method, red areas show evidence for the correct class, and blue areas show evidence against the class (e.g., the scuba diver looks more like a tea pot to the classifier). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            131,
+            821,
+            797
+        ],
+        "page_idx": 11
+    }
+]

parse/train/GY6-6sTvGaf/GY6-6sTvGaf.md

@@ -0,0 +1,437 @@
+# IMAGE AUGMENTATION IS ALL YOU NEED: REGULARIZING DEEP REINFORCEMENT LEARNING FROM PIXELS
+
+Denis Yarats∗ New York University & Facebook AI Research denisyarats@cs.nyu.edu
+
+Ilya Kostrikov∗ New York University kostrikov@cs.nyu.edu
+
+Rob Fergus New York University fergus@cs.nyu.edu
+
+# ABSTRACT
+
+Existing model-free reinforcement learning (RL) approaches are effective when trained on states but struggle to learn directly from image observations. We propose an augmentation technique that can be applied to standard model-free RL algorithms, enabling robust learning directly from pixels without the need for auxiliary losses or pre-training. The approach leverages input perturbations commonly used in computer vision tasks to transform input examples, as well as regularizing the value function and policy. Our approach reaches a new stateof-the-art performance on DeepMind control suite and Atari $1 0 0 \mathrm { k }$ benchmark, surpassing previous model-free (Haarnoja et al., 2018; van Hasselt et al., 2019a), model-based (Hafner et al., 2019; Lee et al., 2019; Hafner et al., 2018; Kaiser et al., 2019) and contrastive learning (Srinivas et al., 2020) approaches. It also closes the gap between state-based and image-based RL training. Our method, which we dub DrQ: Data-regularized Q, can be combined with any model-free RL algorithm. To the best of our knowledge, our approach is the first effective data augmentation method for RL on these benchmarks.
+
+# 1 INTRODUCTION
+
+Sample-efficient deep reinforcement learning (RL) algorithms capable of directly training from image pixels would open up many real-world applications in control and robotics. However, simultaneously training a convolutional encoder alongside a policy network is challenging when given limited environment interaction, strong correlation between samples and a typically sparse reward signal. Limited supervision is a common problem across AI and two approaches are commonly taken: (i) training with an additional auxiliary losses, such as those based on self-supervised learning (SSL) and (ii) training with data augmentation.
+
+A wide range of auxiliary loss functions have been proposed to augment supervised objectives, e.g. weight regularization, noise injection (Hinton et al., 2012), or various forms of auto-encoder (Kingma et al., 2014). In RL, reconstruction losses (Jaderberg et al., 2017; Yarats et al., 2019) or SSL objectives (Dwibedi et al., 2018; Srinivas et al., 2020) are used. However, these objectives are unrelated to the task at hand, thus have no guarantee of inducing an appropriate representation for the policy network. SSL losses are highly effective in the large data regime, e.g. in domains such as vision (Chen et al., 2020; He et al., 2019) and NLP (Collobert et al., 2011; Devlin et al., 2018) where large (unlabeled) datasets are readily available. However, in sample-efficient RL, training data is more limited due to restricted interaction between the agent and the environment, limiting their effectiveness.
+
+Data augmentation methods are widely used in vision and speech domains, where output-invariant perturbations can easily be applied to the labeled input examples. Surprisingly, data augmentation has received little attention in the RL community. In this paper we propose augmentation approaches appropriate for sample-efficient RL and comprehensively evaluate them. The key idea of our approach is to use standard image transformations to perturb input observations, as well as regularizing the $Q$ -function learned by the critic so that different transformations of the same input image have similar $Q$ -function values. No further modifications to standard actor-critic algorithms are required. Our study is, to the best of our knowledge, the first careful examination of image augmentation in sample-efficient RL.
+
+The main contributions of the paper are as follows: (i) the first to demonstrate that data augmentation greatly improves performance when training model-free RL algorithms from images; (ii) introducing a natural way to exploit MDP structure through two mechanisms for regularizing the value function, in a manner that is generally applicable to model-free RL and (iii) setting a new state-of-the-art performance on the standard DeepMind control suite (Tassa et al., 2018), closing the gap between learning from states, and Atari 100k (Kaiser et al., 2019) benchmarks.
+
+# 2 RELATED WORK
+
+Data Augmentation in Computer Vision Data augmentation via image transformations has been used to improve generalization since the inception of convolutional networks (Becker & Hinton, 1992; Simard et al., 2003; LeCun et al., 1989; Ciresan et al., 2011; Ciregan et al., 2012). Following AlexNet (Krizhevsky et al., 2012), they have become a standard part of training pipelines. For object classification tasks, the transformations are selected to avoid changing the semantic category, i.e. translations, scales, color shifts, etc. While a similar set of transformations are potentially applicable to control tasks, the RL context does require modifications to be made to the underlying algorithm.
+
+Data augmentation methods have also been used in the context of self-supervised learning. Dosovitskiy et al. (2016) use per-exemplar perturbations in a unsupervised classification framework. More recently, several approaches (Chen et al., 2020; He et al., 2019; Misra & van der Maaten, 2019) have used invariance to imposed image transformations in contrastive learning schemes, producing state-of-the-art results on downstream recognition tasks. By contrast, our scheme addresses control tasks, utilizing different types of invariance.
+
+Data Augmentation in RL In contrast to computer vision, data augmentation is rarely used in RL. Certain approaches implicitly adopt it, for example Levine et al. (2018); Kalashnikov et al. (2018) use image augmentation as part of the AlexNet training pipeline without analysing the benefits occurring from it, thus being overlooked in subsequent work. HER (Andrychowicz et al., 2017) exploits information about the observation space by goal and reward relabeling, which can be viewed as a way to perform data augmentation. Other work uses data augmentation to improve generalization in domain transfer (Cobbe et al., 2018). However, the classical image transformations used in vision have not previously been shown to definitively help on standard RL benchmarks. Concurrent with our work, RAD (Laskin et al., 2020) performs an exploration of different data augmentation approaches, but is limited to transformations of the image alone, without the additional augmentation of the Q-function used in our approach. Moreover, RAD can be regarded as a special case of our algorithm. Multiple follow ups to our initial preprint appeared on ArXiv (Raileanu et al., 2020; Okada & Taniguchi, 2020), using similar techniques on other tasks, thus supporting the effectiveness and generality of data augmentation in RL.
+
+Continuous Control from Pixels There are a variety of methods addressing the sample-efficiency of RL algorithms that directly learn from pixels. The most prominent approaches for this can be classified into two groups, model-based and model-free methods. The model-based methods attempt to learn the system dynamics in order to acquire a compact latent representation of high-dimensional observations to later perform policy search (Hafner et al., 2018; Lee et al., 2019; Hafner et al., 2019). In contrast, the model-free methods either learn the latent representation indirectly by optimizing the RL objective (Barth-Maron et al., 2018; Abdolmaleki et al., 2018) or by employing auxiliary losses that provide additional supervision (Yarats et al., 2019; Srinivas et al., 2020; Sermanet et al., 2018; Dwibedi et al., 2018). Our approach is complementary to these methods and can be combined with them to improve performance.
+
+# 3 BACKGROUND
+
+Reinforcement Learning from Images We formulate image-based control as an infinite-horizon partially observable Markov decision process (POMDP) (Bellman, 1957; Kaelbling et al., 1998). An POMDP can be described as the tuple $( \mathcal { O } , \mathcal { A } , p , r , \gamma )$ , where $\mathcal { O }$ is the high-dimensional observation space (image pixels), $\mathcal { A }$ is the action space, the transition dynamics $p = P r ( o _ { t } ^ { \prime } | o _ { \leq t } , a _ { t } )$ capture the probability distribution over the next observation $o _ { t } ^ { \prime }$ given the history of previous observations $O { \le } t$ and current action $a _ { t }$ , $r : \mathcal { O } \times \mathcal { A } \to \mathbb { R }$ is the reward function that maps the current observation and action to a reward $r _ { t } = r ( o _ { \leq t } , a _ { t } )$ , and $\gamma \in [ 0 , 1 )$ is a discount factor. Per common practice (Mnih et al., 2013), throughout the paper the POMDP is converted into an MDP (Bellman, 1957) by stacking several consecutive image observations into a state $s _ { t } = \{ o _ { t } , o _ { t - 1 } , o _ { t - 2 } , . . . \}$ . For simplicity we redefine the transition dynamics $p = P r \big ( s _ { t } ^ { \prime } | s _ { t } , a _ { t } \big )$ and the reward function $r _ { t } \dot { = } r ( s _ { t } , a _ { t } )$ . We then aim to find a policy $\pi ( a _ { t } | s _ { t } )$ t  that maximizes the cumulative discounted return $\begin{array} { r } { \mathbb { E } _ { \pi } [ \sum _ { t = 1 } ^ { \infty } \gamma ^ { t } r _ { t } | a _ { t } \sim } \end{array}$ $\pi ( \cdot | s _ { t } ) , s _ { t } ^ { \prime } \sim p ( \cdot | s _ { t } , a _ { t } ) , \dot { s } _ { 1 } \sim p ( \cdot ) ]$ .
+
+Soft Actor-Critic The Soft Actor-Critic (SAC) (Haarnoja et al., 2018) learns a state-action value function $Q _ { \theta }$ , a stochastic policy $\pi _ { \theta }$ and a temperature $\alpha$ to find an optimal policy for an MDP $( S , \mathcal { A } , p , r , \gamma )$ by optimizing a $\gamma$ -discounted maximum-entropy objective (Ziebart et al., 2008). $\theta$ is used generically to denote the parameters updated through training in each part of the model.
+
+Deep Q-learning DQN (Mnih et al., 2013) also learns a convolutional neural net to approximate Q-function over states and actions. The main difference is that DQN operates on discrete actions spaces, thus the policy can be directly inferred from Q-values. In practice, the standard version of DQN is frequently combined with a set of refinements that improve performance and training stability, commonly known as Rainbow (van Hasselt et al., 2015). For simplicity, the rest of the paper describes a generic actor-critic algorithm rather than DQN or SAC in particular. Further background on DQN and SAC can be found in Appendix A.
+
+# 4 SAMPLE EFFICIENT REINFORCEMENT LEARNING FROM PIXELS
+
+# 4.1 OPTIMALITY INVARIANT IMAGE TRANSFORMATIONS FOR Q FUNCTION
+
+We first introduce a general framework for regularizing the value function through transformations of the input state. For a given task, we define an optimality invariant state transformation $f : S \times \mathcal { T }  S$ as a mapping that preserves the $Q$ -values
+
+$$
+Q ( s , a ) = Q ( f ( s , \nu ) , a ) { \mathrm { ~ f o r ~ a l l ~ } } s \in S , a \in { \mathcal { A } } { \mathrm { ~ a n d ~ } } \nu \in \mathcal { T } .
+$$
+
+where $\nu$ are the parameters of $f ( \cdot )$ , drawn from the set of all possible parameters $\tau$ . One example of such transformations are the random image translations successfully applied in the previous section.
+
+For every state, the transformations allow the generation of several surrogate states with the same $Q$ -values, thus providing a mechanism to reduce the variance of $Q$ -function estimation. In particular, for an arbitrary distribution of states $\mu ( \cdot )$ and policy $\pi$ , instead of using a single sample $s ^ { * } \sim \mu ( \cdot )$ , $a ^ { * } \sim \pi ( \cdot | s ^ { * } )$ estimation of the following expectation
+
+$$
+\begin{array} { r } { { \mathbb E } _ { s \sim \mu ( \cdot ) } \left[ Q ( s , a ) \right] \approx Q ( s ^ { * } , a ^ { * } ) } \end{array}
+$$
+
+we generate $K$ samples via random transformations and obtain an estimate with lower variance
+
+$$
+\mathbb { E } _ { \mathbf { \Phi } _ { a \sim \pi ( \cdot | s ) } } \left[ Q ( s , a ) \right] \approx \frac { 1 } { K } \sum _ { k = 1 } ^ { K } Q ( f ( s ^ { * } , \nu _ { k } ) , a _ { k } ) \mathrm { ~ w h e r e ~ } \nu _ { k } \in \mathcal { T } \mathrm { ~ a n d ~ } a _ { k } \sim \pi ( \cdot | f ( s ^ { * } , \nu _ { k } ) ) .
+$$
+
+This suggests two distinct ways to regularize $Q$ -function. First, we use the data augmentation to compute the target values for every transition tuple $( s _ { i } , a _ { i } , r _ { i } , s _ { i } ^ { \prime } )$ as
+
+$$
+y _ { i } = r _ { i } + \gamma \frac { 1 } { K } \sum _ { k = 1 } ^ { K } Q _ { \theta } \big ( f \big ( s _ { i } ^ { \prime } , \nu _ { i , k } ^ { \prime } \big ) , a _ { i , k } ^ { \prime } \big ) \mathrm { ~ w h e r e ~ } a _ { i , k } ^ { \prime } \sim \pi ( \cdot | f \big ( s _ { i } ^ { \prime } , \nu _ { i , k } ^ { \prime } \big ) )
+$$
+
+where $\nu _ { i , k } ^ { \prime } \in \mathcal { T }$ corresponds to a transformation parameter of $s _ { i } ^ { \prime }$ . Then the Q-function is updated using these targets through an SGD update using learning rate $\lambda _ { \theta }$
+
+$$
+\theta  \theta - \lambda _ { \theta } \nabla _ { \theta } \frac { 1 } { N } \sum _ { i = 1 } ^ { N } ( Q _ { \theta } ( f ( s _ { i } , \nu _ { i } ) , a _ { i } ) - y _ { i } ) ^ { 2 } .
+$$
+
+In tandem, we note that the same target from Equation (1) can be used for different augmentations of $s _ { i }$ , resulting in the second regularization approach
+
+$$
+\theta \gets \theta - \lambda _ { \theta } \nabla _ { \theta } \frac { 1 } { N M } \sum _ { i = 1 , m = 1 } ^ { N , M } ( Q _ { \theta } ( f ( s _ { i } , \nu _ { i , m } ) , a _ { i } ) - y _ { i } ) ^ { 2 } .
+$$
+
+When both regularization methods are used, $\nu _ { i , m }$ and $\nu _ { i , k } ^ { \prime }$ are drawn independently.
+
+# 4.2 PRACTICAL INSTANTIATION OF OPTIMALITY INVARIANT IMAGE TRANSFORMATION
+
+A range of successful image augmentation techniques have been developed in computer vision (Ciregan et al., 2012; Ciresan et al., 2011; Simard et al., 2003; Krizhevsky et al., 2012; Chen et al., 2020). These apply transformations to the input image for which the task labels are invariant, e.g. for object recognition tasks, image flips and rotations do not alter the semantic label. However, tasks in RL differ significantly from those in vision and in many cases the reward would not be preserved by these transformations. We examine image transformations from Chen et al. (2020) (random shifts, random cutouts, horizontal/vertical flips, rotations and intensity shifts) in Appendix E and conclude that random shifts strike a good balance between simplicity and performance, we therefore limit our choice of transformation function $f ( \cdot )$ to random shifts.
+
+We apply shifts to the images sampled from the replay buffer. For example, images from the DeepMind control suite used in our experiments are $8 4 \times 8 4$ . We pad each side by 4 pixels (by repeating boundary pixels) and then select a random $8 4 \times 8 4$ crop, yielding the original image shifted by $\pm 4$ pixels. This procedure is repeated every time an image is sampled from the replay buffer.
+
+# 4.3 OUR APPROACH: DATA-REGULARIZED Q (DRQ)
+
+Our approach, $\mathbf { D r Q }$ , is the union of the three separate regularization mechanisms introduced above:
+
+1. transformations of the input image (Section 4.2).   
+2. averaging the $Q$ target over K image transformations (Equation (1)).   
+3. averaging the $Q$ function itself over M image transformations (Equation (3)).
+
+Algorithm 1 details how they are incorporated into a generic pixel-based off-policy actor-critic algorithm. Note that if $[ \mathsf { K } { = } 1 , \mathsf { M } { = } 1 ]$ then $\mathbf { D r Q }$ reverts to image transformations alone, this makes applying $\mathbf { D r Q }$ to any model-free RL algorithm straightforward.
+
+For the experiments in this paper, we pair DrQ with SAC (Haarnoja et al., 2018) and DQN (Mnih et al., 2013), popular model-free algorithms for control in continuous and discrete action spaces respectively. We select image shifts as the class of image transformations $f$ , with $\nu \pm 4$ , as explained in Section 4.2.
+
+# 5 EXPERIMENTS
+
+# 5.1 ABLATION EXPERIMENT
+
+Figure 1 shows the effect of image shift augmentation applied to three tasks from the DeepMind control suite (Tassa et al., 2018). Figure 1a shows unmodified SAC (Haarnoja et al., 2018) parameterized with different image encoders, taken from: NatureDQN (Mnih et al., 2013), Dreamer (Hafner et al., 2019), Impala (Espeholt et al., 2018), SAC-AE (Yarats et al., 2019), and D4PG (Barth-Maron et al., 2018). The encoders vary significantly in their architecture and capacity, with parameter
+
+Algorithm 1 DrQ: Data-regularized Q applied to a generic off-policy actor critic algorithm.   
+Black: unmodified off-policy actor-critic. Orange: image transformation.   
+Green: target $Q$ augmentation.   
+Blue: $Q$ augmentation.
+
+Hyperparameters: Total number of environment steps $T$ , mini-batch size $N$ , learning rate $\lambda _ { \theta }$ target network update rate $\tau$ , image transformation $f$ , number of target $Q$ augmentations $K$ number of $Q$ augmentations $M$ .
+
+for each timestep $t = 1 . . T$ do
+
+$$
+\mathcal { D } \gets \mathcal { D } \cup ( s _ { t } , a _ { t } , r ( s _ { t } , a _ { t } ) , s _ { t } ^ { \prime } )
+$$
+
+# end for
+
+$\{ \nu _ { i , m } | \nu _ { i , m } \sim \mathcal { U } ( \mathcal { T } ) , i = 1 . . N , m = 1 . . M \}$ $\begin{array} { r } { J _ { Q } ( \theta ) = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } ( Q _ { \theta } ( s _ { i } , a _ { i } ) - y _ { i } ) ^ { 2 } } \end{array}$ or $\begin{array} { r } { J _ { Q } ( \theta ) = \frac { 1 } { N M } \sum _ { i , m = 1 } ^ { N , M } ( Q _ { \theta } ( f ( s _ { i } , \nu _ { i , m } ) , a _ { i } ) - y _ { i } ) ^ { 2 } } \end{array}$ . Uniformly sample Q augmentations θ ← θ − λθ∇θJQ(θ) $\triangleright$ Update the critic $\theta ^ { \prime }  ( 1 - \tau ) \theta ^ { \prime } + \tau \theta$ $\triangleright$ Update the critic target
+
+end procedure
+
+counts ranging from $2 2 0 \mathrm { k }$ to 2.4M. None of these train satisfactorily, with performance decreasing for the larger capacity models. Figure 1b shows SAC with the application of our random shifts transformation of the input images (i.e. just Section 4.2, not Q augmentation also). The results for all encoder architectures improve dramatically, suggesting that our method is general and can assist many different encoder architectures. To the best of our knowledge, this is the first successful demonstration of applying image augmentation on the standard benchmarks for continuous control. Furthermore, Figure 2 shows the full $\mathbf { D r Q }$ , with both image shifts and Q augmentation (Section 4.1), as well as ablated versions. Q augmentation provides additional consistent gain over image shift augmentation alone (full results are in Appendix F).
+
+# 5.2 DEEPMIND CONTROL SUITE EXPERIMENTS
+
+In this section we evaluate our algorithm $\mathbf { ( D r Q ) }$ on the two commonly used benchmarks based on the DeepMind control suite (Tassa et al., 2018), namely the PlaNet (Hafner et al., 2018) and Dreamer (Hafner et al., 2019) setups. Throughout these experiments all hyper-parameters of the algorithm are kept fixed: the actor and critic neural networks are trained using the Adam optimizer (Kingma & Ba, 2014) with default parameters and a mini-batch size of 512 1. For SAC, the soft target update rate $\tau$ is 0.01, initial temperature is 0.1, and target network and the actor updates are made every 2 critic updates (as in Yarats et al. (2019)). We use the image encoder architecture from SAC-AE (Yarats et al., 2019) and follow their training procedure. The full set of parameters can be found in Appendix B. Following Henderson et al. (2018), the models are trained using 10 different seeds; for every seed the mean episode returns are computed every 10000 environment steps, averaging over 10 episodes. All figures plot the mean performance over the 10 seeds, together with $\pm$ 1 standard deviation shading. We compare our $\mathbf { D r Q }$ approach to leading model-free and model-based approaches: PlaNet (Hafner et al., 2018), SAC-AE (Yarats et al., 2019), SLAC (Lee et al., 2019), CURL (Srinivas et al., 2020) and Dreamer (Hafner et al., 2019). The comparisons use the results provided by the authors of the corresponding papers.
+
+![](images/35c073a5e4788f323043f33a4dbb6e01475ff02ce5ddc7ce8afc73164d000317.jpg)
+
+![](images/48e9ad967dfa82b0a828a8a5eb98565bedce8de1f087eeb5eaf9086f5486c456.jpg)  
+Figure 1: The performance of SAC trained from pixels on the DeepMind control suite using image encoder networks of different capacity (network architectures taken from recent RL algorithms, with parameter count indicated). (a): unmodified SAC. Task performance can be seen to get worse as the capacity of the encoder increases. For Walker Walk (right), all architectures provide mediocre performance, demonstrating the inability of SAC to train directly from pixels on harder problems. (b): SAC combined with image augmentation in the form of random shifts. The task performance is now similar for all architectures, regardless of their capacity, which suggests the generality of our method. There is also a clear performance improvement relative to (a), particularly for the more challenging Walker Walk task.   
+Figure 2: Different combinations of our three regularization techniques on tasks from (Tassa et al., 2018) using SAC. Black: standard SAC. Blue: DrQ $[ \mathsf { K } { = } 1 , \mathsf { M } { = } 1 ]$ , SAC augmented with random shifts. Red: DrQ $[ \mathsf { K } { = } 2 , \mathsf { M } { = } 1 ]$ , random shifts $^ +$ Target Q augmentations. Purple: DrQ $[ \mathsf { K } { = } 2 , \mathsf { M } { = } 2 ]$ , random shifts $^ +$ Target $\mathbf { Q } + \mathbf { Q }$ augmentations. All three regularization methods correspond to Algorithm 1 with different K,M showing clear gains when both Target Q and Q augmentations are used.
+
+PlaNet Benchmark (Hafner et al., 2018) consists of six challenging control tasks from (Tassa et al., 2018) with different traits. The benchmark specifies a different action-repeat hyper-parameter for each of the six tasks2. Following common practice (Hafner et al., 2018; Lee et al., 2019; Yarats et al.,
+
+![](images/310af58b4e79339c5369ae180225441f2653d233cfa703f98b317a7c8daf3ca1.jpg)  
+Figure 3: The PlaNet benchmark. Our algorithm $\mathbf { D r Q }$ $[ \mathsf { K } = 2 , \mathsf { M } = 2 ]$ ) outperforms the other methods and demonstrates the state-of-the-art performance. Furthermore, on several tasks $\mathbf { D r Q }$ is able to match the upper-bound performance of SAC trained directly on internal state, rather than images. Finally, our algorithm not only shows improved sample-efficiency relative to other approaches, but is also faster in terms of wall clock time.
+
+2019; Mnih et al., 2013), we report the performance using true environment steps, thus are invariant to the action-repeat hyper-parameter. Aside from action-repeat, all other hyper-parameters of our algorithm are fixed across the six tasks, using the values previously detailed.
+
+Figure 3 compares DrQ $\mathrm { K } { = } 2 , \mathrm { M } { = } 2$ ] to PlaNet (Hafner et al., 2018), SAC-AE (Yarats et al., 2019), CURL (Srinivas et al., 2020), SLAC (Lee et al., 2019), and an upper bound performance provided by SAC (Haarnoja et al., 2018) that directly learns from internal states. We use the version of SLAC that performs one gradient update per an environment step to ensure a fair comparison to other approaches. $\mathbf { D r Q }$ achieves state-of-the-art performance on this benchmark on all the tasks, despite being much simpler than other methods. Furthermore, since $\mathbf { D r Q }$ does not learn a model (Hafner et al., 2018; Lee et al., 2019) or any auxiliary tasks (Srinivas et al., 2020), the wall clock time also compares favorably to the other methods.
+
+In Table 1 we also compare performance given at a fixed number of environment interactions (e.g. $1 0 0 \mathbf k$ and 500k). Furthermore, in Appendix G we demonstrate that $\mathbf { D r Q }$ is robust to significant changes in hyper-parameter settings.
+
+Dreamer Benchmark is a more extensive testbed that was introduced in Dreamer (Hafner et al., 2019), featuring a diverse set of tasks from the DeepMind control suite. Tasks involving sparse reward were excluded (e.g. Acrobot and Quadruped) since they require modification of SAC to incorporate multi-step returns (Barth-Maron et al., 2018), which is beyond the scope of this work. We evaluate on the remaining 15 tasks, fixing the action-repeat hyper-parameter to 2 as in Hafner et al. (2019).
+
+We compare DrQ $[ { \cal K } = 2 , { \cal M } = 2 ]$ ] to Dreamer (Hafner et al., 2019) and the upper-bound performance of SAC (Haarnoja et al., 2018) from states3. Again, we keep all the hyper-parameters of our algorithm fixed across all the tasks. In Figure 4, DrQ demonstrates the state-of-the-art results by collectively outperforming Dreamer (Hafner et al., 2019), although Dreamer is superior on 3 of the 15 tasks (Walker Run, Cartpole Swingup Sparse and Pendulum Swingup). On many tasks $\mathbf { D r Q }$ approaches the upper-bound performance of SAC (Haarnoja et al., 2018) trained directly on states.
+
+Table 1: The PlaNet benchmark at $1 0 0 \mathrm { k }$ and $5 0 0 \mathrm { k }$ environment steps. Our method $\mathbf { ( D r Q }$ $[ \mathsf { K } { = } 2 , \mathsf { M } { = } 2 ]$ ) outperforms other approaches in both the data-efficient (100k) and asymptotic performance (500k) regimes. Random shifts only version (e.g. $\mathbf { D r Q }$ $[ \mathsf { K } = 1 , \mathsf { M } = 1 ]$ ) has a competitive performance but is consistently inferior to DrQ $[ { \cal K } = 2 , { \cal M } = 2 ]$ , particularly for $1 0 0 \mathrm { k }$ steps. We emphasize, that both versions of DrQ use exactly the same number of interactions with both the environment and replay buffer. Note that $\mathbf { D r Q }$ $[ \mathsf { K } { = } 1 , \mathsf { M } { = } 1 ]$ ] is almost identical to RAD (Laskin et al., 2020), modulo some hyper-parameter differences.
+
+<table><tr><td>500k step scores</td><td>DrQ[K=2,M=2]</td><td>DrQ[K=1,M=1]</td><td>CURL</td><td>PlaNet</td><td>SAC-AE</td><td>SLAC</td><td>SAC State</td></tr><tr><td>Finger Spin</td><td>938±103</td><td>913±151</td><td>874±151</td><td>718±40</td><td>914±107</td><td>771±203</td><td>927±43</td></tr><tr><td>Cartpole Swingup</td><td>868±10</td><td>845±39</td><td>861±30</td><td>787±46</td><td>730±152</td><td>-</td><td>870±7</td></tr><tr><td>Reacher Easy</td><td>942±71</td><td>857±120</td><td>904±94</td><td>588±471</td><td>601±135</td><td></td><td>975±5</td></tr><tr><td>Cheetah Run</td><td>660±96</td><td>460±59</td><td>500±91</td><td>568±21</td><td>544±50</td><td>629±74</td><td>772±60</td></tr><tr><td>Walker Walk</td><td>921±45</td><td>897±47</td><td>906±56</td><td>478±164</td><td>858±82</td><td>865±97</td><td>964±8</td></tr><tr><td>Ball In Cup Catch</td><td>963±9</td><td>961±12</td><td>958±13</td><td>939±43</td><td>810±121</td><td>959±4</td><td>979±6</td></tr><tr><td>100k step scores</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Finger Spin</td><td>901±104</td><td>744±144</td><td>779±108</td><td>560±77</td><td>747±130</td><td>680±130</td><td>672±76</td></tr><tr><td>Cartpole Swingup</td><td>759±92</td><td>537±119</td><td>592±170</td><td>563±73</td><td>276±38</td><td>-</td><td>812±45</td></tr><tr><td>Reacher Easy</td><td>601±213</td><td>451±210</td><td>517±113</td><td>82±174</td><td>225±164</td><td>=</td><td>919±123</td></tr><tr><td>Cheetah Run</td><td>344±67</td><td>250±58</td><td>307±48</td><td>252±173</td><td>240±38</td><td>391±47</td><td>228±95</td></tr><tr><td>Walker Walk</td><td>612±164</td><td>501±68</td><td>344±132</td><td>221±43</td><td>395±58</td><td>428±74</td><td>604±317</td></tr><tr><td>Ball In Cup Catch</td><td>913±53</td><td>667±146</td><td>772±241</td><td>710±217</td><td>338±196</td><td>607±173</td><td>957±26</td></tr></table>
+
+![](images/f933076d7387bc93e88ccad71021979f8f57380c16dde4d934d1d22a5258b5d4.jpg)  
+Figure 4: The Dreamer benchmark. Our method (DrQ $[ { \bf K } { = } 2 , { \bf M } { = } 2 ]$ ) again demonstrates superior performance over Dreamer on 12 out 15 selected tasks. In many cases it also reaches the upper-bound performance of SAC that learns directly from states.
+
+# 5.3 ATARI 100K EXPERIMENTS
+
+We evaluate $\mathbf { D r Q }$ $[ \mathsf { K } { = } 1 , \mathsf { M } { = } 1 ]$ on the Atari 100k benchmark (Kaiser et al., 2019) – a sampleconstrained evaluation for discrete control algorithms. The underlying RL approach to which $\mathbf { D r Q }$ is applied is a DQN, combined with double Q-learning (van Hasselt et al., 2015), n-step returns (Mnih et al., 2016), and dueling critic architecture (Wang et al., 2015). As per common practice (Kaiser et al., 2019; van Hasselt et al., 2019a), we evaluate our agent for $1 2 5 \mathrm { k }$ environment steps at the end of training and average its performance over 5 random seeds. Figure 5 shows the median humannormalized episode returns performance (as in Mnih et al. (2013)) of the underlying model, which we refer to as Efficient DQN, in pink. When DrQ is added there is a significant increase in performance (cyan), surpassing OTRainbow (Kielak, 2020) and Data Efficient Rainbow (van Hasselt et al., 2019a). DrQ is also superior to CURL (Srinivas et al., 2020) that uses an auxiliary loss built on top of a hybrid between OTRainbow and Efficient rainbow. DrQ combined with Efficient DQN thus achieves state-of-the-art performance, despite being significantly simpler than the other approaches. The experimental setup and full results are detailed in Appendix C and Appendix D respectively.
+
+![](images/fbcc51e4af935e2be2c7e57346f73897201298d3eb9034b6668acad9863e7880.jpg)  
+Figure 5: The Atari $1 0 0 \mathrm { k }$ benchmark. Compared to a set of leading baselines, our method $\mathbf { ( D r Q }$ $[ \mathsf { K } = 1 , \mathsf { M } = 1 ]$ , combined with Efficient DQN) achieves the state-of-the-art performance, despite being considerably simpler. Note the large improvement that results from adding DrQ to Efficient DQN (pink vs cyan). By contrast, the gains from CURL, that utilizes tricks from both Data Efficient Rainbow and OTRainbow, are more modest over the underlying RL methods.
+
+# 6 CONCLUSION
+
+We have introduced a regularization technique, based on image shifts and Q-function augmentation, that significantly improves the performance of model-free RL algorithms trained directly from images. In contrast to the concurrent work of Laskin et al. (2020), which is a special case of $\mathbf { D r Q }$ , our method exploits the MDP structure of the problem, demonstrating gains over image augmentations alone. Our method is easy to implement and adds a negligible computational burden. We compared our method to state-of-the-art approaches on the DeepMind control suite, outperforming them on the majority of tasks and closing the gap with state-based training. On the Atari $1 0 0 \mathrm { k }$ benchmark DrQ outperforms other SOTA methods in the median metric. To the best of our knowledge, this is the first convincing demonstration of the utility of data augmentation on these standard benchmarks. Furthermore, we demonstrate the method to be robust to the choice of hyper-parameters.
+
+# REFERENCES
+
+Abbas Abdolmaleki, Jost Tobias Springenberg, Yuval Tassa, Remi Munos, Nicolas Heess, and Martin Riedmiller. Maximum a posteriori policy optimisation. arXiv preprint arXiv:1806.06920, 2018.
+
+Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAI Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in neural information processing systems, pp. 5048–5058, 2017.
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. Layer normalization. arXiv e-prints, 2016.
+
+Gabriel Barth-Maron, Matthew W. Hoffman, David Budden, Will Dabney, Dan Horgan, Dhruva TB, Alistair Muldal, Nicolas Heess, and Timothy Lillicrap. Distributional policy gradients. In International Conference on Learning Representations, 2018.
+
+S. Becker and G. E. Hinton. Self-organizing neural network that discovers surfaces in random-dot stereograms. Nature, 1992.
+
+Richard Bellman. A markovian decision process. Indiana Univ. Math. J., 1957.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020.
+
+Dan Ciregan, Ueli Meier, and Jurgen Schmidhuber. Multi-column deep neural networks for image classification. In 2012 IEEE conference on computer vision and pattern recognition, pp. 3642–3649, 2012.
+
+Dan C Ciresan, Ueli Meier, Jonathan Masci, Luca M Gambardella, and Jurgen Schmidhuber. Highperformance neural networks for visual object classification. arXiv preprint arXiv:1102.0183, 2011.
+
+Karl Cobbe, Oleg Klimov, Chris Hesse, Taehoon Kim, and John Schulman. Quantifying generalization in reinforcement learning. arXiv preprint arXiv:1812.02341, 2018.
+
+Ronan Collobert, Jason Weston, Leon Bottou, Michael Karlen, Koray Kavukcuoglu, and Pavel Kuksa. Natural language processing (almost) from scratch. Journal of machine learning research, 2011.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.
+
+Alexey Dosovitskiy, Philipp Fischer, Jost Tobias Springenberg, Martin Riedmiller, and Thomas Brox. Discriminative unsupervised feature learning with exemplar convolutional neural networks. TPAMI, 2016.
+
+Debidatta Dwibedi, Jonathan Tompson, Corey Lynch, and Pierre Sermanet. Learning actionable representations from visual observations. CoRR, 2018.
+
+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.
+
+Scott Fujimoto, Herke van Hoof, and David Meger. Addressing function approximation error in actor-critic methods. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018, 2018.
+
+Tuomas Haarnoja, Aurick Zhou, Kristian Hartikainen, George Tucker, Sehoon Ha, Jie Tan, Vikash Kumar, Henry Zhu, Abhishek Gupta, Pieter Abbeel, et al. Soft actor-critic algorithms and applications. arXiv preprint arXiv:1812.05905, 2018.
+
+Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. arXiv preprint arXiv:1811.04551, 2018.
+
+Danijar Hafner, Timothy Lillicrap, Jimmy Ba, and Mohammad Norouzi. Dream to control: Learning behaviors by latent imagination. arXiv preprint arXiv:1912.01603, 2019.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. arXiv preprint arXiv:1911.05722, 2019.
+
+Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. Thirty-Second AAAI Conference On Artificial Intelligence (AAAI), 2018.
+
+Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Czarnecki, Tom Schaul, Joel Z. Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. International Conference on Learning Representations, 2017.
+
+Leslie Pack Kaelbling, Michael L Littman, and Anthony R Cassandra. Planning and acting in partially observable stochastic domains. Artificial intelligence, 1998.
+
+Lukasz Kaiser, Mohammad Babaeizadeh, Piotr Milos, Blazej Osinski, Roy H. Campbell, Konrad Czechowski, Dumitru Erhan, Chelsea Finn, Piotr Kozakowski, Sergey Levine, Ryan Sepassi, George Tucker, and Henryk Michalewski. Model-based reinforcement learning for atari. arXiv preprint arXiv:1903.00374, 2019.
+
+Dmitry Kalashnikov, Alex Irpan, Peter Pastor, Julian Ibarz, Alexander Herzog, Eric Jang, Deirdre Quillen, Ethan Holly, Mrinal Kalakrishnan, Vincent Vanhoucke, et al. Qt-opt: Scalable deep reinforcement learning for vision-based robotic manipulation. arXiv preprint arXiv:1806.10293, 2018.
+
+Kacper Piotr Kielak. Do recent advancements in model-based deep reinforcement learning really improve data efficiency? openreview, 2020. URL https://openreview.net/forum? id $=$ Bke9u1HFwB.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Durk P Kingma, Shakir Mohamed, Danilo Jimenez Rezende, and Max Welling. Semi-supervised learning with deep generative models. In Advances in neural information processing systems, pp. 3581–3589, 2014.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, 2012.
+
+Michael Laskin, Kimin Lee, Adam Stooke, Lerrel Pinto, Pieter Abbeel, and Aravind Srinivas. Reinforcement learning with augmented data, 2020.
+
+Yann LeCun, Bernhard Boser, John S Denker, Donnie Henderson, Richard E Howard, Wayne Hubbard, and Lawrence D Jackel. Backpropagation applied to handwritten zip code recognition. Neural computation, 1989.
+
+A. X. Lee, A. Nagabandi, P. Abbeel, and S. Levine. Stochastic latent actor-critic: Deep reinforcement learning with a latent variable model. arXiv e-prints, 2019.
+
+Sergey Levine, Peter Pastor, Alex Krizhevsky, Julian Ibarz, and Deirdre Quillen. Learning handeye coordination for robotic grasping with deep learning and large-scale data collection. The International Journal of Robotics Research, 37(4-5):421–436, 2018.
+
+Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. CoRR, 2015.
+
+Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. arXiv:1912.01991, 2019.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv e-prints, 2013.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. CoRR, 2016.
+
+Masashi Okada and Tadahiro Taniguchi. Dreaming: Model-based reinforcement learning by latent imagination without reconstruction. arXiv preprint arXiv:2007.14535, 2020.
+
+Roberta Raileanu, Max Goldstein, Denis Yarats, Ilya Kostrikov, and Rob Fergus. Automatic data augmentation for generalization in deep reinforcement learning. 2020.
+
+Edgar Riba, Dmytro Mishkin, Daniel Ponsa, Ethan Rublee, and Gary Bradski. Kornia: an open source differentiable computer vision library for pytorch. In The IEEE Winter Conference on Applications of Computer Vision, pp. 3674–3683, 2020.
+
+Andrew M. Saxe, James L. McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv e-prints, 2013.
+
+Pierre Sermanet, Corey Lynch, Yevgen Chebotar, Jasmine Hsu, Eric Jang, Stefan Schaal, Sergey Levine, and Google Brain. Time-contrastive networks: Self-supervised learning from video. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 1134–1141. IEEE, 2018.
+
+Patrice Y Simard, David Steinkraus, John C Platt, et al. Best practices for convolutional neural networks applied to visual document analysis. In Icdar, 2003.
+
+Aravind Srinivas, Michael Laskin, and Pieter Abbeel. Curl: Contrastive unsupervised representations for reinforcement learning. arXiv preprint arXiv:2004.04136, 2020.
+
+Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018.
+
+Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. arXiv e-prints, 2015.
+
+Hado van Hasselt, Matteo Hessel, and John Aslanides. When to use parametric models in reinforce ment learning? arXiv preprint arXiv:1906.05243, 2019a.
+
+Hado P van Hasselt, Matteo Hessel, and John Aslanides. When to use parametric models in reinforcement learning? In Advances in Neural Information Processing Systems, 2019b.
+
+Ziyu Wang, Tom Schaul, Matteo Hessel, Hado Van Hasselt, Marc Lanctot, and Nando De Freitas. Dueling network architectures for deep reinforcement learning. arXiv preprint arXiv:1511.06581, 2015.
+
+Denis Yarats and Ilya Kostrikov. Soft actor-critic (sac) implementation in pytorch. https:// github.com/denisyarats/pytorch_sac, 2020.
+
+Denis Yarats, Amy Zhang, Ilya Kostrikov, Brandon Amos, Joelle Pineau, and Rob Fergus. Improving sample efficiency in model-free reinforcement learning from images. arXiv preprint arXiv:1910.01741, 2019.
+
+Brian D. Ziebart, Andrew Maas, J. Andrew Bagnell, and Anind K. Dey. Maximum entropy inverse reinforcement learning. In Proceedings of the 23rd National Conference on Artificial Intelligence - Volume 3, 2008.
+
+# APPENDIX
+
+# A EXTENDED BACKGROUND
+
+Reinforcement Learning from Images We formulate image-based control as an infinite-horizon partially observable Markov decision process (POMDP) (Bellman, 1957; Kaelbling et al., 1998). An POMDP can be described as the tuple $( \mathcal { O } , \mathcal { A } , p , r , \gamma )$ , where $\mathcal { O }$ is the high-dimensional observation space (image pixels), $\mathcal { A }$ is the action space, the transition dynamics $p = P r ( o _ { t } ^ { \prime } | o _ { \leq t } , a _ { t } )$ capture the probability distribution over the next observation $o _ { t } ^ { \prime }$ given the history of previous observations $O { \le } t$ and current action $a _ { t }$ , $r : \mathcal { O } \times \mathcal { A } \to \mathbb { R }$ is the reward function that maps the current observation and action to a reward $r _ { t } = r ( o _ { \leq t } , a _ { t } )$ , and $\gamma \in [ 0 , 1 )$ is a discount factor. Per common practice (Mnih et al., 2013), throughout the paper the POMDP is converted into an MDP (Bellman, 1957) by stacking several consecutive image observations into a state $s _ { t } = \{ o _ { t } , o _ { t - 1 } , o _ { t - 2 } , . . . \}$ . For simplicity we redefine the transition dynamics $p = P r \big ( s _ { t } ^ { \prime } | s _ { t } , a _ { t } \big )$ and the reward function $r _ { t } \dot { = } r ( s _ { t } , a _ { t } )$ . We then aim to find a policy $\pi ( a _ { t } | s _ { t } )$ t  that maximizes the cumulative discounted return $\begin{array} { r } { \mathbb { E } _ { \pi } [ \sum _ { t = 1 } ^ { \infty } \gamma ^ { t } r _ { t } | a _ { t } \sim } \end{array}$ $\pi ( \cdot | s _ { t } ) , s _ { t } ^ { \prime } \sim \bar { p } ( \cdot | s _ { t } , a _ { t } ) , \dot { s } _ { 1 } \sim p ( \cdot ) \mathrm { ~ . ~ }$ .
+
+Soft Actor-Critic The Soft Actor-Critic (SAC) (Haarnoja et al., 2018) learns a state-action value function $Q _ { \theta }$ , a stochastic policy $\pi _ { \theta }$ and a temperature $\alpha$ to find an optimal policy for an MDP $( S , \mathcal { A } , p , r , \gamma )$ by optimizing a $\gamma$ -discounted maximum-entropy objective (Ziebart et al., 2008). $\theta$ is used generically to denote the parameters updated through training in each part of the model. The actor policy $\pi _ { \boldsymbol { \theta } } \big ( a _ { t } | \boldsymbol { s } _ { t } \big )$ is a parametric tanh-Gaussian that given $s _ { t }$ samples $a _ { t } = \operatorname { t a n h } ( \mu _ { \theta } ( s _ { t } ) + \sigma _ { \theta } ( s _ { t } ) \epsilon )$ , where $\epsilon \sim \mathcal { N } ( 0 , 1 )$ and $\mu _ { \theta }$ and $\sigma _ { \theta }$ are parametric mean and standard deviation.
+
+The policy evaluation step learns the critic $Q _ { \theta } ( s _ { t } , a _ { t } )$ network by optimizing a single-step of the soft Bellman residual
+
+$$
+\begin{array} { r l } & { J _ { Q } ( \mathcal { D } ) = \mathbb { E } _ { ( s _ { t } , a _ { t } , s _ { t } ^ { \prime } ) \sim \mathcal { D } } [ ( Q _ { \theta } ( s _ { t } , a _ { t } ) - y _ { t } ) ^ { 2 } ] } \\ & { \qquad a _ { t } ^ { \prime } \sim \pi ( \cdot | s _ { t } ^ { \prime } ) } \\ & { y _ { t } = r ( s _ { t } , a _ { t } ) + \gamma [ Q _ { \theta ^ { \prime } } ( s _ { t } ^ { \prime } , a _ { t } ^ { \prime } ) - \alpha \log \pi _ { \theta } ( a _ { t } ^ { \prime } | s _ { t } ^ { \prime } ) ] , } \end{array}
+$$
+
+where $\mathcal { D }$ is a replay buffer of transitions, $\theta ^ { \prime }$ is an exponential moving average of the weights as done in (Lillicrap et al., 2015). SAC uses clipped double-Q learning (van Hasselt et al., 2015; Fujimoto et al., 2018), which we omit from our notation for simplicity but employ in practice.
+
+The policy improvement step then fits the actor policy $\pi _ { \boldsymbol { \theta } } ( a _ { t } | \boldsymbol { s } _ { t } )$ network by optimizing the objective
+
+$$
+J _ { \pi } ( \mathcal { D } ) = \mathbb { E } _ { s _ { t } \sim \mathcal { D } } [ D _ { \mathrm { K L } } ( \pi _ { \theta } ( \cdot | s _ { t } ) | | \exp \{ \frac { 1 } { \alpha } Q _ { \theta } ( s _ { t } , \cdot ) \} ) ] .
+$$
+
+Finally, the temperature $\alpha$ is learned with the loss
+
+$$
+J _ { \alpha } ( \mathcal { D } ) = \mathbb { E } _ { \underset { a _ { t } \sim \pi _ { \theta } ( \cdot | s _ { t } ) } { s _ { t } \sim \mathcal { D } } } [ - \alpha \log \pi _ { \theta } ( a _ { t } | s _ { t } ) - \alpha \bar { \mathcal { H } } ] ,
+$$
+
+where $\bar { \mathcal { H } } \in \mathbb { R }$ is the target entropy hyper-parameter that the policy tries to match, which in practice is usually set to $\bar { \mathcal { H } } = - | \bar { \mathcal { A } } |$ .
+
+Deep Q-learning DQN (Mnih et al., 2013) also learns a convolutional neural net to approximate Q-function over states and actions. The main difference is that DQN operates on discrete actions spaces, thus the policy can be directly inferred from Q-values. The parameters of DQN are updated by optimizing the squared residual error
+
+$$
+\begin{array} { r l } & { J _ { Q } ( \mathcal { D } ) = \mathbb { E } _ { ( s _ { t } , a _ { t } , s _ { t } ^ { \prime } ) \sim \mathcal { D } } [ ( Q _ { \theta } ( s _ { t } , a _ { t } ) - y _ { t } ) ^ { 2 } ] } \\ & { \qquad y _ { t } = r ( s _ { t } , a _ { t } ) + \gamma \underset { a ^ { \prime } } { \operatorname* { m a x } } Q _ { \theta ^ { \prime } } ( s _ { t } ^ { \prime } , a ^ { \prime } ) . } \end{array}
+$$
+
+In practice, the standard version of DQN is frequently combined with a set of tricks that improve performance and training stability, wildly known as Rainbow (van Hasselt et al., 2015).
+
+# B THE DEEPMIND CONTROL SUITE EXPERIMENTS SETUP
+
+Our PyTorch SAC (Haarnoja et al., 2018) implementation is based off of Yarats & Kostrikov (2020).
+
+# B.1 ACTOR AND CRITIC NETWORKS
+
+We employ clipped double Q-learning (van Hasselt et al., 2015; Fujimoto et al., 2018) for the critic, where each $Q$ -function is parametrized as a 3-layer MLP with ReLU activations after each layer except of the last. The actor is also a 3-layer MLP with ReLUs that outputs mean and covariance for the diagonal Gaussian that represents the policy. The hidden dimension is set to 1024 for both the critic and actor.
+
+# B.2 ENCODER NETWORK
+
+We employ an encoder architecture from Yarats et al. (2019). This encoder consists of four convolutional layers with $3 \times 3$ kernels and 32 channels. The ReLU activation is applied after each conv layer. We use stride to 1 everywhere, except of the first conv layer, which has stride 2. The output of the convnet is feed into a single fully-connected layer normalized by LayerNorm (Ba et al., 2016). Finally, we apply tanh nonlinearity to the 50 dimensional output of the fully-connected layer. We initialize the weight matrix of fully-connected and convolutional layers with the orthogonal initialization (Saxe et al., 2013) and set the bias to be zero.
+
+The actor and critic networks both have separate encoders, although we share the weights of the conv layers between them. Furthermore, only the critic optimizer is allowed to update these weights (e.g. we stop the gradients from the actor before they propagate to the shared conv layers).
+
+# B.3 TRAINING AND EVALUATION SETUP
+
+Our agent first collects 1000 seed observations using a random policy. The further training observations are collected by sampling actions from the current policy. We perform one training update every time we receive a new observation. In cases where we use action repeat, the number of training observations is only a fraction of the environment steps (e.g. a 1000 steps episode at action repeat 4 will only results into 250 training observations). We evaluate our agent every 10000 true environment steps by computing the average episode return over 10 evaluation episodes. During evaluation we take the mean policy action instead of sampling.
+
+# B.4 PLANET AND DREAMER BENCHMARKS
+
+We consider two evaluation setups that were introduced in PlaNet (Hafner et al., 2018) and Dreamer (Hafner et al., 2019), both using tasks from the DeepMind control suite (Tassa et al., 2018). The PlaNet benchmark consists of six tasks of various traits. Importantly, the benchmark proposed to use a different action repeat hyper-parameter for each task, which we summarize in Table 2.
+
+The Dreamer benchmark considers an extended set of tasks, which makes it more difficult that the PlaNet setup. Additionally, this benchmark requires to use the same set hyper-parameters for each task, including action repeat (set to 2), which further increases the difficulty.
+
+Table 2: The action repeat hyper-parameter used for each task in the PlaNet benchmark.   
+
+<table><tr><td>Task name</td><td>Action repeat</td></tr><tr><td>Cartpole Swingup</td><td>8</td></tr><tr><td>Reacher Easy</td><td>4</td></tr><tr><td>Cheetah Run</td><td>4</td></tr><tr><td>Finger Spin</td><td>2</td></tr><tr><td>Ball In Cup Catch</td><td>4</td></tr><tr><td>Walker Walk</td><td>2</td></tr></table>
+
+# B.5 PIXELS PREPROCESSING
+
+We construct an observational input as an 3-stack of consecutive frames (Mnih et al., 2013), where each frame is a RGB rendering of size $8 4 \times 8 4$ from the 0th camera. We then divide each pixel by 255 to scale it down to [0, 1] range.
+
+# B.6 OTHER HYPER PARAMETERS
+
+Due to computational constraints for all the continuous control ablation experiments in the main paper and appendix we use a minibatch size of 128, while for the main results we use minibatch of size 512. In Table 3 we provide a comprehensive overview of all the other hyper-parameters.
+
+Table 3: An overview of used hyper-parameters in the DeepMind control suite experiments.   
+
+<table><tr><td>Parameter Replay buffer capacity</td><td>Setting 100000</td></tr><tr><td>Seed steps Ablations minibatch size Main results minibatch size Discount y Optimizer</td><td>1000 128 512 0.99</td></tr><tr><td>Learning rate Critic target update frequency Critic Q-function soft-update rate T Actor update frequency Actor log stddev bounds</td><td>Adam 10-3 2 0.01 2 [-10,2]</td></tr></table>
+
+# C THE ATARI 100K EXPERIMENTS SETUP
+
+For ease of reproducibility in Table 4 we report the hyper-parameter settings used in the Atari $1 0 0 \mathrm { k }$ experiments. We largely reuse the hyper-parameters from OTRainbow (Kielak, 2020), but adapt them for DQN (Mnih et al., 2013). Per common practise, we average performance of our agent over 5 random seeds. The evaluation is done for $1 2 5 \mathrm { k }$ environment steps at the end of training for 100k environment steps.
+
+Table 4: A complete overview of hyper parameters used in the Atari $1 0 0 \mathrm { k }$ experiments.   
+
+<table><tr><td>Parameter Data augmentation</td><td>Setting Random shifts and Intensity</td></tr><tr><td>Grey-scaling Observation down-sampling Frames stacked Action repetitions Reward clipping Terminal on loss of life Max frames per episode Update Dueling Target network: update period Discount factor Minibatch size Optimizer Optimizer: learning rate Optimizer: β1 Optimizer: β2 Optimizer: ∈ Max gradient norm Training steps Evaluation steps Min replay size for sampling Memory size Replay period every Multi-step return length Q network:channels Q network: filter size Q network: stride Q network: hidden units</td><td>True 84×84 4 4 [-1,1] True 108k Double Q True 1 0.99 32 Adam 0.0001 0.9 0.999 0.00015 10 100k 125k 1600 Unbounded 1 step 10 32,64,64 8×8,4×4,3×3 4,2,1</td></tr></table>
+
+# D FULL ATARI 100K RESULTS
+
+Besides reporting in Figure 5 median human-normalized episode returns over the 26 Atari games used in (Kaiser et al., 2019), we also provide the mean episode return for each individual game in Table 5.
+
+Table 5: Mean episode returns on each of 26 Atari games from the setup in Kaiser et al. (2019). The results are recorded at the end of training and averaged across 5 random seeds (the CURL’s results are averaged over 3 seeds as reported in Srinivas et al. (2020)). On each game we mark as bold the highest score. Our method demonstrates better overall performance (as reported in Figure 5).   
+
+<table><tr><td>Game</td><td>Rainbow</td><td>SimPLe</td><td>OTRainbow</td><td>Eff. Rainbow</td><td>OT/Eff.Rainbow +CURL</td><td>Eff. DQN</td><td>Eff. DQN +DrQ (Ours)</td></tr><tr><td>Alien</td><td>318.7</td><td>616.9</td><td>824.7</td><td>739.9</td><td>1148.2</td><td>558.1</td><td>702.5</td></tr><tr><td>Amidar</td><td>32.5</td><td>88.0</td><td>82.8</td><td>188.6</td><td>232.3</td><td>63.7</td><td>100.2</td></tr><tr><td>Assault</td><td>231.0</td><td>527.2</td><td>351.9</td><td>431.2</td><td>543.7</td><td>589.5</td><td>490.3</td></tr><tr><td>Asterix</td><td>243.6</td><td>1128.3</td><td>628.5</td><td>470.8</td><td>524.3</td><td>341.9</td><td>577.9</td></tr><tr><td>BankHeist</td><td>15.6</td><td>34.2</td><td>182.1</td><td>51.0</td><td>193.7</td><td>74.0</td><td>205.3</td></tr><tr><td>BattleZone</td><td>2360.0</td><td>5184.4</td><td>4060.6</td><td>10124.6</td><td>11208.0</td><td>4760.8</td><td>6240.0</td></tr><tr><td>Boxing</td><td>-24.8</td><td>9.1</td><td>2.5</td><td>0.2</td><td>4.8</td><td>-1.8</td><td>5.1</td></tr><tr><td>Breakout</td><td>1.2</td><td>16.4</td><td>9.8</td><td>1.9</td><td>18.2</td><td>7.3</td><td>14.3</td></tr><tr><td>ChopperCommand</td><td>120.0</td><td>1246.9</td><td>1033.3</td><td>861.8</td><td>1198.0</td><td>624.4</td><td>870.1</td></tr><tr><td>CrazyClimber</td><td>2254.5</td><td>62583.6</td><td>21327.8</td><td>16185.3</td><td>27805.6</td><td>5430.6</td><td>20072.2</td></tr><tr><td>DemonAttack</td><td>163.6</td><td>208.1</td><td>711.8</td><td>508.0</td><td>834.0</td><td>403.5</td><td>1086.0</td></tr><tr><td>Freeway</td><td>0.0</td><td>20.3</td><td>25.0</td><td>27.9</td><td>27.9</td><td>3.7</td><td>20.0</td></tr><tr><td>Frostbite</td><td>60.2</td><td>254.7</td><td>231.6</td><td>866.8</td><td>924.0</td><td>202.9</td><td>889.9</td></tr><tr><td>Gopher</td><td>431.2</td><td>771.0</td><td>778.0</td><td>349.5</td><td>801.4</td><td>320.8</td><td>678.0</td></tr><tr><td>Hero</td><td>487.0</td><td>2656.6</td><td>6458.8</td><td>6857.0</td><td>6235.1</td><td>2200.1</td><td>4083.7</td></tr><tr><td>Jamesbond</td><td>47.4</td><td>125.3</td><td>112.3</td><td>301.6</td><td>400.1</td><td>133.2</td><td>330.3</td></tr><tr><td>Kangaroo</td><td>0.0</td><td>323.1</td><td>605.4</td><td>779.3</td><td>345.3</td><td>448.6</td><td>1282.6</td></tr><tr><td>Krull</td><td>1468.0</td><td>4539.9</td><td>3277.9</td><td>2851.5</td><td>3833.6</td><td>2999.0</td><td>4163.0</td></tr><tr><td>KungFuMaster</td><td>0.0</td><td>17257.2</td><td>5722.2</td><td>14346.1</td><td>14280.0</td><td>2020.9</td><td>7649.0</td></tr><tr><td>MsPacman</td><td>67.0</td><td>1480.0</td><td>941.9</td><td>1204.1</td><td>1492.8</td><td>872.0</td><td>1015.9</td></tr><tr><td>Pong</td><td>-20.6</td><td>12.8</td><td>1.3</td><td>-19.3</td><td>2.1</td><td>-19.4</td><td>-17.1</td></tr><tr><td>PrivateEye</td><td>0.0</td><td>58.3</td><td>100.0</td><td>97.8</td><td>105.2</td><td>351.3</td><td>-50.4</td></tr><tr><td>Qbert</td><td>123.5</td><td>1288.8</td><td>509.3</td><td>1152.9</td><td>1225.6</td><td>627.5</td><td>769.1</td></tr><tr><td>RoadRunner</td><td>1588.5</td><td>5640.6</td><td>2696.7</td><td>9600.0</td><td>6786.7</td><td>1491.9</td><td>8296.3</td></tr><tr><td>Seaquest</td><td>131.7</td><td>683.3</td><td>286.9</td><td>354.1</td><td>408.0</td><td>240.1</td><td>299.4</td></tr><tr><td>UpNDown</td><td>504.6</td><td>3350.3</td><td>2847.6</td><td>2877.4</td><td>2735.2</td><td>2901.7</td><td>3134.8</td></tr><tr><td>Median human-normalised episode returns</td><td>0.020</td><td>0.135</td><td>0.208</td><td>0.147</td><td>0.240</td><td>0.094</td><td>0.270</td></tr></table>
+
+# E IMAGE AUGMENTATIONS ABLATION
+
+Following (Chen et al., 2020), we evaluate popular image augmentation techniques, namely random shifts, cutouts, vertical and horizontal flips, random rotations and imagewise intensity jittering. Below, we provide a comprehensive overview of each augmentation. Furthermore, we examine effectiveness of these techniques in Figure 6.
+
+Random Shift We bring our attention to random shifts that are commonly used to regularize neural networks trained on small images (Becker & Hinton, 1992; Simard et al., 2003; LeCun et al., 1989; Ciresan et al., 2011; Ciregan et al., 2012). In our implementation of this method images of size $8 4 \times 8 4$ are padded each side by 4 pixels (by repeating boundary pixels) and then randomly cropped back to the original $8 4 \times 8 4$ size.
+
+Cutout Cutouts introduced in DeVries & Taylor (2017) represent a generalization of Dropout (Hinton et al., 2012). Instead of masking individual pixels cutouts mask square regions. Since image pixels can be highly correlated, this technique is proven to improve training of neural networks.
+
+Horizontal/Vertical Flip This technique simply flips an image either horizontally or vertically with probability 0.1.
+
+Rotate Here, an image is rotated by $r$ degrees, where $r$ is uniformly sampled from $[ - 5 , - 5 ]$
+
+Intensity Each $N \times C \times 8 4 \times 8 4$ image tensor is multiplied by a single scalar $s$ , which is computed as $s = \mu + \sigma \cdot \mathrm { c l i p } ( r , - 2 , 2 )$ , where $r \sim \mathcal { N } ( 0 , 1 )$ . For our experiments we use $\mu = 1 . 0$ and $\sigma = 0 . 1$
+
+![](images/9053fd74cd643c1d6e7fbbb037032e8c32f7d54efc0baae648f60b58ea8a2788.jpg)  
+Figure 6: Various image augmentations have different effect on the agent’s performance. Overall, we conclude that using image augmentations helps to fight overfitting. Moreover, we notice that random shifts proven to be the most effective technique for tasks from the DeepMind control suite.
+
+Implementation Finally, we provide Python-like implementation for the aforementioned augmentations powered by Kornia (Riba et al., 2020).
+
+import torch import torch.nn as nn import kornia.augmentation as aug
+
+random_shift $=$ nn.Sequential(nn.ReplicationPad2d(4),aug.RandomCrop((84, 84)))
+
+cutout $=$ aug.RandomErasing( $\mathrm { . p } { = } 0 \cdot 5$ )
+
+h_flip $=$ aug.RandomHorizontalFlip $\mathrm { \cdot p = 0 ~ . ~ }$ 1)
+
+v_flip $=$ aug.RandomVerticalFlip( $\mathrm { . p = 0 . 1 }$ )
+
+rotate $=$ aug.RandomRotation(degree $\mathtt { S } = 5 \mathtt { . } 0$ )
+
+intensity $=$ Intensity(scale ${ \tt a } = 0$ .1)
+
+class Intensity(nn.Module): def __init__(self, scale): super().__init__() self.scale $\qquad = \quad \ S \subset$ ale
+
+def forward(self, x): $\qquad \pm \quad =$ torch.randn((x.size(0), 1, 1, 1), device $= \times$ .device) noise $= \ 1 . 0 \mathrm { ~ \Omega ~ } +$ (self.scale $\star$ r.clamp(-2.0, 2.0)) return x $\star$ noise
+
+# F K AND M HYPER-PARAMETERS ABLATION
+
+We further ablate the K,M hyper-parameters from Algorithm 1 to understand their effect on performance. In Figure 7 we observe that increase values of K,M improves the agent’s performance. We choose to use the $[ { \cal K } = 2 , { \cal M } = 2 ]$ parametrization as it strikes a good balance between performance and computational demands.
+
+![](images/a14dbf1be0cbfbaf553d5b0ddd7d8b09fbdc7d1c0922d93a33002addc3f166f9.jpg)  
+Figure 7: Increasing values of K,M hyper-parameters generally correlates positively with the agent’s performance, especially on the harder tasks, such as Cheetah Run.
+
+# G ROBUSTNESS INVESTIGATION
+
+To demonstrate the robustness of our approach (Henderson et al., 2018), we perform a comprehensive study on the effect different hyper-parameter choices have on performance. A review of prior work (Hafner et al., 2018; 2019; Lee et al., 2019; Srinivas et al., 2020) shows consistent values for discount $\gamma = 0 . 9 9$ and target update rate $\tau = 0 . 0 1$ parameters, but variability on network architectures, mini-batch sizes, learning rates. Since our method is based on SAC (Haarnoja et al., 2018), we also check whether the initial value of the temperature is important, as it plays a crucial role in the initial phase of exploration. We omit search over network architectures since Figure 1b shows our method to be robust to the exact choice. We thus focus on three hyper-parameters: mini-batch size, learning rate, and initial temperature.
+
+Due to computational demands, experiments are restricted to a subset of tasks from Tassa et al. (2018): Walker Walk, Cartpole Swingup, and Finger Spin. These were selected to be diverse, requiring different behaviors including locomotion and goal reaching. A grid search is performed over minibatch sizes $\{ 1 2 8 , 2 5 6 , 5 1 2 \}$ , learning rates $\{ 0 . 0 0 0 1 , 0 . 0 0 0 5 , 0 . 0 0 1 , 0 . 0 0 5 \}$ , and initial temperatures $\{ 0 . 0 0 5 , 0 . 0 1 , 0 . 0 5 , 0 . 1 \}$ . We follow the experimental setup from Appendix B, except that only 3 seeds are used due to the computation limitations, but since variance is low the results are representative.
+
+![](images/dc3d860e8a9345e3a2ff263f3cccf54250a78df72cda9340f303663e3249d1ed.jpg)  
+Figure 8: A robustness study of our algorithm $\mathbf { ( D r Q ) }$ to changes in mini-batch size, learning rate, and initial temperature hyper-parameters on three different tasks from (Tassa et al., 2018). Each row corresponds to a different mini-batch size. The low variance of the curves and heat-maps shows DrQ to be generally robust to exact hyper-parameter settings.
+
+Figure 8 shows performance curves for each configuration as well as a heat map over the mean performance of the final evaluation episodes, similar to Mnih et al. (2016). Our method demonstrates good stability and is largely invariant to the studied hyper-parameters. We emphasize that for simplicity the experiments in Section 5 use the default learning rate of Adam (Kingma & Ba, 2014) (0.001), even though it is not always optimal.
+
+# H IMPROVED DATA-EFFICIENT REINFORCEMENT LEARNING FROM PIXELS
+
+Our method allows to generate many various transformations from a training observation due to the data augmentation strategy. Thus, we further investigate whether performing more training updates per an environment step can lead to even better sample-efficiency. Following van Hasselt et al. (2019b) we compare a single update with a mini-batch of 512 transitions with 4 updates with 4 different mini-batches of size 128 samples each. Performing more updates per an environment step leads to even worse over-fitting on some tasks without data augmentation (see Figure 9a), while our method $\mathbf { D r Q }$ , that takes advantage of data augmentation, demonstrates improved sample-efficiency (see Figure 9b).
+
+![](images/07b1da1b0826219bbe015466bb032d01d332406ce9f130673091e5bb63629967.jpg)  
+Figure 9: In the data-efficient regime, where we measure performance at $1 0 0 \mathrm { k }$ environment steps, $\mathbf { D r Q }$ is able to enhance its efficiency by performing more training iterations per an environment step. This is because $\mathbf { D r Q }$ allows to generate various transformations for a training observation.

parse/train/HJC2SzZCW/HJC2SzZCW.md

@@ -0,0 +1,533 @@
+# SENSITIVITY AND GENERALIZATION IN NEURAL NETWORKS: AN EMPIRICAL STUDY
+
+Roman Novak, Yasaman Bahri∗, Daniel A. Abolafia, Jeffrey Pennington, Jascha Sohl-Dickstein
+
+Google Brain
+
+{romann, yasamanb, danabo, jpennin, jaschasd}@google.com
+
+# ABSTRACT
+
+In practice it is often found that large over-parameterized neural networks generalize better than their smaller counterparts, an observation that appears to conflict with classical notions of function complexity, which typically favor smaller models. In this work, we investigate this tension between complexity and generalization through an extensive empirical exploration of two natural metrics of complexity related to sensitivity to input perturbations. Our experiments survey thousands of models with various fully-connected architectures, optimizers, and other hyper-parameters, as well as four different image classification datasets.
+
+We find that trained neural networks are more robust to input perturbations in the vicinity of the training data manifold, as measured by the norm of the input-output Jacobian of the network, and that it correlates well with generalization. We further establish that factors associated with poor generalization – such as full-batch training or using random labels – correspond to lower robustness, while factors associated with good generalization – such as data augmentation and ReLU non-linearities – give rise to more robust functions. Finally, we demonstrate how the input-output Jacobian norm can be predictive of generalization at the level of individual test points.
+
+# 1 INTRODUCTION
+
+The empirical success of deep learning has thus far eluded interpretation through existing lenses of computational complexity (Blum & Rivest, 1988), numerical optimization (Choromanska et al., 2015; Goodfellow & Vinyals, 2014; Dauphin et al., 2014) and classical statistical learning theory (Zhang et al., 2016): neural networks are highly non-convex models with extreme capacity that train fast and generalize well. In fact, not only do large networks demonstrate good test performance, but larger networks often generalize better, counter to what would be expected from classical measures, such as VC dimension. This phenomenon has been observed in targeted experiments (Neyshabur et al., 2015), historical trends of Deep Learning competitions (Canziani et al., 2016), and in the course of this work (Figure 1).
+
+This observation is at odds with Occam’s razor, the principle of parsimony, as applied to the intuitive notion of function complexity (see A.2 for extended discussion). One resolution of the apparent contradiction is to examine complexity of functions in conjunction with the input domain. $f ( x ) =$ $x ^ { 3 } \sin ( x )$ may seem decisively more complex than $g ( x ) \ = \ x$ . But restrained to a narrow input domain of $[ - 0 . 0 1 , 0 . 0 1 ]$ they appear differently: $g$ remains a linear function of the input, while $f ( x ) = \mathcal { O } \left( x ^ { 4 } \right)$ resembles a constant 0. In this work we find that such intuition applies to neural networks, that behave very differently close to the data manifold than away from it (§4.1).
+
+We therefore analyze the complexity of models through their capacity to distinguish different inputs in the neighborhood of datapoints, or, in other words, their sensitivity. We study two simple metrics presented in $\ S$ and find that one of them, the norm of the input-output Jacobian, correlates with generalization in a very wide variety of scenarios.
+
+![](images/70e4dcb8c0388fbbde3942926af0c8f10e7242245a9f4630754e1feb8e6f2486.jpg)  
+Figure 1: 2160 networks trained to $100 \%$ training accuracy on CIFAR10 (see $\ S$ for experimental details). Left: while increasing capacity of the model allows for overfitting (top), very few models do, and a model with the maximum parameter count yields the best generalization (bottom right). Right: train loss does not correlate well with generalization, and the best model (minimum along the $y$ -axis) has training loss many orders of magnitude higher than models that generalize worse (left). This observation rules out underfitting as the reason for poor generalization in low-capacity models. See (Neyshabur et al., 2015) for similar findings in the case of achievable 0 training loss.
+
+This work considers sensitivity only in the context of image classification tasks. We interpret the observed correlation with generalization as an expression of a universal prior on (natural) image classification functions that favor robustness (see $\ S \mathrm { A } . 2$ for details). While we expect a similar prior to exist in many other perceptual settings, care should be taken when extrapolating our findings to tasks where such a prior may not be justified (e.g. weather forecasting).
+
+# 1.1 PAPER OUTLINE
+
+We first define sensitivity metrics for fully-connected neural networks in §3. We then relate them to generalization through a sequence of experiments of increasing level of nuance:
+
+• In §4.1 we begin by comparing the sensitivity of trained neural networks on and off the training data manifold, i.e. in the regions of best and typical (over the whole input space) generalization.   
+• In §4.2 we compare sensitivity of identical trained networks that differ in a single hyperparameter which is important for generalization. Further, $\ S$ associates sensitivity and generalization in an unrestricted manner, i.e. comparing networks of a wide variety of hyper-parameters such as width, depth, non-linearity, weight initialization, optimizer, learning rate and batch size.   
+• Finally, $\ S$ explores how predictive sensitivity (as measured by the Jacobian norm) is for individual test points.
+
+# 1.2 SUMMARY OF CONTRIBUTIONS
+
+The novelty of this work can be summarized as follows:
+
+• Study of the behavior of trained neural networks on and off the data manifold through sensitivity metrics (§4.1). • Evaluation of sensitivity metrics on trained neural networks in a very large-scale experimental setting and finding that they correlate with generalization (§4.2, §4.3, §4.4).
+
+§2 puts our work in context of related research studying complexity, generalization, or sensitivity metrics similar to ours.
+
+# 2 RELATED WORK
+
+# 2.1 COMPLEXITY METRICS
+
+We analyze complexity of fully-connected neural networks for the purpose of model comparison through the following sensitivity measures (see §3 for details):
+
+• estimating the number of linear regions a network splits the input space into;   
+• measuring the norm of the input-output Jacobian within such regions.
+
+A few prior works have examined measures related to the ones we consider. In particular, Pascanu et al. (2013); Montufar et al. ´ (2014); Raghu et al. (2016) have investigated the expressive power of fully-connected neural networks built out of piecewise-linear activation functions. Such functions are themselves piecewise-linear over their input domain, so that the number of linear regions into which input space is divided is one measure of how nonlinear the function is. A function with many linear regions has the capacity to build complex, flexible decision boundaries. It was argued in (Pascanu et al., 2013; Montufar et al. ´ , 2014) that an upper bound to the number of linear regions scales exponentially with depth but polynomially in width, and a specific construction was examined. Raghu et al. (2016) derived a tight analytic bound and considered the number of linear regions for generic networks with random weights, as would be appropriate, for instance, at initialization. However, the evolution of this measure after training has not been investigated before. We examine a related measure, the number of hidden unit transitions along one-dimensional trajectories in input space, for trained networks. Further motivation for this measure is discussed in §3.
+
+Another perspective on function complexity can be gained by studying their robustness to perturbations to the input. Indeed, Rasmussen & Ghahramani (2000) demonstrate on a toy problem how complexity as measured by the number of parameters may be of limited utility for model selection, while measuring the output variation allows the invocation of Occam’s razor. In this work we apply related ideas to a large-scale practical context of neural networks with up to a billion free parameters ( 4.2, 4.3) and discuss potential ways in which sensitivity permits the application of Occam’s razor to neural networks (§A.2).
+
+Sokolic et al. (2017) provide theoretical support for the relevance of robustness, as measured by the input-output Jacobian, to generalization. They derive bounds for the generalization gap in terms of the Jacobian norm within the framework of algorithmic robustness (Xu & Mannor, 2012). Our results provide empirical support for their conclusions through an extensive number of experiments. Several other recent papers have also focused on deriving tight generalization bounds for neural networks (Bartlett et al., 2017; Dziugaite & Roy, 2017; Neyshabur et al., 2018). We do not propose theoretical bounds in this paper but establish a correlation between our metrics and generalization in a substantially larger experimental setting than undertaken in prior works.
+
+# 2.2 REGULARIZATION
+
+In the context of regularization, increasing robustness to perturbations is a widely-used strategy: data augmentation, noise injection (Jiang et al., 2009), weight decay (Krogh & Hertz, 1992), and max-pooling all indirectly reduce sensitivity of the model to perturbations, while Rifai et al. (2011); Sokolic et al. (2017) explicitly penalize the Frobenius norm of the Jacobian in the training objective.
+
+In this work we relate several of the above mentioned regularizing techniques to sensitivity, demonstrating through extensive experiments that improved generalization is consistently coupled with better robustness as measured by a single metric, the input-output Jacobian norm (§4.2). While some of these findings confirm common-sense expectations (random labels increase sensitivity, Figure 4, top row), others challenge our intuition of what makes a neural network robust (ReLU-networks, with unbounded activations, tend to be more robust than saturating HardSigmoid-networks, Figure 4, third row).
+
+# 2.3 INDUCTIVE BIAS OF SGD
+
+One of our findings demonstrates an inductive bias towards robustness in stochastic mini-batch optimization compared to full-batch training (Figure 4, bottom row). Interpreting this regularizing effect in terms of some measure of sensitivity, such as curvature, is not new (Hochreiter & Schmidhuber, 1997; Keskar et al., 2016), yet we provide a novel perspective by relating it to reduced sensitivity to inputs instead of parameters.
+
+The inductive bias of SGD (“implicit regularization”) has been previously studied in (Neyshabur et al., 2015), where it was shown through rigorous experiments how increasing the width of a singlehidden-layer network improves generalization, and an analogy with matrix factorization was drawn to motivate constraining the norm of the weights instead of their count. Neyshabur et al. (2017) further explored several weight-norm based measures of complexity that do not scale with the size of the model. One of our measures, the Frobenius norm of the Jacobian is of similar nature (since the Jacobian matrix size is determined by the task and not by a particular network architecture). However, this particular metric was not considered, and, to the best of our knowledge, we are the first to evaluate it in a large-scale setting (e.g. our networks are up to 65 layers deep and up to $2 ^ { 1 6 }$ units wide).
+
+# 2.4 ADVERSARIAL EXAMPLES
+
+Sensitivity to inputs has attracted a lot of interest in the context of adversarial examples (Szegedy et al., 2013). Several attacks locate points of poor generalization in the directions of high sensitivity of the network (Goodfellow et al., 2014; Papernot et al., 2016; Moosavi-Dezfooli et al., 2016), while certain defences regularize the model by penalizing sensitivity (Gu & Rigazio, 2014) or employing decaying (hence more robust) non-linearities (Kurakin et al., 2016). However, work on adversarial examples relates highly specific perturbations to a similarly specific kind of generalization (i.e. performance on a very small, adversarial subset of the data manifold), while this paper analyzes average-case sensitivity (§3) and typical generalization.
+
+# 3 SENSITIVITY METRICS
+
+We propose two simple measures of sensitivity for a fully-connected neural network (without biases) $\mathbf { f } : \bar { \mathbb { R } } ^ { d } \overset { \cdot } {  } \mathbb { R } ^ { n }$ with respect to its input $\mathbf { x } \in \mathbb { R } ^ { d }$ (the output being unnormalized logits of the $n$ classes). Assume f employs a piecewise-linear activation function, like ReLU. Then f itself, as a composition of linear and piecewise-linear functions, is a piecewise-linear map, splitting the input space $\mathbf { \mathbb { R } } ^ { d }$ into disjoint regions, implementing a single affine mapping on each. Then we can measure two aspects of sensitivity by answering
+
+1. How does the output of the network change as the input is perturbed within the linear region?
+
+2. How likely is the linear region to change in response to change in the input?
+
+We quantify these qualities as follows:
+
+1. For a local sensitivity measure we adopt the Frobenius norm of the class probabilities Jacobian $\mathbf { J } ( \mathbf { x } ) = \partial \mathbf { f } _ { \sigma } \left( \mathbf { x } \right) / \partial \mathbf { x } ^ { \mathbf { T } }$ (with $\bar { J _ { i j } } ( \mathbf { x } ) = \partial \left[ \mathbf { f } _ { \sigma } \left( \mathbf { x } \right) \right] _ { i } / \partial x _ { j } )$ , where $\mathbf { f } _ { \sigma } = \sigma \circ \mathbf { f }$ with $\pmb { \sigma }$ being the softmax function1. Given points of interest $\mathbf { x } _ { \mathrm { t e s t } }$ , we estimate the sensitivity of the function in those regions with the average Jacobian norm:
+
+$$
+\mathbb { E } _ { \mathbf { x } _ { \mathrm { t e s t } } } \left[ \left. \mathbf { J } \left( \mathbf { x } _ { \mathrm { t e s t } } \right) \right. _ { F } \right] ,
+$$
+
+that we will further refer to as simply “Jacobian norm”. Note that this does not require the labels for $\mathbf { x } _ { \mathrm { t e s t } }$ .
+
+Interpretation. The Frobenius norm $\begin{array} { r } { \| \mathbf { J } ( \mathbf { x } ) \| _ { F } = \sqrt { \sum _ { i j } J _ { i j } ( \mathbf { x } ) ^ { 2 } } } \end{array}$ estimates the averagecase sensitivity of $\mathbf { f } _ { \sigma }$ around $\mathbf { x }$ . Indeed, consider an infinitesimal Gaussian perturbation
+
+$\Delta \mathbf { x } \sim \mathcal { N } \left( \mathbf { 0 } , \epsilon \mathbf { I } \right)$ : the expected magnitude of the output change is then
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } _ { \Delta \mathbf { x } } \left[ \big \| \mathbf { f } _ { \sigma } \left( \mathbf { x } \right) - \mathbf { f } _ { \sigma } \left( \mathbf { x } + \Delta \mathbf { x } \right) \big \| _ { 2 } ^ { 2 } \right] \approx \mathbb { E } _ { \Delta \mathbf { x } } \left[ \big \| \mathbf { J } ( \mathbf { x } ) \Delta \mathbf { x } \big \| _ { 2 } ^ { 2 } \right] = \mathbb { E } _ { \Delta \mathbf { x } } \bigg [ \displaystyle \sum _ { i } \left( \displaystyle \sum _ { j } J _ { i j } x _ { j } \right) ^ { 2 } \bigg ] } \\ { = \displaystyle \sum _ { i j j ^ { \prime } } J _ { i j ^ { \prime } } \mathbb { E } _ { \Delta \mathbf { x } } \left[ x _ { j } x _ { j ^ { \prime } } \right] = \displaystyle \sum _ { i j } J _ { i j } ^ { 2 } \mathbb { E } _ { \Delta \mathbf { x } } \left[ x _ { j } ^ { 2 } \right] } \\ { = \epsilon \left\| \mathbf { J } \left( \mathbf { x } \right) \right\| _ { F } ^ { 2 } . } \end{array}
+$$
+
+2. To detect a change in linear region (further called a “transition”), we need to be able to identify it. We do this analogously to Raghu et al. (2016). For a network with piecewiselinear activations, we can, given an input $\mathbf { x }$ , assign a code to each neuron in the network f, that identifies the linear region of the pre-activation of that neuron. E.g. each ReLU unit will have 0 or 1 assigned to it if the pre-activation value is less or greater than 0 respectively. Similarly, a ReLU6 unit (see definition in A.4) will have a code of 0, 1, or 2 assigned, since it has 3 linear regions2. Then, a concatenation of codes of all neurons in the network (denoted by $\mathbf { c } ( \mathbf { x } ) \dot { }$ ) uniquely identifies the linear region of the input $\mathbf { x }$ (see A.1.1 for discussion of edge cases).
+
+Given this encoding scheme, we can detect a transition by detecting a change in the code. We then sample $k$ equidistant points $\mathbf { z } _ { 0 } , \ldots , \mathbf { z } _ { k - 1 }$ on a closed one-dimensional trajectory $\tau ( \mathbf { x } )$ (generated from a data point $\mathbf { x }$ and lying close to the data manifold; see below for details) and count transitions $t ( \mathbf { x } )$ along it to quantify the number of linear regions:
+
+$$
+t ( \mathbf { x } ) : = \sum _ { i = 0 } ^ { k - 1 } \left\| \mathbf { c } \left( \mathbf { z } _ { i } \right) - \mathbf { c } \left( \mathbf { z } _ { ( i + 1 ) } \% \right) \right\| _ { 1 } \approx \oint _ { \mathbf { z } \in \mathcal { T } ( \mathbf { x } ) } \left\| \frac { \partial \mathbf { c } ( \mathbf { z } ) } { \partial \left( d \mathbf { z } \right) } \right\| _ { 1 } d \mathbf { z } ,
+$$
+
+where the norm of the directional derivative $\| \partial \mathbf { c ( z ) } / \partial \left( d \mathbf { z } \right) \| _ { 1 }$ amounts to a Dirac delta function at each transition (see A.1.2 for further details).
+
+By sampling multiple such trajectories around different points, we estimate the sensitivity metric:
+
+$$
+\mathbb { E } _ { \mathbf { x } _ { \mathrm { t e s t } } } \left[ t \left( \mathbf { x } _ { \mathrm { t e s t } } \right) \right] ,
+$$
+
+that we will further refer to as simply “transitions” or “number of transitions.”
+
+To assure the sampling trajectory $\tau ( \mathbf { x } _ { \mathrm { t e s t } } )$ is close to the data manifold (since this is the region of interest), we construct it through horizontal translations of the image $\mathbf { x } _ { \mathrm { t e s t } }$ in pixel space (Figure App.7, right). We similarly augment our training data with horizontal and vertical translations in the corresponding experiments (Figure 4, second row).
+
+As earlier, this metric does not require knowing the label of $\mathbf { x } _ { \mathrm { t e s t } }$
+
+Interpretation. We can draw a qualitative parallel between the number of transitions and curvature of the function. One measure of curvature of a function $\mathbf { f }$ is the total norm of the directional derivative of its first derivative $\mathbf { f ^ { \prime } }$ along a path:
+
+$$
+C \left( \mathbf { f } , \mathcal { T } \left( \mathbf { x } \right) \right) : = \oint _ { \mathbf { z } \in \mathcal { T } \left( \mathbf { x } \right) } \left. \frac { \partial \mathbf { f } ^ { \prime } \left( \mathbf { z } \right) } { \partial \left( d \mathbf { z } \right) } \right. _ { F } d \mathbf { z } .
+$$
+
+A piecewise-linear function $\mathbf { f }$ has a constant first derivative $\mathbf { f ^ { \prime } }$ everywhere except for the transition boundaries. Therefore, for a sufficiently large $k$ , curvature can be expressed as
+
+$$
+C \left( \mathbf { f } , \mathcal { T } \left( { \mathbf { x } } \right) \right) = \frac { 1 } { 2 } \sum _ { i = 0 } ^ { k - 1 } \left\| \mathbf { f } ^ { \prime } \left( \mathbf { z } _ { i } \right) - \mathbf { f } ^ { \prime } \left( \mathbf { z } _ { \left( i + 1 \right) \mathcal { V } _ { 0 } k } \right) \right\| _ { F } ,
+$$
+
+where $\mathbf { z } _ { 0 } , \ldots , \mathbf { z } _ { k - 1 }$ are equidistant samples on $\tau ( \mathbf { x } )$ . This sum is similar to $t ( \mathbf { x } )$ as defined in Equation 1, but quantifies the amount of change in between two linear regions in a nonbinary way. However, estimating it on a densely sampled trajectory is a computationallyintensive task, which is one reason we instead count transitions.
+
+As such, on a qualitative level, the two metrics (Jacobian norm and number of transitions) track the first and second order terms of the Taylor expansion of the function.
+
+Above we have defined two sensitivity metrics to describe the learned function around the data, on average. In $\ S 4 . 1$ we analyze these measures on and off the data manifold by simply measuring them along circular trajectories in input space that intersect the data manifold at certain points, but generally lie away from it (Figure 2, left).
+
+# 4 EXPERIMENTAL RESULTS
+
+In the following subsections $( \ S 4 . 2 , \ S 4 . 3 )$ each study analyzes performance of a large number (usually thousands) of fully-connected neural networks having different hyper-parameters and optimization procedures. Except where specified, we include only models which achieve $1 0 0 \%$ training accuracy. This allows us to study generalization disentangled from properties like expressivity and trainability, which are outside the scope of this work.
+
+In order to efficiently evaluate the compute-intensive metrics (§3) in a very wide range of hyperparameters settings (see e.g. §A.5.5) we only consider fully-connected networks. Extending the investigation to more complex architectures is left for future work.
+
+# 4.1 SENSITIVITY ON AND OFF THE TRAINING DATA MANIFOLD
+
+We analyze the behavior of a trained neural network near and away from training data. We do this by comparing sensitivity of the function along 3 types of trajectories:
+
+1. A random ellipse. This trajectory is extremely unlikely to pass anywhere near the real data, and indicates how the function behaves in random locations of the input space that it never encountered during training.   
+2. An ellipse passing through three training points of different class (Figure 2, left). This trajectory does pass through the three data points, but in between it traverses images that are linear combinations of different-class images, and are expected to lie outside of the natural image space. Sensitivity of the function along this trajectory allows comparison of its behavior on and off the data manifold, as it approaches and moves away from the three anchor points.   
+3. An ellipse through three training points of the same class. This trajectory is similar to the previous one, but, given the dataset used in the experiment (MNIST), is expected to traverse overall closer to the data manifold, since linear combinations of the same digit are more likely to resemble a realistic image. Comparing transition density along this trajectory to the one through points of different classes allows further assessment of how sensitivity changes in response to approaching the data manifold.
+
+We find that, according to both the Jacobian norm and transitions metrics, functions exhibit much more robust behavior around the training data (Figure 2, center and right). We further visualize this effect in 2D in Figure 3, where we plot the transition boundaries of the last (pre-logit) layer of a neural network before and after training. After training we observe that training points lie in regions of low transition density.
+
+The observed contrast between the neural network behavior near and away from data further strengthens the empirical connection we draw between sensitivity and generalization in 4.2, $\ S$ and $\ S 4 . 4$ ; it also confirms that, as mentioned in $\ S$ , if a certain quality of a function is to be used for model comparison, input domain should always be accounted for.
+
+# 4.2 SENSITIVITY AND GENERALIZATION FACTORS
+
+In §4.1 we established that neural networks implement more robust functions in the vicinity of the training data manifold than away from it.
+
+We now consider the more practical context of model selection. Given two perfectly trained neural networks, does the model with better generalization implement a less sensitive function?
+
+![](images/666edda8ac9d9eaf5f6fdc66680a7967be41df151d5abab635405f764d8a91b0.jpg)  
+Figure 2: A $100 \%$ -accurate (on training data) MNIST network implements a function that is much more stable near training data than away from it. Left: depiction of a hypothetical circular trajectory in input space passing through three digits of different classes, highlighting the training point locations $( \pi / 3 , \pi , 5 \pi / 3 )$ . Center: Jacobian norm as the input traverses an elliptical trajectory. Sensitivity drops significantly in the vicinity of training data while remaining uniform along random ellipses. Right: transition density behaves analogously. According to both metrics, as the input moves between points of different classes, the function becomes less stable than when it moves between points of the same class. This is consistent with the intuition that linear combinations of different digits lie further from the data manifold than those of same-class digits (which need not hold for more complex datasets). See §A.5.2 for experimental details.
+
+![](images/26dc8232e5455fc3cbb5efbca372d66b95f65de0585c5ca9cc90eb6957706b9c.jpg)  
+Figure 3: Transition boundaries of the last (pre-logits) layer over a 2-dimensional slice through the input space defined by 3 training points (indicated by inset squares). Left: boundaries before training. Right: after training, transition boundaries become highly non-isotropic, with training points lying in regions of lower transition density. See §A.5.3 for experimental details.
+
+We study approaches in the machine learning community that are commonly believed to influence generalization (Figure 4, top to bottom):
+
+random labels;   
+• data augmentation;   
+• ReLUs;   
+• full-batch training.
+
+We find that in each case, the change in generalization is coupled with the respective change in sensitivity (i.e. lower sensitivity corresponds to smaller generalization gap) as measured by the Jacobian norm (and almost always for the transitions metric).
+
+![](images/0bc5498be3d19fbcc6011eabf8d2030c7f31633b9b2f22923c2c452f4aa39526.jpg)  
+Figure 4: Improvement in generalization (left column) due to using correct labels, data augmentation, ReLUs, mini-batch optimization (top to bottom) is consistently coupled with reduced sensitivity as measured by the Jacobian norm (center column). Transitions (right column) correlate with generalization in all considered scenarios except for comparing optimizers (bottom right). Each point on the plot corresponds to two neural networks that share all hyper-parameters and the same optimization procedure, but differ in a certain property as indicated by axes titles. The coordinates along each axis reflect the values of the quantity in the title of the plot in the respective setting (i.e. with true or random labels). All networks have reached $1 0 0 \%$ training accuracy on CIFAR10 in both settings (except for the data-augmentation study, second row; see $\ S$ for details). See §A.5.5 for experimental details (§A.5.4 for the data-augmentation study) and §4.2.1 for plot interpretation.
+
+# 4.2.1 HOW TO READ PLOTS
+
+In Figure 4, for many possible hyper-parameter configurations, we train two models that share all parameters and optimization procedure, but differ in a single binary setting (i.e. trained on true or random labels; with or without data augmentation; etc). Out of all such network pairs, we select only those where each network reached $100 \%$ training accuracy on the whole training set (apart from the data augmentation study). The two generalization or sensitivity values are then used as the $x$ and $y$ coordinates of a point corresponding to this pair of networks (with the plot axes labels denoting the respective value of the binary parameter considered). The position of the point with respect to the diagonal $y = x$ visually demonstrates which configuration has smaller generalization gap / lower sensitivity.
+
+# 4.3 SENSITIVITY AND GENERALIZATION GAP
+
+We now perform a large-scale experiment to establish direct relationships between sensitivity and generalization in a realistic setting. In contrast to $\ S 4 . 1$ , where we selected locations in the input space, and $\ S 4 . 2$ , where we varied a single binary parameter impacting generalization, we now sweep simultaneously over many different architectural and optimization choices (§A.5.5).
+
+Our main result is presented in Figure 5, indicating a strong relationship between the Jacobian norm and generalization. In contrast, Figure App.8 demonstrates that the number of transitions is not alone sufficient to compare networks of different sizes, as the number of neurons in the networks has a strong influence on transition count.
+
+![](images/26166cb15d9564aa43e341cc1c2adec5770289cc4323ba4a4686e1bf2299d8f6.jpg)  
+Figure 5: Jacobian norm correlates with generalization gap on all considered datasets. Each point corresponds to a network trained to $100 \%$ training accuracy (or at least $9 9 . 9 \%$ in the case of CIFAR100). See §A.5.4 and §A.5.5 for experimental details of bottom and top plots respectively.
+
+# 4.4 SENSITIVITY AND PER-POINT GENERALIZATION
+
+In §4.3 we established a correlation between sensitivity (as measured by the Jacobian norm) and generalization averaged over a large test set $1 0 ^ { 4 }$ points). We now investigate whether the Jacobian norm can be predictive of generalization at individual points.
+
+As demonstrated in Figure 6 (top), Jacobian norm at a point is predictive of the cross-entropy loss, but the relationship is not a linear one, and not even bijective (see $\ S$ for analytic expressions explaining it). In particular, certain misclassified points (right sides of the plots) have a Jacobian norm many orders of magnitude smaller than that of the correctly classified points (left sides). However, we do remark a consistent tendency for points having the highest values of the Jacobian norm to be mostly misclassified. A similar yet noisier trend is observed in networks trained using $\ell _ { 2 }$ -loss as depicted in Figure 6 (bottom). These observations make the Jacobian norm a promising quantity to consider in the contexts of active learning and confidence estimation in future research.
+
+![](images/c9925fc3388e008626ec6a041d41f0857febf74c821ea40576c4b1e1fc8a20b5.jpg)  
+Figure 6: Jacobian norm plotted against individual test point loss. Each plot shows 5 random networks that fit the respective training set with $1 0 0 \%$ accuracy, with each network having a unique color. Top: Jacobian norm plotted against cross-entropy loss. These plots experimentally confirm the relationship established in $\ S$ and Figure App.11. Bottom: Jacobian norm plotted against $\ell _ { 2 }$ -loss, for networks trained on $\ell _ { 2 }$ -loss, exhibits a similar behavior. See $\ S$ for experimental details and Figure App.9 for similar observations on other datasets.
+
+# 5 CONCLUSION
+
+We have investigated sensitivity of trained neural networks through the input-output Jacobian norm and linear regions counting in the context of image classification tasks. We have presented extensive experimental evidence indicating that the local geometry of the trained function as captured by the input-output Jacobian can be predictive of generalization in many different contexts, and that it varies drastically depending on how close to the training data manifold the function is evaluated. We further established a connection between the cross-entropy loss and the Jacobian norm, indicating that it can remain informative of generalization even at the level of individual test points. Interesting directions for future work include extending our investigation to more complex architectures and other machine learning tasks.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016.
+
+Peter L Bartlett, Dylan J Foster, and Matus J Telgarsky. Spectrally-normalized margin bounds for neural networks. In Advances in Neural Information Processing Systems, pp. 6241–6250, 2017.
+
+Avrim Blum and Ronald L. Rivest. Training a 3-node neural network is np-complete. In Machine Learning: From Theory to Applications, 1988.
+
+Alfredo Canziani, Adam Paszke, and Eugenio Culurciello. An analysis of deep neural network models for practical applications. CoRR, abs/1605.07678, 2016.
+
+Anna Choromanska, Mikael Henaff, Michael Mathieu, Gerard Ben Arous, and Yann LeCun. The ´ loss surfaces of multilayer networks. In Artificial Intelligence and Statistics, pp. 192–204, 2015.
+
+Yann Dauphin, Razvan Pascanu, aglar Gulehre, Kyunghyun Cho, Surya Ganguli, and Yoshua Ben- ¨ gio. Identifying and attacking the saddle point problem in high-dimensional non-convex optimization. In NIPS, 2014.
+
+Gintare Karolina Dziugaite and Daniel M Roy. Computing nonvacuous generalization bounds for deep (stochastic) neural networks with many more parameters than training data. arXiv preprint arXiv:1703.11008, 2017.
+
+Daniel Golovin, Benjamin Solnik, Subhodeep Moitra, Greg Kochanski, John Karro, and D Sculley. Google vizier: A service for black-box optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1487–1495. ACM, 2017.
+
+Ian J. Goodfellow and Oriol Vinyals. Qualitatively characterizing neural network optimization problems. CoRR, abs/1412.6544, 2014.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Shixiang Gu and Luca Rigazio. Towards deep neural network architectures robust to adversarial examples. arXiv preprint arXiv:1412.5068, 2014.
+
+Caglar Gulcehre, Marcin Moczulski, Misha Denil, and Yoshua Bengio. Noisy activation functions. In International Conference on Machine Learning, pp. 3059–3068, 2016.
+
+Geoffrey Hinton, Nitish Srivastava, and Kevin Swersky. Neural networks for machine learninglecture 6a-overview of mini-batch gradient descent, 2012.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Flat minima. ¨ Neural Computation, 9(1):1–42, 1997.
+
+William H Jefferys and James O Berger. Ockham’s razor and bayesian analysis. American Scientist, 80(1):64–72, 1992.
+
+Yulei Jiang, Richard M Zur, Lorenzo L Pesce, and Karen Drukker. A study of the effect of noise injection on the training of artificial neural networks. In Neural Networks, 2009. IJCNN 2009. International Joint Conference on, pp. 1428–1432. IEEE, 2009.
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky. Convolutional deep belief networks on cifar-10. 2010.
+
+Anders Krogh and John A Hertz. A simple weight decay can improve generalization. In Advances in neural information processing systems, pp. 950–957, 1992.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+Jaehoon Lee, Yasaman Bahri, Roman Novak, Sam Schoenholz, Jeffrey Pennington, and Jascha Sohldickstein. Deep neural networks as gaussian processes. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\equiv$ B1EA-M-0Z.
+
+David JC MacKay. Bayesian interpolation. 1991.
+
+David JC MacKay. A practical bayesian framework for backpropagation networks. Neural computation, 4(3):448–472, 1992.
+
+G. Montufar, R. Pascanu, K. Cho, and Y. Bengio. On the Number of Linear Regions of Deep Neural ´ Networks. Neural Information Processing Systems, February 2014.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. arXiv preprint arXiv:1610.08401, 2016.
+
+Iain Murray and Zoubin Ghahramani. A note on the evidence and bayesian occam’s razor, 2005.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th international conference on machine learning (ICML-10), pp. 807–814, 2010.
+
+Radford M. Neal. Priors for infinite networks (tech. rep. no. crg-tr-94-1). University of Toronto, 1994.
+
+Behnam Neyshabur, Ryota Tomioka, and Nathan Srebro. In search of the real inductive bias: On the role of implicit regularization in deep learning. Proceeding of the international Conference on Learning Representations workshop track, abs/1412.6614, 2015.
+
+Behnam Neyshabur, Srinadh Bhojanapalli, David McAllester, and Nathan Srebro. Exploring generalization in deep learning. CoRR, abs/1706.08947, 2017.
+
+Behnam Neyshabur, Srinadh Bhojanapalli, and Nathan Srebro. A PAC-bayesian approach to spectrally-normalized margin bounds for neural networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id=Skz_WfbCZ.
+
+Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In Security and Privacy (EuroS&P), 2016 IEEE European Symposium on, pp. 372–387. IEEE, 2016.
+
+R. Pascanu, G. Montufar, and Y. Bengio. On the number of response regions of deep feed forward networks with piece-wise linear activations. International Conference on Learning Representations, December 2013.
+
+B. Poole, S. Lahiri, M. Raghu, J. Sohl-Dickstein, and S. Ganguli. Exponential expressivity in deep neural networks through transient chaos. Neural Information Processing Systems, June 2016.
+
+M. Raghu, B. Poole, J. Kleinberg, S. Ganguli, and J. Sohl-Dickstein. On the Expressive Power of Deep Neural Networks. International Conference on Machine Learning, June 2016.
+
+Carl E. Rasmussen and Zoubin Ghahramani. Occam’s razor. In NIPS, 2000.
+
+Salah Rifai, Pascal Vincent, Xavier Muller, Xavier Glorot, and Yoshua Bengio. Contractive autoencoders: Explicit invariance during feature extraction. In Proceedings of the 28th international conference on machine learning (ICML-11), pp. 833–840, 2011.
+
+David E Rumelhart, Geoffrey E Hinton, Ronald J Williams, et al. Learning representations by back-propagating errors. Cognitive modeling, 5(3):1, 1988.
+
+Jure Sokolic, Raja Giryes, Guillermo Sapiro, and Miguel RD Rodrigues. Robust large margin deep neural networks. IEEE Transactions on Signal Processing, 2017.
+
+Ercan Solak, Roderick Murray-Smith, William E Leithead, Douglas J Leith, and Carl E Rasmussen. Derivative observations in gaussian process models of dynamic systems. In Advances in neural information processing systems, pp. 1057–1064, 2003.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Matus Telgarsky. Representation benefits of deep feedforward networks. CoRR, abs/1509.08101, 2015.
+
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms, 2017.
+
+Huan Xu and Shie Mannor. Robustness and generalization. Machine learning, 86(3):391–423, 2012.
+
+C. Zhang, S. Bengio, M. Hardt, B. Recht, and O. Vinyals. Understanding deep learning requires rethinking generalization. International Conference on Learning Representations, November 2016.
+
+# A APPENDIX
+
+# A.1 TRANSITION METRIC DETAILS
+
+# A.1.1 LINEAR REGION ENCODING
+
+The way of encoding a linear region $\mathbf { c } \left( \mathbf { z } \right)$ of a point $\mathbf { z }$ described in §3 (2) guarantees that different regions obtain different codes, but different codes might be assigned to the same region if all the neurons in any layer of the network are saturated (or if weights leading from the transitioning unit to active units are exactly zero, or exactly cancel). However, the probability of such an arrangement drops exponentially with width and hence is ignored in this work.
+
+# A.1.2 TRANSITION COUNTING
+
+The equality between the discrete and continuous versions of $t \left( \mathbf { x } \right)$ in Equation 1 becomes exact with a high-enough sampling density $k$ such that there are no narrow linear regions missed in between consecutive points (precisely, the encoding $\mathbf { c } \left( \mathbf { z } \right)$ has to only change at most once on the line between two consecutive points $\mathbf { z } _ { i }$ and $\mathbf { z } _ { i + 1 }$ ).
+
+For computational efficiency we also assume that no two neurons transitions simultaneously, which is extremely unlikely in the context of random initialization and stochastic optimization.
+
+![](images/1a3bf6f1955f6cf898f95de9d05feffa17ba642a01582b9d5c4d3f71d290741a.jpg)  
+Figure App.7: Depiction of a trajectory in input space used to count transitions as defined in §3 (2). An interpolation between 28 horizontal translations of a single digit results in a complex trajectory that constrains all points to lie close to the translation-augmented data, and allows for a tractable estimate of transition density around the data manifold. This metric is used to compare models in 4.2 and 4.3. Straight lines indicate boundaries between different linear regions (straight-line boundaries between linear regions is accurate for the case of a single-layer piecewise-linear network. The partition into linear regions is more complex for deeper networks (Raghu et al., 2016)).
+
+![](images/f27e7f4b1b4dd167346b5033c21867861f4178042017ef8e48e7ba3e522d108b.jpg)  
+Figure App.8: Number of transitions, in contrast to Figure 5, does not generally correlate with generalization gap. Left: 2160 networks with $1 0 0 \%$ train accuracy on CIFAR10. Right: 2097 networks with at least $9 9 . 9 \%$ training accuracy on CIFAR100. See §A.5.5 for experimental details.
+
+![](images/3c841fa462085be2747162741dc6ac9a5e7c78e3273c86d56ac75bc6efde0b3f.jpg)  
+Figure App.9: Jacobian norm plotted against individual test point loss on Fashion-MNIST (Xiao et al., 2017) and CIFAR100. As in Figure 6, each plot shows 5 random networks that fit the respective training set to a $1 0 0 \%$ with each network having a unique color. See §A.5.6 for experimental details.
+
+# A.2 DO NEURAL NETWORKS DEFY OCCAM’S RAZOR?
+
+Here we briefly discuss the motivation of this work in the context of Occam’s razor.
+
+Occam’s razor is a heuristic for model comparison based on their complexity. Given a dataset $\mathcal { D }$ , Occam’s razor gives preference to simpler models $\mathcal { H }$ . In the Bayesian interpretation of the heuristic (Jefferys & Berger, 1992) simplicity is defined as evidence $\mathbb { P } \left[ \mathcal { D } | \mathcal { H } \right]$ and is often computed using the Laplace approximation. Under further assumptions (MacKay, 1991), this evidence can be shown to be inversely proportional to the number of parameters in the model. Therefore, given a uniform prior $\mathbb { P } \left[ \mathcal { H } \right]$ on two competing hypothesis classes, the class posterior $\mathbb { P } \left[ \mathcal { H } | \mathcal { D } \right] \sim \bar { \mathbb { P } } \left[ \mathcal { D } | \mathcal { H } \right] \mathbb { P } \left[ \mathcal { H } \right]$ is higher for a model with fewer parameters.
+
+An alternative, qualitative justification of the heuristic is through considering the evidence as a normalized probability distribution over the whole dataset space:
+
+$$
+\int _ { D ^ { \prime } } \mathbb { P } \left[ \mathcal { D ^ { \prime } } | \mathcal { H } \right] d \mathcal { D ^ { \prime } } = 1
+$$
+
+and remarking that models with more parameters have to spread the probability mass more evenly across all the datasets by virtue of being able to fit more of them (Figure App.10, left). This similarly suggests (under a uniform prior on competing hypothesis classes) preferring models with fewer parameters, assuming that evidence is unimodal and peaks close to the dataset of interest.
+
+Occam’s razor for neural networks. As seen in Figure 1, the above reasoning does not apply to neural networks: the best achieved generalization is obtained by a model that has around $1 0 ^ { \bar { 4 } }$ times as many parameters as the simplest model capable of fitting the dataset (within the evaluated search space).
+
+On one hand, Murray & Ghahramani (2005); Telgarsky (2015) demonstrate on concrete examples that a high number of free parameters in the model doesn’t necessarily entail high complexity. On the other hand, a large body of work on the expressivity of neural networks (Pascanu et al., 2013; Montufar et al. ´ , 2014; Raghu et al., 2016; Poole et al., 2016) shows that their ability to compute complex functions increases rapidly with size, while Zhang et al. (2016) validates that they also easily fit complex (even random) functions with stochastic optimization. Classical metrics like VC dimension or Rademacher complexity increase with size of the network as well. This indicates that weights of a neural network may actually correspond to its usable capacity, and hence “smear” the evidence $\mathbb { P } \left[ \mathcal { D } | \mathcal { H } \right]$ along a very large space of datasets $\mathcal { D } ^ { \prime }$ , making the dataset of interest $\mathcal { D }$ less likely.
+
+Potential issues. We conjecture the Laplace approximation of the evidence $\mathbb { P } \left[ \mathcal { D } | \mathcal { H } \right]$ and the simplified estimation of the “Occam’s factor” in terms of the accessible volume of the parameter space might not hold for neural networks in the context of stochastic optimization, and, in particular, do not account for the combinatorial growth of the accessible volume of parameter space as width increases (MacKay, 1992). Similarly, when comparing evidence as probability distributions over datasets, the difference between two neural networks may not be as drastic as in Figure App.10 (left), but more nuanced as depicted in Figure App.10 (right), with the evidence ratio being highly dependent on the particular dataset.
+
+We interpret our work as defining hypothesis classes based on sensitivity of the hypothesis (which yielded promising results in (Rasmussen & Ghahramani, 2000) on a toy task) and observing a strongly non-uniform prior on these classes that enables model comparison. Indeed, at least in the context of natural images classification, putting a prior on the number of parameters or Kolmogorov complexity of the hypothesis is extremely difficult. However, a statement that the true classification function is robust to small perturbations in the input is much easier to justify. As such, a prior $\mathbb { P } \left[ \mathcal { H } \right]$ in favor of robustness over sensitivity might fare better than a prior on specific network hyper-parameters.
+
+Above is one way to interpret the correlation between sensitivity and generalization that we observe in this work. It does not explain why large networks tend to converge to less sensitive functions. We conjecture large networks to have access to a larger space of robust solutions due to solving a highly-underdetermined system when fitting a dataset, while small models converge to more extreme weight values due to being overconstrained by the data. However, further investigation is needed to confirm this hypothesis.
+
+![](images/12e600f6f7004b1aeff2de1183fd3bae4d13d1b72b3ab0b7d54ee9951c86c3aa.jpg)  
+Figure App.10: Occam’s razor: simplified expectation vs hypothesized reality. All datasets $\mathcal { D } ^ { \prime }$ with input and target dimensions matching those of a particular dataset $\mathcal { D }$ are sorted according to the evidence $\mathbb { P } \left[ \mathcal { D } ^ { \prime } | \mathcal { H } \right]$ of a large model $\mathcal { H } _ { \mathrm { l } }$ from left to right along the horizontal axis. Left: a classic simplified depiction of Bayesian Occam’s razor. Evidence $\mathbb { P } [ \bar { \mathcal { D } } ^ { \prime } | \mathcal { H } ]$ of a small model $\mathcal { H } _ { \mathrm { s } }$ with few parameters has narrow support in the dataset space and is more peaked. If the model fits the dataset $\mathcal { D }$ well, it falls close to the peak and outperforms a larger model $\mathcal { H } _ { \mathrm { l } }$ with more parameters, having wider support. Right: suggested potential reality of neural networks. Evidence of the small model $\mathcal { H } _ { \mathrm { s } }$ peaks higher, but the large model $\mathcal { H } _ { \mathrm { l } }$ might nonetheless concentrate the majority of probability mass on simple functions and the evidence curves might intersect at a small angle. In this case, while a dataset $\mathcal { D }$ lying close to the intersection can be fit by both models, the Bayesian evidence ratio depends on its exact position with respect to the intersection.
+
+# A.3 BOUNDING THE JACOBIAN NORM
+
+Here we analyze the relationship between the Jacobian norm and the cross-entropy loss at individual test points as studied in §4.4.
+
+Target class Jacobian. We begin by relating the derivative of the target class probability $\mathbf { J } _ { y ( \mathbf { x } ) }$ to per-point cross-entropy loss $l ( \mathbf { x } ) = - \log \left[ \mathbf { f } _ { \sigma } ( \mathbf { x } ) \right] _ { y ( \mathbf { x } ) }$ (where $y ( \mathbf x )$ is the correct integer class).
+
+We will denote ${ \bf f } _ { \sigma } ( { \bf x } )$ by $\sigma$ and drop the $\mathbf { x }$ argument to de-clutter notation (i.e. write f instead of $\mathbf { f } \left( \mathbf { x } \right) .$ ). Then the Jacobian can be expressed as
+
+$$
+\mathbf { J } = \left[ \left( \sigma \mathbf { 1 } ^ { T } \right) \odot \left( \mathbf { I } - \pmb { \sigma } \mathbf { 1 } ^ { T } \right) ^ { T } \right] \left( \frac { \partial \mathbf { f } } { \partial \mathbf { x } ^ { T } } \right) ,
+$$
+
+where $\odot$ is the Hadamard element-wise product. Then indexing both sides of the equation at the correct class $y$ yields
+
+$$
+\mathbf { J } _ { y } = \sigma _ { y } \left( \left( \mathbf { e } _ { y } - \pmb { \sigma } \right) ^ { T } \left( \frac { \partial \mathbf { f } } { \partial \mathbf { x } ^ { T } } \right) \right) ,
+$$
+
+where $\mathbf { e } _ { y }$ is a vector of zeros everywhere except for $e _ { y } = 1$ . Taking the norm of both sides results in
+
+$$
+\begin{array} { c } { \displaystyle | | \mathbf { J } _ { y } | | _ { 2 } ^ { 2 } = \sigma _ { y } ^ { 2 } \sum _ { k = 1 } ^ { d } \left[ \left( 1 - \sigma _ { y } \right) ^ { 2 } \left( \frac { \partial f _ { y } } { \partial x _ { k } } \right) ^ { 2 } + \sum _ { j \neq y } ^ { n } \left( \sigma _ { j } \frac { \partial f _ { j } } { \partial x _ { k } } \right) ^ { 2 } \right] } \\ { = \displaystyle \sigma _ { y } ^ { 2 } \left[ \left( 1 - \sigma _ { y } \right) ^ { 2 } \sum _ { k = 1 } ^ { d } \left( \frac { \partial f _ { y } } { \partial x _ { k } } \right) ^ { 2 } + \sum _ { j \neq y } ^ { n } \sigma _ { j } ^ { 2 } \sum _ { k = 1 } ^ { d } \left( \frac { \partial f _ { j } } { \partial x _ { k } } \right) ^ { 2 } \right] } \\ { = \displaystyle \sigma _ { y } ^ { 2 } \left[ \left( 1 - \sigma _ { y } \right) ^ { 2 } \left\| \frac { \partial f _ { y } } { \partial \mathbf { x } ^ { T } } \right\| _ { 2 } ^ { 2 } + \sum _ { j \neq y } ^ { n } \sigma _ { j } ^ { 2 } \left\| \frac { \partial f _ { j } } { \partial \mathbf { x } ^ { T } } \right\| _ { 2 } ^ { 2 } \right] } \end{array}
+$$
+
+We now assume that magnitudes of the individual logit derivatives vary little in between logits and over the input space3:
+
+$$
+\left. \frac { \partial f _ { i } } { \partial \mathbf { x } ^ { T } } \right. _ { 2 } ^ { 2 } \approx \frac { 1 } { n } \mathbb { E } _ { \mathbf { x } _ { \mathrm { t e s t } } } \left. \frac { \partial \mathbf { f } } { \partial \mathbf { x } _ { \mathrm { t e s t } } ^ { T } } \right. _ { F } ^ { 2 } ,
+$$
+
+which simplifies Equation 4 to
+
+$$
+\left\| \mathbf { J } _ { y } \right\| _ { 2 } ^ { 2 } \approx M \sigma _ { y } ^ { 2 } \left[ ( 1 - \sigma _ { y } ) ^ { 2 } + \sum _ { j \neq y } ^ { n } \sigma _ { j } ^ { 2 } \right] ,
+$$
+
+where $M = \mathbb { E } _ { \mathbf { x } _ { \mathrm { t e s t } } } \left\| \partial \mathbf { f } / \partial \mathbf { x } _ { \mathrm { t e s t } } ^ { T } \right\| _ { F } ^ { 2 } / n$ . Since $\sigma$ lies on the $( n - 1 )$ -simplex $\Delta ^ { n - 1 }$ , under these assumptions we can bound:
+
+$$
+\frac { ( 1 - \sigma _ { y } ) ^ { 2 } } { n - 1 } \leqslant \sum _ { j \neq y } ^ { n } \sigma _ { j } ^ { 2 } \leqslant ( 1 - \sigma _ { y } ) ^ { 2 } ,
+$$
+
+and finally
+
+$$
+\frac { n } { n - 1 } M \sigma _ { y } ^ { 2 } \left( 1 - \sigma _ { y } \right) ^ { 2 } \lessapprox \left\| \mathbf { J } _ { y } \right\| _ { 2 } ^ { 2 } \lessapprox 2 M \sigma _ { y } ^ { 2 } \left( 1 - \sigma _ { y } \right) ^ { 2 } ,
+$$
+
+or, in terms of the cross-entropy loss $l = - \log \sigma _ { y }$
+
+$$
+\sqrt { \frac { n M } { n - 1 } } \mathbb { e } ^ { - l } \left( 1 - \Phi ^ { - l } \right) \lessapprox \left. \mathbf { J } _ { y } \right. _ { 2 } \lessapprox \sqrt { 2 M } \mathbb { e } ^ { - l } \left( 1 - \Phi ^ { - l } \right) .
+$$
+
+We validate these approximate bounds in Figure App.11 (top).
+
+Full Jacobian. Equation 5 establishes a close relationship between $\mathbf { J } _ { y }$ and loss $l = - \log \sigma _ { y }$ , but of course, at test time we do not know the target class $y$ . This allows us to only bound the full Jacobian norm from below:
+
+$$
+\sqrt { \frac { n M } { n - 1 } } \circledast ^ { - l } \left( 1 - \circledast ^ { - l } \right) \precapprox \| \mathbf { J } _ { y } \| _ { 2 } \leqslant \| \mathbf { J } \| _ { F } .
+$$
+
+For the upper bound, we assume the maximum-entropy case of $\sigma _ { y }$ : $\sigma _ { i } \approx ( 1 - \sigma _ { y } ) / ( n - 1 )$ , for $i \neq y$ . The Jacobian norm is
+
+$$
+\left\| \mathbf { J } \right\| _ { F } ^ { 2 } = \sum _ { i = 1 } ^ { n } \left\| \mathbf { J } _ { i } \right\| _ { 2 } ^ { 2 } = \left\| \mathbf { J } _ { y } \right\| _ { 2 } ^ { 2 } + \sum _ { i \neq y } ^ { n } \left\| \mathbf { J } _ { i } \right\| _ { 2 } ^ { 2 } ,
+$$
+
+where the first summand becomes:
+
+$$
+\Vert \mathbf { J } _ { y } \Vert _ { 2 } ^ { 2 } \approx M \sigma _ { y } ^ { 2 } \left[ \left( 1 - \sigma _ { y } \right) ^ { 2 } + \left( n - 1 \right) \left( \frac { 1 - \sigma _ { y } } { n - 1 } \right) ^ { 2 } \right] = \frac { M n } { n - 1 } \sigma _ { y } ^ { 2 } \left( 1 - \sigma _ { y } \right) ^ { 2 } ,
+$$
+
+and each of the others
+
+$$
+\begin{array} { l } { { \displaystyle \left\| { \bf J } _ { i } \right\| _ { 2 } ^ { 2 } \approx M \left( \frac { 1 - \sigma _ { y } } { n - 1 } \right) ^ { 2 } \left[ \left( 1 - \frac { 1 - \sigma _ { y } } { n - 1 } \right) ^ { 2 } + \left( \sigma _ { y } ^ { 2 } + ( n - 2 ) \left( \frac { 1 - \sigma _ { y } } { n - 1 } \right) ^ { 2 } \right) \right] } } \\ { { \displaystyle \qquad = \frac { M } { ( n - 1 ) ^ { 3 } } \left( 1 - \sigma _ { y } \right) ^ { 2 } \left( n \sigma _ { y } ^ { 2 } + n - 2 \right) ^ { 2 } . } } \end{array}
+$$
+
+Adding $n - 1$ of such summands to $\| \mathbf { J } _ { y } \| _ { 2 } ^ { 2 }$ results in
+
+$$
+\| { \bf J } \| _ { F } \approx \frac { \sqrt { M } } { ( n - 1 ) } ( 1 - \sigma _ { y } ) \sqrt { n ^ { 2 } \sigma _ { y } ^ { 2 } + n - 2 } = \frac { \sqrt { M } } { ( n - 1 ) } \left( 1 - \mathrm { e } ^ { - l } \right) \sqrt { n ^ { 2 } \mathrm { e } ^ { - 2 l } + n - 2 } ,
+$$
+
+compared against the lower bound (Equation 6) and experimental data in Figure App.11.
+
+![](images/e0625d13f1d1704d242feb7d156eb440d03aab6c519bb88881e108cfcac63f04.jpg)  
+Cross-entropy loss
+
+Figure App.11: Top: Jacobian norm $\left\| \mathbf { J } _ { y } \left( \mathbf { x } \right) \right\| _ { 2 } = \left\| \partial \mathbf { f } _ { \sigma } \left( \mathbf { x } \right) _ { y } / \partial \mathbf { x } ^ { T } \right\| _ { 2 }$ of the true class $y$ output probability is tightly related to the cross-entropy loss. Each point corresponds to one of the 1000 test inputs to a $100 \%$ trained network on CIFAR10, while lines depict analytic bounds from Equation 5. Bottom: Same experiment plotting the full Jacobian norm $\| \bar { \mathbf { J } } \| _ { F }$ against cross-entropy. Solid lines correspond to the lower bound from Equation 6 and the norm approximation from Equation 7. See $\ S _ { \mathrm { A } . 5 . 7 }$ for experimental details and Figures 6 and App.9 for empirical evaluation of this relationship on multiple datasets and models.
+
+# A.4 NON-LINEARITIES DEFINITIONS
+
+Following activation functions are used in this work:
+
+1. ReLU (Nair & Hinton, 2010): $\mathrm { m a x } ( x , 0 )$ ;   
+2. ReLU6 (Krizhevsky, 2010): min $( \operatorname* { m a x } ( x , 0 ) , 6 )$ ;   
+3. Tanh: hyperbolic tangent, $( e ^ { x } - e ^ { - x } ) / ( e ^ { x } + e ^ { - x } )$ ;   
+4. HardTanh (Gulcehre et al., 2016): $\operatorname* { m i n } { ( \operatorname* { m a x } ( x , - 1 ) , 1 ) }$ ;   
+5. HardSigmoid (Gulcehre et al., 2016): $\operatorname* { m i n } { ( \operatorname* { m a x } ( x + 0 . 5 , 0 ) , 1 ) }$ ;
+
+# A.5 EXPERIMENTAL SETUP
+
+All experiments were implemented in Tensorflow (Abadi et al., 2016) and executed with the help of Vizier (Golovin et al., 2017). All networks were trained with cross-entropy loss. All networks were trained without biases. All computations were done with 32-bit precision. Learning rate decayed by a factor of 0.1 every 500 epochs.
+
+Unless specified otherwise, initial weights were drawn from a normal distribution with zero mean and variance $2 / n$ for ReLU, ReLU6 and HardSigmoid; $1 / n$ for Tanh and HardTanh, where $n$ is the number of inputs to the current layer.
+
+All inputs were normalized to have zero mean and unit variance, or, in other terms, lie on the $d$ - dimensional sphere of radius $\sqrt { d }$ , where $d$ is the dimensionality of the input.
+
+All reported values, when applicable, were evaluated on the whole training and test sets of sizes 50000 and 10000 respectively. E.g. “generalization gap” is defined as the difference between train and test accuracies evaluated on the whole train and test sets.
+
+When applicable, all trajectories/surfaces in input space were sampled with $2 ^ { 2 0 }$ points.
+
+# A.5.1 PLOTS AND ERROR BARS
+
+All figures except for 6 and App.11 are plotted with (pale) error bars (when applicable). The reported quantity was usually evaluated 8 times with random seeds from 1 to $8$ , unless specified otherwise. E.g. if a network is said to be $100 \%$ -accurate on the training set, it means that each of the 8 randomlyinitialized networks is $100 \%$ -accurate after training.
+
+The error bar is centered at the mean value of the quantity and spans the standard error of the mean in each direction. If the bar appears to not be visible, it may be smaller than the mean value marker.
+
+Weight initialization, training set shuffling, data augmentation, picking anchor points of data-fitted trajectories, selecting axes of a zero-centered elliptic trajectory depend on the random seed.
+
+# A.5.2 SENSITIVITY ALONG A TRAJECTORY
+
+Relevant figure 2.
+
+A 20-layer ReLU-network of width 200 was trained on MNIST 128 times, with plots displaying the averaged values.
+
+A random zero-centered ellipse was obtained by generating two axis vectors with normallydistributed entries of zero mean and unit variance (as such making points on the trajectory have an expected norm equal to that of training data) and sampling points on the ellipse with given axes.
+
+A random data-fitted ellipse was generated by projecting three arbitrary input points onto a plane where they fall into vertices of an equilateral triangle, and then projecting their circumcircle back into the input space.
+
+# A.5.3 LINEAR REGION BOUNDARIES
+
+Relevant figure 3.
+
+A 15-layer ReLU6-network of width 300 was trained on MNIST for $2 ^ { 1 8 }$ steps using SGD with momentum (Rumelhart et al., 1988); images were randomly translated with wrapping by up to 4 pixels in each direction, horizontally and vertically, as well as randomly flipped along each axis, and randomly rotated by 90 degrees clockwise and counter-clockwise.
+
+The sampling grid in input space was obtain by projecting three arbitrary input points into a plane as described in §A.5.2 such that the resulting triangle was centered at 0 and it’s vertices were at a distance 0.8 form the origin. Then, a sampling grid of points in the $[ - 1 ; 1 ] ^ { \times 2 }$ square was projected back into the input space.
+
+# A.5.4 SMALL EXPERIMENT
+
+Relevant figures: 4 (second row) and 5 (bottom).
+
+All networks were trained for $2 ^ { 1 8 }$ steps of batch size of 256 using SGD with momentum. Learning rate was set to 0.005 and momentum term coefficient to 0.9.
+
+Data augmentation consisted of random translation of the input by up to 4 pixels in each direction with wrapping, horizontally and vertically. The input was also flipped horizontally with probability 0.5. When applying data augmentation (second row of Figure 4), the network is unlikely to encounter the canonical training data, hence few configurations achieved $1 0 0 \%$ training accuracy. However, we verified that all networks trained with data augmentation reached a higher test accuracy than their analogues without, ensuring that the generalization gap shrinks not simply because of lower training accuracy.
+
+For each dataset, networks of width $\{ 1 0 0 , 2 0 0 , 5 0 0 , 1 0 0 0 , 2 0 0 0 , 3 0 0 0 \}$ , depth $\{ 2 , 3 , 5 , 1 0 , 1 5 , 2 0 \}$ and activation function ReLU, ReLU6, HardTanh, HardSigmoid were evaluated on 8 random seeds from 1 to 8.
+
+# A.5.5 LARGE EXPERIMENT
+
+Relevant figures: 1, 4 (except for the second row), 5 (top), App.8.
+
+335671 networks were trained for $2 ^ { 1 9 }$ steps with random hyper-parameters; if training did not complete, a checkpoint at step $2 ^ { 1 8 }$ was used instead, if available. When using L-BFGS, the maximum number of iterations was set to 2684. The space of available hyper-parameters included5:
+
+1. CIFAR10 and CIFAR100 datasets cropped to a $2 4 \times 2 4$ center region;   
+2. all 5 non-linearities from $\ S _ { \mathrm { ~ \tiny ~ \cdot ~ } }$ ;   
+3. SGD, Momentum, ADAM (Kingma & Ba, 2014), RMSProp (Hinton et al., 2012) and LBFGS optimizers;   
+4. learning rates from $\{ 0 . 0 1 , 0 . 0 0 5 , 0 . 0 0 0 5 \}$ , when applicable. Secondary coefficients were fixed at default values of Tensorflow implementations of respective optimizers;   
+5. batch sizes of $\{ 1 2 8 , 5 1 2 \}$ (unless using L-BFGS with the full batch of 50000);   
+6. standard deviations of initial weights from $\{ 0 . 5 , 1 , 4 , 8 \}$ multiplied by the default value described in $\ S _ { \mathrm { A } . 5 }$ ;   
+7. widths from $\{ 1 , 2 , 4 , \cdots , 2 ^ { 1 6 } \}$ ;   
+8. depths from $\{ 2 , 3 , 5 , \cdots , 2 ^ { 6 } + 1 \}$ ;   
+9. true and random training labels;   
+10. random seeds from 1 to 8.
+
+# A.5.6 PER-POINT GENERALIZATION
+
+Relevant figures 6, App.9.
+
+Networks were with either cross-entropy or $\ell _ { 2 }$ -loss trained for $2 ^ { 1 9 }$ steps on whole datasets (CIFAR100, CIFAR10, Fashion-MNIST and MNIST) and evaluated on random subsets of 1000 test images.
+
+Hyper-parameters were: non-linearity (all functions from §A.4), width (50, 100, 200, 500, 1000), depth (2, 5, 10, 20, 30), learning rate (0.0001, 0.001, 0.01), optimizer (SGD, Momentum, ADAM, RMSProp). Only one random seed (1) was used. For each dataset a random subset of 5 configurations among all the $1 0 0 \%$ -accurate (on training) networks was plotted (apart from the case of CIFAR100, where networks of training accuracy of at least $9 9 . 9 8 \%$ were selected).
+
+# A.5.7 CROSS-ENTROPY AND SENSITIVITY ANALYSIS
+
+Relevant figure App.11.
+
+Networks were trained for $2 ^ { 1 8 }$ on the whole CIFAR10 training set and evaluated networks on a random test subset of size 1000. The hyper-parameters consisted of non-linearity (all functions from $\ S \mathrm { A } . 4 )$ , width (50, 100 or 200) and depth (2, 5, 10, 20). Only one random seed (1) was considered. A single random $100 \%$ -accurate (on training data) network was drawn to compare experimental measurements with analytic bounds on the Jacobian norm.

parse/train/HJeO7RNKPr/HJeO7RNKPr.md

@@ -0,0 +1,479 @@
+# DEEPV2D: VIDEO TO DEPTH WITH DIFFERENTIABLE STRUCTURE FROM MOTION
+
+Zachary Teed   
+Princeton University   
+zteed@cs.princeton.edu   
+Jia Deng   
+Princeton University   
+jiadeng@cs.princeton.edu
+
+# ABSTRACT
+
+We propose DeepV2D, an end-to-end deep learning architecture for predicting depth from video. DeepV2D combines the representation ability of neural networks with the geometric principles governing image formation. We compose a collection of classical geometric algorithms, which are converted into trainable modules and combined into an end-to-end differentiable architecture. DeepV2D interleaves two stages: motion estimation and depth estimation. During inference, motion and depth estimation are alternated and converge to accurate depth. Code is available https://github.com/princeton-vl/DeepV2D.
+
+# 1 INTRODUCTION
+
+In video to depth, the task is to estimate depth from a video sequence. The problem has traditionally been approached using Structure from Motion (SfM), which takes a collection of images as input, and jointly optimizes over 3D structure and camera motion (Schonberger & Frahm, 2016b). The resulting camera parameter estimates can be used as input to Multi-View Stereo in order to build a more complete 3D representation such as surface meshes and depth maps (Furukawa et al., 2015; Furukawa & Ponce, 2010).
+
+In parallel, deep learning has been highly successful in a number of 3D reconstruction tasks. In particular, given ground truth depth, a network can learn to predict depth from a single image (Eigen et al., 2014; Eigen & Fergus, 2015; Laina et al., 2016), stereo images (Kendall et al., 2017; Mayer et al., 2016a), or collections of frames (Zhou et al., 2018; Kar et al., 2017; Tang & Tan, 2018; Yao et al., 2018). One advantage of deep networks is that they can use single-image cues such as texture gradients and shading as shown by their strong performance on depth estimation from a single image (Eigen et al., 2014; Eigen & Fergus, 2015; Laina et al., 2016). Furthermore, differentiable network modules can be composed so that entire pipelines (i.e. feature extraction, feature matching, regularization) can be learned directly from training data. On the other hand, as recent work has shown, it is often hard to train generic network layers to directly utilize multiview geometry (e.g. using interframe correspondence to recover depth), and it is often advantageous to embed knowledge of multiview geometry through specially designed layers or losses (Ummenhofer et al., 2017; Kendall & Cipolla, 2017; Zhou et al., 2017; Vijayanarasimhan et al., 2017; Zhou et al., 2018).
+
+In this work, we continue the direction set forth by recent works (Ummenhofer et al., 2017; Kendall et al., 2017; Tang & Tan, 2018; Zhou et al., 2018; Kar et al., 2017; Wang et al., 2018) that combine the representation ability of neural networks with the geometric principles underlying image formation. We propose DeepV2D, a composition of classical geometrical algorithms which we turn into differentiable network modules and combine into an end-to-end trainable architecture. DeepV2D interleaves two stages: camera motion estimation and depth estimation (Figure 1). The motion module takes depth as input, and outputs an incremental update to camera motion. The depth module takes camera motion as input, and performs stereo reconstruction to predict depth. At test time, DeepV2D acts as block coordinate descent, alternating between updating depth and camera motion.
+
+![](images/b68c2e980ef306146d4a300a5bd11351fab877600bae08cd56881af8c60e9bbf.jpg)  
+Figure 1: DeepV2D predicts depth from video. It is the composition of classical geometric algorithms, made differentiable, and combined into an end-to-end trainable network architecture. Video to depth is broken down into the subproblems of motion estimation and depth estimation, which are solved by the Motion Module and Depth Module respectively.
+
+To estimate camera motion we introduce Flow-SE3, a new motion estimation architecture, which outputs an incremental update to camera motion. Flow-SE3 takes depth as input, and estimates dense 2D correspondence between pairs of frames. We unroll a single iteration of Perspectiven-Point (PnP) (Lepetit et al., 2009; Li et al., 2012) performing Gauss-Newton updates over SE3 perturbations to minimize geometric reprojection error. The new estimate of camera motion can then be fed back into Flow-SE3, which re-estimates correspondence for a finer grain pose update.
+
+Our Depth Module builds upon prior work (Kendall et al., 2017; Yao et al., 2018) and formulates multiview-stereo (MVS) reconstruction as a single feed-forward network. Like classical MVS, we leverage geometry to build a cost volume over video frames, but use trainable network for both feature extraction and matching.
+
+Our work shares similarities with prior works (Ummenhofer et al., 2017; Kendall et al., 2017; Tang & Tan, 2018; Zhou et al., 2018; Kar et al., 2017; Wang et al., 2018) that also combine deep learning and multiview geometry, but is novel and unique in that it essentially “differentializes” a classical SfM pipeline that alternates between stereopsis, dense 2D feature matching, and $\mathrm { P n P } .$ As a comparison, DeMon (Ummenhofer et al., 2017) and DeepTAM (Zhou et al., 2018) differentialize stereopsis and feature matching, but not PnP because they use a generic network to predict camera motion.
+
+Another comparison is with BA-Net (Tang & Tan, 2018), whose classical analogue is performing bundle adjustment from scratch to optimize feature alignment over camera motion and the coefficients of a limited set of depth maps (depth basis). In other words, BA-Net performs one joint nonlinear optimization over all variables, whereas we decompose the joint optimization into more tractable subproblems and do block coordinate descent. Our decomposition is more expressive in terms of reconstruction since we can optimize directly over per-pixel depth and are not constrained by a depth basis, which can potentially limit the accuracy of the final depth.
+
+In our experiments, we demonstrate the effectiveness of DeepV2D across a variety of datasets and tasks, and outperform strong methods such as DeepTAM (Zhou et al., 2018), DeMoN (Ummenhofer et al., 2017), BANet (Tang & Tan, 2018), and MVSNet (Yao et al., 2018). As we show, alternating depth and motion estimation quickly converges to good solutions. On all datasets we outperform all existing single-view and multi-view approaches. We also show superior cross-dataset generalizability, and can outperform existing methods even when training on entirely different datasets.
+
+# 2 RELATED WORK
+
+Structure from Motion: Beginning with early systems designed for small image collections (Longuet-Higgins, 1981; Mohr et al., 1995), Structure from Motion (SfM) has improved dramatically in regards to robustness, accuracy, and scalability. Advances have come from improved features (Lowe, 2004; Han et al., 2015), optimization techniques (Snavely, 2009), and more scalable data structures and representations (Schonberger & Frahm, 2016a; Gherardi et al., 2010), culminating in a number of robust systems capable of large-scale reconstruction task (Schonberger & Frahm, 2016a; Snavely, 2011; Wu et al., 2011). Ranftl et al. (2016) showed that SfM could be extended to reconstruct scenes containing many dynamically moving objects. However, SfM is limited by the accuracy and availability of correspondence. In low texture regions, occlusions, or lighting changes SfM can produce noisy or missing reconstructions.
+
+Simultaneous Localization and Mapping (SLAM) jointly estimates camera motion and 3D structure from a video sequence (Engel et al., 2014; Mur-Artal et al., 2015; Mur-Artal & Tardos, 2017; New- ´ combe et al., 2011; Engel et al., 2018). LSD-SLAM (Engel et al., 2014) is unique in that it relies on a featureless approach to 3D reconstruction, directly estimating depth maps and camera pose by minimizing photometric error. Our Motion Network behaves similarly to the tracking component in LSD-SLAM, but we use a network which predicts misalignment directly instead of using intensity gradients. We end up with an easier optimization problem characteristic of indirect methods (Mur
+
+Artal et al., 2015), while retaining the flexibility of direct methods in modeling edges and smooth intensity changes (Engel et al., 2018).
+
+Geometry and Deep Learning: Geometric principles has motivated the design of many deep learning architectures. In video to depth, we need to solve two subproblems: depth estimation and motion estimation.
+
+Depth: End-to-end networks can be trained to predict accurate depth from a rectified pair of stereo images (Han et al., 2015; Mayer et al., 2016a; Kendall et al., 2017; Chang & Chen, 2018). Kendall et al. (2017) and Chang & Chen (2018) design network architectures specifically for stereo matching. First, they apply a 2D convolutional network to extract learned features, then build a cost volume over the learned features. They then apply 3-D convolutions to the cost volume to perform feature matching and regularization. A similar idea has been extended to estimate 3D structure from multiple views (Kar et al., 2017; Yao et al., 2018). In particular, MVSNet (Yao et al., 2018) estimates depth from multiple images. However, these works require known camera poses as input, while our method estimates depth from a video where the motion of the camera is unknown and estimated during inference.
+
+Motion: Several works have used deep networks to predict camera pose. Kendall et al. (2015) focus on the problem of camera localization, while other work (Zhou et al., 2017; Vijayanarasimhan et al., 2017; Wang et al., 2017) propose methods which estimate camera motion between a pairs of frames in a video. Networks for motion estimation have typically relied on generic network components whereas we formulate motion estimation as a least-squares optimization problem. Whereas prior work has focused on estimating relative motion between pairs of frames, we can jointly update the pose of a variable number of frames.
+
+Depth and Motion: Geometric information has served as a self-supervisory signal for many recent works (Vijayanarasimhan et al., 2017; Zhou et al., 2017; Wang et al., 2018; Yin & Shi, 2018; Yang et al., 2018; Godard et al., 2017; Mahjourian et al., 2018). In particular, Zhou et al. (2017) and Vijayanarasimhan et al. (2017) trained a single-image depth network and a pose network while supervising on photometric consistency. However, while these works use geometric principles for training, they do not use multiple frames to predict depth at inference.
+
+DeMoN (Ummenhofer et al., 2017) and DeepTAM (Zhou et al., 2018) where among the first works to combine motion estimation and multi-view reconstruction into a trainable pipeline. DeMoN (Ummenhofer et al., 2017) operates on two frames and estimates depth and motion in separate network branches, while DeepTAM (Zhou et al., 2018) can be used on variable number of frames. Like our work and other classical SLAM framesworks (Engel et al., 2014; Newcombe et al., 2011), DeepTAM separates depth and motion estimation, however we maintain end-to-end differentiablity between our modules. A major innovation of DeepTAM was to formulate camera motion estimation in the form of incremental updates. In each iteration, DeepTAM renders the keyframe from a synthetic viewpoint, and predicts the residual motion from the rendered viewpoint and the target frame.
+
+Estimating depth and camera motion can be naturally modeled as a non-linear least squares problem, which has motivated several works to include an differentiable optimization layer within network architectures (Tang & Tan, 2018; Wang et al., 2018; Clark et al., 2018; Bloesch et al., 2018). We follow this line of work, and propose the Flow-SE3 module which introduces a direct mapping from 2D correspondence to a 6-dof camera motion update. Our Flow-SE3 module is different from prior works such as DeMon (Ummenhofer et al., 2017) and DeepTAM (Zhou et al., 2018) which do not impose geometric constraints on camera motion and use generic layers. BA-Net (Tang & Tan, 2018) and LS-Net (Clark et al., 2018) include optimization layers, but instead optimize over photometric error (either pixel alignment (Clark et al., 2018) or feature alignment (Tang & Tan, 2018)). Our Flow-SE3 module still imposes geometric constraints on camera motion like BA-Net (Tang & Tan, 2018), but we show that in minimizing geometric reprojection error ( difference of pixel locations), we end up with a well-behaved optimization problem, well-suited for end-to-end training.
+
+An important difference between our approach and BA-Net is that BA-Net performs one joint optimization problem by formulating Bundle-Adjustment as a differentiable network layer, whereas we separate motion and depth estimation. With this separation, we avoid the need for a depth basis. Our final reconstructed depth is the product of a cost volume, which can adapt the reconstruction as camera motion updates improve, while the output of BA-Net is restricted by the initial quality of the depth basis produced by a single-image network.
+
+![](images/6b67b5e1b0c4a8c67334cab07168e5af6d6980ef7f3bc9d70c8d4291f05d7dd3.jpg)  
+Figure 2: The Depth Module performs stereo matching over multiple frames to estimate depth. First each image is fed through a network to extract a dense feature map. The 2D features are backprojected into a set of cost volumes. The cost volumes are processed by a set of 3D hourglass networks to perform feature matching. The final cost volume is processed by the differentiable arg-max operator to produce a pixelwise depth estimate.
+
+# 3 APPROACH
+
+DeepV2D predicts depth from a calibrated video sequence. We take a video as input and output dense depth. We consider two subproblems: depth estimation and motion estimation. Both subproblems are formulated as trainable neural network modules, which we refer to as the Depth Module and the Motion Module. Our depth module takes camera motion as input and outputs an updated depth prediction. Our motion module takes depth as input, and outputs a motion correction term. In the forward pass, we alternate between the depth and motion modules as we show in Figure 1.
+
+Notation and Camera Geometry: As a preliminary, we define some of the operations used within the depth and motion modules. We define $\pi$ to be the camera projection operator which maps a 3D point $\mathbf { X } = ( X , Y , Z , 1 ) ^ { T }$ to image coordinates $\mathbf { x } = ( u , v )$ . Likewise, $\pi ^ { \dot { - } 1 }$ is defined to be the backprojection operator, which maps a pixel $x$ and depth $z$ to a 3D point. Using the pinhole camera model with intrinsics $( f _ { x } , f _ { y } , c _ { x } , c _ { y } )$ we have
+
+$$
+\pi ( { \bf X } ) = ( f _ { x } \frac { X } { Z } + c _ { x } , f _ { y } \frac { Y } { Z } + c _ { y } ) , \qquad \pi ^ { - 1 } ( { \bf x } , z ) = ( z \frac { u - c _ { x } } { f _ { x } } , z \frac { v - c _ { y } } { f _ { y } } , z , 1 ) ^ { T }
+$$
+
+The camera pose is represented using rigid body transform $\mathbf { G } \in S E ( 3 )$ . To find the image coordinates of point $\mathbf { X }$ in camera $i$ , we chain the projection and transformation: $( u , v ) ^ { T } = \bar { \pi ( \mathbf { G } _ { i } \mathbf { X } ) }$ , where $\mathbf { G } _ { i }$ is the pose of camera $i$ .
+
+Now, given two cameras $\mathbf { G } _ { i }$ and $\mathbf { G } _ { j }$ . If we know the depth of a point $\mathbf { x } ^ { i } = ( u ^ { i } , v ^ { i } )$ in camera $i$ , we can find its reprojected coordinates in camera $j$ :
+
+$$
+\binom { u ^ { j } } { v ^ { j } } = \pi ( \mathbf { G } _ { j } \mathbf { G } _ { i } ^ { - 1 } \pi ^ { - 1 } ( \mathbf { x } , z ) ) = \pi ( \mathbf { G } _ { i j } \pi ^ { - 1 } ( \mathbf { x } , z ) )
+$$
+
+using the notation $\mathbf { G } _ { i j } = \mathbf { G } _ { j } \mathbf { G } _ { i } ^ { - 1 }$ for the relative pose between cameras $i$ and $j$ .
+
+# 3.1 DEPTH MODULE
+
+The depth module takes a collection of frames, $\mathbf { I } = \{ I _ { 1 } , I _ { 2 } , . . . , I _ { N } \}$ , along with their respective pose estimates, $\mathbf { G } = \{ G _ { 1 } , G _ { 2 } , . . . , G _ { N } \}$ , and predicts a dense depth map $D ^ { * }$ for the keyframe (Figure 2). The depth module works by building a cost volume over learned features. Information is aggregated over multiple viewpoints by applying a global pooling layer which pools across viewpoints.
+
+The depth module can be viewed as the composition of 3 building blocks: 2D feature extractor, cost volume backprojection, and 3D stereo matching.
+
+2D Feature Extraction: The Depth Module begins by extracting learned features from the input images. The 2D encoder consists of 2 stacked hourglass modules (Newell et al., 2016) which maps each image to a dense feature map $I _ { i } \to F _ { i }$ . More information regarding network architectures is provided in the appendix.
+
+Cost Volume Backprojection: Take $I _ { 1 }$ to be the keyframe, a cost volume is constructed for each of the remaining N-1 frames. The cost volume for frame $j$ , $\mathbf { C } ^ { j }$ , is constructed by backprojecting 2D features into the coordinate system defined by the keyframe image. To build the cost volume, we enumerate over a range of depths $z _ { 1 } , z _ { 2 } , . . . , z _ { D }$ which is chosen to span the ranges observed in the dataset $0 . 2 \mathrm { m } \cdot 1 0 \mathrm { m }$ for indoor scenes). For every depth $z _ { k }$ , we use Equation 2 to find the reprojected coordinates on frame $j$ , and then use differentiable bilinear sampling of the feature map $F _ { j }$ .
+
+More formally, given a pixel $\mathbf { x } = ( u , v ) \in \mathbb { N } ^ { 2 }$ in frame $I _ { 1 }$ and depth $z _ { k }$
+
+$$
+C _ { u v k } ^ { j } = F _ { j } ( \pi ( \mathbf { G } _ { j } \mathbf { G } _ { 1 } ^ { - 1 } \pi ^ { - 1 } ( \mathbf { x } , z _ { k } ) ) ) \in \mathbb { R } ^ { H \times W \times D \times C }
+$$
+
+where $F ( \cdot )$ is the differentiable bilinear sampling operator (Jaderberg et al., 2015). Since the bilinear sampling is differentiable, $\mathbf { C } ^ { j }$ is differentiable w.r.t all inputs, including the camera pose.
+
+Applying this operation to each frame, gives us a set of N-1 cost volumes each with dimension $\mathbf { H } { \times } \mathbf { W } { \times } \mathbf { D } { \times } \mathbf { C }$ . As a final step, we concatenate each cost volume with the keyframe image features increasing the dimension to $\mathrm { H } { \times } \mathrm { W } { \times } \mathrm { D } { \times } 2 \mathrm { C }$ . By concatenating features, we give the network the necessary information to perform feature matching between the keyframe/image pairs without decimating the feature dimension.
+
+3D Matching Network: The set of N-1 cost volumes are first processed by a series of 3D convolutional layers to perform stereo matching. We then perform view pooling by averaging over the N-1 volumes to aggregate information across frames. View pooling leaves us with a single volume of dimension $\mathbf { H } { \times } \mathbf { W } { \times } \mathbf { D } { \times } \mathbf { C }$ . The aggregated volume is then processed by a series of 3D hourglass modules, each outputs an intermediate depth.
+
+Each 3D hourglass module predicts an intermediate depth estimate. We produce an intermediate depth representation by first applying a 1x1x1 convolution to a produce $\mathrm { H } \times \mathrm { W } \times \mathrm { D }$ volume. We then apply the softmax operator over the depth dimension, so that for each pixel, we get a probability distribution over depths. We map the probability volume into a single depth estimate using the differentiable argmax function (Kendall et al., 2017) which computes the expected depth.
+
+# 3.2 MOTION MODULE
+
+The objective of the motion module is to update the camera motion estimates given depth as input. Given the input poses, $\mathbf { G } = \{ G _ { 1 } , G _ { 2 } , . . . , G _ { N } \}$ , the motion module outputs a set of local perturbations $\pmb { \xi } = \{ \xi _ { 1 } , \xi _ { 2 } , . . . , \xi _ { N } \} , \xi _ { i } \in s e ( 3 )$ used to update the poses. The updates are found by setting up a least squares optimization problem which is solved using a differentiable in-network optimization layer.
+
+Initialization: We use a generic network architecture to predict the initial pose estimates similiar to prior work Zhou et al. (2017). We choose one frame to be the keyframe. The poses are initialized by setting the keyframe pose to be the identity matrix, and then predicting the relative motion between the keyframe and each of the other frames in the video.
+
+Feature Extraction: Our motion module operates over learned features. The feature extractor maps every frame to a dense feature map, $I _ { i } \to F _ { i }$ . The weights of the feature extractor are shared across all frames. Network architecture details are provided in the appendix.
+
+Error Term: Take two frames, $( I _ { i } , I _ { j } )$ , with respective poses $( \mathbf { G } _ { i } , \mathbf { G } _ { j } )$ and feature maps $( F _ { i } , F _ { j } )$ . Given depth $Z _ { i }$ we can use Equation 2 we can warp $F _ { j }$ onto camera $i$ to generate the warped feature map $\tilde { F } _ { j }$ . If the relative pose $\mathbf { G } _ { i j } = \mathbf { G } _ { j } \mathbf { G } _ { i } ^ { - 1 }$ is correct, then the feature maps $F _ { i }$ and $\tilde { F } _ { j }$ should align. However, if the relative pose is noisy, then there will be misalignment between the feature images which should be corrected by the pose update.
+
+We concatenate $F _ { i }$ and $\tilde { F } _ { j }$ , and send the concatenated feature map through an hourglass network to predict the dense residual flow between the feature maps, which we denote $\mathbf { R }$ , and corresponding confidence map W. Using the residual flow, we define the following error term:
+
+$$
+\mathbf { e } _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } ) = \mathbf { r } _ { k } - [ \pi ( ( e ^ { \xi _ { j } } \mathbf { G } _ { j } ) ( e ^ { \xi _ { i } } \mathbf { G } _ { i } ) ^ { - 1 } \mathbf { X } _ { k } ^ { i } ) - \pi ( \mathbf { G } _ { i j } \mathbf { X } _ { k } ^ { i } ) ] , \qquad \mathbf { X } _ { k } ^ { i } = \pi ^ { - 1 } ( \mathbf { x } _ { k } , z _ { k } )
+$$
+
+![](images/3c66c6e35702e8a89a2cba47238a015bf4bcafca5a75911beab7b97ba10d39f7.jpg)  
+Figure 3: The Motion Module updates the input pose estimates by solving a least squares optimization problem. The motion module predicts the residual flow between pairs of frames, and uses the residual terms to define the optimization objective. Pose increments $\boldsymbol { \xi }$ are found by performing a single differentiable Gauss-Newton optimization step.
+
+where $\mathbf { r } _ { k }$ is the residual flow at pixel $\mathbf { x } _ { k }$ predicted by the network, and $z _ { k }$ is the predicted depth. The weighting map W is mapped to $( 0 , 1 )$ using the sigmoid activation, and is used to determine how the individual error terms are weighted in the final objective.
+
+Optimization Objective: The previous section showed how two frames $( i , j )$ can be used to define a collection of error terms $\mathbf { e } _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } )$ for each pixel $\mathbf { x } _ { k }$ in image $I _ { i }$ . The final optimization objective is a weighted combination of error terms:
+
+$$
+E ( \pmb { \xi } ) = \sum _ { ( i , j ) \in \mathcal { C } } \sum _ { k } \mathbf { e } _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } ) ^ { T } d i a g ( \mathbf { w } _ { k } ) \mathbf { e } _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } ) , \qquad d i a g ( \mathbf { w } _ { k } ) = \left( \begin{array} { l l } { w _ { k } ^ { u } } & { 0 } \\ { 0 } & { w _ { k } ^ { v } } \end{array} \right)
+$$
+
+This leaves us with the question of which frames pairs $( i , j ) \in \mathcal { C }$ to use when defining the optimization objective. In this paper, we consider two different approaches which we refer to as Global pose optimization and Keyframe pose optimization.
+
+Global Pose Optimization: Our global pose optimization uses all pairs of frames ${ \mathcal { C } } = ( i , j ) , i \neq j$ to define the objective function (Equation 5) and the pose increment $\xi$ is solved for jointly over all poses. Therefore, given $N$ frames, dense pose optimization uses $\mathbf { N } { \times } \mathbf { N } { - } 1$ frame pairs. Since every pair of frames is compared, this means that the global pose optimization requires the predicted depth maps for all frames as input. Although each pair $( i , j )$ only gives us information about the relative pose $\mathbf { G } _ { i j }$ , considering all pairs allows us to converge to a globally consistent pose graph.
+
+Keyframe Pose Optimization: Our keyframe pose optimization selects a given frame to be the keyframe (i.e select $I _ { 1 }$ as the keyframe), and only computes the error terms between the keyframe and each of the other frames: $\mathcal { C } \overset { \cdot } { = } \left( 1 , j \right)$ for $j = 2 , . . . , N$ .
+
+Fixing the pose of the keyframe, we can remove $\xi _ { 1 }$ from the optimization objective. This means that each error $\mathbf { e } _ { k } ^ { i j } ( \mathbf { 0 } , \boldsymbol { \xi } _ { j } )$ term is only a function of a single pose increment $\xi _ { j }$ . Therefore, we can solve for each of the $N - 1$ pose increments independently. Additionally, since $i = 1$ for all pairs $( i , j ) \in \mathcal { C }$ , we only need the depth of the keyframe as input when using keyframe pose optimization.
+
+LS-Optimization Layer: Using the optimization objective in Equation 5, we solve for the pose increments $\boldsymbol { \xi }$ by applying a Gauss-Newton update. We backpropogate through the Gauss-Newton update so that the weights of the motion module (both feature extractor and flow network) can be trained on the final objective function. In the appendix, we provide additional information for how the update is derived and the expression for the Jacobian of Equation 4.
+
+# 3.3 FULL SYSTEM
+
+During inference, we alternate the depth and motion modules for a selected number of iterations. The motion module uses depth to predict camera pose. As the depth estimates converge, the camera poses become more accurate. Likewise, as camera poses converge, the depth module can estimate more accurate depth.
+
+![](images/8c1100db2950f560056a49cd8fdfa00352b5fdd3edae4548c7a76b405d822571.jpg)  
+Figure 4: Visualization of predicted depth maps on NYU, ScanNet, and SUN3D. On ScanNet and SUN3D (marked with \*) we show the results of the model trained only on NYU data.
+
+Initialization: We try two different strategies for initialization in our experiments: (1) self initialization initializes DeepV2D with a constant depth map and (2) single image initialization uses the output of a single-image depth network for initialization. Both methods give good performance.
+
+# 3.4 SUPERVISION
+
+Depth Supervision: We supervise on the L1 distance between the ground truth and predicted depth. We additionally apply a small L1 smoothness penalty to the predicted depth map. Given predicted depth $Z$ and ground truth depth $Z ^ { \ast }$ , the depth loss is defined as:
+
+$$
+\mathcal { L } _ { d e p t h } ( Z ) = \sum _ { \mathbf { x } _ { i } } \left| Z ( \mathbf { x } _ { i } ) - Z ^ { * } ( \mathbf { x _ { i } } ) \right| + w _ { s } \sum _ { \mathbf { x } _ { i } } \left| \partial _ { x } Z ( \mathbf { x } _ { i } ) \right| + \left| \partial _ { y } Z ( \mathbf { x } _ { i } ) \right|
+$$
+
+Motion Supervision: We supervise pose using the geometric reprojection error. Given predicted pose $\mathbf { G }$ and ground truth pose $\mathbf { G } ^ { \ast }$ , the pose loss is defined
+
+$$
+\mathcal { L } _ { m o t i o n } ( \mathbf { G } ) = \sum _ { \mathbf { x } _ { i } } | | \pi ( \mathbf { G } \pi ^ { - 1 } ( \mathbf { x } _ { i } , Z ( \mathbf { x } _ { i } ) ) ) - \pi ( \mathbf { G } ^ { * } \pi ^ { - 1 } ( \mathbf { x } _ { i } , Z ( \mathbf { x } _ { i } ) ) ) | | _ { \delta }
+$$
+
+where $| | \cdot | | _ { \delta }$ is the robust Huber loss; we set $\delta = 1$ .
+
+Total Loss: The total loss is taken as a weighted combination of the depth and motion loss terms: $\mathcal { L } = \mathcal { L } _ { d e p t h } + \lambda \mathcal { L } _ { m o t i o n }$ , where we set $\lambda = 1 . 0$ in our experiments.
+
+# 4 EXPERIMENTS
+
+We test DeepV2D across a wide range of benchmarks to provide a thorough comparison to other methods. While the primary focus of these experiments is to compare to other works which estimate depth from multiple frames, often single-view networks still outperform multiview depth estimation. To put our results in proper context, we include both multiview and state-of-the-art single-image comparisons. Since it is not possible to recover the absolute scale of the scene through SfM, we report all results (both ours and all other approaches) using scale matched depth (Tang & Tan, 2018).
+
+Our primary experiments are on NYU, ScanNet, SUN3D, and KITTI, and we report strong results across all datasets. We show visualization of our predicted depth maps in Figure 4. The figure shows that DeepV2D can recover accurate and sharp depth even when applied to unseen datasets. One aspect of particular interest is cross-dataset generalizability. Our results show that DeepV2D generalizes very well—we achieve the highest accuracy on ScanNet and SUN3D even without training on either dataset.
+
+# 4.1 DEPTH EXPERIMENTS
+
+We evaluate depth on NYU (Silberman et al., 2012), ScanNet (Dai et al., 2017), SUN3D (Xiao et al., 2013), and KITTI (Geiger et al., 2013). On all datasets, DeepV2D is given a video clip with unknown camera poses and alternates depth and pose updates and is evaluated after 8 iterations.
+
+NYU: NYU depth (Silberman et al., 2012) is a dataset composed of videos taken in indoor settings including offices, bedrooms, and libraries. We experiment on NYU using the standard train/test split (Eigen et al., 2014) and report results in Table 1 using scaled depth (Zhou et al., 2017; Tang & Tan, 2018). We evaluate two different initialization methods of our approach. Self-init uses a constant depth map for initialization, while fcrn-init uses the output of a FCRN (Laina et al., 2016)—a singleview network for initialization. Using a single-image depth network for initialization gives a slight improvement in performance.
+
+<table><tr><td>NYUv2</td><td></td><td>δ&lt;1.25↑</td><td>δ&lt;1.25²↑</td><td>δ&lt;1.253 个</td><td>Abs Rel↓</td><td>Sc Inv↓</td><td>RMSE↓</td><td>log10↓</td></tr><tr><td rowspan="3"></td><td>FCRN (Laina et al., 2016)</td><td>0.853</td><td>0.965</td><td>0.991</td><td>0.121</td><td>0.151</td><td>0.592</td><td>0.052</td></tr><tr><td>DORN (Fu et al., 2018)</td><td>0.875</td><td>0.966</td><td>0.989</td><td>0.109</td><td>-</td><td>0.464</td><td>0.047</td></tr><tr><td>Alhashim&amp; Wonka (2018) COLMAP</td><td>0.895</td><td>0.980</td><td>0.996</td><td>0.103</td><td>-</td><td>0.390</td><td>0.043</td></tr><tr><td rowspan="6">mnnian DeMoN †</td><td>DfUSMC DeMoN</td><td>0.619 0.487</td><td>0.760 0.697</td><td>0.829 0.814</td><td>0.312 0.447</td><td>1.512 0.456</td><td>1.381 1.793</td><td>0.153 0.169</td></tr><tr><td>MVSNet + OpenMVG</td><td>0.766</td><td>0.913</td><td>0.965</td><td>0.181</td><td>0.212</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>0.917</td><td>0.072</td></tr><tr><td></td><td>0.776</td><td>0.933</td><td>0.979</td><td>0.160</td><td>0.196</td><td>0.775</td><td>0.067</td></tr><tr><td>0.805</td><td>0.951</td><td></td><td>0.985</td><td>0.144</td><td>0.179</td><td>0.717</td><td>0.061</td></tr><tr><td rowspan="4">Ours (self-init)-Keyframe Ours (fcrn-init) - Keyframe Ours (self-init) - Global</td><td>0.940</td><td>0.985</td><td>0.995</td><td>0.072</td><td>0.105</td><td>0.459</td><td></td><td>0.031</td></tr><tr><td></td><td>0.955 0.942</td><td>0.990</td><td>0.996</td><td>0.062</td><td>0.095</td><td>0.405</td><td>0.027</td></tr><tr><td></td><td>0.986</td><td>0.995</td><td>0.070</td><td>0.104</td><td></td><td>0.454</td><td>0.030</td></tr><tr><td>Ours (fcrn-init) -Global 0.956</td><td>0.989</td><td>0.996</td><td>0.061</td><td></td><td>0.094</td><td>0.403</td><td>0.026</td></tr></table>
+
+Table 1: Results on the NYU dataset. Our approach outperforms existing single-view and multiview depth estimation methods. Ours (self-init) uses a constant depth map for initialization while ours(fcrn-init) uses a single-image depth network for initialization.
+
+We compare to state-of-the-art single-image depth networks DORN (Fu et al., 2018) and DenseDepth (Alhashim & Wonka, 2018) which are built on top of a pretrained ResNet (DORN) or DenseNet-201 (DenseDepth). The results show that we can do much better than single-view depth by using multiple views. We also include classical multiview approaches such as COLMAP (Schonberger & Frahm, 2016a) and DfUSMC (Ha et al., 2016) which estimate poses with bundle adjustment, followed by dense stereo matching. While COLMAP uses SIFT features, DfUSMC is built on local-feature tracking and is designed for small baseline videos.
+
+Table 1 also includes results using multi-view deep learning approaches. MVSNet (Yao et al., 2018) is trained to estimate depth from multiple viewpoints. Unlike our approach which estimates camera pose during inference, MVSNet requires ground truth poses as input. We train MVSNet on NYU and use poses estimated from OpenMVG (Moulon et al.) during inference. Finally, we also evaluate DeMoN (Ummenhofer et al., 2017) on NYU. DeMoN is not originally trained on NYU, but instead trained on a combination of 5 other datasets. We also try a version of DeMoN which we retrain on NYU using the code provided by the authors (denoted †).
+
+In Appendix C, we include additional results on NYU where we test different versions of our model, along with parameter counts, timing information, peak memory usage, and depth accuracy. A shallower version of DeepV2D (replacing the stacked hourglass networks with a single hourglass network) and lower resolution inference still outperform existing work on NYU. However, using a 3D network for stereo matching turns out to be very important for depth accuracy. When the 3D stereo network is replaced with a correlation layer (Dosovitskiy et al., 2015) and 2d encoder-decoder, depth accuracy is worse increasing Abs-Rel from 0.062 to 0.135.
+
+Figure 5 shows the impact of the number of iterations and views on the scale-invariant (sc-inv) validation set accuracy. Figure 5 (left) shows that DeepV2D requires very few iterations to converge, suggesting that block coordinate descent is effective for estimate depth from small video clips. In Figure 5 (right) we test accuracy as a function of the number of input frames used. Although DeepV2D is trained using a fixed number (4) frames as input, accuracy continues to improve a more frames are added.
+
+ScanNet: ScanNet is a large indoor dataset consisting of 1513 RGB-D videos in distinct scenes. We use the train/test split proposed by Tang & Tan (2018) and evaluate depth and pose accuracy in Table 2. While our primary focus is on depth, DeepV2D accurately predicts camera motion.
+
+We use ScanNet to test cross-dataset generalization and report results from two versions of our approach: ours (nyu) is our method trained only on nyu, ours (scannet) is our method trained on ScanNet. As expected, when we train on the ScanNet training set we do better than if we train only on NYU. But the performance of our NYU model is still good and outperforms BA-Net on all metrics. The design of our approach is motivated by generalizability. Our network only needs to learn feature matching and correspondence; this experiment indicates that by learning these low level tasks, we can generalize well to new data.
+
+![](images/36d9f7a5ae059ac7be779f6ce91e5242e008cb9039a92cfb4b83c830a444c06f.jpg)  
+Figure 5: Impact of the number of iterations (left) and frames (right) on sc-inv validation accuracy. (left) shows that DeepV2D quickly converges within a small number of iterations. In (right) we see that accuracy consistently improves as more views are added. DeepV2D can be applied to variable numbers of views for a variable number of iterations without retraining.
+
+Table 2: ScanNet experiments evaluating depth and pose accuracy and cross-dataset generalization. Our approach trained on NYU (ours nyu) outperforms BA-Net despite BA-Net being trained on ScanNet data; training on ScanNet (ours scannet) gives even better performance.   
+
+<table><tr><td>ScanNet</td><td>Abs Rel↓</td><td>Sq Rel↓</td><td>RMSE、</td><td>RMSE log √</td><td>sc inv</td><td>rot.(deg)↓</td><td>tr. (deg)↓</td><td>tr.(cm)↓</td></tr><tr><td>DeMoN</td><td>0.231</td><td>0.520</td><td>0.761</td><td>0.289</td><td>0.284</td><td>3.791</td><td>31.626</td><td>15.50</td></tr><tr><td>BA-Net (orig.)</td><td>0.161</td><td>0.092</td><td>0.346</td><td>0.214</td><td>0.184</td><td>1.018</td><td>20.577</td><td>3.390</td></tr><tr><td>BA-Net (5-view)</td><td>0.091</td><td>0.058</td><td>0.223</td><td>0.147</td><td>0.137</td><td>1.009</td><td>14.626</td><td>2.365</td></tr><tr><td>DSO (Engel et al., 2018)</td><td></td><td></td><td></td><td></td><td></td><td>0.925</td><td>19.728</td><td>2.174</td></tr><tr><td>DSO (fcrn-init)</td><td></td><td></td><td></td><td></td><td></td><td>0.946</td><td>19.238</td><td>2.165</td></tr><tr><td>Ours (nyu) Ours (scannet)</td><td>0.080 0.057</td><td>0.018 0.010</td><td>0.223 0.168</td><td>0.109 0.080</td><td>0.105 0.077</td><td>0.714 0.628</td><td>12.205 10.800</td><td>1.514 1.373</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Pose accuracy from DSO Engel et al. (2018) is also included in Table 2. We test DSO using both the default initialization and single-image depth initialization using the output of FCRN (Laina et al., 2016). DSO fails to initialize or loses tracking on some of the test sequences so we only evaluate on sequences where DSO is successful. DSO fails on 335 of the 2000 test sequences while DSO (fcrn-init) fails on only 271.
+
+SUN3D: SUN3D (Xiao et al., 2013) is another indoor scenes dataset which we use for comparison with DeepTAM. DeepTAM only evaluates their depth module in isolation using the poses provided by dataset, while our approach is designed to estimate poses during inference. We provide results from our SUN3D experiments in Table 3.
+
+Table 3: Results on SUN3D dataset and comparison to DeepTAM. DeepTAM only evaluates depth in isolation and uses the poses from the dataset during inference, while our approach jointly estimates camera poses during inference. We outperform DeepTAM and DeMoN on SUN3D even when we do not use SUN3D data for training.   
+
+<table><tr><td>SUN3D</td><td>Training Data</td><td>L1-Inv ↓</td><td>L1-Rel↓</td><td>Sc-Inv↓</td></tr><tr><td>SGM DTAM</td><td>=</td><td>0.197</td><td>0.412</td><td>0.340</td></tr><tr><td>DeMoN</td><td>=</td><td>0.210</td><td>0.423</td><td>0.374</td></tr><tr><td>DeepTAM</td><td>S11+RGBD+MVS+SUN3D</td><td>=</td><td>=</td><td>0.146</td></tr><tr><td>Ours</td><td>MVS+SUNCG+SUN3D</td><td>0.054 0.056</td><td>0.101</td><td>0.128</td></tr><tr><td>Ours</td><td>NYU NYU+ ScanNet</td><td>0.041</td><td>0.106</td><td>0.134</td></tr><tr><td></td><td></td><td></td><td>0.077</td><td>0.104</td></tr></table>
+
+We cannot train using the same data as DeepTAM since DeepTAM is trained using a combination of SUN3D, SUNCG, and MVS, and, at this time, neither MVS nor SUNCG are publicly available. Instead we train on alternate data and test on SUN3D. We test two different versions of our model; one where we train only on NYU, and another where we train on a combination of NYU and ScanNet data. Our NYU model performs similiar to DeepTAM; When we combine with ScanNet data, we outperform DeepTAM even though DeepTAM is trained on SUN3D and is evaluated with ground truth pose as input.
+
+KITTI: The KITTI dataset (Geiger et al., 2013) is captured from a moving vehicle and has been widely used to evaluate depth estimation and odometry. We follow the Eigen train/test split (Eigen et al., 2014), and report results in Table 4. We evaluate using the official ground truth depth maps. We compare to the state-of-the-art single-view methods and also multiview approaches such as BANet (Tang & Tan, 2018), and outperform previous methods on the KITTI dataset across all metrics.
+
+<table><tr><td>KITTI</td><td>Multi</td><td>δ&lt;1.25↑</td><td>δ&lt;1.25²↑</td><td>δ&lt;1.25³↑</td><td>AbsRel↓</td><td>Sq Rel↓</td><td>Sq Rel†↓</td><td>RMSE↓</td><td>RMSE log↓</td></tr><tr><td>DORN</td><td>N</td><td>0.945</td><td>0.988</td><td>0.996</td><td>0.069</td><td>0.300</td><td>=</td><td>2.857</td><td>0.112</td></tr><tr><td>DfUSMC</td><td>Y</td><td>0.617</td><td>0.796</td><td>0.874</td><td>0.346</td><td>5.984</td><td></td><td>8.879</td><td>0.454</td></tr><tr><td>BA-Net</td><td>Y</td><td>=</td><td>=</td><td>=</td><td>0.083</td><td>=</td><td>0.025</td><td>3.640</td><td>0.134</td></tr><tr><td>Ours</td><td>Y</td><td>0.977</td><td>0.993</td><td>0.997</td><td>0.037</td><td>0.174</td><td>0.013</td><td>2.005</td><td>0.074</td></tr></table>
+
+Table 4: Results on the KITTI dataset. We compare to state-of-the-art single-image depth network DORN (Fu et al., 2018) and multiview BA-Net (Tang & Tan, 2018). BA-Net reports results using a different form of the Sq-Rel metric which we denote by $\dagger$ .
+
+Overall, the depth experiments demonstrates that imposing geometric constraints on the model architecture leads to higher accuracy and better cross-dataset generalization. By providing a differentiable mapping from optical flow to camera motion, the motion network only needs to learn to estimate interframe correspondence. Likewise, the 3D cost volume means the the depth network only needs to learn to perform stereo matching. These tasks are easy for the network to learn, which leads to strong results on all datasets, and can generalize to new datasets.
+
+# 4.2 TRACKING EXPERIMENTS
+
+DeepV2D can be turned into a basic SLAM system. Using NYU and ScanNet for training, we test tracking performance on the TUM-RGBD tracking benchmark (Table 5) using sensor depth as input. We achieve a lower translational rmse $[ \mathrm { m } / \mathrm { s } ]$ than DeepTAM on most of the sequences. DeepTAM uses optical flow supervision to improve performance, but since our network directly maps optical flow to camera motion, we do not need supervision on optical flow.
+
+We use our global pose optimization in our tracking experiments. We maintain a fixed window of 8 frames during tracking. At each timestep, the pose of the first 3 frames in the window are fixed and the remaining 5 are updated using the motion module. After the update, the start of the tracking window is incremented by 1 frame. We believe our ability to jointly update the pose of multiple frames is a key reason for our strong performance on the RGB-D benchmark.
+
+Table 5: Tracking results in the RGB-D benchmark (translational rmse $[ \mathrm { m } / \mathrm { s } ] ,$ ).   
+
+<table><tr><td></td><td>360</td><td>desk</td><td>desk2</td><td>plant</td><td>room</td><td>rpy</td><td>xyz</td><td>mean</td></tr><tr><td>DVO (Kerl et al., 2013)</td><td>0.125</td><td>0.037</td><td>0.020</td><td>0.062</td><td>0.042</td><td>0.082</td><td>0.051</td><td>0.060</td></tr><tr><td>DeepTAM (Zhou et al., 2018)</td><td>0.054</td><td>0.027</td><td>0.017</td><td>0.057</td><td>0.039</td><td>0.065</td><td>0.019</td><td>0.040</td></tr><tr><td>DeepTAM(w/o flow) (Zhou et al.,2018)</td><td>0.069</td><td>0.042</td><td>0.025</td><td>0.063</td><td>0.051</td><td>0.070</td><td>0.030</td><td>0.050</td></tr><tr><td>Ours</td><td>0.046</td><td>0.034</td><td>0.017</td><td>0.052</td><td>0.032</td><td>0.037</td><td>0.014</td><td>0.033</td></tr></table>
+
+# 5 CONCLUSION
+
+We propose DeepV2D, a deep learning architecture which is built by composing classical geometric algorithms into a fully differentiable pipeline. DeepV2D is flexible and performs well across a variety of tasks and datasets.
+
+Acknowledgements We would like to thank Zhaoheng Zheng for helping with baseline experiments. This work was partially funded by the Toyota Research Institute, the King Abdullah University of Science and Technology (KAUST) Office of Sponsored Research (OSR) under Award No. OSR2015-CRG4-2639, and the National Science Foundation under Grant No. 1617767.
+
+# REFERENCES
+
+Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for largescale machine learning. In OSDI, volume 16, pp. 265–283, 2016.
+
+Sameer Agarwal, Keir Mierle, et al. Ceres solver. 2012.
+
+Ibraheem Alhashim and Peter Wonka. High quality monocular depth estimation via transfer learning. arXiv preprint arXiv:1812.11941, 2018.
+
+Michael Bloesch, Jan Czarnowski, Ronald Clark, Stefan Leutenegger, and Andrew J Davison. Codeslam—learning a compact, optimisable representation for dense visual slam. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2560–2568, 2018.
+
+Jia-Ren Chang and Yong-Sheng Chen. Pyramid stereo matching network. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5410–5418, 2018.
+
+Tianqi Chen, Bing Xu, Chiyuan Zhang, and Carlos Guestrin. Training deep nets with sublinear memory cost. arXiv preprint arXiv:1604.06174, 2016.
+
+Ronald Clark, Michael Bloesch, Jan Czarnowski, Stefan Leutenegger, and Andrew J Davison. Learning to solve nonlinear least squares for monocular stereo. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 284–299, 2018.
+
+Angela Dai, Angel X Chang, Manolis Savva, Maciej Halber, Thomas Funkhouser, and Matthias Nießner. Scannet: Richly-annotated 3d reconstructions of indoor scenes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5828–5839, 2017.
+
+Alexey Dosovitskiy, Philipp Fischer, Eddy Ilg, Philip Hausser, Caner Hazirbas, Vladimir Golkov, Patrick Van Der Smagt, Daniel Cremers, and Thomas Brox. Flownet: Learning optical flow with convolutional networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2758–2766, 2015.
+
+David Eigen and Rob Fergus. Predicting depth, surface normals and semantic labels with a common multi-scale convolutional architecture. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2650–2658, 2015.
+
+David Eigen, Christian Puhrsch, and Rob Fergus. Depth map prediction from a single image using a multi-scale deep network. In Advances in neural information processing systems, pp. 2366–2374, 2014.
+
+Jakob Engel, Thomas Schops, and Daniel Cremers. Lsd-slam: Large-scale direct monocular slam.¨ In European Conference on Computer Vision, pp. 834–849. Springer, 2014.
+
+Jakob Engel, Vladlen Koltun, and Daniel Cremers. Direct sparse odometry. IEEE transactions on pattern analysis and machine intelligence, 40(3):611–625, 2018.
+
+Huan Fu, Mingming Gong, Chaohui Wang, Kayhan Batmanghelich, and Dacheng Tao. Deep ordinal regression network for monocular depth estimation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2002–2011, 2018.
+
+Yasutaka Furukawa and Jean Ponce. Accurate, dense, and robust multiview stereopsis. IEEE transactions on pattern analysis and machine intelligence, 32(8):1362–1376, 2010.
+
+Yasutaka Furukawa, Carlos Hernandez, et al. Multi-view stereo: A tutorial. ´ Foundations and Trends $\textsuperscript { \textregistered }$ in Computer Graphics and Vision, 9(1-2):1–148, 2015.
+
+Andreas Geiger, Philip Lenz, Christoph Stiller, and Raquel Urtasun. Vision meets robotics: The kitti dataset. The International Journal of Robotics Research, 32(11):1231–1237, 2013.
+
+Riccardo Gherardi, Michela Farenzena, and Andrea Fusiello. Improving the efficiency of hierarchical structure-and-motion. In Computer Vision and Pattern Recognition (CVPR), 2010 IEEE Conference on, pp. 1594–1600. IEEE, 2010.
+
+Clement Godard, Oisin Mac Aodha, and Gabriel J Brostow. Unsupervised monocular depth estima- ´ tion with left-right consistency. In CVPR, volume 2, pp. 7, 2017.
+
+Hyowon Ha, Sunghoon Im, Jaesik Park, Hae-Gon Jeon, and In So Kweon. High-quality depth from uncalibrated small motion clip. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5413–5421, 2016.
+
+Xufeng Han, Thomas Leung, Yangqing Jia, Rahul Sukthankar, and Alexander C Berg. Matchnet: Unifying feature and metric learning for patch-based matching. In Computer Vision and Pattern Recognition (CVPR), 2015 IEEE Conference on, pp. 3279–3286. IEEE, 2015.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in neural information processing systems, pp. 2017–2025, 2015.
+
+Abhishek Kar, Jitendra Malik, and Christian Hane. Learning a multi-view stereo machine. In ¨ Advances in Neural Information Processing Systems, pp. 364–375, 2017.
+
+Alex Kendall and Roberto Cipolla. Geometric loss functions for camera pose regression with deep learning. In Proc. CVPR, volume 3, pp. 8, 2017.
+
+Alex Kendall, Matthew Grimes, and Roberto Cipolla. Posenet: A convolutional network for realtime 6-dof camera relocalization. In Computer Vision (ICCV), 2015 IEEE International Conference on, pp. 2938–2946. IEEE, 2015.
+
+Alex Kendall, Hayk Martirosyan, Saumitro Dasgupta, Peter Henry, Ryan Kennedy, Abraham Bachrach, and Adam Bry. End-to-end learning of geometry and context for deep stereo regression. In Proceedings of the IEEE International Conference on Computer Vision, pp. 66–75, 2017.
+
+Christian Kerl, Jurgen Sturm, and Daniel Cremers. Dense visual slam for rgb-d cameras. In Intelligent Robots and Systems (IROS), 2013 IEEE/RSJ International Conference on, pp. 2100–2106. IEEE, 2013.
+
+Iro Laina, Christian Rupprecht, Vasileios Belagiannis, Federico Tombari, and Nassir Navab. Deeper depth prediction with fully convolutional residual networks. In 3D Vision (3DV), 2016 Fourth International Conference on, pp. 239–248. IEEE, 2016.
+
+Vincent Lepetit, Francesc Moreno-Noguer, and Pascal Fua. Epnp: An accurate o (n) solution to the pnp problem. International journal of computer vision, 81(2):155, 2009.
+
+Shiqi Li, Chi Xu, and Ming Xie. A robust o (n) solution to the perspective-n-point problem. IEEE transactions on pattern analysis and machine intelligence, 34(7):1444–1450, 2012.
+
+H Christopher Longuet-Higgins. A computer algorithm for reconstructing a scene from two projections. Nature, 293(5828):133–135, 1981.
+
+David G Lowe. Distinctive image features from scale-invariant keypoints. International journal of computer vision, 60(2):91–110, 2004.
+
+Reza Mahjourian, Martin Wicke, and Anelia Angelova. Unsupervised learning of depth and egomotion from monocular video using 3d geometric constraints. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5667–5675, 2018.
+
+Nikolaus Mayer, Eddy Ilg, Philip Hausser, Philipp Fischer, Daniel Cremers, Alexey Dosovitskiy, and Thomas Brox. A large dataset to train convolutional networks for disparity, optical flow, and scene flow estimation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4040–4048, 2016a.
+
+Nikolaus Mayer, Eddy Ilg, Philip Hausser, Philipp Fischer, Daniel Cremers, Alexey Dosovitskiy, and Thomas Brox. A large dataset to train convolutional networks for disparity, optical flow, and scene flow estimation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4040–4048, 2016b.
+
+Roger Mohr, Long Quan, and Franc¸oise Veillon. Relative 3d reconstruction using multiple uncalibrated images. The International Journal of Robotics Research, 14(6):619–632, 1995.
+
+Pierre Moulon, Pascal Monasse, Renaud Marlet, and Others. Openmvg. an open multiple view geometry library. https://github.com/openMVG/openMVG.
+
+Raul Mur-Artal and Juan D Tardos. Orb-slam2: An open-source slam system for monocular, stereo, ´ and rgb-d cameras. IEEE Transactions on Robotics, 33(5):1255–1262, 2017.
+
+Raul Mur-Artal, Jose Maria Martinez Montiel, and Juan D Tardos. Orb-slam: a versatile and accurate monocular slam system. IEEE Transactions on Robotics, 31(5):1147–1163, 2015.
+
+Richard A Newcombe, Steven J Lovegrove, and Andrew J Davison. Dtam: Dense tracking and mapping in real-time. In 2011 international conference on computer vision, pp. 2320–2327. IEEE, 2011.
+
+Alejandro Newell, Kaiyu Yang, and Jia Deng. Stacked hourglass networks for human pose estimation. In European Conference on Computer Vision, pp. 483–499. Springer, 2016.
+
+Rene Ranftl, Vibhav Vineet, Qifeng Chen, and Vladlen Koltun. Dense monocular depth estimation ´ in complex dynamic scenes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4058–4066, 2016.
+
+Johannes L Schonberger and Jan-Michael Frahm. Structure-from-motion revisited. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4104–4113, 2016a.
+
+Johannes L Schonberger and Jan-Michael Frahm. Structure-from-motion revisited. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4104–4113, 2016b.
+
+Nathan Silberman, Derek Hoiem, Pushmeet Kohli, and Rob Fergus. Indoor segmentation and support inference from rgbd images. Computer Vision–ECCV 2012, pp. 746–760, 2012.
+
+Keith N Snavely. Scene reconstruction and visualization from internet photo collections. 2009.
+
+Noah Snavely. Scene reconstruction and visualization from internet photo collections: A survey. IPSJ Transactions on Computer Vision and Applications, 3:44–66, 2011.
+
+Deqing Sun, Xiaodong Yang, Ming-Yu Liu, and Jan Kautz. Pwc-net: Cnns for optical flow using pyramid, warping, and cost volume. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8934–8943, 2018.
+
+Chengzhou Tang and Ping Tan. Ba-net: Dense bundle adjustment network. arXiv preprint arXiv:1806.04807, 2018.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26– 31, 2012.
+
+Benjamin Ummenhofer, Huizhong Zhou, Jonas Uhrig, Nikolaus Mayer, Eddy Ilg, Alexey Dosovitskiy, and Thomas Brox. Demon: Depth and motion network for learning monocular stereo. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5038– 5047, 2017.
+
+Sudheendra Vijayanarasimhan, Susanna Ricco, Cordelia Schmid, Rahul Sukthankar, and Katerina Fragkiadaki. Sfm-net: Learning of structure and motion from video. arXiv preprint arXiv:1704.07804, 2017.
+
+Chaoyang Wang, Jose Miguel Buenaposada, Rui Zhu, and Simon Lucey. Learning depth from ´ monocular videos using direct methods. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2022–2030, 2018.
+
+Sen Wang, Ronald Clark, Hongkai Wen, and Niki Trigoni. Deepvo: Towards end-to-end visual odometry with deep recurrent convolutional neural networks. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 2043–2050. IEEE, 2017.
+
+Changchang Wu et al. Visualsfm: A visual structure from motion system. 2011.
+
+Jianxiong Xiao, Andrew Owens, and Antonio Torralba. Sun3d: A database of big spaces reconstructed using sfm and object labels. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1625–1632, 2013.
+
+Nan Yang, Rui Wang, Jorg Stuckler, and Daniel Cremers. Deep virtual stereo odometry: Leveraging deep depth prediction for monocular direct sparse odometry. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 817–833, 2018.
+
+Yao Yao, Zixin Luo, Shiwei Li, Tian Fang, and Long Quan. Mvsnet: Depth inference for unstructured multi-view stereo. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 767–783, 2018.
+
+Zhichao Yin and Jianping Shi. Geonet: Unsupervised learning of dense depth, optical flow and camera pose. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1983–1992, 2018.
+
+Huizhong Zhou, Benjamin Ummenhofer, and Thomas Brox. Deeptam: Deep tracking and mapping. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 822–838, 2018.
+
+Tinghui Zhou, Matthew Brown, Noah Snavely, and David G Lowe. Unsupervised learning of depth and ego-motion from video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1851–1858, 2017.
+
+# A APPENDIX
+
+# A.1 LS-OPTIMIZATION LAYER:
+
+In Equation 4 we defined the residual error to be:
+
+$$
+\mathbf { e } _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } ) = \mathbf { r } _ { k } - [ \pi ( ( e ^ { \xi _ { j } } \mathbf { G } _ { j } ) ( e ^ { \xi _ { i } } \mathbf { G } _ { i } ) ^ { - 1 } \mathbf { X } _ { k } ^ { i } ) - \pi ( \mathbf { G } _ { i j } \mathbf { X } _ { k } ^ { i } ) ] , \qquad \mathbf { X } _ { k } ^ { i } = \pi ^ { - 1 } ( \mathbf { x } _ { k } , z _ { k } )
+$$
+
+and the objective function as the weighted sum of error terms:
+
+$$
+E ( \pmb { \xi } ) = \sum _ { ( i , j ) \in \mathcal { C } } \sum _ { k } \mathbf { e } _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } ) ^ { T } d i a g ( \mathbf { w } _ { k } ) \mathbf { e } _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } ) , \qquad d i a g ( \mathbf { w } _ { k } ) = \left( \begin{array} { l l } { w _ { k } ^ { u } } & { 0 } \\ { 0 } & { w _ { k } ^ { v } } \end{array} \right)
+$$
+
+We apply a Gauss-Newton update to Equation 9. The Gauss-Newton update is computed by solving for the minimum of the second order approximation of the objective function:
+
+$$
+\boldsymbol { \xi } ^ { * } = - ( \mathbf { J } ^ { T } \mathbf { W } \mathbf { J } ) ^ { - 1 } \mathbf { J } ^ { T } \mathbf { W } \mathbf { r } ( \xi _ { 1 } , . . . , \xi _ { N } ) , \qquad \mathbf { J } _ { p } = \frac { \partial r _ { p } ( \epsilon ) } { \partial \epsilon } | _ { \epsilon = 0 }
+$$
+
+where $\mathbf { r } ( \xi _ { 1 } , . . . , \xi _ { N } )$ is the stack of residuals and $\mathbf { J }$ is the Jacobian matrix. Each row $\mathbf { J } _ { i }$ is the Jacobian of the $\mathrm { i } ^ { t h }$ error term w.r.t to each of the parameters. Each $\xi$ is 6-dimensional, so optimizing over $N$ poses means we are updating $6 N$ variables.
+
+Let $r _ { p } = e _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } )$ be the $\mathrm { p } ^ { t h }$ residual, then
+
+$$
+\begin{array} { r l r } & { } & { \displaystyle { \frac { \partial e _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } ) } { \partial \xi _ { j } } } \vert _ { \xi _ { i } = 0 , \xi _ { j } = 0 } = \frac { \partial } { \partial \xi _ { j } } [ { \bf r } _ { k } - [ \pi ( ( e ^ { \xi _ { j } } { \bf G } _ { j } ) ( e ^ { \xi _ { i } } { \bf G } _ { i } ) ^ { - 1 } { \bf X } _ { k } ^ { i } ) - \pi ( { \bf G } _ { i j } { \bf X } _ { k } ^ { i } ) ] ] = } \\ & { } & { \displaystyle { \frac { \partial } { \partial \xi _ { j } } \pi ( ( e ^ { \xi _ { j } } { \bf G } _ { j } ) ( e ^ { \xi _ { i } } { \bf G } _ { i } ) ^ { - 1 } { \bf X } _ { k } ^ { i } ) } = \frac { \partial } { \partial \xi _ { j } } \pi ( e ^ { \xi _ { j } } ( { \bf G } _ { i j } { \bf X } _ { k } ^ { i } ) ) } \\ & { } & { \displaystyle { \frac { \partial e _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } ) } { \partial \xi _ { j } } \vert _ { \xi _ { i } = 0 , \xi _ { j } = 0 } = \frac { \partial } { \partial ( { \bf G } _ { i j } { \bf X } _ { k } ^ { i } ) } \pi ( { \bf G } _ { i j } { \bf X } _ { k } ^ { i } ) \cdot \frac { \partial } { \partial \xi _ { j } } e ^ { \xi _ { i } } ( { \bf G } _ { i j } { \bf X } _ { k } ^ { i } ) } } \end{array}
+$$
+
+Likewise, the Jacobian for $\xi _ { j }$ is
+
+$$
+\begin{array} { r l } & { \displaystyle \frac { \partial e _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } ) } { \partial \xi _ { j } } \vert _ { \xi _ { i } = 0 , \xi _ { j } = 0 } = \frac { \partial } { \partial \xi _ { i } } [ \mathbf { r } _ { k } - [ \pi ( ( e ^ { \xi _ { j } } \mathbf { G } _ { j } ) ( e ^ { \xi _ { i } } \mathbf { G } _ { i } ) ^ { - 1 } \mathbf { X } _ { k } ^ { i } ) - \pi ( \mathbf { G } _ { i j } \mathbf { X } _ { k } ^ { i } ) ] ] = } \\ & { \displaystyle \frac { \partial } { \partial \xi _ { i } } \pi ( ( e ^ { \xi _ { j } } \mathbf { G } _ { j } ) ( e ^ { \xi _ { i } } \mathbf { G } _ { i } ) ^ { - 1 } \mathbf { X } _ { k } ^ { i } ) = \frac { \partial } { \partial \xi _ { i } } \pi ( \mathbf { G } _ { j } \mathbf { G } _ { i } ^ { - 1 } e ^ { - \xi _ { i } } \mathbf { X } _ { k } ^ { i } ) = \frac { \partial } { \partial \xi _ { i } } \pi ( \mathbf { G } _ { i j } e ^ { - \xi _ { i } } \mathbf { X } _ { k } ^ { i } ) } \end{array}
+$$
+
+using the adjoint to move the increment to the left of the transformation
+
+$$
+\begin{array} { r } { \displaystyle = \frac { \partial } { \partial \xi _ { i } } \pi ( e ^ { w } \mathbf { G } _ { i j } \mathbf { X } _ { k } ^ { i } ) \qquad \mathrm { w h e r e ~ } w = - A d j _ { \mathbf { G } _ { i j } } \cdot \boldsymbol { \xi } } \\ { \displaystyle \frac { \partial e _ { k } ^ { i j } ( \xi _ { i } , \xi _ { j } ) } { \partial \xi _ { j } } \vert _ { \xi _ { i } = 0 , \xi _ { j } = 0 } = - \frac { \partial } { \partial \big ( \mathbf { G } _ { i j } \mathbf { X } _ { k } ^ { i } \big ) } \pi ( \mathbf { G } _ { i j } \mathbf { X } _ { k } ^ { i } ) \cdot \frac { \partial } { \partial w } e ^ { w } \big ( \mathbf { G } _ { i j } \mathbf { X } _ { k } ^ { i } \big ) \cdot A d j _ { \mathbf { G } _ { i j } } } \end{array}
+$$
+
+where the Jacobian of the action of a $\mathbf { S E } ( 3 )$ element on a 3D point is computed
+
+$$
+\frac { \partial e ^ { \xi } \mathbf { X } } { \partial \xi } | _ { \xi = 0 } = [ \begin{array} { c c c } { 1 } & { 0 } & { 0 } \\ { 0 } & { 1 } & { 0 } \\ { 0 } & { 0 } & { 1 } \end{array} ] \begin{array} { c c c } { 0 } & { - Z } & { Y } \\ { Z } & { 0 } & { X } \\ { - Y } & { X } & { 0 } \end{array} ]
+$$
+
+During training, we propagate through the Gauss-Newton update. The update is found by solving the linear system
+
+$$
+\mathbf { H } \xi = - \mathbf { b } , \qquad \mathbf { H } = \mathbf { J } ^ { T } \mathbf { W } \mathbf { J } , \ \mathbf { \ b } = \mathbf { J } ^ { T } \mathbf { W } \mathbf { r } ( \xi _ { 1 } , . . . , \xi _ { N } )
+$$
+
+Since $\mathbf { H }$ is positive definite, we solve Equation 15 using Cholesky decomposition. In the backward pass, the gradients can be found by solving another linear system.
+
+$$
+\frac { \partial \mathcal { L } } { \partial \mathbf { H } } = - ( \mathbf { H } ^ { - 1 } \frac { \partial \mathcal { L } } { \partial \xi } ) ^ { T } \boldsymbol { \xi } , \qquad \frac { \partial \mathcal { L } } { \partial \mathbf { b } } = \mathbf { H } ^ { - 1 } \frac { \partial \mathcal { L } ^ { T } } { \partial \boldsymbol { \xi } }
+$$
+
+# B TRAINING DETAILS
+
+DeepV2D is implemented in Tensorflow (Abadi et al., 2016). All components of the network are trained from scratch without using any pretrained weights. We use gradient checkpointing (Chen et al., 2016) to reduce memory usage and increase batch size.
+
+When training on NYU and ScanNet, we train with 4 frame video clips. On KITTI, we use 5 frame video clips. The video clips are created by first selecting a keyframe. The other frames are randomly sampled from the set of frames within a specified time window of the keyframe. For example, on NYU, we create the training video by sampling from frames within 1 second of the keyframe.
+
+Training occurs in the following two stages:
+
+Stage I: We train the Motion Module using the $L _ { m o t i o n }$ loss with RMSProp (Tieleman & Hinton, 2012) and a learning rate of 0.0001. For the input depth, we use the ground truth depth with missing values interpolated. We train Stage I for 20k iterations on NYU, 16k iterations on KITTI, and 30k iterations on ScanNet.
+
+Stage II: In stage II, we jointly train the motion and depth modules end-to-end on the combined loss with RMSProp. The initial learning rate is set to .001 and decayed to .0002 after 100k training steps. During the second stage we store depth predictions to be used during the next training epoch. We train Stage II for a total of $1 2 0 \mathrm { k }$ iterations with a batch size of 2. In our ScanNet experiments, we train for an additional $6 0 \mathrm { k }$ iterations.
+
+Data Augmentation: We perform data augmentation by adjusting brightness, gamma, and performing random scaling of the image channels. We also randomly perturb the input camera pose to the Motion Module by sampling small perturbations.
+
+# C TIMING AND MEMORY USAGE
+
+In the below table we provide timing and peak memory usage for different versions of our method. All results are obtained using 8 frame video sequences as input with the exception of the basline single-image network FCRN Laina et al. (2016) which uses a single frame as input.
+
+Table 6: Timing and memory details for different versions of our approach.   
+
+<table><tr><td></td><td>Abs-Rel ↓</td><td>Parameters</td><td>PeakGPUMemory</td><td>Iteration Time</td></tr><tr><td>FCRN (Laina et al., 2016)</td><td>0.121</td><td>64M</td><td>0.1G</td><td>0.05s</td></tr><tr><td>Ours (1/2 res)</td><td>0.083</td><td>32M</td><td>0.7G</td><td>0.22s</td></tr><tr><td>Ours (1-HG)</td><td>0.071</td><td>16M</td><td>2.8G</td><td>0.61s</td></tr><tr><td>Ours (corr)</td><td>0.135</td><td>25M</td><td>1.8G</td><td>0.32s</td></tr><tr><td>Ours</td><td>0.062</td><td>32M</td><td>2.8G</td><td>0.69s</td></tr></table>
+
+In ours(1-HG) we replace the feature extractor with a single 2D-hourglass network, and replace the stereo network with a single 3D-hourglass network. The shallower network still performs well, but causes Abs-Rel to increase from 0.065 to 0.071, showing that stacking hourglass networks is beneficial for performance. In ours (1/2 res) we test the performance of DeepV2D when images are downsampled to 1/2 resolution for training and inference. Using lower resolution images decreases memory usage and inference time but slightly decreases accuracy.
+
+We also test a version where we replace the 3d stereo network with a correlation layer and 2d encoder-decoder. In ours(corr), we take the correlation between features over the same depth range as we use to build the 3D cost volume, then concatenate the correlation response with features from the keyframe image, similar to DispNet (Mayer et al., 2016b). The correlation version performs worse, increasing Abs-Rel from 0.065 to 0.135. This is consistent with prior work which has demonstrated that 3D cost volumes give better performance than direct correlation (Kendall et al., 2017; Chang & Chen, 2018).
+
+# D ADDITIONAL TRACKING INFORMATION
+
+In Table 7 we report tracking results for all sequences in the Freiburg 1 dataset.
+
+Table 7: Per-Sequence tracking results on the RGB-D benchmark evaluated using translational RMSE $[ \mathrm { m } / \mathrm { s } ]$ . We outperform DeepTAM and DVO on 12 of the 16 sequences and achieve a lower translational RMSE averaged over all sequences. While DeepTAM requires optical flow supervision to achieve good performance, we do not require supervision on optical flow since the relation between camera motion and optical flow is embedded into our network architecture.   
+
+<table><tr><td> Sequence</td><td>RGB-D SLAM</td><td>DeepTAM</td><td>Ours</td></tr><tr><td>360</td><td>0.119</td><td>0.063</td><td>0.056</td></tr><tr><td>360(v)</td><td>0.125</td><td>0.054</td><td>0.046</td></tr><tr><td>desk</td><td>0.030</td><td>0.033</td><td>0.029</td></tr><tr><td>desk(v)</td><td>0.037</td><td>0.027</td><td>0.034</td></tr><tr><td>desk2</td><td>0.055</td><td>0.046</td><td>0.041</td></tr><tr><td>desk2(v)</td><td>0.020</td><td>0.017</td><td>0.017</td></tr><tr><td>floor</td><td>0.090</td><td>0.081</td><td>0.064</td></tr><tr><td>plant</td><td>0.036</td><td>0.027</td><td>0.019</td></tr><tr><td>plant(v)</td><td>0.062</td><td>0.057</td><td>0.052</td></tr><tr><td>room</td><td>0.048</td><td>0.040</td><td>0.047</td></tr><tr><td>room(v)</td><td>0.042</td><td>0.039</td><td>0.032</td></tr><tr><td>rpy</td><td>0.043</td><td>0.046</td><td>0.039</td></tr><tr><td>rpy(v)</td><td>0.082</td><td>0.065</td><td>0.037</td></tr><tr><td>teddy</td><td>0.067</td><td>0.059</td><td>0.043</td></tr><tr><td>Xyz</td><td>0.051</td><td>0.019</td><td>0.025</td></tr><tr><td>xyz(v)</td><td>0.024</td><td>0.017</td><td>0.016</td></tr><tr><td>Average</td><td>0.058</td><td>0.043</td><td>0.037</td></tr></table>
+
+# E CAMERA POSE ABLATIONS
+
+The focus of this work on depth estimation, but we are interested in how different methods for estimating camera pose impact the final performance. In Table 8, we test different methods for estimating camera pose on NYU. In each experiment, we replace the motion module of our trained network with the given alternative, and test the final results. We also report results from MVSNet (trained on NYU) using each SfM implementation.
+
+COLMAP (Schonberger & Frahm, 2016a) and OpenMVG (Moulon et al.) are publicly available SfM implementations. They do not return results on all input sequences, so we only evaluate sequences were they converge without an error. PWCNet+Ceres takes the output of an optical flow network, PWCNet (Sun et al., 2018), and performs joint optimization of depth and pose using the Ceres solver (Agarwal et al., 2012). Finally, we evaluate MVSNet (Yao et al., 2018) when the pose predicted by DeepV2D is given as input. Note that not all SfM implementations converge on all sequences (success rate is reported in parenthesis) and we only evaluate the method on the frames in which it converges.
+
+<table><tr><td>Depth</td><td>Motion</td><td>Abs-Rel ↓ 81↑</td><td>S↑</td><td>8↑</td></tr><tr><td>MVSNet DeepV2D MVSNet</td><td>Identity Identity COLMAP (274/654)</td><td>0.419 0.382 0.362 0.460 0.244 0.724</td><td>0.681 0.756 0.857</td><td>0.859 0.901 0.925</td></tr><tr><td>DeepV2D MVSNet</td><td>COLMAP OpenMVG(422/654)</td><td>0.199 0.741 0.181 0.766</td><td>0.878 0.913</td><td>0.940 0.965</td></tr><tr><td>DeepV2D MVSNet</td><td>OpenMVG PWC+Ceres (654/654)</td><td>0.173 0.774 0.279 0.651</td><td>0.913 0.845</td><td>0.963 0.925</td></tr><tr><td>DeepV2D MVSNet</td><td>PWC+Ceres DeepV2D (654/654) DeepV2D (ours)</td><td>0.274 0.664 0.101 0.885</td><td>0.846 0.970</td><td>0.925 0.990</td></tr></table>
+
+Table 8: Impact of pose estimation method on depth accuracy. Replacing our motion module with SfM degrades performance for both MVSNet and our approach.
+
+We also show results of our method when the motion module is replaced with other methods for estimation motion. In all cases, using SfM results in worse performance. We observe that classical SfM is not robust enough to consistently produce accurate poses, which leads to large errors on the test set. MVSNet performs better using the poses estimated by our network, but still underperforms our full system, showing the importance of differentiable alternation between pose and stereo.
+
+![](images/b44a3b49655e2f4fc325dbf4b130dd3281f78e41be8dac9faac857f625bda02a.jpg)  
+Figure 6: Visualizations of depth predictions on KITTI dataset.
+
+![](images/b98ffb644e035d6c18d74a2721529a8b9d49988982c81550b90de9ff7340b4c9.jpg)  
+Figure 7: Additional results on the NYU depth dataset Silberman et al. (2012) using 7-frame video clips. We show results compared with Laina et al. (2016) and Ummenhofer et al. (2017).
+
+# G NETWORK ARCHITECTURES
+
+![](images/f884603164e769ba0c5c6e24b87c81601c5702b8b6f6f4bc74f93937dfe2a34d.jpg)  
+Figure 8: Motion Module Architecture: The Encoder(left) extracts a dense 1/4 resolution feature map for each of the input images. The Residual Flow Network (right) takes in a pair of feature maps and estimates the residual flow and corresponding weights. This residual flow is estimated with an encoder-decoder network, with skip connections formed by concatenating feature maps. Numbers in parenthesis correspond to the number of output channels for each layer.
+
+![](images/ab2bb216c977d9d7c8d8565b68d9a4e5f34a434a39c383a2c427c398dc87cee8.jpg)  
+Figure 9: Depth Module Architecture: The 2D encoder (top) is applied to each image in the video sequence. The 2D Encoder consists of a series of residual convolutions and 2 Hourglass Networks. The hourglass networks process the incoming features maps as multiple scales. The hourglass network is defined recursively (i.e. HG(n) contains lower resolution hourglass HG(n-1)). We use 4 nested hourglass modules with feature dimension 64-128-192-256. The resulting feature maps from the 2D encoder are used to construct the cost volumes. The 3D matching network (bottom) takes a collection of cost volumes as input. After a 1x1x1 convolutional layer and a $3 \mathrm { x } 3 \mathrm { x } 3 $ residual convolution, we perform view pooling, which aggregates information over all the frames in the video. The aggregated volume is then processed by a series of 3D hourglass networks, each of which outputs an intermediate depth estimate. The widths of the 3D hourglass is 32-80-128-176.

parse/train/SyxZOsA9tX/SyxZOsA9tX.md

@@ -0,0 +1,424 @@
+# ACCELERATED VALUE ITERATION VIA ANDERSON MIXING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Acceleration for reinforcement learning methods is an important and challenging theme. We introduce the Anderson acceleration technique into the value iteration, developing an accelerated value iteration algorithm that we call Anderson Accelerated Value Iteration (A2VI). We further apply our method to the Deep Q-learning algorithm, resulting in the Deep Anderson Accelerated Q-learning (DA2Q) algorithm. Our approach can be viewed as an approximation of the policy evaluation by interpolating on historical data. A2VI is more efficient than the modified policy iteration, which is a classical approximate method for policy evaluation. We give theoretical analysis of our algorithm and conduct experiments on both toy problems and Atari games. Both the theoretical and empirical results show the effectiveness of our algorithm.
+
+# 1 INTRODUCTION
+
+In reinforcement learning (Sutton & Barto, 1998), an agent seeks for the optimal policy in a specific sequential decision problem. Several algorithms have been proposed over the course of time, including the famous Q-learning (Watkins & Dayan, 1992), SARSA (Rummery & Niranjan, 1994; Sutton & Barto, 1998), and policy gradient methods (Sutton et al., 2000). In complicated decision problems where tabular representations are intractable, function approximations are usually used for estimating state-action values (Kaelbling et al., 1996; Sutton & Barto, 1998; Sutton et al., 2000). Inspired by the success of deep learning, Deep Q-Learning (DQN) (Mnih et al., 2013) and its variants (Bellemare et al., 2017; Schaul et al., 2015; Van Hasselt et al., 2016; Wang et al., 2015) utilize a deep neural network as the value approximator, which has successfully solved end-to-end decision problems such as Atari2000.
+
+The value iteration (VI) Bellman (1957) and policy iteration (PI) (Howard, 1964) are the most classical methods for value updating. The main difference between them is that PI evaluate the current policy accurately during the iteration while VI does not. Thanks to the accurate evaluation of the current policy, policy iteration uses significantly less policy improvement steps to converge to the optimal value. Although PI has a faster convergence rate than VI, most of the existing methods employ a rather slow value iteration procedure, because thoroughly evaluating a policy is costly or even intractable under complex environments. To retain the fast convergence property of policy iteration while reducing its computation overhead, researchers have proposed several modifications to the original policy iteration (Alla et al., 2015; Puterman, 1994). The modified policy iteration (MPI) method (Puterman, 1994) tries to deal with this problem by approximating the solution to policy evaluation via the truncated Neumann expansion of an inverse matrix. However, this approximation requires extra iterative steps, which is still computationally inefficient for complex decision problems where sampling is costly, compared with the value iteration procedure where the policy iteration step is skipped.
+
+Interpolation methods have been widely used in first order optimization problems (Bubeck et al., 2015; Scieur et al., 2016; 2017; Xie et al., 2018). These methods extract information from historical data and are proven to converge faster than vanilla gradient methods. However, the interpolation method is not widely applied in reinforcement learning. The most recent work related to interpolation is the averaged-DQN (Anschel et al., 2016), which calculates the average Q-value over the history and demonstrated that such an operation is effective for variance reduction.
+
+Acceleration in value iteration and policy iteration has attracted researchers’ great attention. Classical methods for accelerating value iteration include Gauss-Seidel value iteration (Puterman, 1994) and Jacobi value iteration (JAC) (Puterman, 1994). More recently, Alla et al. (2015) proposed an acceleration method that switches between a coarse-mesh value iteration and a fine-mesh policy iteration during different stages. Laurini et al. (2016) performed a Jacobi-like acceleration method on dynamic programming problems. In a recent work (Laurini et al., 2017), the value iteration procedure is accelerated by only updating a part of the values. None of the previous methods have proposed acceleration methods with an application of interpolation.
+
+In this paper, to solve the policy evaluation problem more efficiently, we propose an alternative algorithm based on multi-step interpolation. Explicitly, the solution to the policy evaluation problem is approximately represented by a weighted combination of historical values, whose weights are adaptively updated by an optimization procedure. To reduce the computational complexity, we resort to the Anderson mixing method (Anderson, 1965; Walker & Ni, 2011; Toth & Kelley, 2015) to do the approximation with only a short length of history. Our approach fits the gap between value iteration and policy iteration, ending in an updating rule without adding much extra computational complexity to the original value iteration procedure. We also extend this approach to deep reinforcement learning problems.
+
+The remainder of this paper is organized as follows. In Section 2, we introduce the foundations of reinforcement learning and present typical value updating algorithms. In Section 3, we derive the Anderson accelerated methods. In Section 4, we give a theoretical analysis of the convergence of our method. In Section 5, we test our method in different environments and empirically show the effectiveness of it. Finally, we conclude our work in Section 6.
+
+# 2 PRELIMINARIES
+
+In this paper we mainly consider a finite-state and finite-action scenario in reinforcement learning. In this case, an Markov Decision Process (MDP) system is defined by a 5-tuple $( S , { \mathcal { A } } , P , r , \gamma )$ , where $s$ is a finite state space, $\mathcal { A }$ is a finite action space, $P \in \mathbb { R } ^ { ( | S | \times | A | ) \times | S | }$ is the collection of state-to-state transition probabilities, $\pmb { r } \in \mathbb { R } ^ { | S | \times | \mathcal { A } | }$ is the reward matrix, $\gamma$ is the discount factor. A policy $\pi \in { \mathcal { A } } ^ { | s | }$ is a vector of actions at each state. The transition matrix $P _ { \pi } \in \mathbb { R } ^ { | S | \times | S | }$ and reward vector $\boldsymbol { r } _ { \pi } \in \mathbb { R } ^ { | \boldsymbol { S } | }$ under policy $\pi$ are defined as $P _ { \pi } ( i , j ) = P ( ( i , \pi ( i ) ) , j ) , r _ { \pi } ( i ) = r ( i , \pi ( i ) )$ . We further define the value $\pmb { v } ^ { \pi } \in \mathbb { R } ^ { | \mathcal { S } | }$ and the $\mathbf { Q }$ -value $\pmb { q } ^ { \pi } \in \mathbb { R } ^ { | S | \times | \mathcal { A } | }$ under a given MDP and policy, where each element of $\pmb { v } ^ { \pi }$ and $\pmb q ^ { \pi }$ is defined as
+
+$$
+\begin{array} { l } { { \pmb v } ^ { \pi } ( s ) = \mathbb { E } _ { s _ { 0 } = s , s _ { t + 1 } \sim P _ { \pi } ( s _ { t } , \ldots ) } \displaystyle \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } { \pmb r } _ { \pi } ( s _ { t } ) , } \\ { \pmb q ^ { \pi } ( s , a ) = { \pmb r } ( s , a ) + \mathbb { E } _ { s _ { 1 } \sim P ( ( s , a ) , \ldots ) , s _ { t + 1 } \sim P _ { \pi } ( s _ { t } , \ldots ) } \displaystyle \sum _ { t = 1 } ^ { \infty } \gamma ^ { t } { \pmb r } _ { \pi } ( s _ { t } ) . } \end{array}
+$$
+
+We can verify that $\pmb q ^ { \pi } = \pmb r + \gamma P \pmb v ^ { \pi }$ . We define $\pmb { q } _ { \tilde { \pi } } ^ { \pi } \in \mathbb { R } ^ { | s | }$ by $\pmb { q } _ { \tilde { \pi } } ^ { \pi } ( i ) = \pmb { q } ^ { \pi } ( i , \tilde { \pi } ( i ) )$ , and say a vector to be the maximum among a set if each entry of it is bigger than that of the other vectors. The values satisfy the Bellman equation:
+
+$$
+\pmb { v } ^ { \pi } = \Gamma _ { \pi } \big ( \pmb { v } ^ { \pi } \big ) = \pmb { r } _ { \pi } + \gamma P _ { \pi } \pmb { v } ^ { \pi } .
+$$
+
+The policy $\pi ^ { * } = \arg \operatorname* { m a x } _ { \pi } { \pmb q } ^ { \pi }$ is called the optimal policy, whose value or $\mathrm { Q }$ -value is denoted as $v ^ { * }$ or $\pmb q ^ { * }$ . Note that $v ^ { * }$ satisfies the Bellman optimality equation
+
+$$
+\pmb { v } ^ { * } = \Gamma ( \pmb { v } ^ { * } ) = \operatorname* { m a x } _ { \pi } ( \pmb { r } _ { \pi } + \gamma P _ { \pi } \pmb { v } ^ { * } ) .
+$$
+
+Therefore, finding the optimal policy is equivalent to finding the fixed point of the operator $\Gamma ( v )$ .
+
+# 2.1 FIXED POINT ITERATION METHODS
+
+Value iteration (VI) is the most widely used and best-understood algorithm for solving Markov decision problems. It solves the fixed point problem by iterating the following steps repeatedly,
+
+$$
+\pmb { v } ^ { ( t + 1 ) } = \Gamma ( \pmb { v } ^ { ( t ) } ) = \operatorname* { m a x } _ { \pi } ( \pmb { r } _ { \pi } + \gamma P _ { \pi } \pmb { v } ^ { ( t ) } ) .
+$$
+
+An alternative solution is policy iteration (PI), which maintains both the value ${ \pmb v } ^ { ( t ) }$ and the policy $\pi ^ { ( t ) }$ during each iteration. The procedure alternatively iterates the following two steps:
+
+• Policy evaluation: Find a ${ \pmb v } ^ { ( t ) }$ such that
+
+$$
+\pmb { v } ^ { ( t ) } = \Gamma _ { \pi ^ { ( t ) } } \big ( \pmb { v } ^ { ( t ) } \big ) = \pmb { r } _ { \pi ^ { ( t ) } } + \gamma P _ { \pi ^ { ( t ) } } \pmb { v } ^ { ( t ) } ,
+$$
+
+which can be directly computed by
+
+$$
+{ \pmb v } ^ { ( t ) } = ( I - \gamma P _ { \pi ^ { ( t ) } } ) ^ { - 1 } { \pmb r } _ { \pi ^ { ( t ) } } .
+$$
+
+• Policy improvement: Improve the current policy by
+
+$$
+\pi ^ { ( t + 1 ) } = \underset { \pi } { \operatorname { a r g m a x } } ( \pmb { r } _ { \pi } + \gamma P _ { \pi } \pmb { v } ^ { ( t ) } ) .
+$$
+
+Theoretical analysis has shown that VI enjoys a $\gamma$ -linear convergence rate (i.e., $\| \pmb { v } ^ { ( t ) } - \pmb { v } ^ { * } \| _ { \infty } \leq \gamma \| \pmb { v } ^ { ( t - 1 ) } -$ $v ^ { * } \| _ { \infty } )$ , while PI converges much faster with $\| \pmb { v } ^ { ( t ) } - \pmb { v } ^ { * } \| _ { \infty } \leq K \| \pmb { v } ^ { ( t - 1 ) } - \pmb { v } ^ { * } \| _ { \infty } ^ { 2 }$ (Puterman, 1994), where $K$ is some constant related with $\gamma$ and the given MDP. Both VI and PI are model-based, because the greedy policy cannot be determined when $\mathbfit { \Delta } \mathbf { r }$ and $P$ are unknown. The VI under $\pmb q$ -notation is well-known as Q-learning (Watkins & Dayan, 1992). We will analyze our method under $\textbf {  { v } }$ -notation, but our analysis also works under the corresponding $\pmb q$ -notation.
+
+The main difference between VI and PI is whether the current policy is fully evaluated. Though PI converges faster than VI, this advantage diminishes under several settings. In reinforcement learning, we can only access an oracle that returns the reward and next state given the current state and selected action. Under such a setting, each value iteration step can be performed by estimating $\Gamma ( v )$ through sampling. But the policy evaluation step based on equation (2) becomes intractable because it is quite time-consuming to compute $( I - \gamma P _ { \pi ^ { ( t ) } } ) ^ { - \mathbf { \bar { 1 } } }$ . The modified policy iteration method (Puterman & Brumelle, 1978) partially solves the problem by setting ${ \pmb v } ^ { t } \approx ( \Gamma _ { \pi ^ { ( t ) } } ) ^ { m _ { t } } ( { \pmb v } ^ { ( t - 1 ) } )$ where $m _ { t }$ is a (possibly large) integer related to $t$ . However, this method requires to evaluate a series of values $( \Gamma _ { \pi ^ { ( t ) } } ) ^ { i } \big ( { \pmb v } ^ { ( t - 1 ) } \big )$ for $i = 1 , 2 , \dots , m _ { t }$ , which is computationally inefficient.
+
+# 3 ANDERSON ACCELERATED VALUE ITERATION
+
+Based on the observation that full policy evaluation accelerates convergence, we propose an approximate policy evaluation method. The method aims to approximately solve the policy evaluation problem, circumventing the matrix inversion and iterative procedures mentioned above.
+
+We first utilize the linearity of equation (1), defining $B _ { \pi } ( { \pmb v } ) \ = \ \Gamma _ { \pi } ( { \pmb v } ) - { \pmb v }$ and converting the problem into an equivalent form of solving the equation $B _ { \pi } ( \pmb { v } ) = \mathbf { 0 }$ . Suppose we have obtained a set of values $B _ { \pi } ( { \pmb v } ^ { 1 } ) , B _ { \pi } ( { \pmb v } ^ { 2 } ) , \ldots , B _ { \pi } ( { \pmb v } ^ { k } )$ with respect to $\pmb { v } ^ { 1 } , \pmb { v } ^ { 2 } , \ldots , \pmb { v } ^ { k }$ . Consider to find a set of weights ${ \pmb { \alpha } } = ( \alpha _ { 1 } , \alpha _ { 2 } , \ldots , \alpha _ { k } ) ^ { T }$ , subject to $\textstyle \sum _ { i = 1 } ^ { k } \alpha _ { i } = 1$ , which satisfies that
+
+$$
+\sum _ { i = 1 } ^ { k } \alpha _ { i } B _ { \pi } ( { \pmb v } ^ { i } ) = { \bf 0 } .
+$$
+
+Then the combination $\begin{array} { r } { \tilde { \pmb { v } } = \sum _ { i = 1 } ^ { k } \alpha _ { i } \pmb { v } ^ { i } } \end{array}$ will satisfy the following relationship:
+
+$$
+\begin{array} { l } { { \displaystyle B _ { \pi } ( { \tilde { \pmb v } } ) = { \pmb r } _ { \pi } + \gamma P _ { \pi } { \tilde { \pmb v } } - { \tilde { \pmb v } } = \sum _ { i = 1 } ^ { k } \alpha _ { i } ( { \pmb r } _ { \pi } + \gamma P _ { \pi } { \pmb v } ^ { i } - { \pmb v } ^ { i } ) } } \\ { { \displaystyle ~ = \sum _ { i = 1 } ^ { k } \alpha _ { i } B _ { \pi } ( { \pmb v } ^ { i } ) = { \bf 0 } } . } \end{array}
+$$
+
+This relation implies $\tilde { v }$ can be viewed as an approximate solution to equation (1) provided the sampling estimations are accurate enough. However, this step needs to keep track of the previous values and recompute $\Gamma _ { \pi }$ on all of them. To reduce the huge memory usage and computation, we choose $v ^ { i }$ from the recent history, i.e., $\pmb { v } ^ { i } = \pmb { v } ^ { ( t - i ) } , i = 1 , 2 , . . . , \bar { } { k }$ , and replace $B _ { \pi ^ { ( t ) } } ( \pmb { v } ^ { ( t - \bar { i } ) } )$ with the previously computed values $B _ { \pi ^ { ( t - i ) } } ( { \pmb v } ^ { ( t - i ) } )$ . This modification is based on the observation that the recent successive policies do not change sharply and therefore $B _ { \pi ^ { ( t - i ) } } ( \pmb { v } ^ { ( t - i ) } ) \approx B _ { \pi ^ { ( t ) } } ( \pmb { v } ^ { ( t - i ) } )$ . This modification approximately solves the policy evaluation problem without model estimation or extra function evaluations.
+
+Another critical issue is that we cannot guarantee the existence of $_ { \pmb { \alpha } }$ given that $k$ is small, because the dimension of $B _ { \pi } ( \pmb { v } )$ is usually much higher than $k$ . Inspired by the Anderson acceleration technique ega, $\&$ Rheinboldt, 1970; Walker & Ni, 2011), we instead look for a combination of $\{ B _ { \pi ^ { ( t - i ) } } ( { \pmb v } ^ { ( t - i ) } ) \} _ { i = 1 } ^ { k }$
+
+$$
+\pmb { \alpha } ^ { ( t ) } = \underset { \pmb { \alpha } \in \Omega \cap \Lambda } { \mathrm { a r g m i n } } \| \boldsymbol { B } ^ { ( t ) } \pmb { \alpha } \| ,
+$$
+
+where $B ^ { ( t ) } = \big ( B _ { \pi ^ { ( t - 1 ) } } \big ( \pmb { v } ^ { ( t - 1 ) } \big ) , B _ { \pi ^ { ( t - 2 ) } } \big ( \pmb { v } ^ { ( t - 2 ) } \big ) , \dots , B _ { \pi ^ { ( t - k ) } } \big ( \pmb { v } ^ { ( t - k ) } \big ) \big )$ , $\Omega = \{ \pmb { \alpha } | \mathbf { 1 } ^ { T } \pmb { \alpha } = 1 \}$ , $\Lambda$ is an extra constraint on the values attainable by $_ { \pmb { \alpha } }$ . Typically, $\Lambda$ can be chosen from the following forms:
+
+• Total space, $\Lambda _ { \mathrm { t o t } } = \mathbb { R } ^ { k }$ ; • Boxing constraint, $\Lambda _ { \mathrm { b o x } } = \{ { \pmb \alpha } | - m { \bf 1 } \le { \pmb \alpha } \le m { \bf 1 } \}$ ; • Convex combination constraint, $\Lambda _ { \mathrm { c v x } } = \{ \alpha | \mathbf { 0 } \leq \alpha \leq 1 \}$ ; • Extrapolation constraint, $\Lambda _ { \mathrm { e x p } } = \{ \alpha | \alpha _ { 1 } \geq 1 , \alpha _ { i } \leq 0 , i = 2 , 3 , \ldots , k \} .$
+
+When the $\ell _ { 2 }$ norm is used and $\begin{array} { r c l } { \Lambda } & { = } & { \Lambda _ { \mathrm { t o t } } } \end{array}$ , the solution can be written explicitly as $\begin{array} { r l } { \alpha ^ { ( t ) } } & { { } = } \end{array}$ $[ ( B ^ { ( t ) } ) ^ { \top } B ^ { ( t ) } ] ^ { - 1 } { \bf 1 } / { \bf 1 } ^ { \top } [ ( B ^ { ( t ) } ) ^ { \top } B ^ { ( t ) } ] ^ { - 1 } { \bf 1 }$ , whose derivation is placed in the appendix. Note that if we simply set $\begin{array} { r } { \pmb { v } ^ { ( t ) } = \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \pmb { v } ^ { ( t - i ) } } \end{array}$ , the values will always locate in the subspace expanded by historical values $\pmb { v } ^ { ( t - 1 ) } , \pmb { v } ^ { ( t - 2 ) } , \pmb { \dots } , \pmb { v } ^ { ( t - k ) }$ . When the solution to equation (1) does not lie in such a subspace, there is no hope for convergence with application of such updating rule directly. To jump out of the subspace, we perform an extra value iteration step to this combination. Then we will get the updated value,
+
+$$
+\pmb { v } ^ { ( t ) } = \operatorname* { m a x } _ { \pi } \bigg ( \pmb { r } _ { \pi } + \gamma P _ { \pi } \bigg [ \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \pmb { v } ^ { ( t - i ) } \bigg ] \bigg ) .
+$$
+
+Based on our previous discussion, we present the $k$ -step Anderson Accelerated Value Iteration (A2VI) in Algorithm 1. In the first $k$ steps, the value is updated according to the original VI. Otherwise, we perform an interpolation procedure, where the weights are attained from solving the problem (5). The original value iteration algorithm can be viewed as a special case of our algorithm with $k = 1$ .
+
+# Algorithm 1 Anderson Accelerated Value Iteration (A2VI)
+
+Input: ${ \pmb v } ^ { ( 0 ) } , P , { \pmb r } , \gamma , k , T$   
+1: for $t = 1 , 2 , \dots , T$ do   
+2: $\begin{array} { r l } & { ~ B _ { \pi ^ { ( t - 1 ) } } \big ( \pmb { v } ^ { ( t - 1 ) } \big ) = \underset { \pi } { \operatorname* { m a x } } \big ( \pmb { r } _ { \pi } + \gamma P _ { \pi } \pmb { v } ^ { ( t - 1 ) } \big ) - \pmb { v } ^ { ( t - 1 ) } } \\ & { ~ \mathbf { i f } t < k \mathbf { t h e n } } \\ & { ~ \pmb { v } ^ { ( t ) } = \underset { \pi } { \operatorname* { m a x } } \big ( \pmb { r } _ { \pi } + \gamma P _ { \pi } \pmb { v } ^ { ( t - 1 ) } \big ) } \end{array}$   
+3:   
+4:   
+5: 6: els $( \alpha _ { 1 } ^ { ( t ) } , \alpha _ { 2 } ^ { ( t ) } , \ldots , \alpha _ { k } ^ { ( t ) } )$ optimization problem (5)   
+$\begin{array} { r } { \pmb { v } ^ { ( t ) } = \underset { \pi } { \operatorname* { m a x } } \left( \pmb { r } _ { \pi } + \gamma P _ { \pi } \left[ \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \pmb { v } ^ { ( t - i ) } \right] \right) } \end{array}$   
+8: end if   
+9: end for   
+10: $\begin{array} { r } { \pi ^ { ( T ) } = \mathrm { a r g m a x } _ { \pi } ( \pmb { r } _ { \pi } + \gamma P _ { \pi } \pmb { v } ^ { ( T ) } ) } \end{array}$   
+11: return v(T ), π(T )
+
+Both Anderson Acceleration (AA) and A2VI have the same spirit of interpolating on historical data. However, A2VI does not straightforwardly apply AA to the Bellman optimality equation. Note that AA has the updating rule $\begin{array} { r } { \pmb { v } ^ { t } = \sum \alpha _ { i } B ( \mathbf { \bar { v } } ^ { t - i } ) } \end{array}$ , while A2VI exchange the order of the operator sum and $B ( \cdot )$ due to the motivation from equation (3). This exchange puts the nonsmooth operator max out of the affine combination, simplifying the theoretical analysis.
+
+We present a geometric explanation on the iterative steps of VI, PI, A2VI under 1-dimensional case in Figure 1. In value iteration, ${ \pmb v } ^ { ( t ) }$ is attained by making a vertical line at $( \pmb { v } ^ { ( t - 1 ) } , \mathbf { 0 } )$ , finding its intersection with the function line at $( \pmb { v } ^ { ( t - 1 ) } , \boldsymbol { B } ( \pmb { v } ^ { ( t - 1 ) } ) )$ , then drawing a line with slope $- 1$ through $( \pmb { v } ^ { ( t - 1 ) } , \boldsymbol { B } ( \pmb { v } ^ { ( t - 1 ) } ) )$ and finding its intersection with the horizon axis at $( \pmb { v } ^ { ( t ) } , \mathbf { 0 } )$ ; In policy iteration, ${ \pmb v } ^ { ( t ) }$ is attained by first getting $( \pmb { v } ^ { ( t - 1 ) } , \boldsymbol { B } ( \pmb { v } ^ { ( t - 1 ) } ) )$ in the same way as value iteration, then calculating the tangent line through $( \pmb { v } ^ { ( t - 1 ) } , \boldsymbol { B } ( \pmb { v } ^ { ( t - 1 ) } ) )$ and finding its intersection with the horizon axis. In Anderson accelerated value iteration, each step is first performed in a similar style to policy iteration except that the tangent line is replaced with a secant line. Then a value iteration step is performed to get ${ \pmb v } ^ { ( t ) }$ .
+
+From the figure, we can see that VI only utilizes the current value of the Bellman residual, while PI is similar to Newton’s method Puterman & Brumelle (1978), utilizing the gradient information to achieve a faster convergence rate. Our method serves as an intermediate between them, each step of which is composed of an ordinary value iteration step and a secant step. In specific, the replacement of the tangent line to a secant line can be viewed as a quasi-Newton’s method, which is shown computationally more efficient while keeping a fast convergence rate in several particular settings. Both PI and A2VI converge to the fixed point in a smaller number of steps than VI. Compared with PI, A2VI is more practical because it approximates the tangent line by a secant line, which circumvents the costly model estimation step.
+
+# 3.2 EXTENSION TO MODEL-FREE LEARNING ALGORITHM
+
+We can rewrite our algorithm under $\pmb q$ -notation, and get the Anderson Accelerated Q-Learning (A2Q) Algorithm shown in the appendix. Combined with the technique of deep learning, our method can be applied to end-to-end decision problems, resulting in the Deep Anderson Accelerated Q-Learning (DA2Q) Algorithm (Algorithm 2).
+
+![](images/3d826ac40fe3871114092087e3a974454909cd376bd18804a2efe437f1f2ec83.jpg)  
+Figure 1: Geometric interpolation of VI, PI and A2VI.
+
+# Algorithm 2 Deep Anderson Accelerated Q-learning (DA2Q)
+
+<table><tr><td>Input:M,N,T,γ,b,B,ε,n,K,C</td><td>1: Initialize replay memory D to capacity N,initialize Q-value function Q with random weights θ 2:0-k=0,α1=1,αk=0 fork=2,...,K</td></tr><tr><td>3:s=0 4: for episode =1,2,..., M do</td><td></td></tr><tr><td>5:</td><td>Initialize s1 ~ p(s)</td></tr><tr><td>6:</td><td></td></tr><tr><td></td><td>for t=1,2,...,Tdo</td></tr><tr><td>7:</td><td>With probability ε select a random action at,otherwise select at = arg maxa Q(st, a; 0)</td></tr><tr><td>8:</td><td>Execute action at, observe reward rt and state St+1</td></tr><tr><td>9:</td><td>Store transition (St,at,rt,St+1) in D</td></tr><tr><td>10:</td><td>Sample a random minibatch of transitions {(sj,αj,rj,s&#x27;)}=1 from D</td></tr><tr><td>11:</td><td>forj=1,2,...,b do</td></tr><tr><td></td><td>rj for terminal state</td></tr><tr><td>12:</td><td>K</td></tr><tr><td></td><td>yj= M xQ（s,(_)) rj+ymax for non-terminal state a</td></tr><tr><td>13:</td><td>Ak=1 end for</td></tr><tr><td>14:</td><td>L(θ)= 1b j=1(yj -Q(sj,aj;0))²</td></tr><tr><td>15:</td><td>b j aL</td></tr><tr><td>16:</td><td>0=θ-n</td></tr><tr><td>17:</td><td>s=s+1</td></tr><tr><td></td><td>if s mod C= O then</td></tr><tr><td>18:</td><td>Assign0-k =0-(k-1) fork=K,K-1,...,2.Assign0-1=0.</td></tr><tr><td>19:</td><td>if s≥K(C-1) then</td></tr><tr><td>20:</td><td>Sample a random minibatch of transitions {(sj,αj,Tj,s&#x27;)}=1 from D</td></tr><tr><td>21:</td><td>for j=1,2,...,B do</td></tr><tr><td>22:</td><td>for k=1,2,...,K do</td></tr><tr><td></td><td></td></tr><tr><td>23:</td><td>rj-Q(sj,aj;0-k) d</td></tr><tr><td></td><td>𝑟j + γ maxQ(s&#x27;,α;0_k)- Q(sj,αj; 0-k)for non-terminal state</td></tr><tr><td>24:</td><td>α</td></tr><tr><td></td><td>end for</td></tr><tr><td>25:</td><td>end for</td></tr><tr><td>26:</td><td>end if</td></tr><tr><td>27:</td><td>(α1,2.,αk)= argmin(a2a)∑𝑗=1(∑=1kd)² s. ∑1a =1</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>28:</td><td></td></tr><tr><td></td><td>end if</td></tr><tr><td>29:</td><td></td></tr><tr><td></td><td>end for</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>30:</td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>end for</td><td></td></tr></table>
+
+# 4 THEORETICAL ANALYSIS
+
+We first analyze of the local convergence of the A2VI algorithm under boxing constraint. Our result shows that in a small neighborhood of the optimal value, our algorithm enjoys an exponential convergence rate.
+
+Theorem 1. For any MDP with a unique optimal policy, there exists some $\delta > 0$ , such that for any initial value ${ \pmb v } ^ { ( 0 ) } \in U _ { \delta } ( { \pmb v } ^ { * } ) = \{ { \pmb v } | \| { \pmb v } - { \pmb v } ^ { * } \| _ { \infty } ^ { - } \leq \bar { \delta } \}$ , the A2VI algorithm under boxing constraint maintains the following properties:
+
+$$
+\begin{array} { r l } & { \| \Gamma ( \pmb { v } ^ { ( t ) } ) - \pmb { v } ^ { ( t ) } \| _ { \infty } \leq \gamma \| \Gamma ( \pmb { v } ^ { ( t - 1 ) } ) - \pmb { v } ^ { ( t - 1 ) } \| _ { \infty } , \forall t = 1 , 2 , . . . ; } \\ & { \| \pmb { v } ^ { ( t ) } - \pmb { v } ^ { * } \| _ { \infty } \leq \frac { \gamma ^ { t } } { 1 - \gamma } \| \Gamma ( \pmb { v } ^ { ( 0 ) } ) - \pmb { v } ^ { ( 0 ) } \| _ { \infty } , \forall t = 1 , 2 , . . . } \end{array}
+$$
+
+Generally, it is difficult to obtain the global convergence rate of A2VI, since the operation max is nonsmooth. To guarantee the convergence, we introduce a rejection step to the original algorithm. We say $\pmb { v }$ is monotonic improving if $\Gamma ( v ) \geq v$ , and denote the set of such values as $V _ { B }$ . We propose the A2VI algorithm with the rejection step, which only differs with Algorithm 1 at line 6. After calculating $\mathbf { \alpha } _ { \alpha } ( t )$ , we test whether the affine combination an ordinary $\scriptstyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { t - i }$ lies in tep. W $V _ { B }$ . If the answer is negative, the interpolation step will be replaced withut the pseudocode of A2VI with the rejection step in Appendix. With this modification, we can have the following convergence properties.
+
+Theorem 2. For the A2VI algorithm with the rejection step with $\Lambda = \Lambda _ { \mathrm { c v x } }$ , $i f v ^ { ( 0 ) } \in V _ { B }$ , then we have
+
+Theorem 3. For the A2VI algorithm with $\Lambda = \Lambda _ { \mathrm { e x p } }$ , $i f v ^ { 0 } \geq \mathbf { 0 }$ and ${ \pmb v } ^ { ( 0 ) } \in \ d V _ { B }$ , then we have
+
+(a) Monotone improving values, ${ \pmb v } ^ { ( t - 1 ) } \le { \pmb v } ^ { ( t ) } \le { \pmb v } ^ { * } , { \pmb v } ^ { ( t ) } \in V _ { B } , \forall t = 1 , 2 , . . .$ (b) $\gamma$ -linear convergence rate, $\begin{array} { r } { \| \pmb { v } ^ { * } - \pmb { v } ^ { ( t ) } \| _ { \infty } \leq \gamma \| \pmb { v } ^ { * } - \pmb { v } ^ { ( t - 1 ) } \| _ { \infty } } \end{array}$ .
+
+# 5 EXPERIMENTS
+
+To validate the effectiveness of our method, we conduct several experiments.
+
+# 5.1 EXPERIMENTS ON TOY MODELS
+
+We first test our method on three toy models. The first model is a randomly generated MDP with $\vert { \cal S } \vert = 1 0 0$ and $| { \cal A } | = 5 0$ . The transition probabilities of the MDP are generated from a uniform distribution on $[ 0 , 1 ]$ , and the rewards are generated from a standard normal distribution. The second model is the $N$ -Chain problem with $N = 1 0 0$ , where a reward of 0.1 is given at state 0 and a reward of 1 is given at state $N$ . At each state, the agent can either choose to move forward or backward, and will move to the selected direction with probability 0.9 and to the opposite direction with probability 0.1. The last model is a $2 0 \times 2 0$ Gridworld model, where a reward of 1 is given at state (20, 20). At each state, the agent can choose one of the 4 directions and will move to that direction with probability 0.7, or move to one of the other directions with probability 0.1 for each. We perform the standard value iteration, policy iteration and Anderson accelerated value iteration with/without the rejection step on these models. In our experiment, each policy iteration step is approximately solved by the modified policy iteration method with 100 inner iterations. To compare our method with the averaged updating scheme (Anschel et al., 2016), we further construct and compare our algorithm with the averaged value iteration. The value of $\lVert \boldsymbol { v } ^ { t } - \boldsymbol { v } ^ { * } \rVert$ w.r.t. step $t$ is shown in Figure 2, where the results are averaged from 30 independent experiments.
+
+From the results we can see that the policy iteration converges fastest for all of the three models, however, since each of its steps includes 100 inner iterations, the actual computation cost is very high. Among value iteration methods, the Anderson accelerated value iteration converges fastest. The acceleration effect is remarkable in randomly generated MDPs, but A2VI slows down at the first few steps in the latter two experiments. However, adding a rejection step solves the problem and attains a faster convergence rate. Another observation is that in the toy model case, the averaged value iteration cannot be used for acceleration.
+
+![](images/017e0eb5a1424b7b9e919b1e1dd435cf6a48f19d2d12ec966e5213abcc742ec6.jpg)  
+Figure 2: Experiment results on several toy models.
+
+5.2 EXPERIMENTS ON ATARI GAMES WITH DEEP LEARNING BASED TECHNIQUES
+
+To figure out the performance of our method on complex environments, we apply our method to Atari games from Gym (Brockman et al., 2016), which is a Python API to Arcade Learning Environment (Bellemare et al., 2013). We compare DA2Q with DQN (Mnih et al., 2013) and Averaged-DQN (Anschel et al., 2016). Details of the experiment settings are given in Appendix D.
+
+As Figure 3 points out, our algorithm DA2Q obtains a significant improvement over both the original DQN algorithm and the Averaged DQN algorithm. When compared with other interpolation method such as Averaged-DQN, the overall performance of our method also tends to be stabler, always being superior than other methods among all of the three environments, while the performance of Averaged-DQN varies a lot.
+
+![](images/4fe215b114bc3bb117d605d98e305992377703a24aeb1bd876d661d3dd8686b3.jpg)  
+Figure 3: Training Performance on Atari games, score is smoothed with 250 windows while the shaded area is the 0.25 standard deviation.
+
+Compared with DQN, the extra computational cost is actually low, since the $\alpha$ is updated only once every $C$ steps, which only involves an inversion on a very small-size matrix $( k \times k )$ . The $k$ target values are computed parallelly in the TensorFlow (Abadi et al., 2016), which cost the same time as in DQN. Moreover, the extra runtime can be ignored when compared with the costly back propagations and interaction with environments.
+
+# 6 CONCLUSION
+
+We have proposed the Anderson accelerated value iteration method, which is a novel acceleration approach for reinforcement learning. We have proved the convergence property of our method under certain conditions. Our algorithm empirically achieves a superior performance on toy models and several Atari games. Despite the success of our algorithm, several questions remain open. The convergence analysis for the general case is lacking, and we only provide convergence guarantees but do not give a theoretical analysis of the acceleration effect of A2VI, which we leave for future work.
+
+# REFERENCES
+
+Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: a system for large-scale machine learning. In OSDI, volume 16, pp. 265–283, 2016.   
+Alessandro Alla, Maurizio Falcone, and Dante Kalise. An efficient policy iteration algorithm for dynamic programming equations. SIAM Journal on Scientific Computing, 37(1):A181–A200, 2015.   
+Donald G Anderson. Iterative procedures for nonlinear integral equations. Journal of the ACM (JACM), 12 (4):547–560, 1965.   
+Oron Anschel, Nir Baram, and Nahum Shimkin. Averaged-dqn: Variance reduction and stabilization for deep reinforcement learning. arXiv preprint arXiv:1611.01929, 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.   
+Marc G Bellemare, Will Dabney, and Rémi Munos. A distributional perspective on reinforcement learning. arXiv preprint arXiv:1707.06887, 2017.   
+Richard Bellman. A markovian decision process. Journal of Mathematics and Mechanics, pp. 679–684, 1957.   
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.   
+Sébastien Bubeck et al. Convex optimization: Algorithms and complexity. Foundations and Trends $\textsuperscript { \textregistered }$ in Machine Learning, 8(3-4):231–357, 2015.   
+Ronald A Howard. Dynamic programming and markov processes. 1964.   
+Leslie Pack Kaelbling, Michael L Littman, and Andrew W Moore. Reinforcement learning: A survey. Journal of artificial intelligence research, 4:237–285, 1996.   
+Mattia Laurini, Piero Micelli, Luca Consolini, and Marco Locatelli. A jacobi-like acceleration for dynamic programming. In Decision and Control (CDC), 2016 IEEE 55th Conference on, pp. 7371–7376. IEEE, 2016.   
+Mattia Laurini, Luca Consolini, and Marco Locatelli. A consensus approach to dynamic programming. IFAC-PapersOnLine, 50(1):8435–8440, 2017.   
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.   
+James M Ortega and Werner C Rheinboldt. Iterative solution of nonlinear equations in several variables, volume 30. Siam, 1970.   
+Martin L Puterman. Markov decision processes. j. Wiley and Sons, 1994.   
+Martin L Puterman and Shelby L Brumelle. The analytic theory of policy iteration. In Dynamic Programming and its applications, pp. 91–113. Elsevier, 1978.   
+Gavin A Rummery and Mahesan Niranjan. On-line Q-learning using connectionist systems, volume 37. University of Cambridge, Department of Engineering, 1994.   
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015.   
+Damien Scieur, Alexandre d’Aspremont, and Francis Bach. Regularized nonlinear acceleration. In Advances In Neural Information Processing Systems, pp. 712–720, 2016.   
+Damien Scieur, Francis Bach, and Alexandre d’Aspremont. Nonlinear acceleration of stochastic algorithms. In Advances in Neural Information Processing Systems, pp. 3982–3991, 2017.   
+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, pp. 1057–1063, 2000.   
+Alex Toth and CT Kelley. Convergence analysis for anderson acceleration. SIAM Journal on Numerical Analysis, 53(2):805–819, 2015.   
+Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double q-learning. In AAAI, volume 16, pp. 2094–2100, 2016.   
+Homer F Walker and Peng Ni. Anderson acceleration for fixed-point iterations. SIAM Journal on Numerical Analysis, 49(4):1715–1735, 2011.   
+Ziyu Wang, Tom Schaul, Matteo Hessel, Hado Van Hasselt, Marc Lanctot, and Nando De Freitas. Dueling network architectures for deep reinforcement learning. arXiv preprint arXiv:1511.06581, 2015.   
+Christopher JCH Watkins and Peter Dayan. Q-learning. Machine learning, 8(3-4):279–292, 1992.   
+Guangzeng Xie, Yitan Wang, Shuchang Zhou, and Zhihua Zhang. Interpolatron: Interpolation or extrapolation schemes to accelerate optimization for deep neural networks. arXiv preprint arXiv:1805.06753, 2018.
+
+# A. A2Q
+
+Here is the pseudocode of A2Q, which is A2VI in $\pmb q$ -notation.
+
+# Algorithm 3 Anderson Accelerated Q-Learning (A2Q)
+
+Input: $\mathbf { \Psi } _ { q } { } ^ { 0 } , P , r , \gamma , k , T$ 1: for $t = 1 , 2 , \dots , T$ do 2: $B _ { \pi ^ { ( t - 1 ) } } ( { \pmb q } ^ { t - 1 } ) = \mathrm { v e c } ( { \pmb r } ) + \gamma P \mathrm { m a x } _ { \pi } { \pmb q } _ { \pi } ^ { t - 1 } - \mathrm { v e c } ( { \pmb q } ^ { t - 1 } )$ 3: if $t < k$ then 4: $\begin{array} { r } { \mathrm { v e c } ( \pmb q ^ { t } ) = \mathrm { v e c } ( \pmb r ) + \gamma P \mathrm { m a x } _ { \pi } \pmb q _ { \pi } ^ { t - 1 } } \end{array}$ 5: else 6: Calculate $\left( \alpha _ { 1 } , \alpha _ { 2 } , \ldots , \alpha _ { k } \right)$ by solving the optimization problem (5) 7: $\begin{array} { r } { \mathrm { v e c } ( { \pmb q } ^ { t } ) = \mathrm { v e c } ( { \pmb r } ) + \gamma P \mathrm { m a x } _ { \pi } \big ( \sum _ { i = 1 } ^ { k } \alpha _ { i } \pmb q _ { \pi } ^ { t - i } \big ) } \end{array}$ 8: end if   
+9: end for   
+10: πT = arg maxπ qTπ   
+11: return qT , πT
+
+# B. A2VI WITH THE REJECTION STEP
+
+Here is the pseudocode of A2VI with the rejection step, the only difference between this algorithm with algorithm 1 is before the interpolation step, we first check whether the affine combination is in $V _ { B }$ . If the answer is negative, then this interpolation step is replaced with an ordinary value iteration step.
+
+# Algorithm 4 Anderson Accelerated Value Iteration with the Rejection Step
+
+Input: ${ \pmb v } ^ { ( 0 ) } , P , { \pmb r } , \gamma , k , T$   
+1: for $t = 1 , 2 , \cdots , T { \bf d }$ o   
+2: $B _ { \pi ^ { ( t - 1 ) } } ( \pmb { v } ^ { ( t - 1 ) } ) = \operatorname* { m a x } _ { \pi } \left( \pmb { r } _ { \pi } + \gamma P _ { \pi } \pmb { v } ^ { ( t - 1 ) } \right) - \pmb { v } ^ { ( t - 1 ) }$   
+3: if $t < k$ then   
+4: ${ \pmb v } ^ { ( t ) } = \operatorname* { m a x } _ { \pi } ( { \pmb r } _ { \pi } + \gamma P _ { \pi } { \pmb v } ^ { ( t - 1 ) } )$   
+5: else   
+6: Calculate $( \alpha _ { 1 } ^ { ( t ) } , \alpha _ { 2 } ^ { ( t ) } , \cdot \cdot \cdot , \alpha _ { k } ^ { ( t ) } )$ by solving the optimization problem (5)   
+7: 8: v˜ = Pki=1 α(t)i v (t−i) $\begin{array} { c } { { \pmb v = \sum _ { i = 1 } \alpha _ { i } \mathrm {  ~ \pmb { \sigma } ~ } ^ { \ast } { \pmb v } ^ { \ast } } } \\ { { \bf i f \operatorname* { m a x } _ { \pi } ( \pmb r _ { \pi } + \gamma P _ { \pi } \tilde { \pmb v } ) \geq \tilde { v } \ t h e n } } \\ { { \pmb v } ^ { ( t ) } = \operatorname* { m a x } _ { \pi } ( { \pmb r _ { \pi } + \gamma P _ { \pi } \tilde { \pmb v } } ) } \end{array}$   
+9:   
+10: else   
+11: $\mathbf { \tilde { \alpha } } _ { 1 } ^ { ( t ) } = 1 , \alpha _ { i } ^ { ( t ) } = 0$ for i 6= 1   
+12: v(t) = max rπ + γPπv(t−1)
   
+13: end if   
+14: end if   
+15: end for   
+16: $\pi ^ { ( T ) } = \mathrm { a r g m a x } _ { \pi } ( \pmb { r } _ { \pi } + \gamma P _ { \pi } \pmb { v } ^ { ( T ) } )$   
+17: return ${ \pmb v } ^ { ( T ) } , \pi ^ { ( T ) }$
+
+C. PROOFS
+
+Lemma 1. For any MDP whose optimal policy is unique, there exists a $\delta > 0$ and a policy $\pi ^ { * }$ such that for any ${ \pmb v } \in U _ { \delta } ( { \pmb v } ^ { * } ) = \{ { \pmb v } | \| { \pmb v } - { \pmb v } ^ { * } \| _ { \infty } \leq \delta \}$ ,
+
+$$
+\Gamma ( v ) = r _ { \pi ^ { * } } + \gamma P _ { \pi ^ { * } } v
+$$
+
+Proof Because the optimal policy is unique, for any nonoptimal policy $\pi$ , for any state $s$ such that $\pi ( s ) \neq$ $\pi ^ { * } ( s )$ we have that $[ \bar { \Gamma _ { \pi ^ { * } } } ( { \pmb v } ^ { * } ) \bar { \bf \bar { \Big ] } } _ { s } > [ \Gamma _ { \pi } ( { \pmb v } ^ { * } ) ] _ { s } , [ \cdot ] _ { s }$ means executing operations on state $s$ . Denote $A ( \pi ) =$ $\{ s | \dot { \pi } ( s ) \neq \pi ^ { * } ( s ) \}$ .
+
+Suppose the optimal policy is $\pi ^ { * }$ , then there exists $\varepsilon$ such that
+
+$$
+\operatorname* { m i n } _ { \pi \neq \pi ^ { * } } \operatorname* { m i n } _ { s \in A ( \pi ) } ~ [ \Gamma ( \pmb { v } ^ { * } ) - \Gamma _ { \pi } ( \pmb { v } ^ { * } ) ] _ { s } > \varepsilon > 0 ,
+$$
+
+since the optimal policy is unique and the state space and the action space are finite. We choose $\begin{array} { r } { \delta = \frac { \varepsilon } { 3 \gamma } } \end{array}$ , then for any policy $\pi$ and any $\pmb { v } \in U _ { \delta } ( \pmb { v } ^ { * } )$ we have
+
+$$
+\| \Gamma _ { \pi } ( \pmb { v } ^ { * } ) - \Gamma _ { \pi } ( \pmb { v } ) \| _ { \infty } = \| \gamma P _ { \pi } ( \pmb { v } ^ { * } - \pmb { v } ) \| _ { \infty } \leq \gamma \| \pmb { v } ^ { * } - \pmb { v } \| _ { \infty } \leq \frac { \varepsilon } { 3 }
+$$
+
+Then for any policy $\pi$ , for any state $s \in A ( \pi )$ , we have that
+
+$$
+\begin{array} { r l } & { \bigl [ \Gamma _ { \pi ^ { * } } ( \pmb { v } ) - \Gamma _ { \pi } ( \pmb { v } ) \bigr ] _ { s } = \bigl [ \bigl ( \Gamma _ { \pi ^ { * } } ( \pmb { v } ) - \Gamma _ { \pi ^ { * } } ( \pmb { v } ^ { * } ) \bigr ) + \bigl ( \Gamma _ { \pi ^ { * } } ( \pmb { v } ^ { * } ) - \Gamma _ { \pi } ( \pmb { v } ^ { * } ) \bigr ) + \bigl ( \Gamma _ { \pi } ( \pmb { v } ^ { * } ) - \Gamma _ { \pi } ( \pmb { v } ) \bigr ) \bigr ] _ { s } } \\ & { \qquad \geq \varepsilon - \| \Gamma _ { \pi ^ { * } } ( \pmb { v } ) - \Gamma _ { \pi ^ { * } } ( \pmb { v } ^ { * } ) \| _ { \infty } - \| \Gamma _ { \pi } ( \pmb { v } ^ { * } ) - \Gamma _ { \pi } ( \pmb { v } ) \| _ { \infty } } \\ & { \qquad \geq \varepsilon - \frac { \varepsilon } { 3 } - \frac { \varepsilon } { 3 } } \\ & { \qquad = \frac { \varepsilon } { 3 } } \end{array}
+$$
+
+which means $\pi$ does not choose the optimal action in state $s$ . Therefore, if $\pi$ selects the optimal action in every state $s \in S$ , then we must have $\pi _ { s } = \pi _ { s } ^ { * } , \forall s \in \mathcal { S }$ , which implies $\pi ^ { * } \in \arg \operatorname* { m a x } _ { \pi } \Gamma _ { \pi } ( \pmb { v } )$ , i.e., $\Gamma ( v ) = r _ { \pi ^ { * } } + \gamma P _ { \pi ^ { * } } v$ .
+
+Lemma 2. For any given MDP with optimal value $v ^ { * }$ and any value $\textbf {  { v } }$ , we always have
+
+$$
+( 1 - \gamma ) \| \pmb { v } - \pmb { v } ^ { * } \| _ { \infty } \leq \| \Gamma ( \pmb { v } ) - \pmb { v } \| _ { \infty } \leq ( 1 + \gamma ) \| \pmb { v } - \pmb { v } ^ { * } \| _ { \infty } .
+$$
+
+Proof
+
+$$
+\begin{array} { r l } { \| v - v ^ { * } \| _ { \infty } = } & { \| v - \Gamma ( v ) + \Gamma ( v ) - \Gamma ( v ^ { * } ) \| _ { \infty } } \\ & { \leq \| v - \Gamma ( v ) \| _ { \infty } + \| \Gamma ( v ) - \Gamma ( v ^ { * } ) \| _ { \infty } } \\ & { \leq \| v - \Gamma ( v ) \| _ { \infty } + \gamma \| v - v ^ { * } \| _ { \infty } } \\ { \Rightarrow ( 1 - \gamma ) \| _ { \infty } v - v ^ { * } \| _ { \infty } \leq \| \Gamma ( v ) - v \| _ { \infty } } \\ { \| v - v ^ { * } \| _ { \infty } = } & { \| v - \Gamma ( v ) + \Gamma ( v ) - \Gamma ( v ^ { * } ) \| _ { \infty } } \\ & { \geq \| v - \Gamma ( v ) \| _ { \infty } - \| \Gamma ( v ) - \Gamma ( v ^ { * } ) \| _ { \infty } } \\ { \geq \| v - \Gamma ( v ) \| _ { \infty } - \gamma \| v - v ^ { * } \| _ { \infty } } \\ { \Rightarrow ( 1 + \gamma ) \| v - v ^ { * } \| _ { \infty } \geq \| \Gamma ( v ) - v \| _ { \infty } } \end{array}
+$$
+
+Proof of Theorem 1 From lemma 1 we know there exists a policy $\pi$ and a $\tilde { \delta } > 0$ such that the optimal Bellman operator is a linear function on $U _ { \tilde { \delta } } ( \boldsymbol { v } ^ { * } )$ . We now set $\delta$ sufficiently small such that
+
+$$
+\frac { k m ( 1 + \gamma ) } { 1 - \gamma } \| \pmb { v } ^ { ( 0 ) } - \pmb { v } ^ { * } \| _ { \infty } < \frac { k m ( 1 + \gamma ) } { 1 - \gamma } \delta < \widetilde { \delta } .
+$$
+
+The result is trivial for the first $k - 1$ steps, which are performed exactly by standard value iteration. When $t > k$ , we prove the result by induction. Suppose the conclusion is correct for previous steps, then we have
+
+$$
+\begin{array} { r l } { \displaystyle \| \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } - v ^ { * } \| _ { \infty } \leq \displaystyle \sum _ { i = 1 } ^ { k } | \alpha _ { i } ^ { ( t ) } | \| v ^ { ( t - i ) } - v ^ { * } \| _ { \infty } \leq \displaystyle \sum _ { i = 1 } ^ { k } | \alpha _ { i } ^ { ( t ) } | \frac { 1 } { 1 - \gamma } \| B ( v ^ { ( t - i ) } ) \| _ { \infty } } & { } \\ { \leq \displaystyle \sum _ { i = 1 } ^ { k } | \alpha _ { i } ^ { ( t ) } | \frac { 1 } { 1 - \gamma } \| B ( v ^ { ( 0 ) } ) \| _ { \infty } \leq \frac { k m } { 1 - \gamma } \| B ( v ^ { ( 0 ) } ) \| _ { \infty } } & { } \\ { \leq \frac { k m ( 1 + \gamma ) } { 1 - \gamma } \| v ^ { ( 0 ) } - v ^ { * } \| _ { \infty } < \frac { k m ( 1 + \gamma ) } { 1 - \gamma } \delta < \widetilde { \delta } } & { } \end{array}
+$$
+
+It follows that
+
+$$
+\begin{array} { r l } & { \| { \pmb v } ^ { ( t ) } - { \pmb v } ^ { * } \| _ { \infty } = \| \Gamma ( \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } { \pmb v } ^ { t - i } ) - \Gamma ( { \pmb v } ^ { * } ) \| _ { \infty } \leq \gamma \| \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } { \pmb v } ^ { ( t - i ) } - { \pmb v } ^ { * } \| _ { \infty } } \\ & { \qquad \leq \| \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } { \pmb v } ^ { ( t - i ) } - { \pmb v } ^ { * } \| _ { \infty } < \widetilde { \delta } } \end{array}
+$$
+
+Therefore, $\textstyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } { \pmb v } ^ { ( t - i ) } \in U _ { \tilde { \delta } } ( { \pmb v } ^ { * } ) , { \pmb v } ^ { ( t ) } \in U _ { \tilde { \delta } } ( { \pmb v } ^ { * } )$ , which implies
+
+$$
+\Gamma ( \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) = r _ { \pi ^ { * } } + \gamma P _ { \pi ^ { * } } \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } , \Gamma ( v ^ { ( t ) } ) = r _ { \pi ^ { * } } + \gamma P _ { \pi ^ { * } } v ^ { ( t ) } .
+$$
+
+Then we can get
+
+$$
+\begin{array} { l } { { \displaystyle B ( v ^ { t } ) = r _ { \pi ^ { * } } + ( \gamma P _ { \pi ^ { * } } - I ) v ^ { ( t ) } } } \\ { { \displaystyle \quad = r _ { s ^ { * } } + ( \gamma P _ { \pi ^ { * } } - I ) ( r _ { s ^ { * } } + \gamma P _ { \pi ^ { * } } \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) } } \\ { ~ } \\ { { \displaystyle \quad = \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \left( r _ { \pi ^ { * } } + ( \gamma P _ { \pi ^ { * } } - I ) ( r _ { \pi ^ { * } } + \gamma P _ { \pi ^ { * } } \pi ^ { ( t - i ) } ) \right) } } \\ { { \displaystyle \quad = \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \gamma P _ { \pi ^ { * } } \left( r _ { \pi ^ { * } } + \gamma P _ { \pi ^ { * } } v ^ { ( t - i ) } - v ^ { ( t - i ) } \right) } } \\ { { \displaystyle \quad = \gamma P _ { \pi ^ { * } } \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } B ( v ^ { ( t - i ) } ) } } \end{array}
+$$
+
+Taking norm on both side of the equation and utilizing the definition of $\alpha _ { i } ^ { ( t ) } , i = 1 , 2 , \cdots , k$ , we get
+
+$$
+| \Gamma ( \pmb { v } ^ { ( t ) } ) - \pmb { v } ^ { ( t ) } \| _ { \infty } \leq \gamma \| P _ { \pi ^ { * } } \| _ { \infty } \| \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } B ( \pmb { v } ^ { ( t - i ) } ) \| _ { \infty } \leq \gamma \| B ( \pmb { v } ^ { ( t - 1 ) } ) \| _ { \infty } = \gamma \| \Gamma ( \pmb { v } ^ { ( t - 1 ) } ) - \pmb { v } ^ { ( t - 1 ) } \| _ { \infty } .
+$$
+
+Therefore, we justify property (i). Property (ii) then follows directly from Lemma 2.
+
+Lemma 3. For any MDP, suppose the values $\textbf { \em u }$ and $\textbf {  { v } }$ satisfy $\textbf { \em u } \geq v$ , then
+
+$$
+\Gamma ( \boldsymbol { \mathbf { u } } ) \geq \Gamma ( \boldsymbol { \mathbf { v } } ) .
+$$
+
+Proof As stated in section 2, $\textbf { \em u } \geq \textbf { \em v }$ means that $\pmb { u } ( s ) \geq \pmb { v } ( s )$ for any state $s$ . Suppose $\tilde { \pi } = \arg \operatorname* { m a x } _ { \pi } \boldsymbol { r } _ { \pi } +$ $\gamma { P _ { \pi } } v$ , therefore for any $s$ we have that
+
+$$
+\Gamma ( \pmb { u } ) ( s ) \geq \Gamma _ { \widetilde { \pi } } ( \pmb { u } ) ( s ) \geq \Gamma _ { \widetilde { \pi } } ( \pmb { v } ) ( s ) = \Gamma ( \pmb { v } ) ( s ) .
+$$
+
+# Proof of Theorem 2 On the one hand,
+
+$$
+\begin{array} { r l } { \Gamma ( \mathbf { v } ^ { ( t ) } ) - \mathbf { v } ^ { ( t ) } = } & { \underset { \mathbf { n } = 1 } { \operatorname* { m a x } } ( r _ { \mathbf { x } } + \gamma P _ { \mathbf { x } } \mathbf { v } ^ { ( t ) } ) - \underset { \mathbf { n } = 1 } { \operatorname* { m a x } } ( r _ { \mathbf { x } } + \gamma P _ { \mathbf { x } } \mathbf { \Lambda } _ { \leq } ^ { k } \alpha _ { i } ^ { ( t ) } \mathbf { v } ^ { ( t - i \setminus j ) } ) } \\ & { \leq r _ { \mathbf { x } } ( \epsilon ) + \gamma P _ { \mathbf { x } ^ { ( t ) } } \mathbf { v } ^ { ( t ) } - r _ { \mathbf { x } ^ { ( t ) } } \lambda ^ { ( t ) } - \gamma P _ { \mathbf { x } ^ { ( t ) } } \underset { \mathbf { i = 1 } } { \overset { k } { \sum } } \alpha _ { i } ^ { ( t ) } \mathbf { v } ^ { ( t - i ) } } \\ & { = \gamma P _ { \mathbf { n } } ( \epsilon ) \underset { \mathbf { n } = 1 } { \operatorname* { m a x } } ( r _ { \mathbf { x } } + \gamma P _ { \mathbf { x } } \underset { \mathbf { i = 1 } } { \overset { k } { \sum } } \alpha _ { i } ^ { ( t ) } \mathbf { v } ^ { ( t - i ) } ) - \underset { \mathbf { n } = 1 } { \overset { k } { \sum } } \alpha _ { i } ^ { ( t ) } \mathbf { v } ^ { ( t - i ) } , } \\ & { \leq \gamma P _ { \mathbf { n } ^ { ( t ) } } \underset { \mathbf { n } = 1 } { \overset { k } { \sum } } \alpha _ { i } ^ { ( t ) } \underset { \mathbf { n } } { \operatorname* { m a x } } ( r _ { \mathbf { n } } + \gamma P _ { \mathbf { x } } \mathbf { v } ^ { ( t - i ) } ) - \mathbf { v } ^ { ( t - i ) } , } \\ & { = \gamma P _ { \mathbf { n } ^ { ( t ) } } \underset { \mathbf { n } = 1 } { \overset { k } { \sum } } \alpha _ { i } ^ { ( t ) } B ( \mathbf { v } ^ { ( t - i ) } ) } \end{array}
+$$
+
+On the other hand, we denote $\begin{array} { r } { \tilde { \pi } = \mathrm { a r g m a x } _ { \pi } ( { r } _ { \pi } + \gamma P _ { \pi } \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } { \pmb v } ^ { { ( t - i ) } } ) } \end{array}$
+
+$$
+\begin{array} { r l } { v ^ { ( t ) } - \Gamma ( v ^ { ( t ) } ) = \displaystyle \operatorname* { m a x } _ { \pi } ( r _ { \pi } + \gamma P _ { \pi } \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) - \operatorname* { m a x } _ { \pi } ( r _ { \pi } + \gamma P _ { \pi } v ^ { ( t ) } ) } & { } \\ { \le r _ { \pi } + \gamma P _ { \pi } \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } - r _ { \pi } - \gamma P _ { \pi } v ^ { ( t ) } } & { } \\ { = \gamma P _ { \pi } \displaystyle ( \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } - \operatorname* { m a x } _ { \pi } ( r _ { \pi } + \gamma P _ { \pi } \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) ) } & { } \\ { = - \gamma P _ { \pi } B \displaystyle ( \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) } & { } \end{array}
+$$
+
+The above two results shows
+
+$$
+\gamma P _ { \tilde { \pi } } B ( \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \pmb { v } ^ { ( t - i ) } ) \le B ( \pmb { v } ^ { ( t ) } ) \le \gamma P _ { \pi ^ { ( t ) } } \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } B ( \pmb { v } ^ { ( t - i ) } ) .
+$$
+
+Now, consider the rejection step. First we show that if $v \in V _ { B }$ then $\Gamma ( \pmb { v } ) \in V _ { B }$ . If $v \in V _ { B }$ , then $\Gamma ( v ) \geq v$ .   
+With Lemma 3, we have that $\Gamma ( \Gamma ( \pmb { v } ) ) \geq \Gamma ( \pmb { v } )$ , i.e. $\Gamma ( \pmb { v } ) \in V _ { B }$ .
+
+Next we show that if $\pmb { v } ^ { ( i ) } \in V _ { B }$ for $i < t$ , then ${ \pmb v } ^ { ( t ) } \in V _ { B }$ . According to the rejection algorithm, we have $\begin{array} { r } { \pmb { v } ^ { ( t ) } = \Gamma ( \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \pmb { v } ^ { ( t - i ) } ) } \end{array}$ . If $\begin{array} { r } { \Gamma ( \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \pmb { v } ^ { ( t - i ) } ) \ge \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \pmb { v } ^ { ( t - i ) } } \end{array}$ α(t)i v(t−i), then Pki=1 α(t)i v(t−i) ∈ VB and v(t) ∈ VB . If Γ(Pki=1 α(t)i $\begin{array} { r } { \Gamma ( \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \pmb { v } ^ { ( t - i ) } ) < \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } \pmb { v } ^ { ( t - i ) } } \end{array}$ α(t)i v(t−i), then v(t) = Γ(v(t−1)) due to the rejection step. Since $\pmb { v } ^ { ( t - 1 ) } \in V _ { B }$ , we have that ${ \pmb v } ^ { ( t ) } \in V _ { B }$ 1 . Therefore, we also have that ${ \cal B } ( \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( k ) } v ^ { ( t - i ) } ) \geq 0$ α(k)i v(t−i)) ≥ 0. We have that
+
+$$
+\begin{array} { r l } { \| \Gamma ( \pmb { v } ^ { ( t ) } ) - \pmb { v } ^ { t } \| = \| B ( \pmb { v } ^ { ( t ) } ) \| \leq \gamma \| P _ { \pi ^ { ( t ) } } \| \| \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } B ( \pmb { v } ^ { ( t - i ) } ) \| } & { } \\ { \leq \gamma \| B ( \pmb { v } ^ { ( t - 1 ) } ) \| = \gamma \| \Gamma ( \pmb { v } ^ { ( t - 1 ) } ) - \pmb { v } ^ { ( t - 1 ) } \| } & { } \end{array}
+$$
+
+The second inequality is due to the definition of $\alpha _ { i } ^ { ( t ) }$ , $i = 1 , 2 , . . . , k$
+
+Proof of Theorem 3 We prove the conclusion by induction. It is evident that the conclusion holds for the first $k - 1$ steps. Suppose the conclusion holds for the first $t - 1$ steps, then
+
+$$
+\begin{array} { r l } & { v ^ { ( t ) } = \displaystyle \operatorname* { m a x } _ { \pi } ( r _ { \pi } + \gamma P _ { \pi } \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } { \pmb v } ^ { ( t - i ) } ) } \\ & { \quad \ge r _ { \tilde { \pi } } + \gamma P _ { \tilde { \pi } } ( \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } { \pmb v } ^ { ( t - i ) } ) } \\ & { \quad \ge r _ { \tilde { \pi } } + \gamma P _ { \tilde { \pi } } { \pmb v } ^ { ( t - 1 ) } } \\ & { \quad \ge { \pmb v } ^ { ( t - 1 ) } , } \end{array}
+$$
+
+where $\begin{array} { r } { \tilde { \pi } = \arg \operatorname* { m a x } _ { \pi } \pmb { r } _ { \pi } + \gamma P _ { \pi } \pmb { v } ^ { ( t - 1 ) } } \end{array}$ . The second inequality comes from the extrapolation restriction. The Third inequality is due to that if $v \in V _ { B }$ then $\Gamma ( \pmb { v } ) \in \bar { V _ { B } }$ , which is shown in Theorem 2.
+
+As shown in Theorem 2, we have that ${ \pmb v } ^ { ( t ) } \in V _ { B }$ and ${ \textstyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } } { \pmb v } ^ { ( t - i ) } \in V _ { B }$ . Therefore, ${ \pmb v } ^ { ( t ) } \le { \pmb v } ^ { * }$
+
+$$
+\begin{array} { r l } & { v ^ { * } - v ^ { ( t ) } = v ^ { * } - \displaystyle \operatorname* { m a x } _ { \pi } ( r _ { \pi } + \gamma P _ { \pi } \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) } \\ & { \qquad \le v ^ { * } - ( r _ { \pi ^ { * } } + \gamma P _ { \pi ^ { * } } \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) } \\ & { \qquad = \gamma P _ { \pi ^ { * } } \displaystyle \sum _ { i = 1 } ^ { k } \alpha _ { i } ^ { ( t ) } ( v ^ { * } - v ^ { ( t - i ) } ) } \\ & { \qquad \le \gamma P _ { \pi ^ { * } } ( v ^ { * } - v ^ { ( t - 1 ) } ) } \end{array}
+$$
+
+Taking the infinite norm on both sides, we get
+
+$$
+\| \pmb { v } ^ { * } - \pmb { v } ^ { ( t ) } \| _ { \infty } \leq \gamma \| P _ { \pi ^ { * } } \| _ { \infty } \| \pmb { v } ^ { * } - \pmb { v } ^ { ( t - 1 ) } \| _ { \infty } \leq \gamma \| \pmb { v } ^ { * } - \pmb { v } ^ { ( t - 1 ) } \| _ { \infty } ,
+$$
+
+which completes the proof.
+
+# D. EXPERIMENT DETAILS
+
+# D.1 MODEL ARCHITECTURE AND HYPER-PARAMETERS
+
+For our experiments, we used the DQN(Mnih et al., 2013) architecture, where the $\mathbf { Q }$ -value network is composed of 3 convolutional layers, 1 fully connected layer, and 1 output fully connected layer. Each layer except the final layer is followed with a rectified linear activation(ReLU). The first convolutional layer use 32 $8 \times 8$ filters with stride 4, the second has $6 4 4 \times 4$ filters with stride 2, and the third convolutional layer has 64 $3 \times 3$ filters with stride 1. The fully connected layer consists of 512 units and the final layer outputs a single value for each action. We used the Adam optimizer with learning rate 0.0001 and $\epsilon = 0 . 0 0 1 5$ . The discount was set to $\gamma = 0 . 9 9$ . Training is done over 20M or 40M frames. We updated the target networks every 10000 steps. The size of experience replay buffer is 100000 tuples, where $3 2 \mathrm { { m i n i } }$ batches were sampled every 4 steps to update the network. The exploration policy is $\varepsilon$ -greedy policy with fixed $\varepsilon = 0 . 0 1$ .
+
+# D.2 PREPROCESSING OF ENVIRONMENTS
+
+We preprocess the environment in the same way as the original DQN paper (Mnih et al., 2013) does. We utilize the action repeat technique, i.e., each action is repeated for the next four consecutive frames. The frames are firstly grey-scaled and then rescaled to the size of $8 4 \times 8 4$ pixels. Each state is represented by a concatenation of 4 consecutive frames. We fix all positive rewards to be 1 and all negative rewards to be -1, leaving 0 rewards unchanged. Transitions associated with the loss of a life are considered terminal.
+
+E. SOLVING (5) WHEN USING THE $\ell _ { 2 }$ NORM AND TOTAL SPACE CONSTRAINT
+
+Under the given setting, we may rewrite the original problem in the following form,
+
+$$
+\begin{array} { r l } & { \mathrm { m i n i m i z e } \ \pmb { \alpha } ^ { \top } ( \hat { B } ^ { ( t ) } ) ^ { \top } \hat { B } ^ { ( t ) } \pmb { \alpha } } \\ & { \mathrm { s u b j e c t } \ \mathrm { t o \ } \mathbf { 1 } ^ { \top } \pmb { \alpha } = 1 . } \end{array}
+$$
+
+This problem can be directly solved with an application of Lagrange multiplier method, namely, let $\lambda$ be the Lagrange multiplier, then we solve the problem
+
+$$
+\operatorname* { m a x } _ { \alpha } \alpha ^ { \top } ( \hat { B } ^ { ( t ) } ) ^ { \top } \hat { B } ^ { ( t ) } \alpha + \lambda ( \mathbf { 1 } ^ { \top } \alpha - 1 )
+$$
+
+whose solution can be written explicitly as $\begin{array} { r } { \pmb { \alpha } = - \frac { \lambda } { 2 } [ ( \hat { B } ^ { ( t ) } ) ^ { \top } \hat { B } ^ { ( t ) } ] ^ { - 1 } \mathbf { 1 } } \end{array}$ . Combine this result with the constraint, we can get $- \textstyle { \frac { \lambda } { 2 } } = \frac { 1 } { \textstyle { \frac { 1 ^ { \top } [ ( \hat { B } ^ { ( t ) } ) ^ { \top } \hat { B } ^ { ( t ) } ] ^ { - 1 } { \bf 1 } } } }$ , which implies $\begin{array} { r } { \pmb { \alpha } = \frac { [ ( \hat { B } ^ { ( t ) } ) ^ { \top } \hat { B } ^ { ( t ) } ] ^ { - 1 } \mathbf { 1 } } { \mathbf { 1 } ^ { \top } [ ( \hat { B } ^ { ( t ) } ) ^ { \top } \hat { B } ^ { ( t ) } ] ^ { - 1 } \mathbf { 1 } } } \end{array}$ .