Add files using upload-large-folder tool

parse/train/BygkQeHKwB/BygkQeHKwB.md

@@ -0,0 +1,481 @@
+# WALKING ON THE EDGE: FAST, LOW-DISTORTION ADVERSARIAL EXAMPLES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Adversarial examples of deep neural networks are receiving ever increasing attention because they help in understanding and reducing the sensitivity to their input. This is natural given the increasing applications of deep neural networks in our everyday lives. When white-box attacks are almost always successful, it is typically only the distortion of the perturbations that matters in their evaluation.
+
+In this work, we argue that speed is important as well, especially when considering that fast attacks are required by adversarial training. Given more time, iterative methods can always find better solutions. We investigate this speed-distortion trade-off in some depth and introduce a new attack called boundary projection (BP) that improves upon existing methods by a large margin. Our key idea is that the classification boundary is a manifold in the image space: we therefore quickly reach the boundary and then optimize distortion on this manifold.
+
+# 1 INTRODUCTION
+
+Adversarial examples (Szegedy et al., 2013) are small, usually imperceptible perturbations of images or other data (Carlini & Wagner, 2018) that can arbitrarily modify a classifier’s prediction. They have been extended to other tasks like object detection or semantic segmentation (Xie et al., 2017), and image retrieval (Li et al., 2018; Tolias et al., 2019). They are typically generated in a white-box setting, where the attacker has full access to the classifier model and uses gradient signals through the model to optimize for the perturbation. They are becoming increasingly important because they reveal the sensitivity of neural networks to their input (Simon-Gabriel et al., 2018; Fawzi et al., 2016; Amsaleg et al., 2017) including trivial cases (Azulay & Weiss, 2018; Engstrom et al., 2017) and they easily transfer between different models (Moosavi-Dezfooli et al., 2016a; Tramer et al., 2017b). \`
+
+Adversarial examples are typically evaluated by probability of success and distortion. In many cases, white-box attacks have probability of success near one, then only distortion matters, as a (weak) measure of imperceptibility and also of the ease with which adversarial samples can be detected. The speed of an attack is less frequently discussed. The fast single-step FGSM attack (Goodfellow et al., 2014) produces high-distortion examples where adversarial patterns can easily be recognized. At the other extreme, the Carlini & Wagner (C&W) attack (Carlini & Wagner, 2017), considered state of the art, is notoriously expensive. Decoupling direction and norm (DDN) (Rony et al., 2018) has recently shown impressive progress in distortion but mostly in speed.
+
+Speed becomes more important when considering adversarial training (Goodfellow et al., 2014). This defense, where adversarial examples are used for training, was in fact introduced in the same work as FGSM. The latter remains the most common choice for generating those examples because of its speed. However, unless a powerful iterative attack is used (Madry et al., 2017), adversarial training is easily broken (Tramer et al., 2017a). \`
+
+In this work, we investigate in more depth the speed-distortion trade-off in the regime of probability of success near one. We observe that iterative attacks often oscillate across the classification boundary, taking long time to stabilize. We introduce a new attack that rather walks along the boundary. As a result, we improve the state of the art in distortion while keeping iterations at a minimum.
+
+Illustrating the attacks. To better understand how our attack works, we illustrate it qualitatively against a number of existing attacks in Fig. 1. On this toy 2d classification problem, the class boundary and the path followed by the optimizer starting at input x can be easily visualized.
+
+![](images/7f38d7a6ccb2c442280239fa0b5903d0b2b4b1a32de8a772e2e73d1ee38aaf9b.jpg)  
+Figure 1: Adversarial attacks on a binary classifier in two dimensions. The two class regions are shown in red and blue. Contours indicate class probabilities. The objective is to find a point in the red (adversarial) region that is at the minimal distance to input x. Gray (black) paths correspond to low (high) distortion target $\epsilon$ for $\mathrm { P G D _ { 2 } }$ (Kurakin et al., 2016) (a, in green) or parameter $\lambda$ for C&W (Carlini & Wagner, 2017) (b). The simulation is only meant to illustrate basic properties of the methods. In particular, it does not include Adam optimizer (Kingma & Ba, 2015) for C&W.
+
+$\mathrm { P G D _ { 2 } }$ , an $\ell _ { 2 }$ version of I-FGSM (Kurakin et al., 2016), a.k.a. PGD (Madry et al., 2017), is controlled by a distortion target $\epsilon$ and eventually follows a path on a ball of radius $\epsilon$ centered at $\mathbf { x }$ (cf . Fig. 1(a)). Section 4 shows that varying $\epsilon$ is an effective yet expensive strategy. It can only be done for a limited set of values so that the optimal distortion target per image may only be found by luck.
+
+C&W (Carlini & Wagner, 2017) depends on a parameter $\lambda$ that controls the balance between distortion and classification loss. A low value may lead to failure. A higher value may indeed reach the optimal perturbation, but with oscillations across the class boundary (cf . Fig. 1(b)). Therefore, an expensive line search over $\lambda$ is performed internally.
+
+DDN (Rony et al., 2018) (cf . Fig. 1(c)) increases or decreases distortion on the fly depending on success and at the same time pointing towards the gradient direction. It arrives quickly near the optimal perturbation but still suffers from oscillations across the boundary.
+
+On the contrary, boundary projection (BP), introduced in this work (cf . Fig. 1(d)), cares more about quickly reaching the boundary, not necessarily near the optimal solution, and then walks along the boundary, staying mostly in the adversarial (red) region. It therefore makes steady progress towards the solution rather than going back and forth.
+
+Our attack. Our key idea is that, once we reach the adversarial region near the boundary, the problem becomes optimization on a manifold (Absil et al., 2009): in particular, minimization of the $\ell _ { 2 }$ distortion on a level set of the classification loss. When in the adversarial region, we project the distortion gradient on the tangent space of this manifold. We do this simply by targeting a particular reduction of the distortion while moving orthogonally to the gradient of the classification loss.
+
+Our benchmark. Quantization is another major issue in this literature. Most papers implicitly assume that the output of a white-box attack is a matrix where pixel values are real numbers in $[ 0 , 1 ]$ . Rony et al. (2018) is one of the rare works where the output is a quantized. We agree with this definition of the problem. Indeed, an adversarial image is above all an image. The goal of an attacker is to publish images deluding the classifier (for instance on the web), and publishing implies compliance with pixels encoded in bytes.
+
+Contributions. We make the following contributions. To our knowledge, we are the first to
+
+1. Study optimization on the manifold of the classification boundary for an adversarial attack, providing an analysis under a number of constraints, such as staying on the tangent space of the manifold and reaching a distortion target.   
+2. Investigate theoretically and experimentally the quantization impact on the perturbation.   
+3. Achieve at the same speed as I-FGSM (Kurakin et al., 2016) (20 iterations) and under the constraint of a quantization, less distortion than state-of-the-art attacks including DDN, which needs 100 iterations on ImageNet.
+
+# 2 PROBLEM, BACKGROUND AND RELATED WORK
+
+# 2.1 PROBLEM FORMULATION
+
+Preliminaries. Let $\mathcal { X } : = \{ 0 , \Delta , . . . , 1 - \Delta , 1 \} ^ { n }$ with $\Delta : = 1 / ( L - 1 )$ denote the set of grayscale images of $n$ pixels quantized to $L$ levels, and let ${ \hat { \mathcal { X } } } : = [ 0 , 1 ] ^ { n }$ denote the corresponding real-valued images. An image of more than one color channels is treated independently per channel; in this case $n$ stands for the product of pixels and channels. A classifier $f : \hat { \mathcal { X } } \to \mathbf { \mathbb { R } } ^ { \bar { k } }$ maps an image $\mathbf { x }$ to a vector $f ( \mathbf { x } ) \in \mathbb { R } _ { + } ^ { c }$ representing probabilities per class over $c$ given classes. The parameters of the classifier are not shown here because they remain fixed in this work. The classifier prediction $\pi : \hat { \mathcal { X } } \to [ c ] : = \{ 1 , . . . , c \}$ maps $\mathbf { x }$ to the class label having the maximum probability:
+
+$$
+\pi ( \mathbf { x } ) : = \arg \operatorname* { m a x } _ { k \in \left[ c \right] } f ( \mathbf { x } ) _ { k } .
+$$
+
+If a true label $t \in [ c ]$ is known, the prediction is correct if $\pi ( \mathbf { x } ) = t$ .
+
+Problem. Let $\mathbf { x } \in \mathcal { X }$ be a given image with known true label $t$ . An adversarial example $\mathbf { y } \in \mathcal { X }$ is an image such that the distortion $\| \mathbf x - \mathbf y \|$ is small and the probability $f ( \mathbf { y } ) _ { t }$ is also small. This problem takes two forms:
+
+1. Target distortion, minimal probability:
+
+$$
+\begin{array} { c } { \displaystyle \operatorname* { m i n } _ { \mathbf { y } \in \mathcal { X } } f \left( \mathbf { y } \right) _ { t } } \\ { \displaystyle \mathrm { s u b j e c t ~ t o ~ } \left\| \mathbf { x } - \mathbf { y } \right\| \leq \epsilon , } \end{array}
+$$
+
+where $\epsilon$ is a given distortion target. The performance is then measured by the probability of success $P _ { \mathrm { s u c } } ^ { - } : = \mathrm { P } ( \pi ( \mathbf { y } ) \neq t )$ as a function of $\epsilon$ .
+
+2. Target success, minimal distortion:
+
+$$
+\begin{array} { r } { \underset { \mathbf { y } \in \mathcal { X } } { \operatorname* { m i n } } \ \left\| \mathbf { x } - \mathbf { y } \right\| } \\ { \mathrm { s u b j e c t ~ t o ~ } \boldsymbol { \pi } ( \mathbf { y } ) \neq \boldsymbol { t } . } \end{array}
+$$
+
+The performance is then measured by the expected distortion ${ \overline { { D } } } : = \operatorname { E } ( \| \mathbf { x } - \mathbf { y } \| )$ .
+
+This work focuses on the second form, but we present example attacks of both forms in section 2.2.
+
+Untargeted attack. The constraint $\pi ( \mathbf { y } ) \neq t$ in (5) is referred to as an untargeted attack, meaning that $\mathbf { y }$ is misclassified regardless of the actual prediction. As an alternative, a targeted attack requires that the prediction $\pi ( \mathbf { y } ) \bar { } = t ^ { \prime }$ is a target label $t ^ { \prime } \neq t$ . We focus on the former.
+
+Loss function. We focus on a white-box attack in this work. Such an attack is specific to $f$ , which is public. In this setting, attacks typically rely on exploiting the gradient of some loss function, using variants of gradient descent. A classification loss is defined on the probability vector $\mathbf { p } = f ( \mathbf { y } )$ with respect to the true label $t$ . For an untargeted attack, this is typically the negative of cross-entropy
+
+$$
+\ell ( \mathbf { p } , t ) : = \log p _ { t } .
+$$
+
+We should warn that, while the cross-entropy is appropriate for bringing examples into the region of class $t$ during classifier training, its negative (6) is in general not appropriate for pulling them out during an attack. This is because this function is mostly flat in the class region. A common solution is to normalize the gradient of $\ell$ (Goodfellow et al., 2014; Rony et al., 2018), assuming it is nonzero. We consider more options in this work. A targeted attack on the other hand may use  $\log { p _ { t ^ { \prime } } }$ , which works fine because it brings examples into class $t ^ { \prime }$ region.
+
+Distortion. This work focuses on the 2-norm $\lVert \cdot \rVert$ as a measure of distortion. Alternatives like 1-norm and $\infty$ -norm are also common (Goodfellow et al., 2014; Carlini & Wagner, 2017). It is known that none is appropriate for measuring the imperceptibility of adversarial attacks, while more sophisticated measures like structural similarity (SSIM) (Wang et al., 2004) are limited too (Sharif et al., 2018). Measuring imperceptibility is arguably as difficult as classification itself.
+
+Integral constraint. The constraint $\textbf { y } \in \mathcal { X }$ in (3) and (5) is typically relaxed to $\mathbf { y } \in \hat { \mathcal { X } }$ during optimization. Some works conclude the attack by loosely quantizing the optimal solution onto $\mathcal { X }$ , typically by truncation towards zero. To our knowledge, DDN (Rony et al., 2018) is the only work to do rounding instead, and at the end of each iteration. Quantization is becoming an important issue in adversarial examples because the distortions achieved in recent papers are so small that quantization impacts a lot the perturbations. Appendix A provides a more in-depth study of the impact of the quantization.
+
+# 2.2 ATTACKS
+
+Target Distortion. Given a distortion target $\epsilon$ , the fast gradient sign method (FGSM) (Goodfellow et al., 2014) performs a single step in the opposite direction of the (element-wise) sign of the loss gradient with $\infty$ -norm $\epsilon$ ,
+
+$$
+\mathbf { y } : = \mathbf { x } - \epsilon \mathrm { s i g n } \nabla _ { \mathbf { x } } \ell ( f ( \mathbf { x } ) , t ) .
+$$
+
+This is the fastest method for problem (2)-(3). In the same work adversarial training was introduced, this method quickly generates adversarial examples for training. However, the perturbations are usually high-distortion and visible. The iterative-FGSM (I-FGSM) (Kurakin et al., 2016) initializes $\mathbf { y } _ { 0 } : = \mathbf { x }$ and then iterates
+
+$$
+\begin{array} { r } { \mathbf { y } _ { i + 1 } : = \mathrm { p r o j } _ { B _ { \infty } [ \mathbf { x } ; \epsilon ] } \big ( \mathbf { y } _ { i } - \alpha \mathrm { s i g n } \nabla _ { \mathbf { x } } \ell \big ( f ( \mathbf { y } _ { i } ) , t \big ) \big ) , } \end{array}
+$$
+
+where projection1 is element-wise to the closed $\infty$ -norm ball $B _ { \infty } [ { \bf x } ; \epsilon ]$ of radius $\epsilon$ and center $\mathbf { x }$ , and also to $\hat { \mathcal X }$ (element-wise clipping to interval [0; 1]). This method is also known as basic iterative method (BIM) (Papernot et al., 2018) and as projected gradient descent (PGD) (Madry et al., 2017). We refer to as $\mathrm { P G D _ { 2 } }$ a 2-norm version replacing (8) with
+
+$$
+\begin{array} { r } { \mathbf { y } _ { i + 1 } : = \mathrm { p r o j } _ { B _ { 2 } \left[ \mathbf { x } ; \epsilon \right] } \big ( \mathbf { y } _ { i } - \alpha \eta \big ( \nabla _ { \mathbf { x } } \ell \big ( f \left( \mathbf { y } _ { i } \right) , t \big ) \big ) \big ) , } \end{array}
+$$
+
+where $\eta ( \mathbf { x } ) : = \mathbf { x } / \left\| \mathbf { x } \right\|$ denotes 2-normalization, and projection is to the closed 2-norm ball $B _ { 2 } [ { \bf x } ; \epsilon ]$ of radius $\epsilon$ and center $\mathbf { x }$ , followed again by element-wise clipping to $[ 0 , 1 ]$ . Although this method is part of Cleverhans library (Papernot et al., 2018), it is not published according to our knowledge.
+
+Target Success. This family of attacks is typically more expensive. Szegedy et al. (2013) propose a Lagrangian formulation of problem (4)-(5), minimizing the cost function
+
+$$
+J ( \mathbf { y } , c ) : = \left\| \mathbf { x } - \mathbf { y } \right\| ^ { 2 } + \lambda \ell ( f ( \mathbf { y } ) , t ) ,
+$$
+
+where variable $\lambda$ is a Lagrange multiplier for (5). They carry out this optimization by boxconstrained L-BFGS.
+
+The attack of Carlini & Wagner (2017), denoted by C&W in the sequel, pertains to this approach. A change of variable eliminates the box constraint, replacing $\mathbf { y } \in \mathcal { X }$ by $\bar { \sigma ( \mathbf { w } ) }$ , where $\mathbf { w } \in \mathbb { R } ^ { n }$ and $\sigma$ is the element-wise sigmoid function. The classification loss encourages the logit $\log { p _ { t } }$ to be less than any other $\log p _ { k }$ for $k \neq t$ by at least margin $m \geq 0$ ,
+
+$$
+\ell _ { m } ( \mathbf { p } , t ) : = \bigl [ \log p _ { t } - \underset { k \neq t } { \operatorname* { m a x } } \log p _ { k } + m \bigr ] _ { + } ,
+$$
+
+where $[ \cdot ] _ { + }$ denotes the positive part. This function is similar to the multi-class SVM loss by Crammer and Singer (Crammer & Singer, 2001), where $m = 1$ , and, apart from the margin, it is a hard version of negative cross-entropy $\ell$ where softmax is producing the classifier probabilities. It does not have the problem of being flat in the region of class $t$ . The C&W attack uses the Adam optimizer (Kingma & Ba, 2015) to minimize the cost function
+
+$$
+J ( \mathbf { w } , \lambda ) : = \left\| \sigma ( \mathbf { w } ) - \mathbf { x } \right\| ^ { 2 } + \lambda \ell _ { m } ( f ( \sigma ( \mathbf { w } ) ) , t ) .
+$$
+
+for $\mathbf { w } \in \mathbb { R } ^ { n }$ . When the margin is reached, loss $\ell _ { m }$ vanishes and the distortion term pulls $\sigma ( \mathbf { w } )$ back towards $\mathbf { x }$ , causing oscillations around the margin. This is repeated for different $\lambda ^ { \frac { \mathtt { a } } { 2 } }$ by line search, which is expensive.
+
+Decoupling direction and norm (DDN) (Rony et al., 2018) is iterating similarly to $\mathrm { P G D _ { 2 } }$ (9),
+
+$$
+\begin{array} { r } { \mathbf { y } _ { i + 1 } : = \mathrm { p r o j } _ { S [ \mathbf { x } ; \rho _ { i } ] } \big ( \mathbf { y } _ { i } - \alpha \eta \big ( \nabla _ { \mathbf { x } } \ell \big ( f ( \mathbf { y } _ { i } ) , t \big ) \big ) \big ) , } \end{array}
+$$
+
+but projection is to the sphere $S [ \mathbf { x } ; \rho _ { i } ]$ of radius $\rho _ { i }$ and center $\mathbf { x }$ , and the radius is adapted to the current distortion: It is set to $\rho _ { i } ~ = ~ ( 1 - \gamma ) \| \mathbf { y } _ { i } - \mathbf { x } \|$ if $\mathbf { y } _ { i }$ is adversarial and to $( 1 { \bar { + } } \gamma ) \Vert \mathbf { y } _ { i } -$ $\mathbf { x } \Vert$ otherwise, where $\gamma \in \mathsf { \Gamma } ( 0 , 1 )$ is a parameter. Another major difference is that each iteration is concluded by a projection onto $\mathcal { X }$ (rather than $\hat { \mathcal X }$ ) by element-wise clipping to [0; 1] and rounding.
+
+Discussion. Optimizing around the class boundary is not a new idea. All of the above attacks do so in order to minimize distortion; implicitly, even attacks targeting distortion like $\mathrm { P G D _ { 2 } }$ do so, if the minimum parameter $\epsilon$ is sought (cf . Figure 1(a) and Section 4.2). Even black-box attacks do so (Brendel et al., 2018), without having access to the gradient function. The difference of our attack is that our updates are along the class boundary, i.e., in a direction normal to the gradient. DeepFool (Moosavi-Dezfooli et al., 2016b) is a popular attack targeting success, that is not optimizing for distortion and not following a path around the class boundary.
+
+# 2.3 OTHER RELATED WORK
+
+Optimization on manifolds. In the context of deep learning, stochastic gradient descent on Riemanian manifolds has been studied, e.g. RSGD (Bonnabel, 2013) and RSVRG (Zhang et al., 2016). It is usually applied to manifolds whose geometry is known in analytic form, for instance Grassmann manifolds (Bonnabel, 2013), optimizing orthogonal matrices on Stiefel manifolds (Harandi & Fernando, 2016) or embedding trees on the Poincare ball (Nickel & Kiela, 2017). ´
+
+In most cases, the motivation is to optimize a very complex function (e.g. a classification loss) on a well-studied manifold, e.g. matrix manifold (Absil et al., 2009). On the contrary, we are optimizing a very simple quadratic function (the distortion) on a complex manifold not known in analytic form, i.e. a level set of the classification loss.
+
+# 3 METHOD
+
+Our attack is an iterative process with a fixed number $K$ of iterations. Stage 1 aims at quickly producing an adversarial image, whereas Stage 2 is a refinement phase decreasing distortion. The key property of our method is that while in the adversarial region during refinement, it tries to walk along the classification boundary by projecting the distortion gradient onto the tangent hyperplane of the boundary. Hence we call it boundary projection (BP).
+
+# 3.1 STAGE 1
+
+This stage begins at $\mathbf { y } _ { 0 } = \mathbf { x }$ and iteratively updates in the direction of the gradient of the loss function as summarized in Algorithm 1. The gradient is normalized and then scaled by two parameters: a fixed parameter $\alpha$ that is large s.t., with high probability, Stage 1 returns an adversarial image $\mathbf { y } _ { i } \in \hat { \mathcal { X } }$ ; and a parameter $\gamma _ { i }$ that is increasing linearly with iteration $i$ as follows
+
+$$
+\gamma _ { i } : = \gamma _ { \operatorname* { m i n } } + \frac { i } { K + 1 } ( \gamma _ { \operatorname* { m a x } } - \gamma _ { \operatorname* { m i n } } ) ,
+$$
+
+such that updates are slow at the beginning to keep distortion low, then faster until the attack succeeds, where $\gamma _ { \operatorname* { m i n } } \in ( 0 , \gamma _ { \operatorname* { m a x } } )$ and $\gamma _ { \mathrm { m a x } } = 1$ . Clipping is element-wise.
+
+<table><tr><td>Algorithm 1 Stage 1</td></tr><tr><td>Input: x: original image to be attacked</td></tr><tr><td>Input: t: true label (untargeted)</td></tr><tr><td>Output: y with π(y) / t or failure,iteration i</td></tr><tr><td>1:Initialize yo ←x,𝑖 ←0</td></tr><tr><td>2:while(π(yi)=t)^(i&lt;K) do</td></tr><tr><td>3: g←n(Vxl(f(yi),t))</td></tr><tr><td>4: yi+1 ← clip[0,1](yi-αγig)</td></tr><tr><td>5: i←i+1 6: end while</td></tr></table>
+
+# 3.2 STAGE 2
+
+Once Stage 1 has succeeded, Stage 2 continues by considering two cases: if $\mathbf { y } _ { i }$ is adversarial, case OUT aims at minimizing distortion while staying in the adversarial region. Otherwise, case IN aims at decreasing the loss while controlling the distortion. Both work with a first order approximation of the loss around $\mathbf { y } _ { i }$ :
+
+$$
+\ell ( f ( \mathbf { y } _ { i } + \mathbf { u } ) , t ) \approx \ell ( f ( \mathbf { y } _ { i } ) , t ) + \mathbf { u } ^ { \top } \mathbf { g } ,
+$$
+
+where $\mathbf { g } = \nabla _ { \mathbf { x } } \ell \bigl ( f ( \mathbf { y } _ { i } ) , t \bigr )$ . The perturbation at iteration $i$ is $\delta _ { i } : = \mathbf { y } _ { i } - \mathbf { x }$ . Stage 2 is summarized in Algorithm 2. Cases OUT and IN illustrated in Fig. 2 are explained below.
+
+# Algorithm 2 Stage 2
+
+<table><tr><td>Input: t: true label (untargeted),i current iteration number Input: yi:current adversarial image,∈: target distortion</td></tr><tr><td>Output: y K</td></tr><tr><td>1:whilei&lt;Kdo</td></tr><tr><td>2: δ←yi-X perturbation</td></tr><tr><td>3: g←n(Vxl(f(yi）,t）) direction</td></tr><tr><td>4: r←(δi,g) 5: if π(yi）≠tthen γOUT</td></tr><tr><td>6: ∈←γi |lδll &gt; target distortion</td></tr><tr><td>7: v*←x+rg</td></tr><tr><td>8: z ← v*+n(yi-ν*)√[e²- r²]+</td></tr><tr><td>9: yi+1 ←Qour(z,yi)</td></tr><tr><td>10: else γIN</td></tr><tr><td>11: ∈←|δill/γi &gt; target distortion</td></tr><tr><td>12: z ←yi-(r+ √e²-|/δil²+r²) g</td></tr><tr><td></td></tr><tr><td>13: yi+1 ← QiN(z,yi)</td></tr><tr><td>14: end if</td></tr><tr><td>15: i←i+1</td></tr><tr><td>16: end while</td></tr></table>
+
+Case OUT takes as input $\mathbf { y } _ { i }$ outside class $t$ region, i.e. $\pi ( \mathbf { y } _ { i } ) ~ \neq ~ t$ . We set a target distortion $\epsilon = \gamma _ { i } \lVert \delta _ { i } \rVert < \lVert \delta _ { i } \rVert$ (14) such that updates decelerate to convergence once the attack has already succeeded. We then solve the following problem:
+
+$$
+\begin{array} { r l } & { \mathbf { z } : = \arg \underset { \mathbf { v } \in V } { \operatorname* { m i n } } \left\| \mathbf { v } - \mathbf { y } _ { i } \right\| } \\ & { V : = \arg \underset { \mathbf { v } \in P } { \operatorname* { m i n } } \left\| \left\| \mathbf { v } - \mathbf { x } \right\| - \epsilon \right\| , } \end{array}
+$$
+
+where $P : = \{ \mathbf { v } \in \mathbb { R } ^ { n } : \langle \mathbf { v } - \mathbf { y } _ { i } , \hat { \mathbf { g } } \rangle = 0 \}$ is the tangent hyperplane of the level set of the loss at $\mathbf { y } _ { i }$ , normal to $\hat { \bf g }$ . The constraint $\textbf { v } \in { \mathbf { \Omega } } P$ aims at maintaining the value of the loss, up to the first order. On this hyperplane, $V$ is the set of points having distortion close to $\epsilon$ .
+
+Consider the projection $\mathbf { v } ^ { \star } : = \mathbf { x } + r \hat { \mathbf { g } }$ of $\mathbf { x }$ onto that hyperplane, where $r : = \langle \delta _ { i } , \hat { \bf g } \rangle$ . If $r \geq \epsilon$ , then $V = \{ \mathbf { v } ^ { \star } \}$ , and the solution of (16) is trivially $\mathbf { z } = \mathbf { v } ^ { \star }$ . Note that $\mathbf { v } ^ { \star } = \mathbf { y } _ { i }$ if $\delta _ { i } , { \hat { \mathbf { g } } }$ are collinear. If $r < \epsilon$ , there is an infinity of solutions to (17). We pick the one closest to $\mathbf { y } _ { i }$ :
+
+$$
+\mathbf { z } = \mathbf { v } ^ { \star } + \eta \bigl ( \mathbf { y } _ { i } - \mathbf { v } ^ { \star } \bigr ) \sqrt { \epsilon ^ { 2 } - r ^ { 2 } } .
+$$
+
+This case is illustrated in Fig. 2(a), where $V$ is a circle that is the intersection of sphere $S [ \mathbf { x } ; \epsilon ]$ and $P$ ; then $\mathbf { z }$ is the intersection of $V$ and the line through $\mathbf { y } _ { i }$ and $\mathbf { v } ^ { \star }$ .
+
+Directly quantizing vector $\mathbf { z }$ onto $\mathcal { X }$ by $Q ( \cdot )$ , the component-wise rounding, modifies its norm (see App. A). This pulls down our effort to control the distortion. Instead, the process $Q _ { \mathrm { O U T } } ( \mathbf { z } , \mathbf { y } _ { i } )$ in line 9 looks for the scale $\beta$ of the perturbation to be applied s.t. $\| Q ( \mathbf { y } _ { i } + \beta ( \mathbf { z } - \mathbf { y } _ { i } ) ) \| = \| \mathbf { z } \|$ . This is done with a simple line search over $\beta$ .
+
+Case IN takes as input $\mathbf { y } _ { i }$ inside class $t$ region, i.e. $\pi ( \mathbf { y } _ { i } ) ~ = ~ t$ . We set a target distortion $\epsilon =$ $\parallel \delta _ { i } \parallel / \gamma _ { i } > \parallel \delta _ { i } \parallel$ (14) such that updates decelerate as in Case OUT. We then solve the problem:
+
+$$
+\mathbf { z } : = \arg \operatorname* { m i n } _ { \mathbf { v } \in S [ \mathbf { x } ; \epsilon ] } \left. \mathbf { v } , \hat { \mathbf { g } } \right. ,
+$$
+
+![](images/9c257ed46fa7badaff0af686636d8961b4a6956e8ea24d58ff325698d92ef95e.jpg)  
+Figure 2: Refinement stage of BP. Case OUT when $| V | > 1$ (a); case IN (b). See text for details.
+
+i.e., find the point $\mathbf { z }$ at the intersection of sphere $S [ \mathbf { x } ; \epsilon ]$ and the ray through $\mathbf { y } _ { i }$ in the direction opposite of $\mathbf { g }$ as shown in Fig. 2(b). The solution is simple:
+
+$$
+\mathbf { z } = \mathbf { y } _ { i } - \left( r + { \sqrt { \epsilon ^ { 2 } - { \| \delta _ { i } \| } ^ { 2 } + r ^ { 2 } } } \right) \hat { \mathbf { g } } ,
+$$
+
+Vector $\mathbf { z }$ moves away from $\mathbf { y } _ { i }$ along direction $- \hat { \mathbf { g } }$ by a step size so to reach $S [ \mathbf { x } , \epsilon ]$ . Case IN is not guaranteed to succeed, but invoking it means that Stage 1 has succeeded.
+
+Again a direct rounding jeopardizes the norm of the update $\mathbf z - \mathbf y _ { i }$ . Especially, quantization likely results in $Q ( \mathbf { z } ) = Q ( \mathbf { y } _ { i } )$ if $\| \mathbf { z } - \mathbf { y } _ { i } \| < \beta _ { \operatorname* { m i n } } = 0 . 1$ (see App. A). Instead of a line search as in method OUT, line 13 just makes sure that this event will not happen: $Q _ { \mathrm { I N } } ( \mathbf { z } , \mathbf { y } _ { i } ) = Q ( \mathbf { y } _ { i } + \beta ( \mathbf { z } - \mathbf { y } _ { i } ) )$ with $\beta = \operatorname* { m a x } ( 1 , \bar { \beta } _ { \operatorname* { m i n } } / \Vert \mathbf { z } - \mathbf { y } _ { i } \Vert )$ .
+
+# 4 EXPERIMENTS
+
+In this section we compare our method boundary projection (BP) to the attacks presented in Sect. 2, namely: FGSM (Goodfellow et al., 2014), I-FGSM (Kurakin et al., 2016), $\mathrm { P G D _ { 2 } }$ (9), C&W (Carlini & Wagner, 2017), and DDN (Rony et al., 2018). This benchmark is carried out on three well-known datasets, with a different neural network for each.
+
+# 4.1 DATASETS, NETWORKS, AND PARAMETERS
+
+For the target distortion attacks i.e. FGSM, I-FGSM and $\mathrm { P G D _ { 2 } }$ , we test a set of $\epsilon$ and calculate $P _ { \mathrm { s u c } }$ and $\overline { { D } }$ according to our evaluation protocol (cf . section 4.2). For C&W, we test several parameter settings and pick up the optimum setting as specified below. For DDN, the parameter settings are the default (Rony et al., 2018), i.e. $\epsilon _ { 0 } = 1 . 0$ and $\gamma = 0 . 0 5$ . Below we specify different networks and parameters for each dataset.
+
+MNIST (LeCun et al., 2010). We use is a simple network with three convolutional layers and one fully connected layer achieving accuracy 0:99, referred to as C4. The first convolutional layer has 64 features, kernel of size 8 and stride 2; the second has 128 features, kernel 6 and stride 2; the third has also 128 features, but kernel 5 and stride 1. It uses LeakyRelu activation (Maas et al., 2013).
+
+Parameters. We set $\alpha = 0 . 0 8$ for I-FGSM and $\alpha = \epsilon / 2$ for $\mathrm { P G D _ { 2 } }$ . For C&W: for $5 \times 2 0$ iterations3, learning rate $\eta = 0 . 5$ and initial constant $\lambda = 1 . 0$ ; for $1 \times 1 0 0$ iterations, $\eta = 0 . 1$ and $\lambda = 1 0 . 0$ .
+
+CIFAR10 (Krizhevsky & Hinton, 2009). We use a simple CNN network with nine convolutional layers, two max-pooling layers, ending in global average pooling and a fully connected layer. Its accuracy is 0:927. Batch normalization (Ioffe & Szegedy, 2015) is applied after every convolutional layer. It also uses LeakyRelu.
+
+Parameters. We set $\alpha = 0 . 0 8$ for I-FGSM and $\alpha = \epsilon / 2$ for $\mathrm { P G D _ { 2 } }$ . For C&W: for $5 \times 2 0$ iterations, learning rate $\eta = 0 . 1$ and initial constant $\lambda = 0 . 1$ ; for $1 \times 1 0 0$ iterations, $\eta = 0 . 0 1$ , and $\lambda = 1 . 0$ .
+
+<table><tr><td></td><td>#Grads</td><td>Psuc</td><td>D</td></tr><tr><td>Rounding in the end</td><td>20 100</td><td>1.00 1.00</td><td>1.44 1.43</td></tr><tr><td>Rounding at each iteration</td><td>20 100</td><td>1.00 1.00</td><td>0.41 0.32</td></tr><tr><td>Rounding with QIN, QoUT</td><td>20 100</td><td>1.00 1.00</td><td>0.35 0.28</td></tr></table>
+
+Table 1: Success probability $P _ { \mathrm { s u c } }$ and average distortion $\overline { { D } }$ of our method BP on ImageNet with different quantization strategies.
+
+ImageNet (Kurakin et al., 2018) comprises 1,000 images from ImageNet (Deng et al., 2009). We use InceptionV3 (Szegedy et al., 2016) whose accuracy is 0:96.
+
+Parameters. We set $\alpha = 0 . 0 8$ for I-FGSM and $\alpha = 3$ for $\mathrm { P G D _ { 2 } }$ . For C&W: for $5 \times 2 0$ iterations, learning rate $\eta = 0 . 0 1$ and initial constant $\lambda = 2 0$ ; for $1 \times 1 0 0$ iterations, $\eta = 0 . 0 1$ and $\lambda = 1 . 0$ .
+
+# 4.2 EVALUATION PROTOCOL
+
+We evaluate an attack by its runtime, two global statistics $P _ { \mathrm { s u c } }$ and $\overline { { D } }$ , and by an operating characteristic curve $D \to \mathsf { P } ( D )$ measuring distortion vs. probability of success as described below.
+
+Since we focus on the speed-distortion trade-off, we measure the required time for all attacks. For the iterative attacks, the complexity of one iteration is largely dominated by the computation of the gradient, which requires one forward and one backward pass through the network. It is thus fair to gauge their complexity by this number, referred to as iterations or ‘# Grads’. Indeed, the actual timings of 100 iterations for I-FGSM, $\mathrm { P G D _ { 2 } }$ , C&W, DDN and BP are 1.08, 1.36, 1.53, 1.46 and 1.17 s/image on average respectively on ImageNet, using Tensorflow, Cleverhans implementation for I-FGSM and C&W, and authors implementation for DDN.
+
+We measure distortion when the adversarial images are quantized by rounding each element to the nearest element in $\mathcal { X }$ . This makes sense since adversarial images are meant to be stored or communicated as images rather than real-valued matrices. DDN and BP adversarial images are already quantized. For reference, we report distortion without quantization in Appendix B.3.
+
+Given a test set of $N ^ { \prime }$ images, we only consider its subset $X$ of $N$ images that are classified correctly without attack. The accuracy of the classifier is $N / N ^ { \prime }$ . Let $X _ { \mathrm { s u c } }$ be the subset of $X$ with $N _ { \mathrm { s u c } } : =$ $| X _ { \mathrm { s u c } } |$ where the attack succeeds and let $D ( \mathbf { x } ) : = \| \mathbf { x } - \mathbf { y } \|$ be the distortion for image $\mathbf { x } \in X _ { \mathrm { s u c } }$ . The global statistics are the success probability $P _ { \mathrm { s u c } }$ and conditional average distortion $\overline { { D } }$
+
+$$
+P _ { \mathrm { s u c } } : = \frac { N _ { \mathrm { s u c } } } { N } , \quad \overline { { D } } : = \frac { 1 } { N _ { \mathrm { s u c } } } \sum _ { { \bf x } \in X _ { \mathrm { s u c } } } D ( { \bf x } ) .
+$$
+
+Here, $\overline { { D } }$ is conditioned on success. Indeed, distortion makes no sense for a failure.
+
+We define the operating characteristic of a given attack over the set $X$ as the function $\mathsf { P }$ : $[ 0 , D _ { \mathrm { m a x } } ]  [ 0 , \bar { 1 } ]$ , where $D _ { \mathrm { m a x } } : = \mathrm { m a x } _ { \mathbf { x } \in X _ { \mathrm { s u c } } } D ( \mathbf { x } )$ . Given $D \in [ 0 , D _ { \operatorname* { m a x } } ] , \mathsf { P } ( D$ is the probability of success subject to distortion being upper bounded by $D$ ,
+
+$$
+\mathsf { P } ( D ) : = \frac { 1 } { N } | \{ \mathbf { x } \in X _ { \mathrm { s u c } } : D ( \mathbf { x } ) \leq D \} | .
+$$
+
+This function increases from ${ \mathsf { P } } ( 0 ) = 0$ to $\mathsf { P } ( D _ { \mathrm { m a x } } ) = P _ { \mathrm { s u c } }$ . We sample one intermediate point: $P _ { \mathrm { u p p } } : = \mathsf { P } ( D _ { \mathsf { u p p } } )$ is the success rate within a distortion upper bounded by $D _ { \mathsf { u p p } } \in ( 0 , D _ { \mathrm { m a x } } )$ .
+
+It is difficult to define a fair comparison of distortion targeting attacks to success targeting attacks (see section 2.2). For the first family, we run a given attack several times over the test set with different target distortion $\epsilon$ . The attack succeeds on image $\textbf { x } \in \ X$ if it succeeds on at least one of the runs, and the distortion $D ( \mathbf { x } )$ is the minimum distortion over all successful runs. All statistics are then evaluated as above.
+
+Table 2: Success probability $P _ { \mathrm { s u c } }$ and average distortion $\overline { { D } }$ with quantization. $P _ { \mathrm { u p p } }$ is the success rate under distortion budget $D _ { \mathrm { u p p } } = 2$ for MNIST, 0:7 for CIFAR10, and 1 for ImageNet.   
+
+<table><tr><td></td><td></td><td colspan="3">MNIST</td><td colspan="3">CIFAR10</td><td colspan="3">ImageNet</td></tr><tr><td>Attack</td><td>#Grads</td><td>Psuc</td><td>D</td><td>Pupp</td><td>Psuc</td><td>D</td><td>Pupp</td><td>Psuc</td><td>D</td><td>Pupp</td></tr><tr><td>FGSM</td><td>1</td><td>0.99</td><td>5.80</td><td>0.00</td><td>0.95</td><td>5.65</td><td>0.00</td><td>0.88</td><td>9.18</td><td>0.00</td></tr><tr><td rowspan="2">I-FGSM</td><td>20</td><td>1.00</td><td>3.29</td><td>0.17</td><td>1.00</td><td>3.54</td><td>0.00</td><td>1.00</td><td>4.90</td><td>0.00</td></tr><tr><td>100</td><td>1.00</td><td>3.23</td><td>0.18</td><td>1.00</td><td>3.53</td><td>0.00</td><td>1.00</td><td>4.90</td><td>0.00</td></tr><tr><td rowspan="2">PGD2</td><td>20</td><td>1.00</td><td>1.80</td><td>0.63</td><td>1.00</td><td>0.66</td><td>0.76</td><td>0.63</td><td>3.63</td><td>0.00</td></tr><tr><td>100</td><td>1.00</td><td>1.74</td><td>0.66</td><td>1.00</td><td>0.60</td><td>0.84</td><td>1.00</td><td>1.85</td><td>0.00</td></tr><tr><td rowspan="2">C&amp;W</td><td>5×20</td><td>1.00</td><td>1.94</td><td>0.56</td><td>0.99</td><td>0.56</td><td>0.81</td><td>1.00</td><td>1.70</td><td>0.00</td></tr><tr><td>1×100</td><td>0.98</td><td>1.90</td><td>0.57</td><td>0.87</td><td>0.38</td><td>0.76</td><td>0.97</td><td>2.57</td><td>0.00</td></tr><tr><td rowspan="2">DDN</td><td>20</td><td>0.82</td><td>1.40</td><td>0.70</td><td>1.00</td><td>0.63</td><td>0.74</td><td>0.99</td><td>1.18</td><td>0.05</td></tr><tr><td>100</td><td>1.00</td><td>1.41</td><td>0.87</td><td>1.00</td><td>0.21</td><td>0.98</td><td>1.00</td><td>0.43</td><td>0.97</td></tr><tr><td rowspan="2">BP (this work)</td><td>20</td><td>1.00</td><td>1.45</td><td>0.86</td><td>0.97</td><td>0.49</td><td>0.87</td><td>1.00</td><td>0.35</td><td>0.96</td></tr><tr><td>100</td><td>1.00</td><td>1.37</td><td>0.91</td><td>0.97</td><td>0.30</td><td>0.97</td><td>1.00</td><td>0.28</td><td>1.00</td></tr></table>
+
+![](images/e38fcbc23f78850bf24be6cfa547226dd850506b43d018d6e3452f487358efc7.jpg)  
+Figure 3: Operating characteristics on MNIST, CIFAR10 and ImageNet. The number of iterations is $5 \times 2 0$ for C&W and 100 for I-FGSM, $\mathrm { P G D _ { 2 } }$ , DDN and our BP.
+
+# 4.3 QUANTIZATION
+
+Before addressing the benchmark, Table 1 shows the critical role of quantization in our method BP. Since this attack is iterative and works with continuous vectors, one may quantize only at the end of the process, or at the end of each iteration. Another option is to anticipate the detrimental action of quantizing by adapting the length of each step accordingly, as done by $Q _ { \mathrm { I N } } ( \cdot )$ and $Q _ { \mathrm { { o U T } } } ( \cdot )$ in Algorithm 2. The experimental results show that the key is to quantize often so to let the next iterations compensate. Anticipating and adapting gives a substantial extra improvement.
+
+# 4.4 ATTACK EVALUATION
+
+Table 2 summarizes the global statistics of the benchmark. Fig. 3 offers a more detailed view per dataset with operating characteristic plots.
+
+In terms of average distortion, all iterative attacks perform much better than the single-step FGSM. The performances of C&W are on par with those of I-FGSM, which is unexpected for this more elaborated attack design. The reason is that C&W is put under stress in our benchmark. It usually requires a bigger number of iterations to deliver high quality images. Note that it is possible to avoid the line search on parameter $\lambda$ as shown in row $1 \times 1 0 0$ . However, it requires a fine tuning so that this single value works over all the images of the dataset. This is not possible for ImageNet.
+
+DDN and our method BP are clearly ahead of the benchmark. DDN yields lower distortion on MNIST at fewer iterations, but its probability of success is not satisfying. DDN is indeed better than BP only on CIFAR10 at 100 iterations. Fig. 3 reveals that the two attacks have similar operating characteristic on all datasets but this is because it refers to 100 iterations.
+
+In terms of success rate, FGSM fails on MNIST; on CIFAR10, I-FGSM and $\mathrm { P G D _ { 2 } }$ fail as well;   
+finally on ImageNet, C&W fails too. DDN also fails on ImageNet at 20 iterations.
+
+Increasing the number of iterations helps but not at the same rate for all the attacks. For instance, going from 20 to 100 iterations is waste of time for I-FGSM while it is essential for decreasing the distortion of DDN or making $\mathrm { P G D _ { 2 } }$ efficient on ImageNet. Most importantly, our attack BP brings a dramatic improvement in the speed vs. distortion trade-off. Just within 20 iterations, the
+
+<table><tr><td></td><td></td><td colspan="6">MNIST</td><td colspan="6">CIFAR10</td></tr><tr><td>Attack→</td><td></td><td colspan="2">PGD2</td><td colspan="2">DDN</td><td colspan="2">BP</td><td colspan="2">PGD2</td><td colspan="2">DDN</td><td colspan="2">BP</td></tr><tr><td>↓Defense</td><td></td><td>20</td><td>100</td><td>20</td><td>100</td><td>20</td><td>100</td><td>20</td><td>100</td><td>20</td><td>100</td><td>20</td><td>100</td></tr><tr><td rowspan="4">baseline</td><td>Psuc</td><td>1.00</td><td>1.00</td><td>0.82</td><td>1.00</td><td>1.00</td><td>1.00</td><td>1.00</td><td>1.00</td><td>1.00</td><td>1.00</td><td>0.97</td><td>0.97</td></tr><tr><td>D</td><td>1.80</td><td>1.74</td><td>1.40</td><td>1.41</td><td>1.45</td><td>1.37</td><td>0.66</td><td>0.59</td><td>0.63</td><td>0.21</td><td>0.49</td><td>0.30</td></tr><tr><td>Pupp</td><td>0.63</td><td>0.66</td><td>0.70</td><td>0.87</td><td>0.86</td><td>0.91</td><td>0.76</td><td>0.84</td><td>0.74</td><td>0.98</td><td>0.87</td><td>0.97</td></tr><tr><td>Psuc</td><td>1.00</td><td>1.00</td><td>0.51</td><td>1.00</td><td>0.89</td><td>1.00</td><td>1.00</td><td>1.00</td><td>1.00</td><td>1.00</td><td>0.99</td><td>1.00</td></tr><tr><td rowspan="3">FGSM</td><td>D</td><td>1.92</td><td>1.85</td><td>1.28</td><td>1.60</td><td>1.92</td><td>1.58</td><td>0.68</td><td>0.62</td><td>0.59</td><td>0.24</td><td>0.67</td><td>0.24</td></tr><tr><td>Pupp</td><td>0.48</td><td>0.53</td><td>0.44</td><td>0.72</td><td>0.53</td><td>0.73</td><td>0.72</td><td>0.79</td><td>0.80</td><td>0.98</td><td>0.72</td><td>0.99</td></tr><tr><td>Psuc</td><td>0.99</td><td>1.00</td><td>0.29</td><td>1.00</td><td>0.99</td><td>1.00</td><td>1.00</td><td>1.00</td><td>0.98</td><td>1.00</td><td>1.00</td><td>1.00</td></tr><tr><td rowspan="3">DDN</td><td>D</td><td>3.03</td><td>2.89</td><td>1.68</td><td>2.38</td><td>2.69</td><td>2.27</td><td>0.95</td><td>0.94</td><td>0.77</td><td>0.71</td><td>0.75</td><td>0.68</td></tr><tr><td>Pupp</td><td>0.12</td><td>0.14</td><td>0.20</td><td>0.32</td><td>0.28</td><td>0.34</td><td>0.52</td><td>0.52</td><td>0.54</td><td>0.55</td><td>0.56</td><td>0.58</td></tr><tr><td>Psuc</td><td>0.94</td><td>0.96</td><td>0.36</td><td>1.00</td><td>0.95</td><td>1.00</td><td>1.00</td><td>1.00</td><td>0.97</td><td>1.00</td><td>1.00</td><td>1.00</td></tr><tr><td rowspan="3">BP</td><td>D</td><td>3.14</td><td>3.12</td><td>1.65</td><td>2.81</td><td>2.98</td><td>2.73</td><td>0.96</td><td>0.94</td><td>0.75</td><td>0.70</td><td>0.76</td><td>0.69</td></tr><tr><td>Pupp</td><td>0.15</td><td>0.15</td><td>0.24</td><td>0.27</td><td>0.25</td><td>0.26</td><td>0.55</td><td>0.55</td><td>0.57</td><td>0.59</td><td>0.56</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>0.59</td></tr></table>
+
+Table 3: Success probability $P _ { \mathrm { s u c } }$ , average distortion $\overline { { D } }$ , and success rate $P _ { \mathrm { u p p } }$ under adversarial training defense with I-FGSM, DDN, or BP (with 20 iterations) as the reference attack. For the MNIST, the model is trained from scratch. For CIFAR10, it is fine-tuned for 30 extra epochs as suggested by Rony et al. (2018) with DDN and BP, and trained from scratch for 200 epochs with FGSM. $P _ { \mathrm { u p p } }$ measured at distortion $D _ { \mathrm { u p p } } = 2$ for MNIST, and 0:7 for CIFAR10.
+
+distortion achieved on ImageNet is very low compared to the others. Appendix B.2 shows the speed vs. distortion trade-off in more detail.
+
+Statistics of BP stages are as follows: On CIFAR-10 and MNIST, Stage 1 takes 7 iterations on average. On ImageNet, Stage 1 takes on average 3 iterations out of 20, or 8 iterations out of 100.
+
+Appendix C shows examples of images along with corresponding adversarial examples and perturbations for different methods.
+
+# 4.5 DEFENSE EVALUATION WITH ADVERSARIAL TRAINING
+
+We also test under adversarial training (Goodfellow et al., 2014). The network is re-trained with a dataset composed of the original training set and the corresponding adversarial images. This training is special: at the end of each epoch, the network is updated and fixed, then the adversarial images for this new update are forged by some reference attack, and the next epoch starts with this new set. This is tractable only if the reference attack is fast. We use it with FGSM as the reference attack.
+
+It is more interesting to study DDN and BP as alternatives to FGSM: at 20 iterations, they are fast enough to play the role of the reference attack in adversarial training. In this case, we follow the training process suggested by Rony et al. (2018): the model is first trained on clean examples, then fine-tuned for 30 iterations with adversarial examples. As shown in Table 3, DDN and BP perform equally better than FGSM on CIFAR10, in terms of either average distortion or success rate. Among the reliable attacks (i.e. whose $P _ { \mathrm { s u c } }$ is close to 1), the worst attack now requires a distortion three times larger than the distortion of the worst attack without defense. In the same way, on MNIST, the distortion of the worst case attack doubles going from 1:37 (baseline) to 2:73 (BP defense). In most cases, BP is a better defense than DDN, forcing the attacker to have $20 \%$ more distortion. Note that for a given defense, the strongest attack is almost always BP.
+
+# 5 DISCUSSION
+
+The main idea of BP is to travel on the manifold defined by the class boundary while seeking to minimize distortion. This travel is operated by the refinement stage, which alternates on both sides of the boundary, but attempts to stay mostly in the adversarial region. Referring to section 2.1, BP is in effect doing for the target success problem what $\mathrm { P G D _ { 2 } }$ is doing for the target distortion problem: BP minimizes distortion on the class boundary manifold (a level set of the classification loss), while $\mathrm { P G D _ { 2 } }$ minimizes the classification loss on a sphere (a level set of the distortion).
+
+BP also takes into account the detrimental effect of quantization. By doing so, the amplitude of the perturbation is controlled from one iteration to another. The main advantage of our attack is the small number of iterations required to achieve both reliability (probability of success close to one) and high quality (low average distortion).
+
+# REFERENCES
+
+P-A Absil, Robert Mahony, and Rodolphe Sepulchre. Optimization algorithms on matrix manifolds. Princeton University Press, 2009.
+
+Laurent Amsaleg, James E. Bailey, Dominique Barbe, Sarah Erfani, Michael E Houle, Vinh Nguyen, and Milos Radovanovic. The Vulnerability of Learning to Adversarial Perturbation Increases with Intrinsicˇ Dimensionality. In Proc. of WIFS 2017, Rennes, France, December 2017.
+
+Aharon Azulay and Yair Weiss. Why do deep convolutional networks generalize so poorly to small image transformations? Technical report, 2018.
+
+Silvere Bonnabel. Stochastic gradient descent on riemannian manifolds. IEEE Transactions on Automatic Control, 58(9):2217–2229, 2013.
+
+Wieland Brendel, Jonas Rauber, and Matthias Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. In ICLR, 2018.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE Symp. on Security and Privacy, 2017.
+
+Nicholas Carlini and David Wagner. Audio adversarial examples: Targeted attacks on speech-to-text. Technical report, 2018.
+
+Koby Crammer and Yoram Singer. On the algorithmic implementation of multiclass kernel-based vector machines. Journal of Machine Learning Research, 2(Dec), 2001.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pp. 248–255. Ieee, 2009.
+
+Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling cnns with simple transformations. Technical report, 2017.
+
+Alhussein Fawzi, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Robustness of classifiers: From adversarial to random noise. Technical report, 2016.
+
+A. Gersho and R.M. Gray. Vector Quantization and Signal Compression. The Springer International Series in Engineering and Computer Science. Springer US, 1991. ISBN 9780792391814.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv:1412.6572, 2014.
+
+Mehrtash Harandi and Basura Fernando. Generalized backpropagation, etude de cas: Orthogonality. Technical report, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, 2015.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv:1412.6980, 2015.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv:1607.02533, 2016.
+
+Alexey Kurakin, Ian Goodfellow, Samy Bengio, Yinpeng Dong, Fangzhou Liao, Ming Liang, Tianyu Pang, Jun Zhu, Xiaolin Hu, Cihang Xie, et al. Adversarial attacks and defences competition. arXiv:1804.00097, 2018.
+
+Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. AT&T Labs [Online]. Available: http://yann. lecun. com/exdb/mnist, 2, 2010.
+
+Jie Li, Rongrong Ji, Hong Liu, Xiaopeng Hong, Yue Gao, and Qi Tian. Universal perturbation attack against image retrieval. Technical report, 2018.
+
+Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. In ICML, volume 30, 2013.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv:1706.06083, 2017.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. arXiv:1610.08401, 2016a.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In CVPR, 2016b.
+
+Maximilian Nickel and Douwe Kiela. Poincare embeddings for learning hierarchical representations. Technical ´ report, 2017.
+
+Nicolas Papernot, Fartash Faghri, Nicholas Carlini, Ian Goodfellow, Reuben Feinman, Alexey Kurakin, Cihang Xie, Yash Sharma, Tom Brown, Aurko Roy, Alexander Matyasko, Vahid Behzadan, Karen Hambardzumyan, Zhishuai Zhang, Yi-Lin Juang, Zhi Li, Ryan Sheatsley, Abhibhav Garg, Jonathan Uesato, Willi Gierke, Yinpeng Dong, David Berthelot, Paul Hendricks, Jonas Rauber, and Rujun Long. Technical report on the cleverhans v2.1.0 adversarial examples library. arXiv:1610.00768, 2018.
+
+Jer´ ome Rony, Luiz G. Hafemann, Luis S. Oliveira, Ismail Ben Ayed, Robert Sabourin, and Eric Granger. ˆ Decoupling direction and norm for efficient gradient-based l2 adversarial attacks and defenses. Technical report, 2018.
+
+Mahmood Sharif, Lujo Bauer, and Michael K. Reiter. On the suitability of $l _ { p }$ -norms for creating and preventing adversarial examples. arXiv:1802.09653, 2018.
+
+Carl-Johann Simon-Gabriel, Yann Ollivier, Bernhard Scholkopf, L ¨ eon Bottou, and David Lopez-Paz. Adver- ´ sarial vulnerability of neural networks increases with input dimension. Technical report, 2018.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv:1312.6199, 2013.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016.
+
+G. Tolias, F. Radenovic, and O. Chum. Targeted mismatch adversarial attack: Query with a flower to retrieve the tower. In Proc. of ICCV, 2019.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble adversarial \` training: Attacks and defenses. arXiv:1705.07204, 2017a.
+
+Florian Tramer, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick McDaniel. The space of transfer- \` able adversarial examples. arXiv:1704.03453, 2017b.
+
+Zhou Wang, Alan C Bovik, Hamid R Sheikh, and Eero P Simoncelli. Image quality assessment: from error visibility to structural similarity. IEEE Trans. on image processing, 13(4), 2004.
+
+Cihang Xie, Jianyu Wang, Zhishuai Zhang, Yuyin Zhou, Lingxi Xie, and Alan Yuille. Adversarial examples for semantic segmentation and object detection. arXiv:1703.08603, 2017.
+
+Hongyi Zhang, Sashank J Reddi, and Suvrit Sra. Riemannian svrg: Fast stochastic optimization on riemannian manifolds. In NIPS, pp. 4592–4600, 2016.
+
+# A PREDICTING DISTORTION AFTER QUANTIZATION
+
+This appendix aims at predicting the norm of the update after quantization, assuming that it is independent from the computation of the perturbation. Iteration $i$ starts with a quantized image $\mathbf { y } _ { i } \in \mathcal { X }$ , adds update $\mathbf { u } \in \mathbb { R } ^ { n }$ , and then quantizes s.t. $\mathbf { y } _ { i + 1 } = Q ( \mathbf { y } _ { i } + \mathbf { u } )$ . Quantization is done by rounding with $\Delta : = 1 / ( L - 1 )$ the quantization step. Pixel $j$ is quantized to
+
+$$
+y _ { i + 1 , j } = y _ { i , j } + e _ { j }
+$$
+
+for some $e _ { j } \in \Delta \mathbb { Z }$ such that $u _ { j } \in ( e _ { j } - \Delta / 2 , e _ { j } + \Delta / 2 ]$ . Border effects where $y _ { i , j } + e _ { j } \notin \mathcal { X }$ are neglected.
+
+We now take a statistical point of view where the update is modelled by a random vector $\mathbf { U }$ uniformly distributed over the hypersphere of radius $\rho$ . That parameter $\rho$ is the norm of the perturbation before quantization. This yields random quantization values, denoted by $E _ { j } \in \Delta \mathbb { Z }$ for pixel $j$ . The distortion between the two images is
+
+$$
+D ^ { 2 } = \sum _ { j = 1 } ^ { n } \left( y _ { i + 1 , j } - y _ { i , j } \right) ^ { 2 } = \sum _ { j = 1 } ^ { n } E _ { j } ^ { 2 } .
+$$
+
+A common approach in source coding theory is the additive noise model for quantization error in the high resolution regime (Gersho $\&$ Gray, 1991). It states that $E _ { j } ~ = ~ U _ { j } + Q _ { j }$ where $Q _ { j } \in$ $( - \Delta / \bar { 2 } , \Delta / 2 ]$ is the quantization error. When $\rho \gg \Delta$ , then $Q _ { j }$ becomes uniformly distributed (s.t. $\operatorname { E } ( Q _ { j } ) = 0$ and $\mathrm { E } ( Q _ { j } ^ { 2 } ) = \Delta ^ { 2 } / 1 2 )$ and independent of $U _ { j }$ (s.t. $\operatorname { E } ( U _ { j } Q _ { j } ) = \operatorname { E } ( U _ { j } ) \operatorname { E } ( Q _ { j } ) = 0 )$ . Under these assumptions, Eq. 24 simplifies in expectation to:
+
+$$
+\operatorname { E } ( D ^ { 2 } ) = \operatorname { E } \left( \sum _ { j = 1 } ^ { n } U _ { j } ^ { 2 } + Q _ { j } ^ { 2 } + 2 U _ { j } Q _ { j } \right) = \rho ^ { 2 } + n { \frac { \Delta ^ { 2 } } { 1 2 } } .
+$$
+
+This shows that quantization increases the distortion on expectation.
+
+Yet, this simple analysis is wrong outside the high resolution regime, and we need to be more careful. The expectation of a sum is always the sum of the expectations, whatever the dependence between the summands: $\begin{array} { r } { \mathrm { E } ( D ^ { 2 } ) = \sum _ { j = 1 } ^ { n } \bar { \mathrm { E } } ( E _ { j } ^ { 2 } ) = n \mathrm { E } ( E _ { j } ^ { 2 } ) } \end{array}$ with
+
+$$
+\mathrm { E } ( E _ { j } ^ { 2 } ) = \Delta ^ { 2 } \sum _ { \ell = 0 } ^ { L - 1 } \ell ^ { 2 } \mathrm { P } ( | E _ { j } | = \ell \Delta ) .
+$$
+
+We need the distribution of $E _ { j }$ to compute the expected distortion after quantizarion. This random variable $E _ { j }$ takes a value depending on the scalar product $S _ { j } : = \mathbf { U } ^ { \top } \mathbf { c } _ { j }$ , where $\mathbf { c } _ { j }$ is the $j$ -th canonical vector. This scalar product lies in $[ - \rho , \rho ]$ , so that $\mathrm { P } ( E _ { j } \geq \ell \Delta ) = \bar { 0 }$ if $\ell \Delta - \bar { \Delta } / 2 > \| \rho \|$ . Otherwise, $E _ { j } \geq \ell \Delta$ when $| \bar { S _ { j } } | \ge \ell \Delta - \Delta / 2$ , which happens when U lies inside the dual hypercone of axis $\mathbf { c } _ { j }$ and semi-angle $\theta ( \ell ) = \operatorname { a r c c o s } ( s ( \ell ) )$ with $s ( \ell ) : = ( 2 \ell - 1 ) \Delta / 2 \| \rho \|$ . The probability of this event is equal to the ratio of the solid angles of this dual hypercone and the full space $\mathbb { R } ^ { n }$ . This quantity can be expressed via the incomplete regularized beta function p $I$ , and approximately equals $\bar { 2 } \Phi ( \sqrt { n } s ( \ell ) / 2 )$ for large $n$ . In the end, $\forall \ell \in \{ 0 , \ldots , L - 1 \}$ ,
+
+$$
+\begin{array} { r } { \mathrm { P } ( | E _ { j } | \geq \ell \Delta ) = \left\{ \begin{array} { l l } { 1 , \quad \mathrm { i f } \ell = 0 } \\ { 1 - I _ { s ( \ell ) ^ { 2 } } ( 1 / 2 , ( n - 1 ) / 2 ) , \quad \mathrm { i f } 0 \leq s ( \ell ) \leq 1 } \\ { 0 , \quad \mathrm { o t h e r w i s e } } \end{array} \right. } \end{array}
+$$
+
+Computing $\mathrm { E } ( D ^ { 2 } )$ is now possible because $\mathrm { P } \big ( | E _ { j } | = \ell \Delta \big ) = \mathrm { P } \big ( | E _ { j } | \ge \ell \Delta \big ) - \mathrm { P } \big ( | E _ { j } | \ge ( \ell + 1 ) \Delta \big )$ . This expected distortion after quantization depends on $\Delta , n$ , and $\rho$ the norm of the perturbation before quantization. Figure 4 shows that quantization reduces the distortion outside the high resolution regime. Indeed, $\sqrt { \operatorname { E } ( D ^ { 2 } ) }$ is close to 0 for $\rho < 0 . 1$ when $n = 3 * 2 9 9 ^ { 2 }$ (i.e. ImageNet). When the update has a small norm $\rho$ , quantization is likely to kill it, $\mathbf { y } _ { i + 1 } = \mathbf { y } _ { i }$ , and we waste one iteration. On the contrary, $\sqrt { \mathrm { E } ( D ^ { 2 } ) }$ converges to $\sqrt { \rho ^ { 2 } + n \Delta ^ { 2 } / 1 2 }$ for large $\rho$ (i.e. in the high resolution regime). Note that the ratio of the distortions before and after quantization $\rho / \sqrt { \mathrm { E } ( D ^ { 2 } ) }$ quickly converges to 1 for large $\rho$ .
+
+![](images/89ba38a6dd304505852bfadb926fc76a99bf4610ee30ca367361a8b37fdc421e.jpg)  
+Figure 4: $\sqrt { \mathrm { E } ( D ^ { 2 } ) }$ as a function of $\rho$ for $n = 3 * 2 9 9 ^ { 2 }$ and $\Delta = 1 / 2 5 5$ .
+
+# B ADDITIONAL EXPERIMENTS
+
+# B.1 PARAMETER STUDY
+
+There are two parameters in BP: $\alpha$ and $\gamma _ { m i n }$ . Both determine the step size of stage 1, while $\gamma _ { m i n }$ also determines the step size of stage 2. We consider 4 values for $\alpha$ , i.e. 1; 2; 3; 4 and 9 values for $\gamma _ { m i n }$ , i.e. 0:1; 0:2; :::; 0:9. For each pair of values, we evaluate BP with 20 iterations on a validation set, which we define as a random subset sampled of the training set: 10000 images for MNIST and CIFAR10, and 1000 images for ImageNet. As shown in Fig. 5, success probability is close to one in all cases, while average distortion is in general stable up to $\gamma _ { \mathrm { m i n } } = 0 . 8$ . We choose $\alpha = 2$ and $\gamma _ { \mathrm { m i n } } = 0 . 7$ for all experiments.
+
+![](images/9d73dd3d65f9e56ff06446d57c2898a4a7fed84b009358bbc8917870534decf6.jpg)  
+Figure 5: Success probability $P _ { \mathrm { s u c } }$ and average distortion $\overline { { D } }$ for different values of parameters $\alpha$ and $\gamma _ { m i n }$ of BP with 20 iterations.
+
+# B.2 SPEED vs. DISTORTION TRADE-OFF
+
+Figure 6(a) is a graphical view of some results reported in Table 2 with more choices of number of iterations between 20 and 100, and only for ImageNet where our performance gain is the most significant. Just within 20 iterations, its distortion $\breve { D }$ is already so much lower than that of other attacks, that its decrease ( $- 2 0 \%$ at 100 iterations) is not visible in Fig. 6. On the contrary, more iterations are useless for I-FGSM, and $\mathrm { P G D _ { 2 } }$ can achieve low distortion only with a number of iterations bigger than 50. Figure 6(b) confirms that the probability of success is close to 1 for both DDN and BP for the numbers of iterations considered.
+
+![](images/2a7dcbc1fc15cd8d04476ae15eb8511d37536b147d7f856a3f076e905e4bbda2.jpg)  
+Figure 6: (a) Average distortion vs. number of iterations for I-FGSM, $\mathrm { P G D _ { 2 } }$ , C&W, DDN and our method BP on ImageNet. I-FGSM is not improving with iterations because it is constrained by $\epsilon$ . (b) Corresponding probability of success vs. number of iterations for $\mathrm { P G D _ { 2 } }$ and BP.
+
+Table 4 is the equivalent of Table 2 but without the integral constraint: the attack is free to output any real matrix provided that the pixel values all belong to $[ 0 , 1 ]$ . When the distortion is large, there is almost no difference. The model of App. A explains this: We are in the high resolution regime and the extra term in Eq. 25 is negligible compared to the perturbation distortion before quantization. This is especially true when the number of samples $n$ is small (i.e. MNIST, and to some extend, CIFAR-10).
+
+When an attack delivers low distortion on average with real matrices, the quantization may lower the probability of success. This is especially true with the iterative attacks finding adversarial examples just nearby the border between the two classes. Quantization jeopardizes this point and sometimes brings it back in the true class region. More importantly, the impact of the quantization on the distortion is no longer negligible. This is clearly visible when comparing Table 4 and Table 2 for DDN and BP over ImageNet.
+
+Similarly, Fig. 7 is the equivalent of Fig. 3 without the integral constraint. By comparing the two figures, it can be seen that $\mathrm { P G D _ { 2 } }$ and C&W, but also DDN and BP, are improving on ImageNet by having significantly lower distortion. This agrees with measurements of success rate in Table 4, where $\mathrm { P G D _ { 2 } }$ and C&W are not failing as they do in Table 2 with quantization. Our BP is still the strongest attack over all datasets.
+
+<table><tr><td></td><td></td><td colspan="3">MNIST</td><td colspan="3">CIFAR10</td><td colspan="3">ImageNet</td></tr><tr><td>Attack</td><td>#Grads</td><td>Psuc</td><td>D</td><td>Pupp</td><td>Psuc</td><td>D</td><td>Pupp</td><td>Psuc</td><td>D</td><td>Pupp</td></tr><tr><td>FGSM</td><td>1</td><td>0.99</td><td>5.81</td><td>0.00</td><td>0.97</td><td>4.78</td><td>0.00</td><td>0.85</td><td>3.02</td><td>0.00</td></tr><tr><td rowspan="2">I-FGSM</td><td>20</td><td>1.00</td><td>3.22</td><td>0.27</td><td>1.00</td><td>3.54</td><td>0.00</td><td>1.00</td><td>4.47</td><td>0.00</td></tr><tr><td>100</td><td>1.00</td><td>3.16</td><td>0.29</td><td>1.00</td><td>3.53</td><td>0.00</td><td>1.00</td><td>4.47</td><td>0.00</td></tr><tr><td rowspan="2">PGD2</td><td>20</td><td>1.00</td><td>1.76</td><td>0.63</td><td>1.00</td><td>0.51</td><td>0.77</td><td>0.64</td><td>3.94</td><td>0.36</td></tr><tr><td>100</td><td>1.00</td><td>1.70</td><td>0.66</td><td>1.00</td><td>0.43</td><td>0.85</td><td>0.95</td><td>1.11</td><td>0.61</td></tr><tr><td rowspan="2">C&amp;W</td><td>5×20</td><td>1.00</td><td>1.93</td><td>0.56</td><td>1.00</td><td>0.56</td><td>0.81</td><td>1.00</td><td>1.37</td><td>0.23</td></tr><tr><td>1×100</td><td>1.00</td><td>1.89</td><td>0.57</td><td>0.97</td><td>0.38</td><td>0.84</td><td>1.00</td><td>1.87</td><td>0.06</td></tr><tr><td rowspan="2">DDN</td><td>20</td><td>0.82</td><td>1.39</td><td>0.70</td><td>1.00</td><td>0.62</td><td>0.74</td><td>1.00</td><td>0.76</td><td>0.95</td></tr><tr><td>100</td><td>1.00</td><td>1.41</td><td>0.87</td><td>1.00</td><td>0.20</td><td>0.98</td><td>1.00</td><td>0.28</td><td>0.99</td></tr><tr><td rowspan="2">BP (this work)</td><td>20</td><td>1.00</td><td>1.41</td><td>0.86</td><td>0.97</td><td>0.33</td><td>0.87</td><td>1.00</td><td>0.20</td><td>1.00</td></tr><tr><td>100</td><td>1.00</td><td>1.35</td><td>0.91</td><td>0.97</td><td>0.18</td><td>0.97</td><td>1.00</td><td>0.16</td><td>1.00</td></tr></table>
+
+Table 4: Success probability $P _ { \mathrm { s u c } }$ and average distortion $\overline { { D } }$ without quantization. $P _ { \mathrm { u p p } }$ measured at $D _ { \mathrm { u p p } } = 2$ for MNIST, 0:7 for CIFAR10, and 1 for ImageNet.
+
+![](images/83fabdb04f01de533359c4e5af7c94fa5a24d4204daaf1008f564774d77ca00c.jpg)  
+Figure 7: Operating characteristics on MNIST, CIFAR10 and ImageNet without quantization. The number of iterations is $5 \times 2 0$ for C&W and 100 for I-FGSM, $\mathrm { P G D _ { 2 } }$ , DDN and our BP.
+
+# B.4 ATTACK EVALUATION ON ROBUST MODELS
+
+Table 5 is similar to Table 2 but is evaluating attacks on robust models. In particular, on MNIST and CIFAR10, we use the same models as described in Section 4.1, which we adversarially train according to Madry et al. (2017). On ImageNet, we use off-the shelf4 InceptionV3 obtained by ensemble adversarial training on four models Tramer et al. (2017a). \`
+
+In general, DDN and BP outperform all other attacks in terms of either average distortion $\overline { { D } }$ or success rate $P _ { \mathrm { u p p } }$ . On ImageNet in particular, all other attacks have significantly higher distortion and fail in terms of success rate. DDN and BP have similar performance on CIFAR10. On MNIST, DDN fails in terms of probability of success at 20 iterations, while at 100 iterations BP is superior. On ImageNet, DDN has significantly greater distortion than BP and fails in terms of success rate at 20 iterations, while at 100 iterations BP still has lower distortion.
+
+Fig. 8 is showing a more detailed view of operating characteristics, similarly to Fig. 3 for models trained on natural images. We can see that BP is still ahead of the competition. It is close to DDN, but this is because Fig. 8 refers to 100 iterations. The two attacks outperform all others by a large margin.
+
+Table 5: Success probability $P _ { \mathrm { s u c } }$ , average distortion $\overline { { D } }$ , and success rate $P _ { \mathrm { u p p } }$ under adversarial training with PGD as the reference attack, following (Madry et al., 2017) for MNIST and CIFAR10; and ensemble adversarial training (Tramer et al., 2017a) for ImageNet. \` $P _ { \mathrm { u p p } }$ measured at $D _ { \mathrm { u p p } } = 2$ for MNIST, 0:7 for CIFAR10, and 1 for ImageNet.   
+
+<table><tr><td></td><td></td><td colspan="3">MNIST (Madry et al., 2017)</td><td colspan="2">CIFAR10 (Madry et al.,2017)</td><td colspan="3">ImageNet (Tramer et al.,2017a)</td></tr><tr><td>Attack</td><td>#Grads</td><td>Psuc</td><td>D</td><td>Pupp</td><td>Psuc</td><td>D Pupp</td><td>Psuc</td><td>D</td><td>Pupp</td></tr><tr><td>FGSM</td><td>1</td><td>0.48</td><td>5.69</td><td>0.05</td><td>0.98</td><td>6.21 0.00</td><td>0.44</td><td>2.98</td><td>0.00</td></tr><tr><td>I-FGSM</td><td>20 100</td><td>1.00 1.00</td><td>4.99 4.99</td><td>0.08 0.08</td><td>1.00 1.00</td><td>4.53 0.00 4.56 0.00</td><td>1.00 1.00</td><td>4.92 4.93</td><td>0.00 0.00</td></tr><tr><td>PGD2</td><td>20 100</td><td>0.99 1.00</td><td>2.76 2.68</td><td>0.19 0.20</td><td>1.00 1.00</td><td>1.03 0.41 1.02 0.41</td><td>0.76 0.98</td><td>2.14 1.59</td><td>0.00 0.00</td></tr><tr><td>C&amp;W</td><td>5×20 1×100</td><td>0.99 0.94</td><td>2.75 2.22</td><td>0.27 0.34</td><td>0.98 0.60</td><td>1.41 0.22 0.77 0.27</td><td>0.98 0.97</td><td>2.85 2.41</td><td>0.00 0.00</td></tr><tr><td>DDN</td><td>20 100</td><td>0.43 1.00</td><td>1.61 2.12</td><td>0.32 0.48</td><td>0.97 1.00</td><td>0.92 0.41 0.87 0.42</td><td>0.99 1.00</td><td>1.10 0.34</td><td>0.23 0.98</td></tr><tr><td>BP (this work)</td><td>20 100</td><td>1.00 1.00</td><td>2.17 2.00</td><td>0.46 0.51</td><td>1.00 1.00</td><td>0.94 0.41 0.88 0.43</td><td>1.00 1.00</td><td>0.35 0.23</td><td>0.94 0.99</td></tr></table>
+
+![](images/2966278716459b97c37a92849bbe0a641873f2ab60b70e913cd6593ca11d3286.jpg)  
+Figure 8: Operating characteristics of attacks against robust models: adversarial training with PGD as the reference attack (Madry et al., 2017) for MNIST and CIFAR10, and ensemble adversarial training (Tramer et al., 2017a) for ImageNet. The number of iterations is \` $5 \times 2 0$ for C&W and 100 for I-FGSM, $\mathrm { P G D _ { 2 } }$ , DDN and our BP.
+
+# C ADVERSARIAL IMAGE EXAMPLES
+
+Fig. 9 shows the worst-case ImageNet example for BP along with the adversarial examples generated by all methods and the corresponding normalized perturbations. FGSM has the highest distortion over all methods in this example and BP the lowest. DDN has the highest $\infty$ -norm distortion. Observe that for no method is the perturbation visible, although this is a worst-case example.
+
+![](images/e8eb050ec1a2e46767df06e34ae110b52565e61d41a3437baa2fc356ac80d7e8.jpg)  
+Figure 9: Original (left), adversarial (top row) and scaled perturbation (below) images against InceptionV3 on ImageNet. The five images are the worst 5 images for BP requiring the strongest distortions, yet these are smaller than the distortions necessary with all other methods (The red color means that the forged image is not adversarial). Perturbations are inverted (low is white; high is colored, per channel) and scaled in the same way for a fair comparison.

parse/train/KLH36ELmwIB/KLH36ELmwIB.md

@@ -0,0 +1,423 @@
+# DARTS-: ROBUSTLY STEPPING OUT OF PERFORMANCE COLLAPSE WITHOUT INDICATORS
+
+Xiangxiang $\mathbf { C h u ^ { 1 } }$ , Xiaoxing Wang1,2∗, Bo Zhang1, Shun $\mathbf { L u ^ { 1 , 3 * } }$ , Xiaolin Wei1, Junchi $\mathbf { Y a n } ^ { 2 \dagger }$   
+1Meituan, 2Shanghai Jiao Tong University, 3University of Chinese Academy of Sciences   
+{chuxiangxiang,zhangbo97,weixiaolin02}@meituan.com   
+{figure1 wxx,yanjunchi}@sjtu.edu.cn   
+lushun19@mails.ucas.ac.cn
+
+# ABSTRACT
+
+Despite the fast development of differentiable architecture search (DARTS), it suffers from long-standing performance instability, which extremely limits its application. Existing robustifying methods draw clues from the resulting deteriorated behavior instead of finding out its causing factor. Various indicators such as Hessian eigenvalues are proposed as a signal to stop searching before the performance collapses. However, these indicator-based methods tend to easily reject good architectures if the thresholds are inappropriately set, let alone the searching is intrinsically noisy. In this paper, we undertake a more subtle and direct approach to resolve the collapse. We first demonstrate that skip connections have a clear advantage over other candidate operations, where it can easily recover from a disadvantageous state and become dominant. We conjecture that this privilege is causing degenerated performance. Therefore, we propose to factor out this benefit with an auxiliary skip connection, ensuring a fairer competition for all operations. We call this approach DARTS-. Extensive experiments on various datasets verify that it can substantially improve robustness. Our code is available at https://github.com/Meituan-AutoML/DARTS-.
+
+# 1 INTRODUCTION
+
+Recent studies (Zela et al., 2020; Liang et al., 2019; Chu et al., 2020b) have shown that one critical issue for differentiable architecture search (Liu et al., 2019b) regarding the performance collapse due to superfluous skip connections. Accordingly, some empirical indicators for detecting the occurrence of collapse have been produced. R-DARTS (Zela et al., 2020) shows that the loss landscape has more curvatures (characterized by higher Hessian eigenvalues w.r.t. architectural weights) when the derived architecture generalizes poorly. By regularizing for a lower Hessian eigenvalue, Zela et al. (2020); Chen & Hsieh (2020) attempt to stabilize the search process. Meanwhile, by directly constraining the number of skip connections to a fixed number (typically 2), the collapse issue becomes less pronounced (Chen et al., 2019b; Liang et al., 2019). These indicator-based approaches have several main drawbacks. Firstly, robustness relies heavily on the quality of the indicator. An imprecise indicator either inevitably accepts poor models or mistakenly reject good ones. Secondly, indicators impose strong priors by directly manipulating the inferred model, which is somewhat suspicious, akin to touching the test set. Thirdly, extra computing cost (Zela et al., 2020) or careful tuning of hyper-parameters (Chen et al., 2019b; Liang et al., 2019) are required. Therefore, it’s natural to ask the following questions:
+
+• Can we resolve the collapse without handcrafted indicators and restrictions to interfere with the searching and/or discretization procedure?
+
+• Is it possible to achieve robustness in DARTS without tuning extra hyper-parameters?
+
+To answer the above questions, we propose an effective and efficient approach to stabilize DARTS. Our contributions can be summarized as follows:
+
+New Paradigm to Stabilize DARTS. While empirically observing that current indicators (Zela et al., 2020; Chen & Hsieh, 2020) can avoid performance collapse at a cost of reduced exploration coverage in the search space, we propose a novel indicator-free approach to stabilize DARTS, referred to as DARTS-1, which involves an auxiliary skip connection (see Figure 1) to remove the unfair advantage (Chu et al., 2020b) in the searching phase.
+
+Strong Robustness and Stabilization. We conduct thorough experiments across seven search spaces and three datasets to demonstrate
+
+![](images/2ca1f536bf1e323954a28c4fbbd59ffd44b2036412e387cc0ccb940f7be24143.jpg)  
+Figure 1: Schematic illustration about (a) DARTS and (b) the proposed DARTS-, featuring an auxiliary skip connection (thick red line) with a decay rate $\beta$ between every two nodes to remove the potential unfair advantage that leads to performance collapse.
+
+the effectiveness of our method. Specifically, our approach robustly obtains state-of-the-art results on 4 search space with $3 \times$ fewer search cost than R-DARTS (Zela et al., 2020), which requires four independent runs to report the final performance.
+
+Seamless Plug-in Combination with DARTS Variants. We conduct experiments to demonstrate that our approach can work together seamlessly with other orthogonal DARTS variants by removing their handcrafted indicators without extra overhead. In particular, our approach is able to improve $0 . 8 \%$ accuracy for P-DARTS, and $0 . 2 5 \%$ accuracy for PC-DARTS on CIFAR-10 dataset.
+
+# 2 RELATED WORK
+
+Neural architecture search and DARTS variants. Over the years, researchers have sought to automatically discover neural architectures for various deep learning tasks to relieve human from the tedious effort, ranging from image classification (Zoph et al., 2018), objection detection (Ghiasi et al., 2019), image segmentation (Liu et al., 2019a) to machine translation (So et al., 2019) etc. Among many proposed approaches, Differentiable Architecture Search (Liu et al., 2019b) features weight-sharing and resolves the searching problem via gradient descent, which is very efficient and easy to generalize. A short description of DARTS can be found in A.1. Since then, many subsequent works have been dedicated to accelerating the process (Dong & Yang, 2019b), reducing memory cost (Xu et al., 2020), or fostering its ability such as hardware-awareness (Cai et al., 2019; Wu et al., 2019), finer granularity (Mei et al., 2020) and so on. However, regardless of these endeavors, a fundamental issue of DARTS over its searching performance collapse remains not properly solved, which extremely prohibits its application.
+
+Robustifying DARTS. As DARTS (Liu et al., 2019b) is known to be unstable as a result of performance collapse (Chu et al., 2020b), some recent works have devoted to resolving it by either designing indicators like Hessian eigenvalues for the collapse (Zela et al., 2020) or adding perturbations to regularize such an indicator (Chen & Hsieh, 2020). Both methods rely heavily on the indicator’s accurateness, i.e., to what extent does the indicator correlate with the performance collapse? Other methods like Progressive DARTS (Chen et al., 2019b) and ${ \mathrm { D A R T S } } +$ (Liang et al., 2019) employ a strong human prior, i.e., limiting the number of skip-connections to be a fixed value. Fair DARTS (Chu et al., 2020b) argues that the collapse results from the unfair advantage in an exclusive competitive environment, from which skip connections overly benefit to cause an abundant aggregation. To suppress such an advantage from overshooting, they convert the competition into collaboration where each operation is independent of others. It is however an indirect approach. SGAS (Li et al., 2020), instead, circumvents the problem with a greedy strategy where the unfair advantage can be prevented from taking effect. Nevertheless, potentially good operations might be pruned out too early because of greedy underestimation.
+
+# 3 DARTS
+
+# 3.1 MOTIVATION
+
+We start from the detailed analysis of the role of skip connections. Skip connections were proposed to construct a residual block in ResNet (He et al., 2016), which significantly improves training stability. It is even possible to deepen the network up to hundreds of layers without accuracy degradation by simply stacking them up. In contrast, stacking the plain blocks of VGG has degenerated performance when the network gets deeper. Besides, Ren et al. (2015); Wei et al. (2017); Tai et al. (2017); Li et al. (2018b) also empirically demonstrate that deep residual network can achieve better performance on various tasks.
+
+From the gradient flow’s perspective, skip connection is able to alleviate the gradient vanishing problem. Given a stack of $n$ residual blocks, the output of the $( i + 1 ) ^ { \mathrm { t h } }$ residual block $X _ { i + 1 }$ can be computed as $X _ { i + 1 } = f _ { i + 1 } ( X _ { i } , W _ { i + 1 } ) + X _ { i }$ , where $f _ { i + 1 }$ denotes the operations of the $( i + 1 ) ^ { \mathrm { t h } }$ residual block with weights $W _ { i + 1 }$ . Suppose the loss function of the model is $\mathcal { L }$ , and the gradient of $X _ { i }$ can be obtained as follows (1 denotes a tensor whose items are all ones):
+
+$$
+\frac { \partial \mathcal { L } } { \partial X _ { i } } = \frac { \partial \mathcal { L } } { \partial X _ { i + 1 } } \cdot \left( \frac { \partial f _ { i + 1 } } { \partial X _ { i } } + 1 \right) = \frac { \partial \mathcal { L } } { \partial X _ { i + j } } \cdot \prod _ { k = 1 } ^ { j } \left( \frac { \partial f _ { i + k } } { \partial X _ { i + k - 1 } } + 1 \right)
+$$
+
+We observe that the gradient of shallow layers always includes the gradient of deep layers, which mitigates the gradient vanishing of $W _ { i }$ . Formally we have,
+
+$$
+\frac { \partial \mathcal { L } } { \partial W _ { i } } = \frac { \partial \mathcal { L } } { \partial X _ { i + j } } \cdot \prod _ { k = 1 } ^ { j } \left( \frac { \partial f _ { i + k } } { \partial X _ { i + k - 1 } } + \mathbb { 1 } \right) \cdot \frac { \partial f _ { i } } { \partial W _ { i } }
+$$
+
+To analyze how skip connect affects the performance of residual networks, we introduce a trainable coefficient $\beta$ on all skip connections in ResNet. Therefore, the gradient of $X _ { i }$ is converted to:
+
+$$
+\frac { \partial \mathcal { L } } { \partial X _ { i } } = \frac { \partial \mathcal { L } } { \partial X _ { i + 1 } } \cdot \left( \frac { \partial f _ { i + 1 } } { \partial X _ { i } } + \beta \right)
+$$
+
+Once $\beta < 1$ , gradients of deep layers gradually vanish during the back-propagation (BP) towards shallow layers. Here $\beta$ controls the memory of gradients in BP to stabilize the training procedure.
+
+We conduct a confirmatory experiment on ResNet50 and show the result in $\mathrm { F i g } \ 2$ . By initializing $\beta$ with $\{ 0 , 0 . 5 , 1 . 0 \}$ , we can visualize the tendency of $\beta$ along with training epochs. We observe that $\beta$ converges towards 1 after 40 epochs no matter the initialization, which demonstrates that the residual structure learns to push $\beta$ to a rather large value to alleviate gradient vanishing.
+
+Similarly, DARTS (Liu et al., 2019b) utilizes a trainable parameter $\beta _ { s k i p }$ to denote the importance of skip connection. However, In the search stage, $\beta _ { s k i p }$ can generally increase and dominate the architecture parameters, and finally leads to performance collapse. We analyze that a large $\beta _ { s k i p }$ in DARTS could result from two aspects: On the one hand, as the supernet automatically learns to alleviate gradient vanishing, it pushes $\beta _ { s k i p }$ to a proper large value; On the other hand, the skip connection is indeed an important connection for the target network, which should be selected in the discretization stage. As a consequence, the skip connection in DARTS plays two-fold roles: as an auxiliary connection to stabilize the supernet training, and as a candidate operation to build the final network. Inspired by the above observation and analysis, we propose to stabilize the search process by distinguishing the two roles of skip connection and handling the issue of gradient flow.
+
+![](images/6f78ee310b963f27f21baf3e4f1fce76a463b12ab1f9ab3ad040d3d42ec3feeb.jpg)  
+Figure 2: Tendency of trainable coefficient $\beta$ (initialized with $\{ 0 , \ 0 . 5 , \ 1 \} )$ of the skip connection in ResNet50 and test accuracy (inset figure) vs. epochs. The residual structure is proved to learn a large $\beta$ to ease training in all three cases. All models are trained and tested on CIFAR-10.
+
+# 3.2 STEPPING OUT OF THE PERFORMANCE COLLAPSE
+
+To distinguish the two roles, we introduce an auxiliary skip connection between every two nodes in a cell, see Fig. 1 (b). On the one hand, the fixed auxiliary skip connection carries the function of stabilizing the supernet training, even when $\beta _ { s k i p }$ is rather small. On the other hand, it also breaks the unfair advantage (Chu et al., 2020b) as the advantageous contribution from the residual block is factored out. Consequently, the learned architectural parameter $\beta _ { s k i p }$ can be freed from the role of controlling the memory of gradients, and is more precisely aimed to represent the relative importance of skip connection as a candidate operation. In contrast to Eq. 7, the output feature map of edge $e ^ { ( i , j ) }$ can now be obtained by Eq. 4, where $\begin{array} { r } { \beta _ { o } ^ { i , j } = \frac { \exp ( \alpha _ { o } ^ { ( i , j ) } ) } { \sum _ { o ^ { \prime } \in \mathcal { O } } \exp ( \alpha _ { o ^ { \prime } } ^ { ( i , j ) } ) } } \end{array}$ denotes the normalized importance, and $\beta$ is a coefficient independent from the architecture parameters.
+
+Moreover, to eliminate the impact of auxiliary connection on the discretization procedure, we propose to decrease $\beta$ to 0 in the search phase, and our method can be degenerated to standard DARTS at the end of the search. Note that our method is insensitive to the type of decay strategy, so we choose linear decay by default for simplicity.
+
+$$
+\bar { o } ^ { ( i , j ) } ( x ) = \beta x + \sum _ { o \in \mathcal { O } } \beta _ { o } ^ { ( i , j ) } o ( x ) = \left( \beta + \beta _ { s k i p } ^ { ( i , j ) } \right) x + \sum _ { o \neq s k i p } \beta _ { o } ^ { ( i , j ) } o ( x )
+$$
+
+We then analyze how the auxiliary skip connection handles the issue of gradient flow. Referring to the theorem of a recent work by Zhou et al. (2020), the convergence of network weight $\mathbf { W }$ in the supernet can heavily depend on $\beta _ { s k i p }$ . Specifically, suppose only three operations (none, skip connection, and convolution) are included in the search space and MSE loss is utilized as training loss, when architecture parameters $\beta _ { i , j } ^ { o }$ are fixed to optimize $\mathbf { W }$ via gradient descent, training loss can decrease by ratio $( 1 - \eta \lambda / 4 )$ at one step with probability at least $1 - \delta$ , where $\eta$ is the learning rate that should be bounded by $\delta$ , and $\lambda$ follows Eq. 5.
+
+$$
+\lambda \propto \sum _ { i = 0 } ^ { h - 2 } \left[ \left( \beta _ { c o n v } ^ { ( i , h - 1 ) } \right) ^ { 2 } \prod _ { t = 0 } ^ { i - 1 } \left( \beta _ { s k i p } ^ { ( t , i ) } \right) ^ { 2 } \right]
+$$
+
+where $h$ is the number of layers of the supernet. From Eq. 5, we observe that $\lambda$ relies much on $\beta _ { s k i p }$ than $\beta _ { c o n v }$ , which indicates that the network weights $\mathbf { W }$ can converge faster with a large $\beta _ { s k i p }$ . However, by involving an auxiliary skip connection weighted as $\beta$ , Eq. 5 can be refined as follows:
+
+$$
+\lambda \propto \sum _ { i = 0 } ^ { h - 2 } \left[ \left( \beta _ { c o n v } ^ { ( i , h - 1 ) } \right) ^ { 2 } \prod _ { t = 0 } ^ { i - 1 } \left( \beta _ { s k i p } ^ { ( t , i ) } + \beta \right) ^ { 2 } \right]
+$$
+
+where $\beta \ \gg \ \beta _ { s k i p }$ making $\lambda$ insensitive to $\beta _ { s k i p }$ , so that the convergence of network weights $\mathbf { W }$ depends more on $\beta _ { c o n v }$ . In the beginning of the search, the common value for $\beta _ { s k i p }$ is 0.15 while $\beta$ is 1.0. From the view of convergence theorem (Zhou et al., 2020), the auxiliary skip connection alleviates the privilege of $\beta _ { s k i p }$ and equalize the competition among architecture parameters. Even when $\beta$ gradually decays, the fair competition still holds since network weights W have been converged to an optimal point. Consequently, DARTS- is able to stabilize the search stage of DARTS.
+
+Extensive experiments are performed to demonstrate the efficiency of the proposed auxiliary skip connection, and we emphasize
+
+# Algorithm 1 DARTS
+
+# Require:
+
+Network weights $w$ ; Architecture parameters $\alpha$ ;   
+Number of search epochs $E$ ;   
+Decay strategy for $\beta _ { e } , e \in \{ 1 , 2 , . . . , E \}$ .
+
+# Ensure:
+
+Searched architecture parameters $\alpha$ .   
+1: Construct a super-network by stacking cells in which there is an auxiliary skip connection between every two nodes of choice   
+2: for each $e \in [ 1 , E ]$ do   
+3: Update weights $w$ by $\nabla _ { w } \mathcal { L } _ { t r a i n } ( w , \alpha , \beta _ { e } )$   
+4: Update parameters $\alpha$ by $\nabla _ { \alpha } \mathcal { L } _ { v a l } ( w , \alpha , \beta _ { e } )$   
+5: end for   
+6: Derive the final architecture based on learned $\alpha$ from the best validation supernet.
+
+# 3.3 RELATIONSHIP TO PRIOR WORK
+
+Our method is aimed to address the performance collapse in differentiable neural architecture search. Most previous works (Zela et al., 2020; Chen & Hsieh, 2020; Liang et al., 2019) concentrate on developing various criteria or indicators characterizing the occurrence of collapse. Whereas, we don’t study or rely on these indicators because they can mistakenly reject good models. Inspired by Chu et al. (2020b), our method focuses on calibrating the biased searching process. The underlying philosophy is simple: if the biased process is rectified, the searching result will be better. In summary, our method differs from others in two aspects: being process-oriented and indicator-free. Distinct from Chu et al. (2020b) that tweaks the competitive environment, our method can be viewed as one that breaks the unfair advantage. Moreover, we don’t introduce any handcrafted indicators to represent performance collapse, thus greatly reducing the burden of shifting to different tasks.
+
+# 4 EXPERIMENTS
+
+# 4.1 SEARCH SPACES AND TRAINING SETTINGS
+
+For searching and evaluation in the standard DARTS space (we name it as S0 for simplicity), we keep the same settings as in DARTS (Liu et al., 2019b). We follow R-DARTS (Zela et al., 2020) for their proposed reduced spaces S1- S4 (harder than S0). However, the inferred models are trained with two different settings from R-DARTS (Zela et al., 2020) and SDARTS (Chen & Hsieh, 2020). The difference lies in the number of layers and initial channels for evaluation on CIFAR-100. RDARTS sets 8 layers and 16 initial channels. Instead, SDARTS uses 20 and 36 respectively. For the proxyless searching on ImageNet, we instead search in MobileNetV2-like search space (we name it S5) proposed in FBNet (Wu et al., 2019). We use the SGD optimizer for weight and Adam $\beta _ { 1 } = 0 . 5$ and $\beta _ { 2 } = 0 . 9 9 9$ , 0.001 learning rate) for architecture parameters with the batch-size of 768. The initial learning rate is 0.045 and decayed to 0 within 30 epochs following the cosine schedule. We also use L2 regularization with 1e-4. It takes about 4.5 GPU days on Tesla V100. More details are provided in the appendix. We also use NAS-Bench-201 (S6) since DARTS performs severely bad. In total, we use 7 different search spaces to conduct the experiments, which involves three datasets.
+
+# 4.2 SEARCHING RESULTS
+
+CIFAR-10 and CIFAR-100. Following the settings of R-DARTS (Zela et al., 2020), we obtain an average top-1 accuracy of $9 7 . 4 1 \%$ on CIFAR-10, as shown in Table 2. Moreover, our method is very robust since out of 5 independent runs the searching results are quite stable. The best cells found on
+
+Table 1: Comparison of searched CNN in the DARTS search space on two different datasets.   
+
+<table><tr><td>Dataset</td><td>DARTS</td><td>R-DARTS (L2)</td><td>Ours</td></tr><tr><td>C10 (SO)</td><td>2.91±0.25</td><td>2.95±0.21</td><td>2.63±0.07</td></tr><tr><td>C100 (S0)</td><td>20.58±0.44</td><td>18.01±0.26</td><td>17.51±0.25</td></tr></table>
+
+CIFAR-10 $( 9 7 . 5 \% )$ are shown in Figure 9 (B). Results on CIFAR-100 are presented in Table 10 (see A.2.1). Moreover, our method has a much lower searching cost $( 3 \times \mathrm { l e s s } )$ than R-DARTS (Zela et al., 2020), where four independent searches with different regularization settings are needed to generate the best architecture. In other words, its robustness comes from the cost of more $C O _ { 2 }$ emissions.
+
+ImageNet. To further verify the efficiency of DARTS-, we directly search on ImageNet in S5 and compare our results with the state-of-the-art models under the mobile setting in Table 2. The visualization of the architecture is given in Fig 10. DARTS-A obtains $7 6 . 2 \%$ top-1 accuracy on the ImageNet validation dataset. By contrast, direct applying DARTS on this search space only obtains $6 6 . { \bar { 4 \% } }$ (Chu et al., 2020b). Moreover, it obtains $7 7 . 8 \%$ top-1 accuracy after being equipped with auto-augmentation (Cubuk et al., 2019) and squeeze-and-excitation (Hu et al., 2018), which are also used in EfficientNet.
+
+NAS-Bench-201. Apart from standard search spaces, benchmarking with known optimal in a limited setting is also recommended. NAS-Bench-201 (Dong & Yang, 2020) consists of 15,625 architectures in a reduced DARTS-like search space, where it has 4 internal nodes and 5 operations per node. We compare our method with prior work in Table 3. We search on CIFAR-10 and look up the ground-truth performance with found genotypes on various test sets. Remarkably, we achieve a new state of the art, the best of which almost touches the optimal.
+
+Table 2: Comparison of the state-of-the-art models on CIFAR-10 (left) and ImageNet (right). On CIFAR-10 dataset, our average result is obtained on 5 independently searched models to assure the robustness. For ImageNet, networks in the top block are directly searched on ImageNet; the middle indicates that architectures are searched on CIFAR-10 and then transferred to ImageNet; the bottom indicates models have SE and Swish. We search in S0 for CIFAR-10 and S5 for ImageNet.   
+
+<table><tr><td colspan="5"></td><td rowspan="2">Models</td><td colspan="5">FLOPs Params Top-1 Top-5</td><td rowspan="2">Cost (GPU days)</td></tr><tr><td>Models</td><td>Params (M)</td><td>FLOPs Acc (M)</td><td>(%)</td><td>Cost</td><td></td><td>(M)</td><td>(M)</td><td>(%)</td><td>(%)</td></tr><tr><td>NASNet-A (2018)</td><td></td><td>608t</td><td></td><td></td><td>GPU Days AmoebaNet-A (2019) MnasNet-92 (2019)</td><td>555 388</td><td>5.1 3.9</td><td>74.5</td><td>92.0 74.79 92.1</td><td></td><td>3150 3791</td></tr><tr><td></td><td>3.3</td><td>626†</td><td>97.35</td><td>2000</td><td>FBNet-C (2019)</td><td>375</td><td>5.5</td><td></td><td>74.9</td><td>92.3</td><td>9</td></tr><tr><td>ENAS (2018) DARTS (2019b)</td><td>4.6</td><td></td><td>97.11</td><td>0.5</td><td>FairNAS-A (2019b)</td><td>388</td><td>4.6</td><td></td><td>75.3</td><td>92.4</td><td>12</td></tr><tr><td></td><td>3.3</td><td>528t</td><td>97.00±0.14*0.4</td><td></td><td>SCARLET-C(2019a)</td><td>365</td><td>6.7</td><td></td><td>76.9</td><td>93.4</td><td>10</td></tr><tr><td>SNAS (2019)</td><td>2.8</td><td>422t</td><td>97.15±0.02*1.5</td><td></td><td>FairDARTS-D (2020b) 440</td><td></td><td>4.3</td><td></td><td>75.6</td><td>92.6</td><td>3</td></tr><tr><td>GDAS (2019b)</td><td>3.4</td><td>519t</td><td>97.07</td><td>0.2</td><td>PC-DARTS (2020)</td><td>597</td><td>5.3</td><td></td><td>75.8</td><td>92.7</td><td>3.8</td></tr><tr><td>P-DARTS (2019b)</td><td>3.4</td><td>532t</td><td>97.5</td><td>0.3</td><td>DARTS- (ours)</td><td>467</td><td>4.9</td><td></td><td>76.2</td><td>93.0</td><td>4.5</td></tr><tr><td>PC-DARTS (2020) DARTS- (best)</td><td>3.6</td><td>558t 568</td><td>97.43 97.5</td><td>0.1 0.4</td><td>NASNet-A (2018)</td><td>564</td><td>5.3</td><td></td><td>74.0</td><td>91.6</td><td>2000</td></tr><tr><td></td><td>3.5</td><td></td><td></td><td></td><td>DARTS (2019b)</td><td>574</td><td>4.7</td><td></td><td>73.3</td><td>91.3</td><td>0.4</td></tr><tr><td>P-DARTS (2019b)</td><td>3.3±0.21 540±34 97.19±0.14</td><td></td><td></td><td>0.3</td><td>SNAS (2019)</td><td>522</td><td>4.3</td><td></td><td>72.7</td><td>90.8</td><td>1.5</td></tr><tr><td>R-DARTS (2020)</td><td>1</td><td></td><td>97.05±0.21</td><td>1.6</td><td>PC-DARTS (2020)</td><td>586</td><td>5.3</td><td></td><td>74.9</td><td>92.2</td><td>0.1</td></tr><tr><td>SDARTS-ADV (2020) 3.3</td><td></td><td></td><td>97.39±0.02 3.5±0.13 583±22 97.41±0.08</td><td>1.3 0.4</td><td>FairDARTS-B (2020b) 541</td><td></td><td>4.8</td><td></td><td>75.1</td><td>92.5</td><td>0.4</td></tr><tr><td colspan="5">DARTS- (avg.)</td><td>MobileNetV3 (2019)</td><td></td><td>5.4</td><td>75.2</td><td>92.2</td><td></td><td>~3000</td></tr><tr><td colspan="5">† Based on the provided genotypes. ↑</td><td>MoGA-A (2020a)</td><td>219</td><td>5.1</td><td></td><td>75.9</td><td>92.8</td><td>12</td></tr><tr><td colspan="5">5 independent searches using their released code.</td><td>MixNet-M (2019)</td><td>304</td><td>5.0</td><td></td><td>77.0</td><td>93.3</td><td>~3000</td></tr><tr><td colspan="5"></td><td>EfficientNet B0 (2019) 390</td><td>360</td><td>5.3</td><td>76.3</td><td></td><td>93.2</td><td>~3000</td></tr><tr><td colspan="5">* Training the best searched model for several times NoisyDARTS-A</td><td></td><td>449</td><td>5.5</td><td>77.9</td><td></td><td>94.0</td><td>12</td></tr><tr><td colspan="5">(whose average doesn&#x27;t indicate the stability of the DARTS- (ours) method)</td><td></td><td>470</td><td>5.5</td><td>77.8</td><td></td><td>93.9</td><td>4.5</td></tr></table>
+
+‡ Estimated by Wu et al. (2019).  SE modules and Swish enabled.
+
+Table 3: Searching performance on NAS-Bench-201 (Dong & Yang, 2020). Our method robustly obtains new SOTA. Averaged on 4 runs of searching. 1st: first-order, 2nd: second-order   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Cost (hours)</td><td colspan="2">CIFAR-10</td><td colspan="2">CIFAR-100</td><td colspan="2">ImageNet16-120</td></tr><tr><td>valid</td><td>test</td><td>valid</td><td>test</td><td>valid</td><td>test</td></tr><tr><td>DARTS1st (2019b)</td><td>3.2</td><td>39.77±0.00 54.30±0.00</td><td></td><td></td><td>15.03±0.00 15.61±0.00</td><td>16.43±0.00 16.32±0.00</td><td></td></tr><tr><td>DARTS2nd (2019b)</td><td>10.2</td><td>39.77±0.00</td><td>54.30±0.00</td><td>15.03±0.00</td><td>15.61±0.00</td><td>16.43±0.00 16.32±0.00</td><td></td></tr><tr><td>GDAS (2019b)</td><td>8.7</td><td>89.89±0.08 93.61±0.09</td><td></td><td>71.34±0.04</td><td>：70.70±0.30 41.59±1.33 41.71±0.98</td><td></td><td></td></tr><tr><td>SETN (2019a)</td><td>9.5</td><td>84.04±0.28</td><td>87.64±0.00</td><td>58.86±0.06</td><td>59.05±0.24</td><td>33.06±0.02</td><td>32.52±0.21</td></tr><tr><td>DARTS-</td><td>3.2</td><td>91.03±0.44 93.80±0.40</td><td></td><td></td><td>71.36±1.51 71.53±1.51</td><td>44.87±1.46 45.12±0.82</td><td></td></tr><tr><td>DARTS- (best)</td><td>3.2</td><td>91.55</td><td>94.36</td><td>73.49</td><td>73.51</td><td>46.37</td><td>46.34</td></tr><tr><td>optimal</td><td>n/a</td><td>91.61</td><td>94.37</td><td>73.49</td><td>73.51</td><td>46.77</td><td>47.31</td></tr></table>
+
+Transfer results on objection detection We further evaluate the transfer-ability of our models on down-stream object detection task by replacing the backbone of RetinaNet (Lin et al., 2017) on MMDetection toolbox platform (Chen et al., 2019a). Specifically, with the same training setting as Chu et al. (2020b), our model achieves $3 2 . 5 \%$ mAP on the COCO dataset, surpassing other similarsized models such as MobileNetV3, MixNet, and FairDARTS. The detailed results are shown in Appendix (Table 11).
+
+# 4.3 ORTHOGONAL COMBINATION WITH OTHER VARIANTS
+
+Our method can be flexibly adapted to combine with prior work for further improvements. Here we investigate the joint outcome with two methods: P-DARTS and PC-DARTS.
+
+Progressive DARTS (P-DARTS). P-DARTS (Chen et al., 2019b) proposes a progressive approach to search gradually with deeper depths while pruning out the uncompetitive paths. Additionally, it makes use of some handcrafted criteria to address the collapse (the progressive idea itself cannot deal with it), for instance, they impose two strong priors by regularizing the number of skip connections $M$ as 2 as well as dropout. To be fair, we remove such a carefully handcrafted trick and run P-DARTS for several times. As a natural control group, we also combine DARTS- with P-DARTS. We run both experiments for 3 times on CIFAR-10 dataset in Table 4. Without the strong priors, P-DARTS severely suffers from the collapse, where the inferred models contain an excessive number of skip connections. Specifically, it has a very high test error $( 3 . 4 2 \%$ on average), even worse than DARTS. However, P-DARTS can benefit greatly from the combination with DARTS-. The improved version (we call P-DARTS-) obtains much higher top-1 accuracy $( + \mathbf { 0 . 8 \% } )$ on CIFAR-10 than its baseline.
+
+Table 4: We remove the strong constraints on the number of skip connections as 2 and dropout (priors) for PDARTS and compare its performance w/ and w/o DARTS-.   
+
+<table><tr><td>Method</td><td>Setting</td><td>商银 Acc(%)</td></tr><tr><td></td><td>P-DARTS w/o priors 96.48±0.55</td><td></td></tr><tr><td></td><td>P-DARTS- w/o priors 97.28±0.04</td><td></td></tr></table>
+
+Table 7: Comparison in various search spaces. We report the lowest error rate of 3 found architectures. †: under Chen & Hsieh (2020)’s training settings where all models have 20 layers and 36 initial channels (the best is shown in boldface). ‡: under Zela et al. (2020)’s settings where CIFAR-100 models have 8 layers and 16 initial channels (The best is in boldface and underlined).   
+
+<table><tr><td rowspan="2">Benchmark DARTS‡</td><td rowspan="2"></td><td rowspan="2"></td><td colspan="2">R-DARTS‡</td><td colspan="2">DARTS</td><td rowspan="2">Ours</td><td rowspan="2">PC-DARTS+</td><td colspan="2">SDARTS+</td><td rowspan="2">Ourst</td></tr><tr><td>DP</td><td>L2</td><td>ES</td><td>ADA</td><td>RS</td><td>ADV</td></tr><tr><td rowspan="4">C10</td><td>S1</td><td>3.84</td><td>3.11</td><td>2.78</td><td>3.01</td><td>3.10</td><td>2.68</td><td>3.11</td><td>2.78</td><td>2.73</td><td>2.68</td></tr><tr><td>S2</td><td>4.85</td><td>3.48</td><td>3.31</td><td>3.26</td><td>3.35</td><td>2.63</td><td>3.02</td><td>2.75</td><td>2.65</td><td>2.63</td></tr><tr><td>S3</td><td>3.34</td><td>2.93</td><td>2.51</td><td>2.74</td><td>2.59</td><td>2.42</td><td>2.51</td><td>2.53</td><td>2.49</td><td>2.42</td></tr><tr><td>S4</td><td>7.20</td><td>3.58</td><td>3.56</td><td>3.71</td><td>4.84</td><td>2.86</td><td>3.02</td><td>2.93</td><td>2.87</td><td>2.86</td></tr><tr><td rowspan="4">C100</td><td>S1</td><td>29.46</td><td>25.93</td><td>24.25</td><td>28.37</td><td>24.03</td><td>22.41</td><td>18.87</td><td>17.02</td><td>16.88</td><td>16.92</td></tr><tr><td>S2</td><td>26.05</td><td>22.30</td><td>22.24</td><td>23.25</td><td>23.52</td><td>21.61</td><td>18.23</td><td>17.56</td><td>17.24</td><td>16.14</td></tr><tr><td>S3</td><td>28.90</td><td>22.36</td><td>23.99</td><td>23.73</td><td>23.37</td><td>21.13</td><td>18.05</td><td>17.73</td><td>17.12</td><td>15.86</td></tr><tr><td>S4</td><td>22.85</td><td>22.18</td><td>21.94</td><td>21.26</td><td>23.20</td><td>21.55</td><td>17.16</td><td>17.17</td><td>15.46</td><td>17.48</td></tr></table>
+
+Memory Friendly DARTS (PC-DARTS). To alleviate the large memory overhead from the whole supernet, PC-DARTS $\mathrm { { X u } }$ et al., 2020) selects the partial channel for searching. The proportion hyperparameter $K$ needs careful calibration to achieve a good result for specific tasks. As a byproduct, the search time is also reduced to 0.1 GPU days $\left( K { = } 4 \right)$ . We use their released code and run repeated experiments across different seeds under the same settings.
+
+Table 5: Comparison of PC-DARTS removing the strong prior (i.e. channel shuffle) and combining DARTS-. The results are from 3 independent runs on CIFAR-10. The GPU memory cost is on a batch size of 256.   
+
+<table><tr><td>Method</td><td>Setting</td><td>Acc (%）Memory Cost</td></tr><tr><td>PC-DARTS K = 2 97.09±0.14</td><td></td><td>19.9G 股银 3.75h</td></tr><tr><td>PC-DARTS- K = 2 97.35±0.02</td><td></td><td>20.8G 3.41h</td></tr></table>
+
+To accurately evaluate the role of our method, we choose $K { = } 2$ (a bad configuration in the original paper). We make comparisons between the original PC-DARTS and its combination with ours (named PC-DARTS-) in Table 5. PC-DARTS- can marginally boost the CIFAR-10 top-1 accuracy $( + 0 . 2 6 \%$ on average). The result also confirms that our method can make PC-DARTS less sensitive to its hyper-parameter $K$ while keeping its advantage of less memory cost and run time.
+
+# 4.4 ABLATION STUDY
+
+Robustness to Decay Strategy. Our method is insensitive to the type of decay policy on $\beta$ . We design extra two strategies as comparisons: cosine and step decay. They both have the similar performance. Specifically, when $\beta$ is scheduled to zero by the cosine strategy, the average accuracy of four searched CIFAR-10 models in S3 is $9 7 . 3 3 \% \pm 0 . 0 9$ , the best is $9 7 . 4 7 \%$ . The step decay at epoch 45 obtains $9 7 . 3 0 \%$ top-1 accuracy on average in the same search space.
+
+Robustness Comparison on C10 and C100 in S0-S4. To verify the robustness, it is required to search several times to report the average performance of derived models (Yu et al., 2020; Antoine et al., 2020). As shown in Table 1, Table 9 and Table 7, our method outperforms the recent SOTAs across several spaces and datasets. Note that SDARTS-ADV utilizes adversarial training and requires $3 \times$ more search time than ours. Especially, we find a good model in $S _ { 3 }$ on CIFAR-100 with the lowest top-1 test error $1 5 . 8 6 \%$ . The architectures of these models can be found in the appendix.
+
+Table 6: Searching performance on CIFAR-10 in S3 w.r.t the initial linear decay rate $\beta _ { 0 }$ . Each setting is run for three times.   
+
+<table><tr><td>β</td><td>Error (%)</td></tr><tr><td>1</td><td>2.65±0.04</td></tr><tr><td>0.7 0.4</td><td>2.76±0.16</td></tr><tr><td>0.1</td><td>3.04±0.19 3.11±0.16</td></tr><tr><td>0</td><td>4.58±1.3</td></tr></table>
+
+connection branch can be discounted by setting a lower initial $\beta$ . We now evaluate how sensitive our approach is to the value of $\beta$ . It’s trivial to see that our approach degrades to DARTS when $\beta = 0$ . We compare results when searching with $\beta \in \{ 1 , 0 . 7 , 0 . 4 , 0 . 1 , 0 \}$ in Table 6, which show that a bigger $\beta _ { 0 }$ is advantageous to obtain better networks.
+
+The choice of auxiliary branch Apart from the default skip connection serving as the auxiliary branch, we show that it is also effective to replace it with a learnable $1 \times 1$ convolution projection, which is initialized with an identity tensor. The average accuracy of three searched CIFAR-10 models in S3 is $9 7 . 2 5 \% \pm 0 . 0 9$ . Akin to the ablation in He et al. (2016), the projection convolution here works in a similar way as the proposed skip connection. This proves the necessity of the auxiliary branch.
+
+Performance with longer epochs. It is claimed by Bi et al. (2019) that much longer epochs lead to better convergence of the supernet, supposedly beneficial for inferring the final models. However, many of DARTS variants fail since their final models are full of skip connections. We thus evaluate how our method behaves in such a situation. Specifically, we extend the standard 50 epochs to 150, 200 and we search 3 independent times each for S0, S2 and S3. Due to the longer epochs, we slightly change our decay strategy, we keep $\beta = 1$ all the way until for last 50 epochs we decay $\beta$ to 0. Other hyper-parameters are kept unchanged. The results are shown in Table 8 and the found genotypes are listed in Figure 17, 18, 19, 20 and 21. It indicates that DARTS- doesn’t suffer from longer epochs since it has reasonable values for $\# P$ compared with those $( \# P = 0 )$ ) investigated by Bi et al. (2019). Notice S2 and S3 are harder cases where DARTS suffers more severely from the collapse than S0. As a result, DARTS- can successfully survive longer epochs even in challenging search spaces. Noticeably, it is still unclear whether longer epochs can truly boost searching performance. Although we achieve a new state-of-the-art result in S2 where the best model has $2 . 5 0 \%$ error rate (previously $2 . 6 3 \%$ ), it still has worse average performance $( 2 . 7 1 { \pm } 0 . 1 1 \% )$ in S0 than the models searched with 50 epochs $( 2 . 5 9 { \pm } 0 . 0 8 \% )$ , and the best model in S3 $( 2 . 5 3 \% )$ is also weaker than before $( 2 . 4 2 \% )$ .
+
+Table 8: Searching performance on CIFAR-10 in S0, S2 and S3 using longer epochs. Following Bi et al. (2019), $\# P$ means the number of parametric operators in the normal cell. Averaged on 3 runs of search.   
+
+<table><tr><td rowspan="2">Epochl</td><td colspan="3">S0</td><td colspan="3">S2</td><td colspan="3">S3</td></tr><tr><td>#P</td><td>Params (M)</td><td>Error (%)</td><td>#P</td><td>Params (M)</td><td>Error (%)</td><td>#P</td><td>Params (M)</td><td>Error (%)</td></tr><tr><td>150</td><td>6.6±1.1</td><td>3.3±0.3</td><td>2.74±0.066.0±0.0</td><td></td><td>3.9±0.3</td><td>2.58±0.11|6.0±1.0</td><td></td><td>3.6±0.3</td><td>2.55±0.03</td></tr><tr><td>200</td><td>7.3±0.6</td><td>3.2±0.3</td><td>2.71±0.11</td><td>8.0±0.0</td><td>4.3±0.1</td><td>2.65±0.21</td><td>7.6±0.5</td><td>4.3±0.2</td><td>2.66±0.09</td></tr></table>
+
+Besides, compared with first-order DARTS with a cost of 0.4 GPU days in S0, Amended-DARTS (Bi et al., 2019), particularly designed to survive longer epochs, reports 1.7 GPU days even with pruned edges in S0. Our approach has the same cost as first-order DARTS, which is more efficient.
+
+# 5 ANALYSIS AND DISCUSSIONS
+
+# 5.1 FAILURE OF HESSIAN EIGENVALUE
+
+The maximal Hessian eigenvalue calculated from the validation loss w.r.t $\alpha$ is regarded as an indicator of performance collapse (Zela et al., 2020; Chen & Hsieh, 2020). Surprisingly, our method develops a growing eigenvalue in the majority of configurations, which conflicts with the previous observations. We visualize these statistics across different search space and datasets in Figure 4 (A.2.2). Although eigenvalues increase almost monotonously and reach a relatively large value in the end, the final models still have good performance that matches with state-of-the-art ones (see Table 9). These models can be mistakenly deemed as bad ones or never visited according to the eigenvalue criteria. Our observations disclose one fatal drawback of these indicator-based approaches: they are prone to rejecting good models. Further analysis can be found in A.2.2.
+
+# 5.2 VALIDATION ACCURACY LANDSCAPE
+
+Recent works, R-DARTS (Zela et al., 2020) and SDARTS (Chen & Hsieh, 2020) point that the architectural weights are expected to converge to an optimal point where accuracy is insensitive to perturbations to obtain a stable architecture after the discretization process, i.e., the convergence point should have a smooth landscape. SDARTS proposes a perturbation-based regularization, which further stabilizes the searching process of DARTS. However, the perturbation regularization disturbs the training procedure and thus misleads the update of architectural weights. Different from SDARTS that explicitly smooths landscape by perturbation, DARTS- can implicitly do the same without directly perturbing architectural weights.
+
+![](images/9209d9b128c595cbb45eaac137aa78868321675acd149e11fd78d5b77f3ab1a8.jpg)  
+Figure 3: Comparison of the validation accuracy landscape of (a) DARTS and (b) DARTS- w.r.t. $\alpha$ on CIFAR-10 in S3. Their contour maps are shown respectively in (c) and (d), where we set the step of contour map as 0.1. The accuracy of the derived models are $9 4 . 8 4 \%$ (a,c) and $9 7 . 5 8 \%$ (b,d), while the maximum Hessian eigenvalues are similarly high (0.52 and 0.42)
+
+To analyze the efficacy of DARTS-, we plot the validation accuracy landscape w.r.t architectural weights $\alpha$ , and find that auxiliary connection smooths the landscape and thus stabilizes the searching stage. Specifically, we choose two random directions and apply normalized perturbation on $\alpha$ (following Li et al. 2018a). As shown in Figure 3, DARTS- is less sensitive to the perturbation than DARTS, and the contour map of DARTS- descends more gently.
+
+# 6 CONCLUSION
+
+We propose a simple and effective approach named DARTS- to address the performance collapse in differentiable architecture search. Its core idea is to make use of an auxiliary skip connection branch to take over the gradient advantage role from the candidate skip connection operation. This can create a fair competition where the bi-level optimization process can easily differentiate good operations from the bad. As a result, the search process is more stable and the collapse seldom happens across various search spaces and different datasets. Under strictly controlled settings, it steadily outperforms recent state-of-the-art RobustDARTS (Zela et al., 2020) with $3 \times$ fewer search cost. Moreover, our method disapproves of various handcrafted regularization tricks. Last but not least, it can be used stand-alone or in cooperation with various orthogonal improvements if necessary.
+
+This paper conveys two important messages for future research. On the one hand, the Hessian eigenvalue indicator for performance collapse (Zela et al., 2020; Chen & Hsieh, 2020) is not ideal because it has a risk of rejecting good models. On the other hand, handcraft regularization tricks (Chen et al., 2019b) seem more critical to search a good model instead of the proposed methods. Then what’s the solution? In principle, it’s difficult to find a perfect indicator of the collapse. Our approach shows the potential to control the search process and doesn’t impose limitations or priors on the final model. We hope more attention be paid in this direction.
+
+# 7 ACKNOWLEDGEMENT
+
+This research was supported by Meituan.
+
+# REFERENCES
+
+Yang Antoine, Esperanc¸a Pedro M., and Carlucci Fabio M. NAS Evaluation is Frustratingly Hard. In ICLR, 2020.
+
+Kaifeng Bi, Changping Hu, Lingxi Xie, Xin Chen, Longhui Wei, and Qi Tian. Stabilizing darts with amended gradient estimation on architectural parameters. arXiv preprint arXiv:1910.11831, 2019.
+
+Han Cai, Ligeng Zhu, and Song Han. ProxylessNAS: Direct Neural Architecture Search on Target Task and Hardware. In ICLR, 2019.
+
+Kai Chen, Jiaqi Wang, Jiangmiao Pang, Yuhang Cao, Yu Xiong, Xiaoxiao Li, Shuyang Sun, Wansen Feng, Ziwei Liu, Jiarui Xu, et al. MMDetection: Open mmlab detection toolbox and benchmark. arXiv preprint arXiv:1906.07155, 2019a.
+
+Xiangning Chen and Cho-Jui Hsieh. Stabilizing differentiable architecture search via perturbationbased regularization. In ICML, 2020.
+
+Xin Chen, Lingxi Xie, Jun Wu, and Qi Tian. Progressive Differentiable Architecture Search: Bridging the Depth Gap between Search and Evaluation. In ICCV, 2019b.
+
+Xiangxiang Chu, Bo Zhang, Jixiang Li, Qingyuan Li, and Ruijun Xu. Scarletnas: Bridging the gap between scalability and fairness in neural architecture search. arXiv preprint arXiv:1908.06022, 2019a.
+
+Xiangxiang Chu, Bo Zhang, Ruijun Xu, and Jixiang Li. FairNAS: Rethinking Evaluation Fairness of Weight Sharing Neural Architecture Search. arXiv preprint. arXiv:1907.01845, 2019b.
+
+Xiangxiang Chu, Bo Zhang, and Ruijun Xu. MoGA: Searching Beyond MobileNetV3. In ICASSP, pp. 4042–4046, 2020a.
+
+Xiangxiang Chu, Tianbao Zhou, Bo Zhang, and Jixiang Li. Fair darts: Eliminating unfair advantages in differentiable architecture search. In ECCV, 2020b.
+
+Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. AutoAugment: Learning Augmentation Policies from Data. In CVPR, 2019.
+
+Xuanyi Dong and Yi Yang. One-shot neural architecture search via self-evaluated template network. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3681–3690, 2019a.
+
+Xuanyi Dong and Yi Yang. Searching for a Robust Neural Architecture in Four GPU Hours. In CVPR, pp. 1761–1770, 2019b.
+
+Xuanyi Dong and Yi Yang. Nas-bench-201: Extending the scope of reproducible neural architecture search. In International Conference on Learning Representations (ICLR), 2020. URL https: //openreview.net/forum?id $=$ HJxyZkBKDr.
+
+Golnaz Ghiasi, Tsung-Yi Lin, and Quoc V Le. NAS-FPN: Learning scalable feature pyramid architecture for object detection. In CVPR, pp. 7036–7045, 2019.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In CVPR, pp. 770–778, 2016.
+
+Andrew Howard, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang, Yukun Zhu, Ruoming Pang, Vijay Vasudevan, et al. Searching for MobileNetV3. In ICCV, 2019.
+
+Jie Hu, Li Shen, and Gang Sun. Squeeze-and-Excitation Networks. In CVPR, pp. 7132–7141, 2018.
+
+Guohao Li, Guocheng Qian, Itzel C Delgadillo, Matthias Muller, Ali Thabet, and Bernard Ghanem. ¨ Sgas: Sequential greedy architecture search. In CVPR, 2020.
+
+Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. Visualizing the loss landscape of neural nets. In Advances in Neural Information Processing Systems, pp. 6389–6399, 2018a.
+
+Juncheng Li, Faming Fang, Kangfu Mei, and Guixu Zhang. Multi-scale residual network for image super-resolution. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 517–532, 2018b.
+
+Hanwen Liang, Shifeng Zhang, Jiacheng Sun, Xingqiu He, Weiran Huang, Kechen Zhuang, and Zhenguo Li. DARTS $^ +$ : Improved Differentiable Architecture Search with Early Stopping. arXiv preprint arXiv:1909.06035, 2019.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal Loss for Dense ´ Object Detection. In ICCV, pp. 2980–2988, 2017.
+
+Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive Neural Architecture Search. In ECCV, pp. 19–34, 2018.
+
+Chenxi Liu, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, Wei Hua, Alan L Yuille, and Li FeiFei. Auto-deeplab: Hierarchical neural architecture search for semantic image segmentation. In CVPR, pp. 82–92, 2019a.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable Architecture Search. In ICLR, 2019b.
+
+Jieru Mei, Yingwei Li, Xiaochen Lian, Xiaojie Jin, Linjie Yang, Alan Yuille, and Yang Jianchao. AtomNAS: Fine-Grained End-to-End Neural Architecture Search. In ICLR, 2020.
+
+Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient Neural Architecture Search via Parameter Sharing. In ICML, 2018.
+
+Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. In AAAI, volume 33, pp. 4780–4789, 2019.
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In Advances in neural information processing systems, pp. 91–99, 2015.
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. MobileNetV2: Inverted Residuals and Linear Bottlenecks. In CVPR, pp. 4510–4520, 2018.
+
+David So, Quoc Le, and Chen Liang. The evolved transformer. In ICML, pp. 5877–5886, 2019.
+
+Dimitrios Stamoulis, Ruizhou Ding, Di Wang, Dimitrios Lymberopoulos, Bodhi Priyantha, Jie Liu, and Diana Marculescu. Single-Path NAS: Designing Hardware-Efficient ConvNets in less than 4 Hours. ECML PKDD, 2019.
+
+Ying Tai, Jian Yang, and Xiaoming Liu. Image super-resolution via deep recursive residual network. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3147– 3155, 2017.
+
+Mingxing Tan and Quoc V Le. EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks. In ICML, 2019.
+
+Mingxing Tan and Quoc V. Le. MixConv: Mixed Depthwise Convolutional Kernels. In BMVC, 2019.
+
+Mingxing Tan, Bo Chen, Ruoming Pang, Vijay Vasudevan, and Quoc V Le. Mnasnet: PlatformAware Neural Architecture Search for Mobile. In CVPR, 2019.
+
+Yancong Wei, Qiangqiang Yuan, Huanfeng Shen, and Liangpei Zhang. Boosting the accuracy of multispectral image pansharpening by learning a deep residual network. IEEE Geoscience and Remote Sensing Letters, 14(10):1795–1799, 2017.
+
+Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer. FBNet: Hardware-Aware Efficient ConvNet Design via Differentiable Neural Architecture Search. In CVPR, 2019.
+
+Sirui Xie, Hehui Zheng, Chunxiao Liu, and Liang Lin. SNAS: Stochastic Neural Architecture Search. In ICLR, 2019.   
+Yuhui Xu, Lingxi Xie, Xiaopeng Zhang, Xin Chen, Guo-Jun Qi, Qi Tian, and Hongkai Xiong. PCDARTS: Partial Channel Connections for Memory-Efficient Architecture Search. In ICLR, 2020. URL https://openreview.net/forum?id $=$ BJlS634tPr.   
+Kaicheng Yu, Christian Sciuto, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. In ICLR, 2020. URL https://openreview. net/forum?id ${ . } = { }$ H1loF2NFwr.   
+Arber Zela, Thomas Elsken, Tonmoy Saikia, Yassine Marrakchi, Thomas Brox, and Frank Hutter. Understanding and robustifying differentiable architecture search. In ICLR, 2020. URL https: //openreview.net/forum?id $=$ H1gDNyrKDS.   
+Pan Zhou, Caiming Xiong, Richard Socher, and Steven CH Hoi. Theory-inspired path-regularized differential network architecture search. arXiv preprint arXiv:2006.16537, 2020.   
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning Transferable Architectures for Scalable Image Recognition. In CVPR, volume 2, 2018.
+
+# A APPENDIX
+
+# A.1 PRELIMINARY ABOUT DARTS
+
+In differentiable architecture search (Liu et al., 2019b), a cell-based search space in the form of Directed Acyclic Graph (DAG) is constructed. The DAG has two input nodes from the previous layers, four intermediate nodes, and one output node. There are several paralleling operators (denoted as $\mathcal { O }$ ) between each two nodes (say $i , j$ ), whose output $\bar { o } ^ { ( i , j ) }$ given an input $x$ is defined as,
+
+$$
+\bar { o } ^ { ( i , j ) } ( x ) = \sum _ { o \in \mathcal { O } } \frac { \exp ( \alpha _ { o } ^ { ( i , j ) } ) } { \sum _ { o ^ { \prime } \in \mathcal { O } } \exp ( \alpha _ { o ^ { \prime } } ^ { ( i , j ) } ) } o ( x )
+$$
+
+It is essentially applying softmax over all operators where each operator is assigned with an architectural weight $\alpha$ . A supernet is built on two kinds of such cells, so-called normal cells and reduction cells (for down-sampling). The architectural search is then characterized as a bi-level optimization:
+
+$$
+\begin{array} { r l } { \underset { \alpha } { \operatorname* { m i n } } } & { \mathcal { L } _ { v a l } ( w ^ { * } ( \alpha ) , \alpha ) } \\ { s . t . } & { w ^ { * } ( \alpha ) = \arg \underset { w } { \operatorname* { m i n } } \mathcal { L } _ { t r a i n } ( w , \alpha ) } \end{array}
+$$
+
+This indicates that the training of such a cell-based supernet should be interleaved, where at each step the network weights and architectural weights are updated iteratively. The final model is determined by simply choosing operations with the largest architectural weights.
+
+# A.2 EXPERIMENT
+
+# A.2.1 TRAINING DETAILS
+
+CIFAR-10 and CIFAR-100. Table 9 gives the averaged performance in reduced search spaces S1-S4, as well with maximum eigenvalues. Table 10 reports the CIFAR-100 results in S0.
+
+Table 9: Comparison of searched CNN architectures in four reduced search spaces S1-S4 (Zela et al., 2020) on CIFAR-10 and CIFAR-100. We report the mean±std of test error over 3 found architectures retrained from scratch, alongside with eigenvalue (EV) that corresponds to the best validation accuracy. We follow the same settings as Zela et al. (2020).   
+
+<table><tr><td colspan="2">Benchmark</td><td>DARTS</td><td>DARTS-ES</td><td>DARTS-ADA</td><td>ours</td><td>ours (EV)</td></tr><tr><td rowspan="4">C10</td><td>S1</td><td>4.66±0.71</td><td>3.05±0.07</td><td>3.03±0.08</td><td>2.76±0.07</td><td>0.37±0.19</td></tr><tr><td>S2</td><td>4.42±0.40</td><td>3.41±0.14</td><td>3.59±0.31</td><td>2.79±0.04</td><td>0.41±0.08</td></tr><tr><td>S3</td><td>4.12±0.85</td><td>3.71±1.14</td><td>2.99±0.34</td><td>2.65±0.04</td><td>0.31±0.09</td></tr><tr><td>S4</td><td>6.95±0.18</td><td>4.17±0.21</td><td>3.89±0.67</td><td>2.91±0.04</td><td>0.30±0.11</td></tr><tr><td rowspan="4">C100</td><td>S1</td><td>29.93±0.41</td><td>28.90±0.81</td><td>24.94±0.81</td><td>23.26±0.59</td><td>0.60±0.15</td></tr><tr><td>S2</td><td>28.75±0.92</td><td>24.68±1.43</td><td>26.88±1.11</td><td>22.31±0.65</td><td>0.54±0.15</td></tr><tr><td>S3</td><td>29.01±0.24</td><td>26.99±1.79</td><td>24.55±0.63</td><td>21.47±0.40</td><td>0.40±0.03</td></tr><tr><td>S4</td><td>24.77±1.51</td><td>23.90±2.01</td><td>23.66±0.90</td><td>21.75±0.26</td><td>0.93±0.15</td></tr></table>
+
+ImageNet classification. For training on ImageNet, we use the same setting as MnasNet (Tan et al., 2019). To be comparable with EfficientNet (Tan & Le, 2019), we also use squeeze-and-excitation (Hu et al., 2018). Furthermore, we don’t include methods trained using large model distillation, because it can boost final validation accuracy marginally. To be fair, we don’t use the efficient head in MobileNetV3 (Howard et al., 2019) although it can reduce FLOPs marginally.
+
+COCO object detection. All models are trained and evaluated on MS COCO dataset for 12 epochs with a batch size of 16. The initial learning rate is 0.01 and reduced by 0.1 at epoch 8 and 11.
+
+# A.2.2 FURTHER DISCUSSIONS ON FAILURE OF EIGENVALUE
+
+To further explore the relationship between the searching performance and Hessian Eigenvalue, we plot the performance trajectory of the searched models in Figure 4 (b). Specifically, we sample models every 10 epochs and train these models from scratch using the same setting as above (Figure 5). The performance of the inferred models continues growing, where the accuracy is boosted from $9 6 . 5 \%$ to $9 7 . 4 \%$ . This affirms the validity of searching using our method. In contrast, the early-stopping strategies based on eigenvalues (Zela et al., 2020) would fail in this setting. We argue that the proposed auxiliary skip branch can regularize the overfitting of the supernet, leaving the architectural weights to represent the ability of candidate operations. This experiment poses as a counterexample to R-DARTS, where good models can appear albeit Hessian eigenvalues change fast. It again denies the need for a costly indicator.
+
+Table 10: Comparison of searched models on CIFAR-100. : Reported by Dong & Yang (2019b), ?: Reported by Zela et al. (2020), $^ \ddag$ :Rerun their code.   
+
+<table><tr><td>Models</td><td>Params Error (M) (%)</td><td></td><td>Cost GPU Days</td></tr><tr><td>ResNet (2016)</td><td>1.7</td><td>22.10</td><td>-</td></tr><tr><td>AmoebaNet (2019) 3.1</td><td></td><td>18.93</td><td>3150</td></tr><tr><td>PNAS (2018)</td><td>3.2</td><td>19.53</td><td>150</td></tr><tr><td>ENAS (2018)</td><td>4.6</td><td>19.43</td><td>0.45</td></tr><tr><td>DARTS (2019b)</td><td>1</td><td>20.58±0.44*(</td><td>*0.4</td></tr><tr><td>GDAS (2019b)</td><td>3.4</td><td>18.38</td><td>0.2</td></tr><tr><td>P-DARTS (2019b） 3.6</td><td></td><td>17.49‡</td><td>0.3</td></tr><tr><td>R-DARTS (2020)</td><td>1</td><td>18.01±0.26</td><td>1.6</td></tr><tr><td>DARTS- (avg.)</td><td>3.3</td><td>17.51±0.25</td><td>0.4</td></tr><tr><td>DARTS- (best)</td><td>3.4</td><td>17.16</td><td>0.4</td></tr></table>
+
+Table 11: Transfer results on COCO datasets of various drop-in backbones.   
+
+<table><tr><td>Backbones</td><td>Params (M)</td><td>Acc</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td>MobileNetV2 (2018)</td><td>3.4</td><td>72.0</td><td>28.3</td><td>46.7</td><td>29.3</td><td>14.8</td><td>30.7</td><td>38.1</td></tr><tr><td>SingPath NAS (2019)</td><td>4.3</td><td>75.0</td><td>30.7</td><td>49.8</td><td>32.2</td><td>15.4</td><td>33.9</td><td>41.6</td></tr><tr><td>MnasNet-A2 (2019)</td><td>4.8</td><td>75.6</td><td>30.5</td><td>50.2</td><td>32.0</td><td>16.6</td><td>34.1</td><td>41.1</td></tr><tr><td>MobileNetV3 (2019)</td><td>5.4</td><td>75.2</td><td>29.9</td><td>49.3</td><td>30.8</td><td>14.9</td><td>33.3</td><td>41.1</td></tr><tr><td>MixNet-M (2019)</td><td>5.0</td><td>77.0</td><td>31.3</td><td>51.7</td><td>32.4</td><td>17.0</td><td>35.0</td><td>41.9</td></tr><tr><td>FairDARTS-C (2020b)</td><td>5.3</td><td>77.2</td><td>31.9</td><td>51.9</td><td>33.0</td><td>17.4</td><td>35.3</td><td>43.0</td></tr><tr><td>DARTS-A (Ours)</td><td>5.5</td><td>77.8</td><td>32.5</td><td>52.8</td><td>34.1</td><td>18.0</td><td>36.1</td><td>43.4</td></tr></table>
+
+![](images/2ee7c0de76fb6d88dacfb8ce4a9475a0bcf887a3438690ae0338da626d09b87d.jpg)  
+Figure 4: The evolution of maximal eigenvalues of DARTS- when searching in different search spaces S0-S4 on CIFAR-10 (a) and CIFAR-100 (c). We run each experiment 3 times on different seeds. (b) DARTS-’s growing Hessian eigenvalues don’t induce poor performance. Among the sampled five models, the one corresponding to the highest eigenvalue has the best performance. This example is done in S0 on CIFAR-10.
+
+![](images/1f60b3396478452c014f262ef127284e35887acc7e47cddc13310a1ce6cf0b66.jpg)  
+Figure 5: Training five models sampled every 10 epochs during DARTS- searching process. See Fig 4 (b) for the corresponding eigenvalues.
+
+# A.2.3 MORE ABLATION STUDIES
+
+To supplement the sensitivity analysis in Section 4.4, Figure 6 shows the training loss curve when initializing $\beta$ with different values.
+
+![](images/4c385a3466eb060cf91292bd589e967c287ffa63d137801d0e272d3eb19c20bf.jpg)  
+Figure 6: The training loss curve of the over-parameterized network on CIFAR-10 in S3 with different initial $\beta _ { 0 }$ .
+
+# A.3 LOSS LANDSCAPE
+
+To show the consistent smoothing capacity of DARTS-, we draw more loss landscapes in S0 and S3 (on several seeds) w.r.t architectural parameters and their contours in Figure 7 and 8. Generally, DARTS-’s slopes are more inflated if we consider them as camping tents, which suggest better convergence of the over-parameterized network.
+
+# A.4 LIST OF EXPERIMENTS
+
+We summarize all the conducted experiments with their related figures and tables in Table 12.
+
+B FIGURES OF GENOTYPES
+
+![](images/2a9495f4bd817a16ca6ed904008ed76e11422c9c3eb2094c924bde1a84f3ae8c.jpg)  
+Figure 7: More visualization of validation accuracy landscapes of DARTS (a,b) and DARTS- (e,f) w.r.t. the architectural weights $\alpha$ on CIFAR-10 in S0. Their contour maps are shown respectively in (c,d) and $^ { ( \mathrm { g , h } ) }$ . The step of contour map is 0.1. The inferred models by DARTS- have higher accuracies ( $9 7 . 5 0 \%$ , $9 7 . 4 9 \%$ ) than DARTS $( 9 7 . 1 9 \%$ , $9 7 . 2 0 \%$ ).
+
+![](images/29923a592a8d5157ef46cf1e03033d7003870bed18aa6bb44063ecd4855316ca.jpg)  
+Figure 8: More visualization of validation accuracy landscapes of DARTS (a,b) and DARTS- (e,f) w.r.t. the architectural weights $\alpha$ on CIFAR-10 in S3. Their contour maps are shown respectively in (c,d) and $^ { ( \mathrm { g , h } ) }$ . The step of contour map is 0.1.
+
+Table 12: List of experiments conducted in this paper   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Search Space</td><td rowspan="2">Dataset</td><td colspan="2">Figures</td><td colspan="2">Tables</td></tr><tr><td>Main text</td><td>Supp.</td><td>Main text</td><td>Supp.</td></tr><tr><td>DARTS</td><td>S0</td><td>CIFAR-10</td><td></td><td>7</td><td></td><td></td></tr><tr><td>DARTS</td><td>S3</td><td>CIFAR-10</td><td>3</td><td></td><td></td><td></td></tr><tr><td>DARTS-</td><td>S0</td><td>CIFAR-10</td><td></td><td>4,5,9,7</td><td>1,2</td><td></td></tr><tr><td>DARTS-</td><td>S1-S4</td><td>CIFAR-10</td><td>3</td><td>4,6,9,8</td><td>7,9</td><td>6</td></tr><tr><td>DARTS-</td><td>S5</td><td>ImageNet</td><td></td><td>5,10</td><td>2</td><td></td></tr><tr><td>DARTS-</td><td>S5</td><td>MS COCO</td><td></td><td></td><td>11</td><td></td></tr><tr><td>DARTS-</td><td>S6</td><td>CIFAR-10</td><td></td><td></td><td>3</td><td></td></tr><tr><td>DARTS-</td><td>S1-S4</td><td>CIFAR-100</td><td></td><td>4,11</td><td>7</td><td>9</td></tr><tr><td>DARTS-</td><td>S0</td><td>CIFAR-100</td><td></td><td>4,11</td><td>1,10</td><td></td></tr><tr><td>P-DARTS w/o M=2</td><td>S0</td><td>CIFAR-10</td><td></td><td>12</td><td>4</td><td></td></tr><tr><td>P-DARTS w/ auxiliary skip</td><td>S0</td><td>CIFAR-10</td><td></td><td>13</td><td>4</td><td></td></tr><tr><td>PC-DARTS w/o channel shuffling</td><td>S0</td><td>CIFAR-10</td><td></td><td>14</td><td>5</td><td></td></tr><tr><td>PC-DARTS w/ auxiliary skip</td><td>S0</td><td>CIFAR-10</td><td></td><td>15</td><td>5</td><td></td></tr></table>
+
+![](images/8ce376a98a358cfa0571a1d2c1837de2ad9b9ab517055b2a8eaa14526d983be0.jpg)  
+Figure 9: The best found normal cell and reduction cell in search spaces S0-S4 on CIFAR-10 dataset.
+
+![](images/b93e5bebc4be38b06a9a3b3f81f8cfbacd0c45fdf1315c783022ec1efcd1df70.jpg)  
+Figure 10: Architecture of DARTS-A searched on ImageNet dataset.
+
+![](images/bb4cac4e0acfb86c3427107e6b51ea45d471616b65c10e9dd877548cfb58daff.jpg)  
+Figure 11: The best found normal cell and reduction cell in search spaces S0-S4 on CIFAR-100 dataset.
+
+![](images/59168baee3e57e3abbee41b713ad516736821a38c792ebd8b62b612c11983e4a.jpg)  
+Figure 12: Found normal cells and reduction cells by P-DARTS (Chen et al., 2019b) without prior $\left( \mathrm { M } { = } 2 \right)$ in the DARTS’ standard search space on CIFAR-10 dataset.
+
+![](images/4aa6caab7efecd691b10ad7b69ddf96431f90381de5f91f8d8e1de988b899a55.jpg)  
+Figure 13: Found normal cells and reduction cells by P-DARTS (Chen et al., 2019b) with the proposed auxiliary skip connections in the DARTS’ standard search space on CIFAR-10 dataset.
+
+![](images/9eb5847b3748618f79e68edd3e7290ba0b0664ce86d6cf8255072dc4ce5d8afe.jpg)  
+Figure 14: Found normal cells and reduction cells by PC-DARTS (Xu et al., 2020) without channel shuffling in the DARTS’ standard search space on CIFAR-10 dataset.
+
+![](images/87fda05d569e1baffc9c8528bca5132ed0ff26ec88d2ecc4d7d3f62b6ada74bf.jpg)  
+Figure 15: Found normal cells and reduction cells by PC-DARTS (Xu et al., 2020) with the proposed auxiliary skip connections in the DARTS’ standard search space on CIFAR-10 dataset.
+
+![](images/28cb38bdb83fa8425399f9a319693b7f8899d497151c37ee46600553d55deca8.jpg)  
+Figure 16: Keep $\beta _ { s k i p } = 1$ throughout the DARTS- searching in the DARTS’ standard search space on CIFAR-10 dataset.
+
+![](images/68f00aff2b2a8afb574bdce394963b31ea9113387ccc939bc6a9eb4dc8829d7f.jpg)  
+Figure 17: Best cells found when decaying $\beta _ { s k i p }$ in the last 50 epochs during the DARTS- searching for 150 and 200 epochs respectively in the DARTS search space on CIFAR-10.
+
+![](images/fea26212834d7f4e1cfe56c801661a7736ef15af5724913154e8d655e7fb4005.jpg)  
+Figure 18: Decaying $\beta _ { s k i p }$ in the last 50 epochs during the DARTS- searching for 150 epochs in S2 on CIFAR-10 dataset.
+
+![](images/38adf322fed77dcecab1707bc625a43ecd1647d879a59ad0e45618f7a4352828.jpg)  
+Figure 19: Decaying $\beta _ { s k i p }$ in the last 50 epochs during the DARTS- searching for 200 epochs in S2 on CIFAR-10 dataset.
+
+![](images/3105c03082ffb033f6da5cfd8c399b4caf7f314f6bb471176ef9eef614cdd86f.jpg)  
+Figure 20: Decaying $\beta _ { s k i p }$ in the last 50 epochs during the DARTS- searching for 150 epochs in S3 on CIFAR-10 dataset.
+
+![](images/481adfe5288a09b65c0c085885b5bd095d167481e63b455d2b4e4f3ca5e83a57.jpg)  
+Figure 21: Decaying $\beta _ { s k i p }$ in the last 50 epochs during the DARTS- searching for 200 epochs in S3 on CIFAR-10 dataset.

parse/train/SJJinbWRZ/SJJinbWRZ.md

@@ -0,0 +1,347 @@
+# MODEL-ENSEMBLE TRUST-REGION POLICY OPTIMIZATION
+
+Ignasi Clavera Yan Duan Aviv Tamar Pieter Abbeel
+
+Berkeley AI Research   
+University of California, Berkeley   
+Berkeley, CA 94709   
+{thanard.kurutach, iclavera, rockyduan, avivt, pabbeel}@berkeley.edu
+
+# ABSTRACT
+
+Model-free reinforcement learning (RL) methods are succeeding in a growing number of tasks, aided by recent advances in deep learning. However, they tend to suffer from high sample complexity which hinders their use in real-world domains. Alternatively, model-based reinforcement learning promises to reduce sample complexity, but tends to require careful tuning and, to date, it has succeeded mainly in restrictive domains where simple models are sufficient for learning. In this paper, we analyze the behavior of vanilla model-based reinforcement learning methods when deep neural networks are used to learn both the model and the policy, and we show that the learned policy tends to exploit regions where insufficient data is available for the model to be learned, causing instability in training. To overcome this issue, we propose to use an ensemble of models to maintain the model uncertainty and regularize the learning process. We further show that the use of likelihood ratio derivatives yields much more stable learning than backpropagation through time. Altogether, our approach Model-Ensemble Trust-Region Policy Optimization (ME-TRPO) significantly reduces the sample complexity compared to model-free deep RL methods on challenging continuous control benchmark tasks1.
+
+# 1 INTRODUCTION
+
+Deep reinforcement learning has achieved many impressive results in recent years, including learning to play Atari games from raw-pixel inputs (Mnih et al., 2015), mastering the game of Go (Silver et al., 2016; 2017), as well as learning advanced locomotion and manipulation skills from raw sensory inputs (Levine et al., 2016a; Schulman et al., 2015; 2016; Lillicrap et al., 2015). Many of these results were achieved using model-free reinforcement learning algorithms, which do not attempt to build a model of the environment. These algorithms are generally applicable, require relatively little tuning, and can easily incorporate powerful function approximators such as deep neural networks. However, they tend to suffer from high sample complexity, especially when such powerful function approximators are used, and hence their applications have been mostly limited to simulated environments. In comparison, model-based reinforcement learning algorithms utilize a learned model of the environment to assist learning. These methods can potentially be much more sample efficient than model-free algorithms, and hence can be applied to real-world tasks where low sample complexity is crucial (Deisenroth and Rasmussen, 2011; Levine et al., 2016a; Venkatraman et al., 2017). However, so far such methods have required very restrictive forms of the learned models, as well as careful tuning for them to be applicable. Although it is a straightforward idea to extend model-based algorithms to deep neural network models, so far there has been comparatively fewer successful applications.
+
+The standard approach for model-based reinforcement learning alternates between model learning and policy optimization. In the model learning stage, samples are collected from interaction with the environment, and supervised learning is used to fit a dynamics model to the observations. In the policy optimization stage, the learned model is used to search for an improved policy. The underlying assumption in this approach, henceforth termed vanilla model-based RL, is that with enough data, the learned model will be accurate enough, such that a policy optimized on it will also perform well in the real environment.
+
+Although vanilla model-based RL can work well on low-dimensional tasks with relatively simple dynamics, we find that on more challenging continuous control tasks, performance was highly unstable. The reason is that the policy optimization tends to exploit regions where insufficient data is available to train the model, leading to catastrophic failures. Previous work has pointed out this issue as model bias, i.e. (Deisenroth and Rasmussen, 2011; Schneider, 1997; Atkeson and Santamaria, 1997). While this issue can be regarded as a form of overfitting, we emphasize that standard countermeasures from the supervised learning literature, such as regularization or cross validation, are not sufficient here – supervised learning can guarantee generalization to states from the same distribution as the data, but the policy optimization stage steers the optimization exactly towards areas where data is scarce and the model is inaccurate. This problem is severely aggravated when expressive models such as deep neural networks are employed.
+
+To resolve this issue, we propose to use an ensemble of deep neural networks to maintain model uncertainty given the data collected from the environment. During model learning, we differentiate the neural networks by varying their weight initialization and training input sequences. Then, during policy learning, we regularize the policy updates by combining the gradients from the imagined stochastic roll-outs. Each imagined step is uniformly sampled from the ensemble predictions. Using this technique, the policy learns to become robust against various possible scenarios it may encounter in the real environment. To avoid overfitting to this regularized objective, we use the model ensemble for early stopping policy training.
+
+Standard model-based techniques require differentiating through the model over many time steps, a procedure known as backpropagation through time (BPTT). It is well-known in the literature that BPTT can lead to exploding and vanishing gradients (Bengio et al., 1994). Even when gradient clipping is applied, BPTT can still get stuck in bad local optima. We propose to use likelihood ratio methods instead of BPTT to estimate the gradient, which only make use of the model as a simulator rather than for direct gradient computation. In particular, we use Trust Region Policy Optimization (TRPO) (Schulman et al., 2015), which imposes a trust region constraint on the policy to further stabilize learning.
+
+In this work, we propose Model-Ensemble Trust-Region Policy Optimization (ME-TRPO), a modelbased algorithm that achieves the same level of performance as state-of-the-art model-free algorithms with $1 0 0 \times$ reduction in sample complexity. We show that the model ensemble technique is an effective approach to overcome the challenge of model bias in model-based reinforcement learning. We demonstrate that replacing BPTT by TRPO yields significantly more stable learning and much better final performance. Finally, we provide an empirical analysis of vanilla model-based RL using neural networks as function approximators, and identify its flaws when applied to challenging continuous control tasks.
+
+# 2 RELATED WORK
+
+There has been a large body of work on model-based reinforcement learning. They differ by the choice of model parameterization, which is associated with different ways of utilizing the model for policy learning. Interestingly, the most impressive robotic learning applications so far were achieved using the simplest possible model parameterization, namely linear models (Bagnell and Schneider, 2001; Abbeel et al., 2006; Levine and Abbeel, 2014; Watter et al., 2015; Levine et al., 2016a; Kumar et al., 2016), where the model either operates directly over the raw state, or over a feature representation of the state. Such models are very data efficient, and allows for very efficient policy optimization through techniques from optimal control. However, they only have limited expressiveness, and do not scale well to complicated nonlinear dynamics or high-dimensional state spaces, unless a separate feature learning phase is used (Watter et al., 2015).
+
+An alternative is to use nonparametric models such as Gaussian Processes (GPs) (Rasmussen et al., 2003; Ko et al., 2007; Deisenroth and Rasmussen, 2011). Such models can effectively maintain uncertainty over the predictions, and have infinite representation power as long as enough data is available. However, they suffer from the curse of dimensionality, and so far their applications have been limited to relatively low-dimensional settings. The computational expense of incorporating the uncertainty estimates from GPs into the policy update also imposes an additional challenge.
+
+Deep neural networks have shown great success in scaling up model-free reinforcement learning algorithms to challenging scenarios (Mnih et al., 2015; Silver et al., 2016; Schulman et al., 2015; 2016). However, there has been only limited success in applying them to model-based RL. Although many previous studies have shown promising results on relatively simple domains (Nguyen and Widrow, 1990; Schmidhuber and Huber, 1991; Jordan and Rumelhart, 1992; Gal et al., 2016), so far their applications on more challenging domains have either required a combination with model-free techniques (Oh et al., 2015; Heess et al., 2015; Nagabandi et al., 2017), or domain-specific policy learning or planning algorithms (Lenz et al., 2015; Agrawal et al., 2016; Pinto and Gupta, 2016; Levine et al., 2016b; Finn and Levine, 2017; Nair et al., 2017). In this work, we show that our purely model-based approach improves the sample complexity compared to methods that combine model-based and model-free elements.
+
+Two recent studies have shown promising signs towards a more generally applicable model-based RL algorithm. Depeweg et al. (2017) utilize Bayesian neural networks (BNNs) to learn a distribution over dynamics models, and train a policy using gradient-based optimization over a collection of models sampled from this distribution. Mishra et al. (2017) learn a latent variable dynamic model over temporally extended segments of the trajectory, and train a policy using gradient-based optimization over the latent space. Both of these approaches have been shown to work on a fixed dataset of samples which are collected before the algorithm starts operating. Hence, their evaluations have been limited to domains where random exploration is sufficient to collect data for model learning. In comparison, our approach utilizes an iterative process of alternatively performing model learning and policy learning, and hence can be applied to more challenging domains. Additionally, our proposed improvements are orthogonal to both approaches, and can be potentially combined to yield even better results.
+
+# 3 PRELIMINARIES
+
+This paper assumes a discrete-time finite-horizon Markov decision process (MDP), defined by $( S , \mathcal { A } , f , r , \rho _ { 0 } , T )$ , in which $S \subseteq \mathbb { R } ^ { n }$ is the state space, ${ \mathcal { A } } \subseteq \mathbb { R } ^ { m }$ the action space, $f : \mathcal { S } \times \mathcal { A }  \mathcal { S }$ a deterministic transition function, $r : S \times \mathcal { A }  \mathbb { R }$ a bounded reward function, $\rho _ { 0 } : { \mathcal { S } } \to \mathbb { R } _ { + }$ an initial state distribution, and $T$ the horizon. We denote a stochastic policy $\pi _ { \boldsymbol { \theta } } ( a | \boldsymbol { s } )$ as the probability of taking action $a$ at state $s$ . Let $\eta ( \theta )$ denote its expected return: $\begin{array} { r } { \eta ( \theta ) = \mathbb { E } _ { \tau } [ \sum _ { t = 0 } ^ { T } r ( s _ { t } , a _ { t } ) ] } \end{array}$ where $\tau = ( s _ { 0 } , a _ { 0 } , \ldots , a _ { T - 1 } , s _ { T } )$ denotes the whole trajectory, $s _ { 0 } \sim \rho _ { 0 } ( . )$ , $a _ { t } \sim \pi _ { \theta } ( . | s _ { t } )$ , and $s _ { t + 1 } = f ( s _ { t } , \overline { { a _ { t } } } )$ for all $t$ . We assume that the reward function is known but the transition function is unknown. Our goal is to find an optimal policy that maximizes the expected return $\eta ( \theta )$ .
+
+# 4 VANILLA MODEL-BASED DEEP REINFORCEMENT LEARNING
+
+In the most successful methods of model-free reinforcement learning, we iteratively collect data, estimate the gradient of the policy, improve the policy, and then discard the data. Conversely, modelbased reinforcement learning makes more extensive use of the data; it uses all the data collected to train a model of the dynamics of the environment. The trained model can be used as a simulator in which the policy can be trained, and also provides gradient information (Sutton, 1990; Deisenroth and Rasmussen, 2011; Depeweg et al., 2017; Sutton, 1991). In the following section, we describe the vanilla model-based reinforcement learning algorithm (see Algorithm 1). We assume that the model and the policy are represented by neural networks, but the methodology is valid for other types of function approximators.
+
+# 4.1 MODEL LEARNING
+
+The transition dynamics is modeled with a feed-forward neural network, using the standard practice to train the neural network to predict the change in state (rather than the next state) given a state and an action as inputs. This relieves the neural network from memorizing the input state, especially when the change is small (Deisenroth and Rasmussen, 2011; Fu et al., 2016; Nagabandi et al., 2017).
+
+We denote the function approximator for the next state, which is the sum of the input state and the output of the neural network, as $\hat { f } _ { \phi }$ .
+
+The objective of model learning is to find a parameter $\phi$ that minimizes the $\mathrm { L _ { 2 } }$ one-step prediction $\mathrm { l o s s } ^ { 2 }$ :
+
+$$
+\operatorname* { m i n } _ { \phi } \frac { 1 } { | \mathcal { D } | } \sum _ { ( s _ { t } , a _ { t } , s _ { t + 1 } ) \in \mathcal { D } } \Big \| s _ { t + 1 } - \hat { f } _ { \phi } \big ( s _ { t } , a _ { t } \big ) \Big \| _ { 2 } ^ { 2 }
+$$
+
+where $\mathcal { D }$ is the training dataset that stores the transitions the agent has experienced. We use the Adam optimizer (Kingma and Ba, 2014) to solve this supervised learning problem. Standard techniques are followed to avoid overfitting and facilitate the learning such as separating a validation dataset to early stop the training, and normalizing the inputs and outputs of the neural network3
+
+# 4.2 POLICY LEARNING
+
+Given an MDP, $\mathcal { M }$ , the goal of reinforcement learning is to maximize the expected sum of rewards. During training, model-based methods maintain an approximate MDP, $\hat { \mathcal { M } }$ , where the transition function is given by a parameterized model $\hat { f } _ { \phi }$ learned from data. The policy is then updated with respect to the approximate MDP. Hence, the objective we maximize is
+
+$$
+\hat { \eta } ( \theta ; \phi ) : = \mathbb { E } _ { \hat { \tau } } [ \sum _ { t = 0 } ^ { T } r ( s _ { t } , a _ { t } ) ] ,
+$$
+
+where $\hat { \tau } = ( s _ { 0 } , a _ { 0 } , \dotsc ) , s _ { 0 } \sim \rho _ { 0 } ( \cdot ) , a _ { t } \sim \pi _ { \theta } ( \cdot | s _ { t } ) ,$ , and $s _ { t + 1 } = \hat { f } _ { \phi } ( s _ { t } , a _ { t } )$ .
+
+We represent the stochastic policy4 as a conditional multivariate normal distribution with a parametrized mean $\mu _ { \theta } : { \mathcal { S } }  A$ and a parametrized standard deviation $\sigma _ { \theta } : \mathcal { S }  \mathbb { R } ^ { m }$ . Using the re-parametrization trick (Heess et al., 2015), we can write down an action sampled from $\pi _ { \theta }$ at state $s$ as $\mu _ { \boldsymbol { \theta } } ( \boldsymbol { s } ) + \sigma _ { \boldsymbol { \theta } } ( \boldsymbol { s } ) ^ { T } \boldsymbol { \zeta }$ , where $\zeta \sim \mathcal { N } ( 0 , I _ { m } )$ . Given a trajectory $\hat { \tau }$ sampled using the policy $\pi _ { \theta }$ , we can recover the noise vectors $\big \{ \zeta _ { 0 } , . . . , \zeta _ { T } \big \}$ . Thus, the gradient of the objective $\hat { \eta } ( \theta ; \phi )$ can simply be estimated by Monte-Carlo methods:
+
+$$
+\nabla _ { \theta } \hat { \eta } = \mathbb { E } _ { s _ { 0 } \sim \rho _ { 0 } ( s _ { 0 } ) , \zeta _ { i } \sim \mathcal { N } ( 0 , I _ { m } ) } [ \nabla _ { \theta } \sum _ { t = 0 } ^ { T } r ( s _ { t } , a _ { t } ) ]
+$$
+
+This method of gradient computation is called backpropagation through time (BPTT), which can be easily performed using an automatic differentiation library. We apply gradient clipping (Pascanu et al., 2013) to deal with exploding gradients, and we use the Adam optimizer (Kingma and Ba, 2014) for more stable learning. We perform the updates until the policy no longer improves its estimated performance $\hat { \eta }$ over a period of time (controlled by a hyperparameter), and then we repeat the process in the outer loop by using the policy to collect more data with respect to the real model5. The whole procedure terminates when the desired performance according to the real model is accomplished.
+
+# 5 MODEL-ENSEMBLE TRUST-REGION POLICY OPTIMIZATION
+
+Using the vanilla approach described in Section 4, we find that the learned policy often exploits regions where scarce training data is available for the dynamics model. Since we are improving
+
+# Algorithm 1 Vanilla Model-Based Deep Reinforcement Learning
+
+1: Initialize a policy $\pi _ { \theta }$ and a model $\hat { f } _ { \phi }$ .   
+2: Initialize an empty dataset $D$ .   
+3: repeat   
+4: Collect samples from the real environment $f$ using $\pi _ { \theta }$ and add them to $D$ .   
+5: Train the model $\hat { f } _ { \phi }$ using $D$ .   
+6: repeat   
+7: Collect fictitious samples from $\hat { f } _ { \phi }$ using $\pi _ { \theta }$ .   
+8: Update the policy using BPTT on the fictitious samples.   
+9: Estimate the performance $\hat { \eta } ( \theta ; \phi )$ .   
+10: until the performance stop improving.   
+11: until the policy performs well in real environment $f$ .
+
+the policy with respect to the approximate MDP instead of the real one, the predictions then can be erroneous to the policy’s advantage. This overfitting issue can be partly alleviated by early stopping using validation initial states in a similar manner to supervised learning. However, we found this insufficient, since the performance is still evaluated using the same learned model, which tends to make consistent mistakes. Furthermore, although gradient clipping can usually resolve exploding gradients, BPTT still suffers from vanishing gradients, which cause the policy to get stuck in bad local optima (Bengio et al., 1994; Pascanu et al., 2013). These problems are especially aggravated when optimizing over long horizons, which is very common in reinforcement learning problems.
+
+We now present our method, Model-Ensemble Trust-Region Policy Optimization (ME-TRPO). The pseudocode is shown in Algorithm 2. ME-TRPO combines three modifications to the vanilla approach. First, we fit a set of dynamics models $\{ f _ { \phi _ { 1 } } , \dotsc , f _ { \phi _ { K } } \}$ (termed a model ensemble) using the same real world data. These models are trained via standard supervised learning, as described in Section 4.1, and they only differ by the initial weights and the order in which mini-batches are sampled. Second, we use Trust Region Policy Optimization (TRPO) to optimize the policy over the model ensemble. Third, we use the model ensemble to monitor the policy’s performance on validation data, and stops the current iteration when the policy stops improving. The second and third modifications are described in detail below.
+
+Policy Optimization. To overcome the issues with BPTT, we use likelihood-ratio methods from the model-free RL literature. We evaluated using Vanilla Policy Gradient (VPG) (Peters and Schaal, 2006), Proximal Policy Optimization (PPO) (Schulman et al., 2017), and Trust Region Policy Optimization (TRPO) (Schulman et al., 2015). The best results were achieved by TRPO. In order to estimate the gradient, we use the learned models to simulate trajectories as follows: in every step, we randomly choose a model to predict the next state given the current state and action. This avoids the policy from overfitting to any single model during an episode, leading to more stable learning.
+
+Policy Validation. We monitor the policy’s performance using the $K$ learned models. Specifically, we compute the ratio of models in which the policy improves:
+
+$$
+\frac { 1 } { K } \sum _ { k = 1 } ^ { K } \mathbb { 1 } [ \hat { \eta } ( \theta _ { n e w } ; \phi _ { k } ) > \hat { \eta } ( \theta _ { o l d } ; \phi _ { k } ) ] .
+$$
+
+The current iteration continues as long as this ratio exceeds a certain threshold. In practice, we validate the policy after every 5 gradient updates and we use $70 \%$ as the threshold. If the ratio falls below the threshold, a small number of updates is tolerated in case the performance improves, the current iteration is terminated. Then, we repeat the overall process of using the policy to collect more real-world data, optimize the model ensemble, and using the model ensemble to improve the policy. This process continues until the desired performance in the real environment is reached.
+
+The model ensemble serves as effective regularization for policy learning: by using the model ensemble for policy optimization and validation, the policy is forced to perform well over a vast number of possible alternative futures. Even though any of the individual models can still incur model bias, our experiments below suggest that combining these models yields stable and effective policy improvement.
+
+# Algorithm 2 Model Ensemble Trust Region Policy Optimization (ME-TRPO)
+
+1: Initialize a policy $\pi _ { \theta }$ and all models $\hat { f } _ { \phi _ { 1 } } , \hat { f } _ { \phi _ { 2 } } , . . . , \hat { f } _ { \phi _ { K } }$ .   
+2: Initialize an empty dataset $\mathcal { D }$ .   
+3: repeat   
+4: Collect samples from the real system $f$ using $\pi _ { \theta }$ and add them to $D$ .   
+5: Train all models using $\mathcal { D }$ .   
+6: repeat $\triangleright$ Optimize $\pi _ { \theta }$ using all models.   
+7: Collect fictitious samples from $\{ \hat { f } _ { \phi _ { i } } \} _ { i = 1 } ^ { K }$ using $\pi _ { \theta }$ .   
+8: Update the policy using TRPO on the fictitious samples.   
+9: Estimate the performances $\hat { \eta } ( \theta ; \phi _ { i } )$ for $i = 1 , . . . , K$ .   
+10: until the performances stop improving.   
+11: until the policy performs well in real environment $f$ .
+
+# 6 EXPERIMENTS
+
+We design the experiments to answer the following questions:
+
+1. How does our approach compare against state-of-the-art methods in terms of sample complexity and final performance?   
+2. What are the failure scenarios of the vanilla algorithm?   
+3. How does our method overcome these failures?
+
+We also provide in the Appendix D an ablation study to characterize the effect of each component of our algorithm.
+
+# 6.1 ENVIRONMENTS
+
+To answer these questions, we evaluate our method and various baselines over six standard continuous control benchmark tasks (Duan et al., 2016; Hesse et al., 2017) in Mujoco (Todorov et al., 2012): Swimmer, Snake, Hopper, Ant, Half Cheetah, and Humanoid, shown in Figure 1. The details of the tasks can be found in Appendix A.2.
+
+![](images/584eae6d5a8ad247ac909792e26ace2cdc2eea4d297673c15e5881e6797c0bf5.jpg)  
+Figure 1: Mujoco environments used in our experiments. Form left to right: Swimmer, Half Cheetah, Snake, Ant, Hopper, and Humanoid.
+
+# 6.2 COMPARISON TO STATE-OF-THE-ART
+
+We compare our method with the following state-of-the-art reinforcement learning algorithms in terms of sample complexity and performance: Trust Region Policy Optimization (TRPO) (Schulman et al., 2015), Proximal Policy Optimization (PPO) (Schulman et al., 2017), Deep Deterministic Policy Gradient (DDPG) (Lillicrap et al., 2015), and Stochastic Value Gradient (SVG) (Heess et al., 2015).
+
+The results are shown in Figure 2. Prior model-based methods appear to achieve worse performance compared with model-free methods. In addition, we find that model-based methods tend to be difficult to train over long horizons. In particular, SVG(1), not presented in the plots, is very unstable in our experiments. While $\mathrm { S V G } ( \infty )$ is more stable, it fails to achieve the same level of performance as model-free methods. In contrast, our proposed method reaches the same level of performance as model-free approaches with $\approx 1 0 0 \times$ less data. To the best of our knowledge, it is the first purely model-based approach that can optimize policies over high-dimensional motor-control tasks such as Humanoid. For experiment details please refer to Appendix A.
+
+![](images/523e8fa5a5f5ba0883cb6eb9680ef5f39033a973b8117936187d30e9c192a41f.jpg)  
+Figure 2: Learning curves of our method versus state-of-the-art methods. The horizontal axis, in log-scale, indicates the number of time steps of real world data. The vertical axis denotes the average return. These figures clearly demonstrate that our proposed method significantly outperforms other methods in comparison (best viewed in color).
+
+# 6.3 FROM VANILLA TO ME-TRPO
+
+In this section we explain and quantify the failure cases of vanilla model-based reinforcement learning, and how our approach overcomes such failures. We analyze the effect of each of our proposed modifications by studying the learning behavior of replacing BPTT with TRPO in vanilla model-based RL using just a single model, and then the effect of using an ensemble of models.
+
+As discussed above, BPTT suffers from exploding and vanishing gradients, especially when optimizing over long horizons. Furthermore, one of the principal drawbacks of BPTT is the assumption that the model derivatives should match that of the real dynamics, even though the model has not been explicitly trained to provide accurate gradient information. In Figure 3 we demonstrate the effect of using policy gradient methods that make use of a score function estimator, such as VPG and TRPO, while using a single learned model. The results suggest that in comparison with BPTT, policy gradient methods are more stable and lead to much better final performance. By using such model-free algorithms, we require less information from the learned model, which only acts as a simulator. Gradient information through the dynamics model is not needed anymore to optimize the policy.
+
+![](images/46b42e5cc5ce653d045ed61cf0b509f5368828a1fd6445c5e6f31a4b32347d37.jpg)  
+Figure 3: Comparison among different policy optimization techniques with one model. Using TRPO for model-based optimization leads to the best policy learning across the different domains (Best viewed in color).
+
+However, while replacing BPTT by TRPO helps optimization, the learned policy can still suffer from model bias. The learning procedure tends to steer the policy towards regions where it has rarely visited, so that the model makes erroneous predictions to its advantage. The estimated performances of the policy often end up with high rewards according to the learned model, and low rewards according to the real one (see Appendix B for further discussion). In Figure 4, we analyze the effect of using various numbers of ensemble models for sampling trajectories and validating the policy’s performance. The results indicate that as more models are used in the model ensemble, the learning is better regularized and the performance continually improves. The improvement is even more noticeable in more challenging environments like HalfCheetah and Ant, which require more complex dynamics models to be learned, leaving more room for the policy to exploit when model ensemble is not used.
+
+![](images/1ca995a55bd358f5cc3ac206cd67f70fe931abce9cbe2a86ab68d11b3130a7b5.jpg)  
+Figure 4: Comparison among different number of models that the policy is trained on. TRPO is used for the policy optimization. We illustrate the improvement when using 5, 10 and 20 models over a single model (Best viewed in color).
+
+# 7 DISCUSSION
+
+In this work, we present a simple and robust model-based reinforcement learning algorithm that is able to learn neural network policies across different challenging domains. We show that our approach significantly reduces the sample complexity compared to state-of-the-art methods while reaching the same level of performance. In comparison, our analyses suggests that vanilla model-based RL tends to suffer from model bias and numerical instability, and fails to learn a good policy. We further evaluate the effect of each key component of our algorithm, showing that both using TRPO and model ensemble are essential for successful applications of deep model-based RL. We also confirm the results of previous work (Deisenroth and Rasmussen, 2011; Depeweg et al., 2017; Gal et al., 2016) that using model uncertainty is a principled way to reduce model bias.
+
+One question that merits future investigation is how to use the model ensemble to encourage the policy to explore the state space where the different models disagree, so that more data can be collected to resolve their disagreement. Another enticing direction for future work would be the application of ME-TRPO to real-world robotics systems.
+
+# ACKNOWLEDGEMENT
+
+The authors thank Stuart Russell, Abishek Gupta, Carlos Florensa, Anusha Nagabandi, Haoran Tang, and Gregory Kahn for helpful discussions and feedbacks. T. Kurutach has been supported by ONR PECASE grant N000141612723, I. Clavera has been supported by La Caixa Fellowship, Y. Duan has been supported by Huawei Fellowship, and A. Tamar has been supported by Siemens Fellowship.
+
+# REFERENCES
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354–359, 2017.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016a.
+
+John Schulman, Sergey Levine, Philipp Moritz, Michael I Jordan, and Pieter Abbeel. Trust region policy optimization. CoRR, abs/1502.05477, 2015.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. High-dimensional continuous control using generalized advantage estimation. In International Conference on Learning Representations (ICLR2016), 2016.
+
+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, abs/1509.02971, 2015.
+
+Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pages 465–472, 2011.
+
+Arun Venkatraman, Roberto Capobianco, Lerrel Pinto, Martial Hebert, Daniele Nardi, and J. Andrew Bagnell. Improved Learning of Dynamics Models for Control, pages 703–713. Springer International Publishing, Cham, 2017. ISBN 978-3-319-50115-4.
+
+Jeff G Schneider. Exploiting model uncertainty estimates for safe dynamic control learning. In Advances in neural information processing systems, pages 1047–1053, 1997.
+
+Christopher G Atkeson and Juan Carlos Santamaria. A comparison of direct and model-based reinforcement learning. In Robotics and Automation, 1997. Proceedings., 1997 IEEE International Conference on, volume 4, pages 3557–3564. IEEE, 1997.
+
+Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE transactions on neural networks, 5(2):157–166, 1994.
+
+J Andrew Bagnell and Jeff G Schneider. Autonomous helicopter control using reinforcement learning policy search methods. In Robotics and Automation, 2001. Proceedings 2001 ICRA. IEEE International Conference on, volume 2, pages 1615–1620. IEEE, 2001.
+
+Pieter Abbeel, Morgan Quigley, and Andrew Y Ng. Using inaccurate models in reinforcement learning. In Proceedings of the 23rd international conference on Machine learning, pages 1–8. ACM, 2006.
+
+Sergey Levine and Pieter Abbeel. Learning neural network policies with guided policy search under unknown dynamics. In Advances in Neural Information Processing Systems, pages 1071–1079, 2014.
+
+Manuel Watter, Jost Springenberg, Joschka Boedecker, and Martin Riedmiller. Embed to control: A locally linear latent dynamics model for control from raw images. In Advances in Neural Information Processing Systems, pages 2746–2754, 2015.
+
+Vikash Kumar, Emanuel Todorov, and Sergey Levine. Optimal control with learned local models: Application to dexterous manipulation. In Robotics and Automation (ICRA), 2016 IEEE International Conference on, pages 378–383. IEEE, 2016.
+
+Carl Edward Rasmussen, Malte Kuss, et al. Gaussian processes in reinforcement learning. In NIPS, volume 4, page 1, 2003.
+
+Jonathan Ko, Daniel J Klein, Dieter Fox, and Dirk Haehnel. Gaussian processes and reinforcement learning for identification and control of an autonomous blimp. In Robotics and Automation, 2007 IEEE International Conference on, pages 742–747. IEEE, 2007.
+
+Derrick H Nguyen and Bernard Widrow. Neural networks for self-learning control systems. IEEE Control systems magazine, 10(3):18–23, 1990.
+
+Juergen Schmidhuber and Rudolf Huber. Learning to generate artificial fovea trajectories for target detection. International Journal of Neural Systems, 2(01n02):125–134, 1991.
+
+Michael I Jordan and David E Rumelhart. Forward models: Supervised learning with a distal teacher. Cognitive science, 16(3):307–354, 1992.
+
+Yarin Gal, Rowan Thomas McAllister, and Carl Edward Rasmussen. Improving pilco with bayesian neural network dynamics models. In Data-Efficient Machine Learning workshop, volume 951, page 2016, 2016.
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In Advances in Neural Information Processing Systems, pages 2863–2871, 2015.
+
+Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems, pages 2944–2952, 2015.
+
+Anusha Nagabandi, Gregory Kahn, Ronald S. Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. CoRR, abs/1708.02596, 2017.
+
+Ian Lenz, Ross A Knepper, and Ashutosh Saxena. Deepmpc: Learning deep latent features for model predictive control. In Robotics: Science and Systems, 2015.
+
+Pulkit Agrawal, Ashvin Nair, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Learning to poke by poking: Experiential learning of intuitive physics. In Advances In Neural Information Processing Systems, 2016.
+
+Lerrel Pinto and Abhinav Gupta. Supersizing self-supervision: Learning to grasp from 50k tries and 700 robot hours. In Robotics and Automation (ICRA), 2016 IEEE International Conference on, pages 3406–3413. IEEE, 2016.
+
+Sergey Levine, Peter Pastor, Alex Krizhevsky, and Deirdre Quillen. Learning hand-eye coordination for robotic grasping with deep learning and large-scale data collection. arXiv preprint arXiv:1603.02199, 2016b.
+
+Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In IEEE International Conference on Robotics and Automation (ICRA), 2017.
+
+Ashvin Nair, Dian Chen, Pulkit Agrawal, Phillip Isola, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Combining self-supervised learning and imitation for vision-based rope manipulation. arXiv preprint arXiv:1703.02018, 2017.
+
+Stefan Depeweg, Jose Miguel Hern ´ andez-Lobato, Finale Doshi-Velez, and Steffen Udluft. Learning ´ and policy search in stochastic dynamical systems with bayesian neural networks. In International Conference on Learning Representations (ICLR2017), 2017.
+
+Nikhil Mishra, Pieter Abbeel, and Igor Mordatch. Prediction and control with temporal segment models. arXiv preprint arXiv:1703.04070, 2017.
+
+Richard S Sutton. Integrated architectures for learning, planning, and reacting based on approximating dynamic programming. In Proceedings of the seventh international conference on machine learning, pages 216–224, 1990.
+
+Richard S Sutton. Dyna, an integrated architecture for learning, planning, and reacting. ACM SIGART Bulletin, 2(4):160–163, 1991.
+
+Justin Fu, Sergey Levine, and Pieter Abbeel. One-shot learning of manipulation skills with online dynamics adaptation and neural network priors. In Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on, pages 4019–4026. IEEE, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International Conference on Machine Learning, pages 1310–1318, 2013.
+
+J. Peters and S. Schaal. Policy gradient methods for robotics. In 2006 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 2219–2225, Oct 2006. doi: 10.1109/IROS. 2006.282564.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. CoRR, 2017.
+
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In International Conference on Machine Learning, pages 1329–1338, 2016.
+
+Christopher Hesse, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, and Yuhuai Wu. Openai baselines. https://github.com/openai/baselines, 2017.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In IROS, pages 5026–5033. IEEE, 2012.
+
+Matthias Plappert, Rein Houthooft, Prafulla Dhariwal, Szymon Sidor, Richard Y Chen, Xi Chen, Tamim Asfour, Pieter Abbeel, and Marcin Andrychowicz. Parameter space noise for exploration. In International Conference on Learning Representations (ICLR2018), 2018.
+
+Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, et al. Noisy networks for exploration. In International Conference on Learning Representations (ICLR2018), 2018.
+
+# A EXPERIMENT DETAILS
+
+# A.1 MODEL-ENSEMBLE TRUST-REGION POLICY OPTIMIZATION
+
+Our algorithm can be broken down into three parts: data collection, model learning, and policy learning. We describe the numerical details for each part below.
+
+# A.1.1 DATA COLLECTION
+
+In each outer iteration, we use the stochastic policy to collect 3000 timesteps of real world data for every environment, except Humanoid in which we collect 6000 timesteps. At the beginning of every roll-out we sample the policy standard deviation randomly from $\mathcal { U } [ 0 . 0 , 3 . 0 ]$ , and we keep the value fixed throughout the episode. Furthermore, we perturb the policy’s parameters by adding white Gaussian noise with standard deviation proportional to the absolute difference between the current parameters and the previous one (Plappert et al., 2018; Fortunato et al., 2018). Finally, we split the collected data using a 2-to-1 ratio for training and validation datasets.
+
+# A.1.2 MODEL LEARNING
+
+We represent the dynamics model with a 2-hidden-layer feed-forward neural network with hidden sizes 1024-1024 and ReLU nonlinearities. We train the model with the Adam optimizer with learning rate 0.001 using a batch size of 1000. The model is trained until the validation loss has not decreased for 25 passes over the entire training dataset (we validate the training every 5 passes).
+
+# A.1.3 POLICY LEARNING
+
+We represent the policy with a 2-hidden-layer feed-forward neural network with hidden sizes 32-32 and tanh nonlinearities for all the environments, except Humanoid, in which we use the hidden sizes 100-50-25. The policy is trained with TRPO on the learned models using initial standard deviation 1.0, step size $\delta _ { K L } 0 . 0 1$ , and batch size 50000. If the policy fails the validation for 25 updates (we do the validation every 5 updates), we stop the learning and repeat the overall process.
+
+# A.2 ENVIRONMENT DETAILS
+
+The environments we use are adopted from rllab (Duan et al., 2016). The reward functions $r _ { t } ( s _ { t } , a _ { t } )$ and optimization horizons are described below:
+
+<table><tr><td rowspan=1 colspan=1>Environments</td><td rowspan=1 colspan=1>Reward functions</td><td rowspan=1 colspan=1>Horizon</td></tr><tr><td rowspan=1 colspan=1>Swimmer</td><td rowspan=1 colspan=1>sel-0.005lae</td><td rowspan=1 colspan=1>200</td></tr><tr><td rowspan=1 colspan=1>Snake</td><td rowspan=1 colspan=1>sel -0.0051a2</td><td rowspan=1 colspan=1>200</td></tr><tr><td rowspan=1 colspan=1>Hopper</td><td rowspan=1 colspan=1>- 10∑(max(st -100,0))</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Half Cheetah</td><td rowspan=1 colspan=1>gel - 0.051lal2</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Ant</td><td rowspan=1 colspan=1>sel-0.0051all2+0.05</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Humanoid</td><td rowspan=1 colspan=1>(shead-1.5）²+ |lall2</td><td rowspan=1 colspan=1>100</td></tr></table>
+
+Note that in Hopper we relax the early stopping criterion to a soft constraint in reward function, whereas in Ant we early stop when the center of mass long $\mathbf { Z }$ -axis is outside [0.2, 1.0] and have a survival reward when alive.
+
+The state in each environment is composed of the joint angles, the joint velocities, and the cartesian position of the center of mass of a part of the simulated robot. We are not using the contact information, which make the environments effectively POMDPs in Half Cheetah, Ant, Hopper and Humanoid. We also eliminate the redundancies in the state space in order to avoid infeasible states in the prediction.
+
+# A.2.1 BASELINES
+
+In Section 6.2 we compare our method against TRPO, PPO, DDPG, and SVG. For every environment we represent the policy with a feed-forward neural network of the same size, horizon, and discount factor as the ones specified in the Appendix A.1.3. In the following we provide the hyper-parameters details:
+
+Trust Region Policy Optimization (Schulman et al., 2016). We used the implementation of Duan et al. (2016) with a batch size of 50000, and we train the policies for 1000 iterations. The step size $\delta _ { K L }$ that we used in all the experiments was of 0.05.
+
+Proximal Policy Optimization (Schulman et al., 2017). We referred to the implementation of Hesse et al. (2017). The policies were trained for $1 0 ^ { 7 }$ steps using the default hyper-parameters across all tasks.
+
+Deep Deterministic Policy Gradient (Lillicrap et al., 2015). We also use the implementation of Hesse et al. (2017) using a number epochs of 2000, the rest of the hyper-parameters used were the default ones.
+
+Stochastic Value Gradient (Heess et al., 2015). We parametrized the dynamics model as a feedforward neural network of two hidden layers of 512 units each and ReLU non-linearities. The model was trained after every episode with the data available in the replay buffer, using the Adam optimizer with a learning rate of $1 \dot { 0 } ^ { - 4 }$ , and batch size of 128. We additionally clipped the gradient we the norm was larger than 10.
+
+# B OVERFITTING
+
+We show that replacing the ensemble with just one model leads to the policy overoptimization. In each outer iteration, we see that at the end of the policy optimization step the estimated performance increases while the real performance is in fact decreasing (see figure 5).
+
+![](images/4da82d5f058e489432a70a9f6d8bf6e94bf3a080b5d6007f3a980685e9269675.jpg)  
+Figure 5: Predicted and real performances during the training process using our approach with one model instead of an ensemble in Swimmer. The policy overfits to the dynamics model which degrades the real performance.
+
+# C REAL-TIME COMPLEXITY
+
+We provide wall clock time for the ME-TRPO results from figure 2 in the table below:
+
+<table><tr><td rowspan=1 colspan=1>Environments</td><td rowspan=1 colspan=1>Run time (in 1000s)</td></tr><tr><td rowspan=1 colspan=1>Swimmer</td><td rowspan=1 colspan=1>35.3 ± 3.1</td></tr><tr><td rowspan=1 colspan=1>Snake</td><td rowspan=1 colspan=1>60.8± 4.7</td></tr><tr><td rowspan=1 colspan=1>Hopper</td><td rowspan=1 colspan=1>183.6 ± 10.2</td></tr><tr><td rowspan=1 colspan=1>Half Cheetah</td><td rowspan=1 colspan=1>103.7 ± 5.2</td></tr><tr><td rowspan=1 colspan=1>Ant</td><td rowspan=1 colspan=1>395.2 ± 67.1</td></tr><tr><td rowspan=1 colspan=1>Humanoid</td><td rowspan=1 colspan=1>362.1 ± 20.5</td></tr></table>
+
+These experiments were performed on Amazon EC2 using 1 NVIDIA K80 GPU, 4 vCPUs, and 61 GB of memory.
+
+Note that the majority of run time is spent on training model ensemble. However, our algorithm allows this to be simply parallelized across multiple GPUs. This could potentially yield multiple-fold speed-up from our results.
+
+# D ABLATION STUDY
+
+We further provide a series of ablation experiments to characterize the importance of the two main regularization components of our algorithm: the ensemble validation and the ensemble sampling techniques. In these experiments, we make only one change at a time to ME-TRPO with 5 models.
+
+# D.1 ENSEMBLE SAMPLING METHODS
+
+We explore several ways to simulate the trajectories from the model ensemble. At a current state and action, we study the effect of simulating the next step given by: (1) sampling randomly from the different models (step rand), (2) a normal distribution fitted from the predictions (model mean std), (3) the mean of the predictions (model mean), (4) the median of the predictions (model med), (5) the prediction of a fixed model over the entire episode (i.e., equivalent to averaging the gradient across all simulations) (eps rand), and (6) sampling from one model (one model).
+
+The results in Figure 6 provide evidence that using the next step as the prediction of a randomly sampled model from our ensemble is the most robust method across environments. In fact, using the median or the mean of the predictions does not prevent overfitting; this effect is shown in the HalfCheetah environment where we see a decrease of the performance in latter iteration of the optimization process. Using the gradient average (5) also provides room for the policy to overfit to one or more models. This supports that having an estimate of the model uncertainty, such as in (1) and (2), is the principled way to avoid overfitting the learned models.
+
+![](images/3cd0370d465a68ca6706cb959b1bdbc88f102a6a5c66cd32a40719e7f2c9d1ae.jpg)  
+Figure 6: Comparison among different sampling techniques for simulating roll-outs. By sampling each step from a different model, we prevent overfitting and enhance the learning performance (Best viewed in color).
+
+# D.2 ENSEMBLE VALIDATION
+
+Finally, we provide a study of the different ways for validating the policy. We compare the following techniques: (1) using the real performance (i.e., using an oracle) (real), (2) using the average return in the trpo roll-outs (trpo mean), (3) stopping the policy after 50 gradient updates (no early 50), (4) or after 5 gradient updates (no early 5), (5) using one model to predict the performances (one model), and (6) using an ensemble of models (ensemble). The experiments are designed to use the same number of models and hyper-parameters for the other components of the algorithm.
+
+In Figure 7 we can see the effectiveness of each approach. It is noteworthy that having an oracle of the real performance is not the best approach. Such validation is over-cautious, and does not give room for exploration resulting in a poor trained dynamics model. Stopping the gradient after a fixed number of updates results in good performance if the right number of updates is set. This burdens the hyper-parameter search with one more hyper-parameter. On the other hand, using the ensemble of models has good performance across environments without adding extra hyper-parameters.
+
+![](images/a7da04e30ef250206d40d6bea857a807213dc3081486710257bfd1616f46a7c4.jpg)  
+Figure 7: Comparison among validation techniques. The ensemble of models yields to good performance across environments (Best viewed in color).

parse/train/SJJinbWRZ/SJJinbWRZ_content_list.json

@@ -0,0 +1,1812 @@
+[
+    {
+        "type": "text",
+        "text": "MODEL-ENSEMBLE TRUST-REGION POLICY OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            828,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ignasi Clavera Yan Duan Aviv Tamar Pieter Abbeel ",
+        "bbox": [
+            343,
+            170,
+            812,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Berkeley AI Research   \nUniversity of California, Berkeley   \nBerkeley, CA 94709   \n{thanard.kurutach, iclavera, rockyduan, avivt, pabbeel}@berkeley.edu ",
+        "bbox": [
+            184,
+            188,
+            844,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Model-free reinforcement learning (RL) methods are succeeding in a growing number of tasks, aided by recent advances in deep learning. However, they tend to suffer from high sample complexity which hinders their use in real-world domains. Alternatively, model-based reinforcement learning promises to reduce sample complexity, but tends to require careful tuning and, to date, it has succeeded mainly in restrictive domains where simple models are sufficient for learning. In this paper, we analyze the behavior of vanilla model-based reinforcement learning methods when deep neural networks are used to learn both the model and the policy, and we show that the learned policy tends to exploit regions where insufficient data is available for the model to be learned, causing instability in training. To overcome this issue, we propose to use an ensemble of models to maintain the model uncertainty and regularize the learning process. We further show that the use of likelihood ratio derivatives yields much more stable learning than backpropagation through time. Altogether, our approach Model-Ensemble Trust-Region Policy Optimization (ME-TRPO) significantly reduces the sample complexity compared to model-free deep RL methods on challenging continuous control benchmark tasks1. ",
+        "bbox": [
+            233,
+            308,
+            766,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            336,
+            571
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep reinforcement learning has achieved many impressive results in recent years, including learning to play Atari games from raw-pixel inputs (Mnih et al., 2015), mastering the game of Go (Silver et al., 2016; 2017), as well as learning advanced locomotion and manipulation skills from raw sensory inputs (Levine et al., 2016a; Schulman et al., 2015; 2016; Lillicrap et al., 2015). Many of these results were achieved using model-free reinforcement learning algorithms, which do not attempt to build a model of the environment. These algorithms are generally applicable, require relatively little tuning, and can easily incorporate powerful function approximators such as deep neural networks. However, they tend to suffer from high sample complexity, especially when such powerful function approximators are used, and hence their applications have been mostly limited to simulated environments. In comparison, model-based reinforcement learning algorithms utilize a learned model of the environment to assist learning. These methods can potentially be much more sample efficient than model-free algorithms, and hence can be applied to real-world tasks where low sample complexity is crucial (Deisenroth and Rasmussen, 2011; Levine et al., 2016a; Venkatraman et al., 2017). However, so far such methods have required very restrictive forms of the learned models, as well as careful tuning for them to be applicable. Although it is a straightforward idea to extend model-based algorithms to deep neural network models, so far there has been comparatively fewer successful applications. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            823
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The standard approach for model-based reinforcement learning alternates between model learning and policy optimization. In the model learning stage, samples are collected from interaction with the environment, and supervised learning is used to fit a dynamics model to the observations. In the policy optimization stage, the learned model is used to search for an improved policy. The underlying assumption in this approach, henceforth termed vanilla model-based RL, is that with enough data, the learned model will be accurate enough, such that a policy optimized on it will also perform well in the real environment. ",
+        "bbox": [
+            174,
+            830,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Although vanilla model-based RL can work well on low-dimensional tasks with relatively simple dynamics, we find that on more challenging continuous control tasks, performance was highly unstable. The reason is that the policy optimization tends to exploit regions where insufficient data is available to train the model, leading to catastrophic failures. Previous work has pointed out this issue as model bias, i.e. (Deisenroth and Rasmussen, 2011; Schneider, 1997; Atkeson and Santamaria, 1997). While this issue can be regarded as a form of overfitting, we emphasize that standard countermeasures from the supervised learning literature, such as regularization or cross validation, are not sufficient here – supervised learning can guarantee generalization to states from the same distribution as the data, but the policy optimization stage steers the optimization exactly towards areas where data is scarce and the model is inaccurate. This problem is severely aggravated when expressive models such as deep neural networks are employed. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To resolve this issue, we propose to use an ensemble of deep neural networks to maintain model uncertainty given the data collected from the environment. During model learning, we differentiate the neural networks by varying their weight initialization and training input sequences. Then, during policy learning, we regularize the policy updates by combining the gradients from the imagined stochastic roll-outs. Each imagined step is uniformly sampled from the ensemble predictions. Using this technique, the policy learns to become robust against various possible scenarios it may encounter in the real environment. To avoid overfitting to this regularized objective, we use the model ensemble for early stopping policy training. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Standard model-based techniques require differentiating through the model over many time steps, a procedure known as backpropagation through time (BPTT). It is well-known in the literature that BPTT can lead to exploding and vanishing gradients (Bengio et al., 1994). Even when gradient clipping is applied, BPTT can still get stuck in bad local optima. We propose to use likelihood ratio methods instead of BPTT to estimate the gradient, which only make use of the model as a simulator rather than for direct gradient computation. In particular, we use Trust Region Policy Optimization (TRPO) (Schulman et al., 2015), which imposes a trust region constraint on the policy to further stabilize learning. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose Model-Ensemble Trust-Region Policy Optimization (ME-TRPO), a modelbased algorithm that achieves the same level of performance as state-of-the-art model-free algorithms with $1 0 0 \\times$ reduction in sample complexity. We show that the model ensemble technique is an effective approach to overcome the challenge of model bias in model-based reinforcement learning. We demonstrate that replacing BPTT by TRPO yields significantly more stable learning and much better final performance. Finally, we provide an empirical analysis of vanilla model-based RL using neural networks as function approximators, and identify its flaws when applied to challenging continuous control tasks. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            343,
+            696
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There has been a large body of work on model-based reinforcement learning. They differ by the choice of model parameterization, which is associated with different ways of utilizing the model for policy learning. Interestingly, the most impressive robotic learning applications so far were achieved using the simplest possible model parameterization, namely linear models (Bagnell and Schneider, 2001; Abbeel et al., 2006; Levine and Abbeel, 2014; Watter et al., 2015; Levine et al., 2016a; Kumar et al., 2016), where the model either operates directly over the raw state, or over a feature representation of the state. Such models are very data efficient, and allows for very efficient policy optimization through techniques from optimal control. However, they only have limited expressiveness, and do not scale well to complicated nonlinear dynamics or high-dimensional state spaces, unless a separate feature learning phase is used (Watter et al., 2015). ",
+        "bbox": [
+            174,
+            722,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An alternative is to use nonparametric models such as Gaussian Processes (GPs) (Rasmussen et al., 2003; Ko et al., 2007; Deisenroth and Rasmussen, 2011). Such models can effectively maintain uncertainty over the predictions, and have infinite representation power as long as enough data is available. However, they suffer from the curse of dimensionality, and so far their applications have been limited to relatively low-dimensional settings. The computational expense of incorporating the uncertainty estimates from GPs into the policy update also imposes an additional challenge. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks have shown great success in scaling up model-free reinforcement learning algorithms to challenging scenarios (Mnih et al., 2015; Silver et al., 2016; Schulman et al., 2015; 2016). However, there has been only limited success in applying them to model-based RL. Although many previous studies have shown promising results on relatively simple domains (Nguyen and Widrow, 1990; Schmidhuber and Huber, 1991; Jordan and Rumelhart, 1992; Gal et al., 2016), so far their applications on more challenging domains have either required a combination with model-free techniques (Oh et al., 2015; Heess et al., 2015; Nagabandi et al., 2017), or domain-specific policy learning or planning algorithms (Lenz et al., 2015; Agrawal et al., 2016; Pinto and Gupta, 2016; Levine et al., 2016b; Finn and Levine, 2017; Nair et al., 2017). In this work, we show that our purely model-based approach improves the sample complexity compared to methods that combine model-based and model-free elements. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Two recent studies have shown promising signs towards a more generally applicable model-based RL algorithm. Depeweg et al. (2017) utilize Bayesian neural networks (BNNs) to learn a distribution over dynamics models, and train a policy using gradient-based optimization over a collection of models sampled from this distribution. Mishra et al. (2017) learn a latent variable dynamic model over temporally extended segments of the trajectory, and train a policy using gradient-based optimization over the latent space. Both of these approaches have been shown to work on a fixed dataset of samples which are collected before the algorithm starts operating. Hence, their evaluations have been limited to domains where random exploration is sufficient to collect data for model learning. In comparison, our approach utilizes an iterative process of alternatively performing model learning and policy learning, and hence can be applied to more challenging domains. Additionally, our proposed improvements are orthogonal to both approaches, and can be potentially combined to yield even better results. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            464
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            338,
+            505
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This paper assumes a discrete-time finite-horizon Markov decision process (MDP), defined by $( S , \\mathcal { A } , f , r , \\rho _ { 0 } , T )$ , in which $S \\subseteq \\mathbb { R } ^ { n }$ is the state space, ${ \\mathcal { A } } \\subseteq \\mathbb { R } ^ { m }$ the action space, $f : \\mathcal { S } \\times \\mathcal { A }  \\mathcal { S }$ a deterministic transition function, $r : S \\times \\mathcal { A }  \\mathbb { R }$ a bounded reward function, $\\rho _ { 0 } : { \\mathcal { S } } \\to \\mathbb { R } _ { + }$ an initial state distribution, and $T$ the horizon. We denote a stochastic policy $\\pi _ { \\boldsymbol { \\theta } } ( a | \\boldsymbol { s } )$ as the probability of taking action $a$ at state $s$ . Let $\\eta ( \\theta )$ denote its expected return: $\\begin{array} { r } { \\eta ( \\theta ) = \\mathbb { E } _ { \\tau } [ \\sum _ { t = 0 } ^ { T } r ( s _ { t } , a _ { t } ) ] } \\end{array}$ where $\\tau = ( s _ { 0 } , a _ { 0 } , \\ldots , a _ { T - 1 } , s _ { T } )$ denotes the whole trajectory, $s _ { 0 } \\sim \\rho _ { 0 } ( . )$ , $a _ { t } \\sim \\pi _ { \\theta } ( . | s _ { t } )$ , and $s _ { t + 1 } = f ( s _ { t } , \\overline { { a _ { t } } } )$ for all $t$ . We assume that the reward function is known but the transition function is unknown. Our goal is to find an optimal policy that maximizes the expected return $\\eta ( \\theta )$ . ",
+        "bbox": [
+            173,
+            522,
+            825,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 VANILLA MODEL-BASED DEEP REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            660,
+            712,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the most successful methods of model-free reinforcement learning, we iteratively collect data, estimate the gradient of the policy, improve the policy, and then discard the data. Conversely, modelbased reinforcement learning makes more extensive use of the data; it uses all the data collected to train a model of the dynamics of the environment. The trained model can be used as a simulator in which the policy can be trained, and also provides gradient information (Sutton, 1990; Deisenroth and Rasmussen, 2011; Depeweg et al., 2017; Sutton, 1991). In the following section, we describe the vanilla model-based reinforcement learning algorithm (see Algorithm 1). We assume that the model and the policy are represented by neural networks, but the methodology is valid for other types of function approximators. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            820
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 MODEL LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            344,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The transition dynamics is modeled with a feed-forward neural network, using the standard practice to train the neural network to predict the change in state (rather than the next state) given a state and an action as inputs. This relieves the neural network from memorizing the input state, especially when the change is small (Deisenroth and Rasmussen, 2011; Fu et al., 2016; Nagabandi et al., 2017). ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We denote the function approximator for the next state, which is the sum of the input state and the output of the neural network, as $\\hat { f } _ { \\phi }$ . ",
+        "bbox": [
+            171,
+            103,
+            823,
+            135
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The objective of model learning is to find a parameter $\\phi$ that minimizes the $\\mathrm { L _ { 2 } }$ one-step prediction $\\mathrm { l o s s } ^ { 2 }$ : ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6374277f1a22af8dd80da806420dfe6cb205691ba9ca945d6e6672bfae984a5e.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\phi } \\frac { 1 } { | \\mathcal { D } | } \\sum _ { ( s _ { t } , a _ { t } , s _ { t + 1 } ) \\in \\mathcal { D } } \\Big \\| s _ { t + 1 } - \\hat { f } _ { \\phi } \\big ( s _ { t } , a _ { t } \\big ) \\Big \\| _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            186,
+            645,
+            227
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { D }$ is the training dataset that stores the transitions the agent has experienced. We use the Adam optimizer (Kingma and Ba, 2014) to solve this supervised learning problem. Standard techniques are followed to avoid overfitting and facilitate the learning such as separating a validation dataset to early stop the training, and normalizing the inputs and outputs of the neural network3 ",
+        "bbox": [
+            173,
+            238,
+            825,
+            294
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 POLICY LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            311,
+            346,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given an MDP, $\\mathcal { M }$ , the goal of reinforcement learning is to maximize the expected sum of rewards. During training, model-based methods maintain an approximate MDP, $\\hat { \\mathcal { M } }$ , where the transition function is given by a parameterized model $\\hat { f } _ { \\phi }$ learned from data. The policy is then updated with respect to the approximate MDP. Hence, the objective we maximize is ",
+        "bbox": [
+            173,
+            337,
+            825,
+            398
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f64cb9ade137011ee2078b2829b2f6a0867a45fbb3019bdb9709dcbf3fb39730.jpg",
+        "text": "$$\n\\hat { \\eta } ( \\theta ; \\phi ) : = \\mathbb { E } _ { \\hat { \\tau } } [ \\sum _ { t = 0 } ^ { T } r ( s _ { t } , a _ { t } ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            415,
+            593,
+            458
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { \\tau } = ( s _ { 0 } , a _ { 0 } , \\dotsc ) , s _ { 0 } \\sim \\rho _ { 0 } ( \\cdot ) , a _ { t } \\sim \\pi _ { \\theta } ( \\cdot | s _ { t } ) ,$ , and $s _ { t + 1 } = \\hat { f } _ { \\phi } ( s _ { t } , a _ { t } )$ . ",
+        "bbox": [
+            174,
+            463,
+            651,
+            482
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We represent the stochastic policy4 as a conditional multivariate normal distribution with a parametrized mean $\\mu _ { \\theta } : { \\mathcal { S } }  A$ and a parametrized standard deviation $\\sigma _ { \\theta } : \\mathcal { S }  \\mathbb { R } ^ { m }$ . Using the re-parametrization trick (Heess et al., 2015), we can write down an action sampled from $\\pi _ { \\theta }$ at state $s$ as $\\mu _ { \\boldsymbol { \\theta } } ( \\boldsymbol { s } ) + \\sigma _ { \\boldsymbol { \\theta } } ( \\boldsymbol { s } ) ^ { T } \\boldsymbol { \\zeta }$ , where $\\zeta \\sim \\mathcal { N } ( 0 , I _ { m } )$ . Given a trajectory $\\hat { \\tau }$ sampled using the policy $\\pi _ { \\theta }$ , we can recover the noise vectors $\\big \\{ \\zeta _ { 0 } , . . . , \\zeta _ { T } \\big \\}$ . Thus, the gradient of the objective $\\hat { \\eta } ( \\theta ; \\phi )$ can simply be estimated by Monte-Carlo methods: ",
+        "bbox": [
+            173,
+            487,
+            826,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b78f7eb2d246fd963f208f32c9d9ba2b2ac2283c6ec5d192a387e413f99d0a37.jpg",
+        "text": "$$\n\\nabla _ { \\theta } \\hat { \\eta } = \\mathbb { E } _ { s _ { 0 } \\sim \\rho _ { 0 } ( s _ { 0 } ) , \\zeta _ { i } \\sim \\mathcal { N } ( 0 , I _ { m } ) } [ \\nabla _ { \\theta } \\sum _ { t = 0 } ^ { T } r ( s _ { t } , a _ { t } ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            579,
+            656,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This method of gradient computation is called backpropagation through time (BPTT), which can be easily performed using an automatic differentiation library. We apply gradient clipping (Pascanu et al., 2013) to deal with exploding gradients, and we use the Adam optimizer (Kingma and Ba, 2014) for more stable learning. We perform the updates until the policy no longer improves its estimated performance $\\hat { \\eta }$ over a period of time (controlled by a hyperparameter), and then we repeat the process in the outer loop by using the policy to collect more data with respect to the real model5. The whole procedure terminates when the desired performance according to the real model is accomplished. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 MODEL-ENSEMBLE TRUST-REGION POLICY OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            746,
+            704,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Using the vanilla approach described in Section 4, we find that the learned policy often exploits regions where scarce training data is available for the dynamics model. Since we are improving ",
+        "bbox": [
+            174,
+            777,
+            825,
+            808
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Vanilla Model-Based Deep Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            604,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize a policy $\\pi _ { \\theta }$ and a model $\\hat { f } _ { \\phi }$ .   \n2: Initialize an empty dataset $D$ .   \n3: repeat   \n4: Collect samples from the real environment $f$ using $\\pi _ { \\theta }$ and add them to $D$ .   \n5: Train the model $\\hat { f } _ { \\phi }$ using $D$ .   \n6: repeat   \n7: Collect fictitious samples from $\\hat { f } _ { \\phi }$ using $\\pi _ { \\theta }$ .   \n8: Update the policy using BPTT on the fictitious samples.   \n9: Estimate the performance $\\hat { \\eta } ( \\theta ; \\phi )$ .   \n10: until the performance stop improving.   \n11: until the policy performs well in real environment $f$ . ",
+        "bbox": [
+            176,
+            122,
+            710,
+            281
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "the policy with respect to the approximate MDP instead of the real one, the predictions then can be erroneous to the policy’s advantage. This overfitting issue can be partly alleviated by early stopping using validation initial states in a similar manner to supervised learning. However, we found this insufficient, since the performance is still evaluated using the same learned model, which tends to make consistent mistakes. Furthermore, although gradient clipping can usually resolve exploding gradients, BPTT still suffers from vanishing gradients, which cause the policy to get stuck in bad local optima (Bengio et al., 1994; Pascanu et al., 2013). These problems are especially aggravated when optimizing over long horizons, which is very common in reinforcement learning problems. ",
+        "bbox": [
+            173,
+            313,
+            825,
+            425
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now present our method, Model-Ensemble Trust-Region Policy Optimization (ME-TRPO). The pseudocode is shown in Algorithm 2. ME-TRPO combines three modifications to the vanilla approach. First, we fit a set of dynamics models $\\{ f _ { \\phi _ { 1 } } , \\dotsc , f _ { \\phi _ { K } } \\}$ (termed a model ensemble) using the same real world data. These models are trained via standard supervised learning, as described in Section 4.1, and they only differ by the initial weights and the order in which mini-batches are sampled. Second, we use Trust Region Policy Optimization (TRPO) to optimize the policy over the model ensemble. Third, we use the model ensemble to monitor the policy’s performance on validation data, and stops the current iteration when the policy stops improving. The second and third modifications are described in detail below. ",
+        "bbox": [
+            173,
+            431,
+            826,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Policy Optimization. To overcome the issues with BPTT, we use likelihood-ratio methods from the model-free RL literature. We evaluated using Vanilla Policy Gradient (VPG) (Peters and Schaal, 2006), Proximal Policy Optimization (PPO) (Schulman et al., 2017), and Trust Region Policy Optimization (TRPO) (Schulman et al., 2015). The best results were achieved by TRPO. In order to estimate the gradient, we use the learned models to simulate trajectories as follows: in every step, we randomly choose a model to predict the next state given the current state and action. This avoids the policy from overfitting to any single model during an episode, leading to more stable learning. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Policy Validation. We monitor the policy’s performance using the $K$ learned models. Specifically, we compute the ratio of models in which the policy improves: ",
+        "bbox": [
+            173,
+            667,
+            823,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/969af33d461af6094f79c75164800bfa64bef25aec3c69621ef2abf496d41890.jpg",
+        "text": "$$\n\\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } \\mathbb { 1 } [ \\hat { \\eta } ( \\theta _ { n e w } ; \\phi _ { k } ) > \\hat { \\eta } ( \\theta _ { o l d } ; \\phi _ { k } ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            704,
+            622,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The current iteration continues as long as this ratio exceeds a certain threshold. In practice, we validate the policy after every 5 gradient updates and we use $70 \\%$ as the threshold. If the ratio falls below the threshold, a small number of updates is tolerated in case the performance improves, the current iteration is terminated. Then, we repeat the overall process of using the policy to collect more real-world data, optimize the model ensemble, and using the model ensemble to improve the policy. This process continues until the desired performance in the real environment is reached. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The model ensemble serves as effective regularization for policy learning: by using the model ensemble for policy optimization and validation, the policy is forced to perform well over a vast number of possible alternative futures. Even though any of the individual models can still incur model bias, our experiments below suggest that combining these models yields stable and effective policy improvement. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Model Ensemble Trust Region Policy Optimization (ME-TRPO) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            687,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize a policy $\\pi _ { \\theta }$ and all models $\\hat { f } _ { \\phi _ { 1 } } , \\hat { f } _ { \\phi _ { 2 } } , . . . , \\hat { f } _ { \\phi _ { K } }$ .   \n2: Initialize an empty dataset $\\mathcal { D }$ .   \n3: repeat   \n4: Collect samples from the real system $f$ using $\\pi _ { \\theta }$ and add them to $D$ .   \n5: Train all models using $\\mathcal { D }$ .   \n6: repeat $\\triangleright$ Optimize $\\pi _ { \\theta }$ using all models.   \n7: Collect fictitious samples from $\\{ \\hat { f } _ { \\phi _ { i } } \\} _ { i = 1 } ^ { K }$ using $\\pi _ { \\theta }$ .   \n8: Update the policy using TRPO on the fictitious samples.   \n9: Estimate the performances $\\hat { \\eta } ( \\theta ; \\phi _ { i } )$ for $i = 1 , . . . , K$ .   \n10: until the performances stop improving.   \n11: until the policy performs well in real environment $f$ . ",
+        "bbox": [
+            179,
+            121,
+            825,
+            252
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            252,
+            549,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            308,
+            328,
+            323
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We design the experiments to answer the following questions: ",
+        "bbox": [
+            173,
+            338,
+            578,
+            354
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. How does our approach compare against state-of-the-art methods in terms of sample complexity and final performance?   \n2. What are the failure scenarios of the vanilla algorithm?   \n3. How does our method overcome these failures? ",
+        "bbox": [
+            210,
+            366,
+            825,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also provide in the Appendix D an ablation study to characterize the effect of each component of our algorithm. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            330,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To answer these questions, we evaluate our method and various baselines over six standard continuous control benchmark tasks (Duan et al., 2016; Hesse et al., 2017) in Mujoco (Todorov et al., 2012): Swimmer, Snake, Hopper, Ant, Half Cheetah, and Humanoid, shown in Figure 1. The details of the tasks can be found in Appendix A.2. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/584eae6d5a8ad247ac909792e26ace2cdc2eea4d297673c15e5881e6797c0bf5.jpg",
+        "image_caption": [
+            "Figure 1: Mujoco environments used in our experiments. Form left to right: Swimmer, Half Cheetah, Snake, Ant, Hopper, and Humanoid. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            583,
+            820,
+            657
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.2 COMPARISON TO STATE-OF-THE-ART ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            724,
+            470,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare our method with the following state-of-the-art reinforcement learning algorithms in terms of sample complexity and performance: Trust Region Policy Optimization (TRPO) (Schulman et al., 2015), Proximal Policy Optimization (PPO) (Schulman et al., 2017), Deep Deterministic Policy Gradient (DDPG) (Lillicrap et al., 2015), and Stochastic Value Gradient (SVG) (Heess et al., 2015). ",
+        "bbox": [
+            174,
+            750,
+            825,
+            805
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Figure 2. Prior model-based methods appear to achieve worse performance compared with model-free methods. In addition, we find that model-based methods tend to be difficult to train over long horizons. In particular, SVG(1), not presented in the plots, is very unstable in our experiments. While $\\mathrm { S V G } ( \\infty )$ is more stable, it fails to achieve the same level of performance as model-free methods. In contrast, our proposed method reaches the same level of performance as model-free approaches with $\\approx 1 0 0 \\times$ less data. To the best of our knowledge, it is the first purely model-based approach that can optimize policies over high-dimensional motor-control tasks such as Humanoid. For experiment details please refer to Appendix A. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/523e8fa5a5f5ba0883cb6eb9680ef5f39033a973b8117936187d30e9c192a41f.jpg",
+        "image_caption": [
+            "Figure 2: Learning curves of our method versus state-of-the-art methods. The horizontal axis, in log-scale, indicates the number of time steps of real world data. The vertical axis denotes the average return. These figures clearly demonstrate that our proposed method significantly outperforms other methods in comparison (best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            103,
+            782,
+            340
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.3 FROM VANILLA TO ME-TRPO ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            438,
+            426,
+            452
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we explain and quantify the failure cases of vanilla model-based reinforcement learning, and how our approach overcomes such failures. We analyze the effect of each of our proposed modifications by studying the learning behavior of replacing BPTT with TRPO in vanilla model-based RL using just a single model, and then the effect of using an ensemble of models. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            518
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As discussed above, BPTT suffers from exploding and vanishing gradients, especially when optimizing over long horizons. Furthermore, one of the principal drawbacks of BPTT is the assumption that the model derivatives should match that of the real dynamics, even though the model has not been explicitly trained to provide accurate gradient information. In Figure 3 we demonstrate the effect of using policy gradient methods that make use of a score function estimator, such as VPG and TRPO, while using a single learned model. The results suggest that in comparison with BPTT, policy gradient methods are more stable and lead to much better final performance. By using such model-free algorithms, we require less information from the learned model, which only acts as a simulator. Gradient information through the dynamics model is not needed anymore to optimize the policy. ",
+        "bbox": [
+            173,
+            526,
+            825,
+            665
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/46b42e5cc5ce653d045ed61cf0b509f5368828a1fd6445c5e6f31a4b32347d37.jpg",
+        "image_caption": [
+            "Figure 3: Comparison among different policy optimization techniques with one model. Using TRPO for model-based optimization leads to the best policy learning across the different domains (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            680,
+            784,
+            803
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "However, while replacing BPTT by TRPO helps optimization, the learned policy can still suffer from model bias. The learning procedure tends to steer the policy towards regions where it has rarely visited, so that the model makes erroneous predictions to its advantage. The estimated performances of the policy often end up with high rewards according to the learned model, and low rewards according to the real one (see Appendix B for further discussion). In Figure 4, we analyze the effect of using various numbers of ensemble models for sampling trajectories and validating the policy’s performance. The results indicate that as more models are used in the model ensemble, the learning is better regularized and the performance continually improves. The improvement is even more noticeable in more challenging environments like HalfCheetah and Ant, which require more complex dynamics models to be learned, leaving more room for the policy to exploit when model ensemble is not used. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ca995a55bd358f5cc3ac206cd67f70fe931abce9cbe2a86ab68d11b3130a7b5.jpg",
+        "image_caption": [
+            "Figure 4: Comparison among different number of models that the policy is trained on. TRPO is used for the policy optimization. We illustrate the improvement when using 5, 10 and 20 models over a single model (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            228,
+            777,
+            357
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            445,
+            310,
+            462
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present a simple and robust model-based reinforcement learning algorithm that is able to learn neural network policies across different challenging domains. We show that our approach significantly reduces the sample complexity compared to state-of-the-art methods while reaching the same level of performance. In comparison, our analyses suggests that vanilla model-based RL tends to suffer from model bias and numerical instability, and fails to learn a good policy. We further evaluate the effect of each key component of our algorithm, showing that both using TRPO and model ensemble are essential for successful applications of deep model-based RL. We also confirm the results of previous work (Deisenroth and Rasmussen, 2011; Depeweg et al., 2017; Gal et al., 2016) that using model uncertainty is a principled way to reduce model bias. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "One question that merits future investigation is how to use the model ensemble to encourage the policy to explore the state space where the different models disagree, so that more data can be collected to resolve their disagreement. Another enticing direction for future work would be the application of ME-TRPO to real-world robotics systems. ",
+        "bbox": [
+            176,
+            609,
+            825,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            684,
+            326,
+            695
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The authors thank Stuart Russell, Abishek Gupta, Carlos Florensa, Anusha Nagabandi, Haoran Tang, and Gregory Kahn for helpful discussions and feedbacks. T. Kurutach has been supported by ONR PECASE grant N000141612723, I. Clavera has been supported by La Caixa Fellowship, Y. Duan has been supported by Huawei Fellowship, and A. Tamar has been supported by Siemens Fellowship. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            174,
+            126,
+            826,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            176,
+            176,
+            823,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354–359, 2017. ",
+        "bbox": [
+            176,
+            227,
+            823,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016a. ",
+        "bbox": [
+            173,
+            276,
+            823,
+            306
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Philipp Moritz, Michael I Jordan, and Pieter Abbeel. Trust region policy optimization. CoRR, abs/1502.05477, 2015. ",
+        "bbox": [
+            171,
+            314,
+            823,
+            343
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. High-dimensional continuous control using generalized advantage estimation. In International Conference on Learning Representations (ICLR2016), 2016. ",
+        "bbox": [
+            176,
+            351,
+            823,
+            393
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. CoRR, abs/1509.02971, 2015. ",
+        "bbox": [
+            174,
+            401,
+            825,
+            444
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pages 465–472, 2011. ",
+        "bbox": [
+            176,
+            452,
+            823,
+            494
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Arun Venkatraman, Roberto Capobianco, Lerrel Pinto, Martial Hebert, Daniele Nardi, and J. Andrew Bagnell. Improved Learning of Dynamics Models for Control, pages 703–713. Springer International Publishing, Cham, 2017. ISBN 978-3-319-50115-4. ",
+        "bbox": [
+            174,
+            502,
+            823,
+            546
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeff G Schneider. Exploiting model uncertainty estimates for safe dynamic control learning. In Advances in neural information processing systems, pages 1047–1053, 1997. ",
+        "bbox": [
+            169,
+            554,
+            823,
+            583
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christopher G Atkeson and Juan Carlos Santamaria. A comparison of direct and model-based reinforcement learning. In Robotics and Automation, 1997. Proceedings., 1997 IEEE International Conference on, volume 4, pages 3557–3564. IEEE, 1997. ",
+        "bbox": [
+            176,
+            590,
+            823,
+            633
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE transactions on neural networks, 5(2):157–166, 1994. ",
+        "bbox": [
+            171,
+            641,
+            823,
+            671
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J Andrew Bagnell and Jeff G Schneider. Autonomous helicopter control using reinforcement learning policy search methods. In Robotics and Automation, 2001. Proceedings 2001 ICRA. IEEE International Conference on, volume 2, pages 1615–1620. IEEE, 2001. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            722
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pieter Abbeel, Morgan Quigley, and Andrew Y Ng. Using inaccurate models in reinforcement learning. In Proceedings of the 23rd international conference on Machine learning, pages 1–8. ACM, 2006. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            772
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine and Pieter Abbeel. Learning neural network policies with guided policy search under unknown dynamics. In Advances in Neural Information Processing Systems, pages 1071–1079, 2014. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Manuel Watter, Jost Springenberg, Joschka Boedecker, and Martin Riedmiller. Embed to control: A locally linear latent dynamics model for control from raw images. In Advances in Neural Information Processing Systems, pages 2746–2754, 2015. ",
+        "bbox": [
+            176,
+            830,
+            823,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vikash Kumar, Emanuel Todorov, and Sergey Levine. Optimal control with learned local models: Application to dexterous manipulation. In Robotics and Automation (ICRA), 2016 IEEE International Conference on, pages 378–383. IEEE, 2016. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Carl Edward Rasmussen, Malte Kuss, et al. Gaussian processes in reinforcement learning. In NIPS, volume 4, page 1, 2003. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ko, Daniel J Klein, Dieter Fox, and Dirk Haehnel. Gaussian processes and reinforcement learning for identification and control of an autonomous blimp. In Robotics and Automation, 2007 IEEE International Conference on, pages 742–747. IEEE, 2007. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Derrick H Nguyen and Bernard Widrow. Neural networks for self-learning control systems. IEEE Control systems magazine, 10(3):18–23, 1990. ",
+        "bbox": [
+            171,
+            191,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Juergen Schmidhuber and Rudolf Huber. Learning to generate artificial fovea trajectories for target detection. International Journal of Neural Systems, 2(01n02):125–134, 1991. ",
+        "bbox": [
+            169,
+            229,
+            825,
+            258
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael I Jordan and David E Rumelhart. Forward models: Supervised learning with a distal teacher. Cognitive science, 16(3):307–354, 1992. ",
+        "bbox": [
+            171,
+            267,
+            825,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal, Rowan Thomas McAllister, and Carl Edward Rasmussen. Improving pilco with bayesian neural network dynamics models. In Data-Efficient Machine Learning workshop, volume 951, page 2016, 2016. ",
+        "bbox": [
+            174,
+            304,
+            825,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In Advances in Neural Information Processing Systems, pages 2863–2871, 2015. ",
+        "bbox": [
+            174,
+            356,
+            823,
+            398
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems, pages 2944–2952, 2015. ",
+        "bbox": [
+            173,
+            407,
+            826,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Anusha Nagabandi, Gregory Kahn, Ronald S. Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. CoRR, abs/1708.02596, 2017. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Lenz, Ross A Knepper, and Ashutosh Saxena. Deepmpc: Learning deep latent features for model predictive control. In Robotics: Science and Systems, 2015. ",
+        "bbox": [
+            173,
+            511,
+            823,
+            540
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pulkit Agrawal, Ashvin Nair, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Learning to poke by poking: Experiential learning of intuitive physics. In Advances In Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            173,
+            547,
+            825,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lerrel Pinto and Abhinav Gupta. Supersizing self-supervision: Learning to grasp from 50k tries and 700 robot hours. In Robotics and Automation (ICRA), 2016 IEEE International Conference on, pages 3406–3413. IEEE, 2016. ",
+        "bbox": [
+            173,
+            599,
+            823,
+            642
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Peter Pastor, Alex Krizhevsky, and Deirdre Quillen. Learning hand-eye coordination for robotic grasping with deep learning and large-scale data collection. arXiv preprint arXiv:1603.02199, 2016b. ",
+        "bbox": [
+            173,
+            651,
+            823,
+            694
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In IEEE International Conference on Robotics and Automation (ICRA), 2017. ",
+        "bbox": [
+            168,
+            703,
+            825,
+            733
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ashvin Nair, Dian Chen, Pulkit Agrawal, Phillip Isola, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Combining self-supervised learning and imitation for vision-based rope manipulation. arXiv preprint arXiv:1703.02018, 2017. ",
+        "bbox": [
+            176,
+            739,
+            825,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stefan Depeweg, Jose Miguel Hern ´ andez-Lobato, Finale Doshi-Velez, and Steffen Udluft. Learning ´ and policy search in stochastic dynamical systems with bayesian neural networks. In International Conference on Learning Representations (ICLR2017), 2017. ",
+        "bbox": [
+            173,
+            791,
+            825,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nikhil Mishra, Pieter Abbeel, and Igor Mordatch. Prediction and control with temporal segment models. arXiv preprint arXiv:1703.04070, 2017. ",
+        "bbox": [
+            169,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton. Integrated architectures for learning, planning, and reacting based on approximating dynamic programming. In Proceedings of the seventh international conference on machine learning, pages 216–224, 1990. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton. Dyna, an integrated architecture for learning, planning, and reacting. ACM SIGART Bulletin, 2(4):160–163, 1991. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Fu, Sergey Levine, and Pieter Abbeel. One-shot learning of manipulation skills with online dynamics adaptation and neural network priors. In Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on, pages 4019–4026. IEEE, 2016. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International Conference on Machine Learning, pages 1310–1318, 2013. ",
+        "bbox": [
+            171,
+            229,
+            825,
+            260
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J. Peters and S. Schaal. Policy gradient methods for robotics. In 2006 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 2219–2225, Oct 2006. doi: 10.1109/IROS. 2006.282564. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. CoRR, 2017. ",
+        "bbox": [
+            171,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In International Conference on Machine Learning, pages 1329–1338, 2016. ",
+        "bbox": [
+            173,
+            357,
+            825,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher Hesse, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, and Yuhuai Wu. Openai baselines. https://github.com/openai/baselines, 2017. ",
+        "bbox": [
+            174,
+            409,
+            823,
+            439
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In IROS, pages 5026–5033. IEEE, 2012. ",
+        "bbox": [
+            173,
+            446,
+            823,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthias Plappert, Rein Houthooft, Prafulla Dhariwal, Szymon Sidor, Richard Y Chen, Xi Chen, Tamim Asfour, Pieter Abbeel, and Marcin Andrychowicz. Parameter space noise for exploration. In International Conference on Learning Representations (ICLR2018), 2018. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            527
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, et al. Noisy networks for exploration. In International Conference on Learning Representations (ICLR2018), 2018. ",
+        "bbox": [
+            174,
+            535,
+            826,
+            579
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            397,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 MODEL-ENSEMBLE TRUST-REGION POLICY OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            136,
+            633,
+            151
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our algorithm can be broken down into three parts: data collection, model learning, and policy learning. We describe the numerical details for each part below. ",
+        "bbox": [
+            174,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1.1 DATA COLLECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            214,
+            364,
+            228
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In each outer iteration, we use the stochastic policy to collect 3000 timesteps of real world data for every environment, except Humanoid in which we collect 6000 timesteps. At the beginning of every roll-out we sample the policy standard deviation randomly from $\\mathcal { U } [ 0 . 0 , 3 . 0 ]$ , and we keep the value fixed throughout the episode. Furthermore, we perturb the policy’s parameters by adding white Gaussian noise with standard deviation proportional to the absolute difference between the current parameters and the previous one (Plappert et al., 2018; Fortunato et al., 2018). Finally, we split the collected data using a 2-to-1 ratio for training and validation datasets. ",
+        "bbox": [
+            174,
+            241,
+            825,
+            339
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1.2 MODEL LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            364,
+            373
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We represent the dynamics model with a 2-hidden-layer feed-forward neural network with hidden sizes 1024-1024 and ReLU nonlinearities. We train the model with the Adam optimizer with learning rate 0.001 using a batch size of 1000. The model is trained until the validation loss has not decreased for 25 passes over the entire training dataset (we validate the training every 5 passes). ",
+        "bbox": [
+            174,
+            386,
+            825,
+            443
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1.3 POLICY LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            463,
+            364,
+            477
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We represent the policy with a 2-hidden-layer feed-forward neural network with hidden sizes 32-32 and tanh nonlinearities for all the environments, except Humanoid, in which we use the hidden sizes 100-50-25. The policy is trained with TRPO on the learned models using initial standard deviation 1.0, step size $\\delta _ { K L } 0 . 0 1$ , and batch size 50000. If the policy fails the validation for 25 updates (we do the validation every 5 updates), we stop the learning and repeat the overall process. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            559
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 ENVIRONMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            582,
+            387,
+            597
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The environments we use are adopted from rllab (Duan et al., 2016). The reward functions $r _ { t } ( s _ { t } , a _ { t } )$ and optimization horizons are described below: ",
+        "bbox": [
+            173,
+            609,
+            823,
+            638
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/ddf1312dd71e5c412d57ec80a2e0f9e41a72e7e1528e307a6fc3f7dffa44db6c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Environments</td><td rowspan=1 colspan=1>Reward functions</td><td rowspan=1 colspan=1>Horizon</td></tr><tr><td rowspan=1 colspan=1>Swimmer</td><td rowspan=1 colspan=1>sel-0.005lae</td><td rowspan=1 colspan=1>200</td></tr><tr><td rowspan=1 colspan=1>Snake</td><td rowspan=1 colspan=1>sel -0.0051a2</td><td rowspan=1 colspan=1>200</td></tr><tr><td rowspan=1 colspan=1>Hopper</td><td rowspan=1 colspan=1>- 10∑(max(st -100,0))</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Half Cheetah</td><td rowspan=1 colspan=1>gel - 0.051lal2</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Ant</td><td rowspan=1 colspan=1>sel-0.0051all2+0.05</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Humanoid</td><td rowspan=1 colspan=1>(shead-1.5）²+ |lall2</td><td rowspan=1 colspan=1>100</td></tr></table>",
+        "bbox": [
+            303,
+            654,
+            694,
+            805
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Note that in Hopper we relax the early stopping criterion to a soft constraint in reward function, whereas in Ant we early stop when the center of mass long $\\mathbf { Z }$ -axis is outside [0.2, 1.0] and have a survival reward when alive. ",
+        "bbox": [
+            176,
+            819,
+            823,
+            861
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The state in each environment is composed of the joint angles, the joint velocities, and the cartesian position of the center of mass of a part of the simulated robot. We are not using the contact information, which make the environments effectively POMDPs in Half Cheetah, Ant, Hopper and Humanoid. We also eliminate the redundancies in the state space in order to avoid infeasible states in the prediction. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2.1 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            312,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Section 6.2 we compare our method against TRPO, PPO, DDPG, and SVG. For every environment we represent the policy with a feed-forward neural network of the same size, horizon, and discount factor as the ones specified in the Appendix A.1.3. In the following we provide the hyper-parameters details: ",
+        "bbox": [
+            174,
+            128,
+            825,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Trust Region Policy Optimization (Schulman et al., 2016). We used the implementation of Duan et al. (2016) with a batch size of 50000, and we train the policies for 1000 iterations. The step size $\\delta _ { K L }$ that we used in all the experiments was of 0.05. ",
+        "bbox": [
+            173,
+            191,
+            823,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proximal Policy Optimization (Schulman et al., 2017). We referred to the implementation of Hesse et al. (2017). The policies were trained for $1 0 ^ { 7 }$ steps using the default hyper-parameters across all tasks. ",
+        "bbox": [
+            174,
+            241,
+            823,
+            284
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Deep Deterministic Policy Gradient (Lillicrap et al., 2015). We also use the implementation of Hesse et al. (2017) using a number epochs of 2000, the rest of the hyper-parameters used were the default ones. ",
+        "bbox": [
+            176,
+            290,
+            823,
+            332
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Stochastic Value Gradient (Heess et al., 2015). We parametrized the dynamics model as a feedforward neural network of two hidden layers of 512 units each and ReLU non-linearities. The model was trained after every episode with the data available in the replay buffer, using the Adam optimizer with a learning rate of $1 \\dot { 0 } ^ { - 4 }$ , and batch size of 128. We additionally clipped the gradient we the norm was larger than 10. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            409
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B OVERFITTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            325,
+            448
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We show that replacing the ensemble with just one model leads to the policy overoptimization. In each outer iteration, we see that at the end of the policy optimization step the estimated performance increases while the real performance is in fact decreasing (see figure 5). ",
+        "bbox": [
+            174,
+            464,
+            825,
+            507
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/4da82d5f058e489432a70a9f6d8bf6e94bf3a080b5d6007f3a980685e9269675.jpg",
+        "image_caption": [
+            "Figure 5: Predicted and real performances during the training process using our approach with one model instead of an ensemble in Swimmer. The policy overfits to the dynamics model which degrades the real performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            529,
+            805,
+            770
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C REAL-TIME COMPLEXITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            876,
+            421,
+            892
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We provide wall clock time for the ME-TRPO results from figure 2 in the table below: ",
+        "bbox": [
+            173,
+            909,
+            738,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/1ed755561b2a3c622d55911731dc16bc1cfd8776794da95f2dcabd9a659ef91c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Environments</td><td rowspan=1 colspan=1>Run time (in 1000s)</td></tr><tr><td rowspan=1 colspan=1>Swimmer</td><td rowspan=1 colspan=1>35.3 ± 3.1</td></tr><tr><td rowspan=1 colspan=1>Snake</td><td rowspan=1 colspan=1>60.8± 4.7</td></tr><tr><td rowspan=1 colspan=1>Hopper</td><td rowspan=1 colspan=1>183.6 ± 10.2</td></tr><tr><td rowspan=1 colspan=1>Half Cheetah</td><td rowspan=1 colspan=1>103.7 ± 5.2</td></tr><tr><td rowspan=1 colspan=1>Ant</td><td rowspan=1 colspan=1>395.2 ± 67.1</td></tr><tr><td rowspan=1 colspan=1>Humanoid</td><td rowspan=1 colspan=1>362.1 ± 20.5</td></tr></table>",
+        "bbox": [
+            367,
+            101,
+            630,
+            210
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "These experiments were performed on Amazon EC2 using 1 NVIDIA K80 GPU, 4 vCPUs, and 61 GB of memory. ",
+        "bbox": [
+            176,
+            224,
+            823,
+            252
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Note that the majority of run time is spent on training model ensemble. However, our algorithm allows this to be simply parallelized across multiple GPUs. This could potentially yield multiple-fold speed-up from our results. ",
+        "bbox": [
+            174,
+            260,
+            825,
+            301
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            328,
+            359,
+            343
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We further provide a series of ablation experiments to characterize the importance of the two main regularization components of our algorithm: the ensemble validation and the ensemble sampling techniques. In these experiments, we make only one change at a time to ME-TRPO with 5 models. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            404
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D.1 ENSEMBLE SAMPLING METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            426,
+            444,
+            440
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We explore several ways to simulate the trajectories from the model ensemble. At a current state and action, we study the effect of simulating the next step given by: (1) sampling randomly from the different models (step rand), (2) a normal distribution fitted from the predictions (model mean std), (3) the mean of the predictions (model mean), (4) the median of the predictions (model med), (5) the prediction of a fixed model over the entire episode (i.e., equivalent to averaging the gradient across all simulations) (eps rand), and (6) sampling from one model (one model). ",
+        "bbox": [
+            174,
+            453,
+            825,
+            537
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The results in Figure 6 provide evidence that using the next step as the prediction of a randomly sampled model from our ensemble is the most robust method across environments. In fact, using the median or the mean of the predictions does not prevent overfitting; this effect is shown in the HalfCheetah environment where we see a decrease of the performance in latter iteration of the optimization process. Using the gradient average (5) also provides room for the policy to overfit to one or more models. This supports that having an estimate of the model uncertainty, such as in (1) and (2), is the principled way to avoid overfitting the learned models. ",
+        "bbox": [
+            173,
+            545,
+            825,
+            642
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/3cd0370d465a68ca6706cb959b1bdbc88f102a6a5c66cd32a40719e7f2c9d1ae.jpg",
+        "image_caption": [
+            "Figure 6: Comparison among different sampling techniques for simulating roll-outs. By sampling each step from a different model, we prevent overfitting and enhance the learning performance (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            664,
+            782,
+            844
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D.2 ENSEMBLE VALIDATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            385,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Finally, we provide a study of the different ways for validating the policy. We compare the following techniques: (1) using the real performance (i.e., using an oracle) (real), (2) using the average return in the trpo roll-outs (trpo mean), (3) stopping the policy after 50 gradient updates (no early 50), (4) or after 5 gradient updates (no early 5), (5) using one model to predict the performances (one model), and (6) using an ensemble of models (ensemble). The experiments are designed to use the same number of models and hyper-parameters for the other components of the algorithm. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Figure 7 we can see the effectiveness of each approach. It is noteworthy that having an oracle of the real performance is not the best approach. Such validation is over-cautious, and does not give room for exploration resulting in a poor trained dynamics model. Stopping the gradient after a fixed number of updates results in good performance if the right number of updates is set. This burdens the hyper-parameter search with one more hyper-parameter. On the other hand, using the ensemble of models has good performance across environments without adding extra hyper-parameters. ",
+        "bbox": [
+            173,
+            219,
+            825,
+            304
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7da04e30ef250206d40d6bea857a807213dc3081486710257bfd1616f46a7c4.jpg",
+        "image_caption": [
+            "Figure 7: Comparison among validation techniques. The ensemble of models yields to good performance across environments (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            321,
+            781,
+            505
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SJlbGJrtDB/SJlbGJrtDB.md

@@ -0,0 +1,282 @@
+# DYNAMIC SPARSE TRAINING: FIND EFFICIENT SPARSE NETWORK FROM SCRATCH WITH TRAINABLE MASKED LAYERS
+
+Junjie $\mathbf { L I U ^ { 1 } }$ , Zhe $\mathbf { X U } ^ { 2 }$ , Runbin $\mathbf { S H I ^ { 1 } }$ , Ray C.C. CHEUNG2 & Hayden K.H. SO1 1Department of Electrical and Electronic Engineering, The University of Hong Kong 2Department of Electrical Engineering, City University of Hong Kong {jjliu,rbshi,hso}@eee.hku.hk zhexu22-c@my.cityu.edu.hk, r.cheung@cityu.edu.hk
+
+# ABSTRACT
+
+We present a novel network pruning algorithm called Dynamic Sparse Training that can jointly find the optimal network parameters and sparse network structure in a unified optimization process with trainable pruning thresholds. These thresholds can have fine-grained layer-wise adjustments dynamically via backpropagation. We demonstrate that our dynamic sparse training algorithm can easily train very sparse neural network models with little performance loss using the same number of training epochs as dense models. Dynamic Sparse Training achieves state of the art performance compared with other sparse training algorithms on various network architectures. Additionally, we have several surprising observations that provide strong evidence to the effectiveness and efficiency of our algorithm. These observations reveal the underlying problems of traditional three-stage pruning algorithms and present the potential guidance provided by our algorithm to the design of more compact network architectures.
+
+# 1 INTRODUCTION
+
+Despite the impressive success that deep neural networks have achieved in a wide range of challenging tasks, the inference in deep neural networks is highly memory-intensive and computationintensive due to the over-parameterization of deep neural networks. Network pruning (LeCun et al. (1990); Han et al. (2015); Molchanov et al. (2017)) has been recognized as an effective approach to improving the inference efficiency in resource-limited scenarios.
+
+Traditional pruning methods consist of dense network training followed with pruning and fine-tuning iterations. To avoid the expensive pruning and fine-tuning iterations, many sparse training methods (Mocanu et al., 2018; Bellec et al., 2017; Mostafa & Wang, 2019; Dettmers & Zettlemoyer, 2019) have been proposed, where the network pruning is conducted during the training process. However, all these methods suffer from following three problems:
+
+Coarse-grained predefined pruning schedule. Most of the existing pruning methods use a predefined pruning schedule with many additional hyperparameters like pruning $a \%$ parameter each time and then fine-tuning for $b$ epochs with totally $c$ pruning steps. It is non-trivial to determine these hyperparameters for network architectures with various degrees of complexity. Therefore, usually a fixed pruning schedule is adopted for all the network architectures, which means that a very simple network architecture like LeNet-300-100 will have the same pruning schedule as a far more complex network like ResNet-152. Besides, almost all the existing pruning methods conduct epoch-wise pruning, which means that the pruning is conducted between two epochs and no pruning operation happens inside each epoch.
+
+Failure to properly recover the pruned weights. Almost all the existing pruning methods conduct ”hard” pruning that prunes weights by directly setting their values to 0. Many works (Guo et al., 2016; Mocanu et al., 2018; He et al., 2018) have argued that the importance of network weights are not fixed and will change dynamically during the pruning and training process. Previously unimportant weights may tend to be important. So the ability to recover the pruned weights is of high significance. However, directly setting the pruned weights to 0 results in the loss of historical parameter importance, which makes it difficult to determine: 1) whether and when each pruned weight should be recovered, 2) what values should be assigned to the recovered weights. Therefore, existing methods that claim to be able to recover the pruned weights simply choose a predefined portion of pruned weights to recover and these recover weights are randomly initialized or initialized to the same value.
+
+Failure to properly determine layer-wise pruning rates. Modern neural network architectures usually contain dozens of layers with a various number of parameters. Therefore, the degree of parameter redundancy is very different among the layers. For simplicity, some methods prune the same percentage of parameters at each layer, which is not optimal. To obtain dynamic layer-wise pruning rates, a single global pruning threshold or layer-wise greedy algorithms are applied. Using a single global pruning threshold is exceedingly difficult to assess the local parameter importance of the individual layer since each layer has a significantly different amount of parameter and contribution to the model performance. This makes pruning algorithms based on a single global threshold inconsistent and non-robust. The problem of layer-by-layer greedy pruning methods is that the unimportant neurons in an early layer may have a significant influence on the responses in later layers, which may result in propagation and amplification of the reconstruction error (Yu et al., 2018).
+
+We propose a novel end-to-end sparse training algorithm that properly solves the above problems. With only one additional hyperparameter used to set the final model sparsity, our method can achieve dynamic fine-grained pruning and recovery during the whole training process. Meanwhile, the layerwise pruning rates will be adjusted automatically with respect to the change of parameter importance during the training and pruning process. Our method achieves state-of-the-art performance compared with other sparse training algorithms. The proposed algorithm has following promising properties:
+
+• Step-wise pruning and recovery. A training epoch usually will have tens of thousands of training steps, which is the feed-forward and back-propagation pass for a single mini-batch. Instead of pruning between two training epochs with a predefined pruning schedule, our method prunes and recovers the network parameter at each training step, which is far more fine-grained than existing methods.
+
+• Neuron-wise or filter-wise trainable thresholds. All the existing methods adopt a single pruning threshold for each layer or the whole architecture. Our method defines a threshold vector for each layer. Therefore, our method adopts neuron-wise pruning thresholds for fully connected and recurrent layer and filter-wise pruning thresholds for convolutional layer. Additionally, all these pruning thresholds are trainable and will be updated automatically via back-propagation.
+
+• Dynamic pruning schedule. The training process of deep neural network consists of many hyperparameters. The learning rate is perhaps the most important hyperparameter. Usually, the learning rate will decay during the training process. Our method can automatically adjust the layer-wise pruning rates under different learning rates to get the optimal sparse network structure.
+
+• Consistent sparse pattern. Our algorithm can get a consistent layer-wise sparse pattern under different model sparsities, which indicates that our method can automatically determine the optimal layer-wise pruning rates given the target model sparsity.
+
+# 2 RELATED WORK
+
+Traditional Pruning Methods: LeCun et al. (1990) presented the early work about network pruning using second-order derivatives as the pruning criterion. The effective and popular training, pruning and fine-tuning pipeline was proposed by Han et al. (2015), which used the parameter magnitude as the pruning criterion. Narang et al. (2017) extended this pipeline to prune the recurrent neural networks with a complicated pruning strategy. Molchanov et al. (2016) introduced first-order Taylor term as the pruning criterion and conduct global pruning. Li et al. (2016) used $\ell _ { 1 }$ regularization to force the unimportant parameters to zero.
+
+Sparse Neural Network Training: Recently, some works attempt to find the sparse network directly during the training process without the pruning and fine-tuning stage. Inspired by the growth and extinction of neural cells in biological neural networks, Mocanu et al. (2018) proposed a pruneregrowth procedure called Sparse Evolutionary Training (SET) that allows the pruned neurons and connections to revive randomly. However, the sparsity level needs to be set manually and the random recovery of network connections may provoke unexpected effects on the network. DEEP-R proposed by Bellec et al. (2017) used Bayesian sampling to decide the pruning and regrowth configuration, which is computationally expensive. Dynamic Sparse Reparameterization (Mostafa & Wang, 2019) used dynamic parameter reallocation to find the sparse structure. However, the pruning threshold can only get halved if the percentage of parameter pruned is too high or get doubled if that percentage is too low for a certain layer. This coarse-grained adjustment of the pruning threshold significantly limits the ability of Dynamic Sparse Reparameterization. Additionally, a predefined pruning ratio and fractional tolerance are required. Dynamic Network Surgery (Guo et al., 2016) proposed pruning and splicing procedure that can prune or recover network connections according to the parameter magnitude but it requires manually determined thresholds that are fixed during the sparse learning process. These layer-wise thresholds are extremely hard to manually set. Meanwhile, Fixing the thresholds makes it hard to adapt to the rapid change of parameter importance. Dettmers & Zettlemoyer (2019) proposed sparse momentum that used the exponentially smoothed gradients as the criterion for pruning and regrowth. A fixed percentage of parameters are pruned at each pruning step. The pruning ratio and momentum scaling rate need to be searched from a relatively high parameter space.
+
+# 3 DYNAMIC SPARSE TRAINING
+
+# 3.1 NOTATION
+
+Deep neural network consists of a set of parameters $\{ W _ { i } : 1 \leq i \leq C \}$ , where $W _ { i }$ denotes the parameter matrix at layer $i$ and $C$ denotes the number of layers in this network. For each fully connected layer and recurrent layer, the corresponding parameter is $W _ { i } ~ \in ~ \mathbb { R } ^ { c _ { o } \times c _ { i } }$ , where $c _ { o }$ is the output dimension and $c _ { i }$ is the input dimension. For each convolutional layer, there exists a convolution kernel $\pmb { \mathsf { K } } _ { i } \in \mathbb { R } ^ { c _ { o } \times c _ { i } \times w \times h }$ , where $c _ { o }$ is the number of output channels, $c _ { i }$ is the number of input channels, $w$ and $h$ are the kernel sizes. Each filter in a convolution kernel $\mathsf { \pmb { K } } _ { i }$ can be flattened to a vector. Therefore, a corresponding parameter matrix $W _ { i } \in \mathbb { R } ^ { c _ { o } \times z }$ can be derived from each convolution kernel $\mathsf { K } _ { i } \in \mathbb { R } ^ { c _ { o } \times \bar { c _ { i } } \times w \times h }$ , where $z = c _ { i } \times w \times h$ . Actually, the pruning process is equivalent to finding a binary parameter mask $M _ { i }$ for each parameter matrix $W _ { i }$ . Thus, a set of binary parameter masks $\{ M _ { i } : 1 \le i \le C \}$ will be found by network pruning. Each element for these parameter masks $M _ { i }$ is either 1 or 0.
+
+# 3.2 THRESHOLD VECTOR AND DYNAMIC PARAMETER MASK
+
+Pruning can be regarded as applying a binary mask $M$ to each parameter $W$ . This binary parameter mask $M$ preserves the information about the sparse structure. Given the parameter set $\{ W _ { 1 } , W _ { 2 } , \cdot \cdot \cdot , \bar { W } _ { C } \}$ , our method will dynamically find the corresponding parameter masks $\{ M _ { 1 } , M _ { 2 } , \cdots , M _ { C } \}$ . To achieve this, for each parameter matrix $W \in \mathbb { R } ^ { c _ { o } \times c _ { i } }$ , a trainable pruning threshold vector $\pmb { t } \in \mathbb { R } ^ { c _ { o } }$ is defined. Then we utilize a unit step function $S ( x )$ as shown in Figure 2(a) to get the masks according to the magnitude of parameters and corresponding thresholds as present below.
+
+$$
+\begin{array} { c } { { Q _ { i j } = F ( W _ { i j } , t _ { i } ) = | W _ { i j } | - t _ { i } \quad 1 \leq i \leq c _ { o } , 1 \leq j \leq c _ { i } } } \\ { { \qquad M _ { i j } = S ( Q _ { i j } ) \quad 1 \leq i \leq c _ { o } , 1 \leq j \leq c _ { i } } } \end{array}
+$$
+
+With the dynamic parameter mask $M$ , the corresponding element in mask $M _ { i j }$ will be set to 0 if $W _ { i j }$ needs to be pruned. This means that the weight $W _ { i j }$ is masked out by the 0 at $M _ { i j }$ to get a sparse parameter $W \odot M$ . The value of underlying weight $W _ { i j }$ will not change, which preserves the historical information about the parameter importance.
+
+For a fully connected layer or recurrent layer with parameter $W \in \mathbb { R } ^ { c _ { o } \times c _ { i } }$ and threshold vector $\pmb { t } ~ \in \mathbb { R } ^ { c _ { o } }$ , each weight $W _ { i j }$ will have a neuron-wise threshold $\mathbf { \Delta } _ { t _ { i } }$ , where $W _ { i j }$ is the $j$ th weight associated with the ith output neuron. Similarly, the thresholds are filter-wise for convolutional layer. Besides, a threshold matrix or a single scalar threshold can also be chosen. More details are present in Appendix A.2.
+
+With the threshold vector and dynamic parameter mask, the trainable masked fully connected, convolutional and recurrent layer are introduced as shown in Figure 1, where $\boldsymbol { X }$ is the input of current layer and $\mathbf { Y }$ is the output. For fully connected and recurrent layers, instead of the dense parameter $W$ , the sparse product $W \odot M$ will be used in the batched matrix multiplication, where $\odot$ denote Hadamard product operator. For convolutional layers, each convolution kernel $\pmb { \ K } \in \mathbb { R } ^ { c _ { o } \times c _ { i } \times w \times h }$ can be flatten to get $W \in \mathbb { R } ^ { c _ { o } \times z }$ . Therefore, the sparse kernel can be obtained by a similar process as fully connected layers. This sparse kernel will be used for subsequent convolution operation.
+
+![](images/1a30d3262a631b3117c1bdd1c859215c91da40701d3d06e3d4d10cd58b80a30f.jpg)  
+Figure 1: Detailed structure of trainable masked layer
+
+![](images/00542c352c49df5a1ceb9e149b18f26a83137a68ceb185bcf0327280a5c61f45.jpg)  
+Figure 2: The unit step function $S ( x )$ and its derivative approximations.
+
+In order to make the elements in threshold vector $\pmb { t }$ trainable via back-propagation, the derivative of the binary step function $S ( x )$ is required. However, its original derivative is an impulse function whose value is zero almost everywhere and infinite at zero as shown in Figure 2(b). Thus the original derivative of the binary step function $S ( x )$ cannot be applied in back-propagation and parameter updating directly. Some previous works (Hubara et al. (2016); Rastegari et al. (2016); Zhou et al. (2016)) demonstrated that by providing a derivative estimation, it is possible to train networks containing such binarization function. A clip function called straight-through estimator (STE) (Bengio et al., 2013) was employed in these works and is illustrated in Figure 2(c).
+
+Furthermore, Xu & Cheung (2019) discussed the derivative estimation in a balance of tight approximation and smooth back-propagation. We adopt this long-tailed higher-order estimator $H ( x )$ in our method. As shown in Figure 2(d), it has a wide active range between $[ - 1 , 1 ]$ with a non-zero gradient to avoid gradient vanishing during training. On the other hand, the gradient value near zero is a piecewise polynomial function giving tighter approximation than STE. The estimator is represented as
+
+$$
+\frac { d } { d x } S ( x ) \approx H ( x ) = \left\{ \begin{array} { l l } { 2 - 4 | x | , } & { - 0 . 4 \leq x \leq 0 . 4 } \\ { 0 . 4 , } & { 0 . 4 < | x | \leq 1 } \\ { 0 , } & { o t h e r w i s e } \end{array} \right.
+$$
+
+With this derivative estimator, the elements in the vector threshold $\pmb { t }$ can be trained via backpropagation. Meanwhile, in trainable masked layers, the network parameter $W$ can receive two branches of gradient, namely the performance gradient for better model performance and the structure gradient for better sparse structure, which helps to properly update the network parameter under sparse network connectivity. The structure gradient enables the pruned (masked) weights to be updated via back-propagation. The details about the feed-forward and back-propagation of the trainable masked layer are present in Appendix A.3.
+
+Therefore, the pruned (masked) weights, the unpruned (unmasked) weights and the elements in the threshold vector can all be updated via back-propagation at each training step. The proposed method will conduct fine-grained step-wise pruning and recovery automatically.
+
+# 3.4 SPARSE REGULARIZATION TERM
+
+Now that the thresholds of each layer are trainable, a higher percentage of pruned parameter is de  
+sired. To get the parameter masks $M$ with high sparsity, higher pruning thresholds are needed. To   
+achieve this, we add a sparse regularization term $L _ { s }$ to the training loss that penalizes the low thresh  
+old vtermwith sked layer with threshold . Thus, the sparse regulars is: $\pmb { t } \in \mathbb { R } ^ { c _ { o } }$ , therm rresponding regularizationfor a deep neural network $\begin{array} { r } { R = \sum _ { i = 1 } ^ { c _ { o } } \exp ( - t _ { i } ) } \end{array}$ $L _ { s }$ $C$
+
+$$
+L _ { s } = \sum _ { i = 1 } ^ { C } R _ { i }
+$$
+
+We use $\exp ( - x )$ as the regularization function since it is asymptotical to zero as $x$ increases. Consequently, it penalizes low thresholds without encouraging them to become extremely large.
+
+# 3.5 DYNAMIC SPARSE TRAINING
+
+The traditional fully connected, convolutional and recurrent layers can be replaced with the corresponding trainable masked layers in deep neural networks. Then we can train a sparse neural network directly with back-propagation algorithm given the training dataset $\begin{array} { r l } { \mathcal { D } } & { { } = } \end{array}$ $\{ ( { \pmb x } _ { 1 } , { \pmb y } _ { 1 } ) , ( { \pmb x } _ { 2 } , { \pmb y } _ { 2 } ) , \cdot \cdot \cdot \ , ( { \pmb x } _ { N } , { \pmb y } _ { N } ) \}$ , the network parameter $W$ and the layer-wise threshold $\pmb { t }$ as follows:
+
+$$
+\mathcal { I } ( W , t ) = \frac { 1 } { N } ( \sum _ { i = 1 } ^ { N } \mathcal { L } ( ( x _ { i } , y _ { i } ) ; W , t ) ) + \alpha L _ { s }
+$$
+
+where $\mathcal { L } ( \cdot )$ is the loss function, e.g. cross-entropy loss for classification and $\alpha$ is the scaling coefficient for the sparse regularization term, which can control the percentage of parameter remaining. The sparse regularization term $L _ { s }$ tends to increase the threshold $\pmb { t }$ for each layer thus getting higher model sparsity. However, higher sparsity tends to increase the loss function, which reversely tends to reduce the threshold and level of sparsity. Consequently, the training process of the thresholds can be regarded as a contest between the sparse regularization term and the loss function in the sense of game theory. Therefore, our method can dynamically find the sparse structure that properly balances the model sparsity and performance.
+
+# 4 EXPERIMENTS
+
+The proposed method is evaluated on MNIST, CIFAR-10 and ImageNet with various modern network architectures including fully connected, convolutional and recurrent neural networks. To quantify the pruning performance, the layer remaining ratio is defined to be $k _ { l } = n / m$ , where $n$ is the number of elements equal to 1 in the mask $M$ and $m$ is the total number of elements in $M$ . The model remaining ratio $k _ { m }$ is the overall ratio of the non-zero elements in the parameter masks for all trainable masked layers. The model remaining percentage is defined as $k _ { m } \times \mathrm { 1 0 0 \% }$ . For all trainable masked layers, the trainable thresholds are initialized to zero since it is assumed that originally the network is dense. The detailed experimental setup is present in Appendix A.1.
+
+# 4.1 PRUNING PERFORMANCE ON VARIOUS DATASETS
+
+MNIST. Table 1 presents the pruning results of proposed method for Lenet-300-100 (LeCun et al., 1998), Lenet-5-Caffe and LSTM (Hochreiter & Schmidhuber, 1997). Both LSTM models have two LSTM layers with hidden size 128 for LSTM-a and 256 for LSTM-b. Our method can prune almost $98 \%$ parameter with little loss of performance on Lenet-300-100 and Lenet-5-Caffe. For the LSTM models adapted for the sequential MNIST classification, our method can find sparse models with better performance than dense baseline with over $9 9 \%$ parameter pruned.
+
+CIFAR-10. The pruning performance of our method on CIFAR-10 is tested on VGG (Simonyan & Zisserman, 2014) and WideResNet (Zagoruyko & Komodakis, 2016). We compare our method
+
+<table><tr><td>Architecture</td><td>Dense Baseline (%)</td><td>Model Remaining Percentage (%)</td><td>Sparse Accuracy (%)</td><td>Difference</td></tr><tr><td>Lenet-300-100</td><td>98.16 ± 0.06</td><td>2.48 ± 0.21</td><td>97.69±0.14</td><td>-0.47</td></tr><tr><td>Lenet-5-Caffe</td><td>99.18 ± 0.05</td><td>1.64 ± 0.13</td><td>99.11±0.07</td><td>-0.07</td></tr><tr><td>LSTM-a</td><td>98.64 ± 0.12</td><td>1.93 ± 0.03</td><td>98.70±0.06</td><td>+0.06</td></tr><tr><td>LSTM-b</td><td>98.87 ± 0.07</td><td>0.98 ± 0.04</td><td>98.89±0.11</td><td>+0.02</td></tr></table>
+
+Table 1: The pruning results on MNIST for various architectures
+
+with other sparse learning algorithms on CIFAR-10 as presented in Table 2. The state-of-the-art algorithms, DSR (Mostafa & Wang, 2019) and Sparse momentum (Dettmers & Zettlemoyer, 2019), are selected for comparison. Dynamic Sparse Training (DST) outperforms them in almost all the settings as present in Table 2.   
+Table 2: Comparison with other sparse training methods on CIFAR-10.   
+
+<table><tr><td>Architecture</td><td>Method</td><td>Dense baseline</td><td>Model Remaining Percentage (%)</td><td>Sparse Accuracy</td><td>Difference</td></tr><tr><td rowspan="3">VGG-16</td><td rowspan="2">Sparse Momentum</td><td rowspan="2">93.51 ± 0.05</td><td>10</td><td>93.36± 0.04</td><td>-0.15</td></tr><tr><td>5</td><td>93.00 ± 0.07</td><td>-0.51</td></tr><tr><td rowspan="2">DST (Ours)</td><td rowspan="2">93.75 ± 0.21</td><td>8.82 ± 0.34</td><td>93.93 ± 0.05</td><td>+0.18</td></tr><tr><td>3.76 ± 0.53</td><td>93.02 ± 0.37</td><td>-0.73</td></tr><tr><td rowspan="5">WideResNet-16-8</td><td rowspan="2">Sparse Momentum</td><td rowspan="2">95.43 ± 0.02</td><td>10</td><td>94.87 ± 0.04</td><td>-0.56</td></tr><tr><td>5</td><td>94.38 ± 0.05</td><td>-1.05</td></tr><tr><td rowspan="2">DSR</td><td rowspan="2">95.21± 0.05</td><td>10</td><td>94.93 ± 0.04</td><td>-0.28</td></tr><tr><td>5</td><td>94.68 ± 0.05</td><td>-0.53</td></tr><tr><td rowspan="2">DST (Ours)</td><td rowspan="2">95.18 ± 0.06</td><td>9.86± 0.22</td><td>95.05 ± 0.08</td><td>-0.13</td></tr><tr><td>4.64 ± 0.15</td><td>94.73 ± 0.11</td><td>-0.45</td></tr></table>
+
+ImageNet. For ResNet-50 on ImageNet (ILSVRC2012), we present the performance and comparison with other methods in Table 3. Dynamic Sparse Training (DST) achieves better top-1 and top-5 accuracy with slightly higher model sparsity. The number of parameters for the dense ResNet-50 model is $2 5 . 5 6 \mathrm { M }$ .   
+Table 3: Comparison with other sparse training methods for ResNet-50 on ImageNet.   
+
+<table><tr><td>Method</td><td>Dense baseline Top-1 /Top-5 (%)</td><td>Model Remaining Percentage (%)</td><td>Sparse accuracy Top-1/Top-5(%)</td><td>Difference</td><td>Remaining number of parameters</td></tr><tr><td>Sparse Momentum</td><td>74.90 /92.40</td><td>20 10</td><td>73.80/91.80 72.30 /91.00</td><td>-1.10/-0.60 -2.60 / -1.40</td><td>5.12M 2.56M</td></tr><tr><td>DSR</td><td>74.90 / 92.40</td><td>20 10</td><td>73.30/92.40 71.60 / 90.50</td><td>-1.60/+0.00 -3.30 /-1.90</td><td>5.14M 2.56M</td></tr><tr><td>DST (Ours)</td><td>74.95 /92.60</td><td>19.24 9.87</td><td>74.02/92.49 72.78 /91.53</td><td>-0.73/-0.11 -2.17 / -1.07</td><td>5.08M 2.49M</td></tr></table>
+
+# 4.2 PRUNING PERFORMANCE ON VARIOUS REMAINING RATIO
+
+By varying the scaling coefficient $\alpha$ for sparse regularization term, we can control the model remaining ratios of sparse models generated by dynamic sparse training. The relationships between $\alpha$ , model remaining ratio and sparse model accuracy of VGG, WideResNet-16-8 and WideResNet-28-8 on CIFAR-10 are presented in Figure 3. As demonstrated, the model remaining ratio keeps decreasing with increasing $\alpha$ . With a moderate $\alpha$ value, it is easy to obtain a sparse model with comparable or even higher accuracy than the dense counterpart. On the other side, if the $\alpha$ value is too large that makes the model remaining percentage less than $5 \%$ , there will be a noticeable accuracy drop. As demonstrated in Figure 3, the choice of $\alpha$ ranges from $1 0 ^ { - 9 }$ to $1 0 ^ { - 4 }$ . Depending on the application scenarios, we can either get models with similar or better performance as dense counterparts by a relatively small $\alpha$ or get a highly sparse model with little performance loss by a larger $\alpha$ .
+
+![](images/8c61539f18d580e8692dab1995bd784ceeeb3706bef4c1300337ea4e499c975c.jpg)  
+Figure 3: Test accuracy of sparse model on CIFAR-10 and model remaining ratio for different $\alpha$
+
+# 5 DISCUSSION
+
+# 5.1 FINE-GRAINED STEP-WISE PRUNING
+
+Figure 4(a) demonstrates the change of layer remaining ratios for Lenet-300-100 trained with DST at each training step during the first training epoch. And Figure 4(b) presents the change of layer remaining ratios during the whole training process (20 epochs). As present in these two figures, instead of decreasing by manually set fixed step size as in other pruning methods, our method makes the layer remaining ratios change smoothly and continuously at each training step. Meanwhile, as shown in Figure 4(a), the layer remaining ratios fluctuate dynamically within the first 100 training steps, which indicates that DST can achieve step-wise fine-grained pruning and recovery.
+
+Meanwhile, for multilayer neural networks, the parameters in different layers will have different relative importance. For example, Lenet-300-100 has three fully connected layers. Changing the parameter of the last layer (layer 3) can directly affect the model output. Thus, the parameter of layer 3 should be pruned more carefully. The input layer (layer 1) has the largest amount of parameters and takes the raw image as input. Since the images in MNIST dataset consist of many unchanged pixels (the background) that have no contribution to the classification process, it is expected that the parameters that take these invariant background pixels as input can be pruned safely. Therefore, the remaining ratio should be the highest for layer 3 and the lowest for layer 1 if a Lenet-300-100 model is pruned. To check the pruning effect of our method on these three layers, Lenet-300-100 model is sparsely trained by the default hyperparameters setting present in Appendix A.1. The pruning trends of these three layers during dynamic sparse training are present in Figure 4(b). During the whole sparse training process, the remaining ratios of layer 1 and layer 2 keep decreasing and the remaining ratio of layer 3 maintains to be 1 after the fluctuation during the first epoch. The remaining ratio of layer 1 is the lowest and decrease to less than $10 \%$ quickly, which is consistent with the expectation. In the meantime, the test accuracy of the sparse model is almost the same as the test accuracy on the dense model in the whole training process. This indicates that our method can properly balance the model remaining ratio and the model performance by continuous fine-grained pruning throughout the entire sparse training procedure. A similar training tendency can be observed in other network architectures. The detailed results for other architectures are present in Appendix A.4.
+
+![](images/5f8e480c791c6d048d65e1561d679279ae15b6e7f7e8bbf609861e3f68b5c48d.jpg)  
+Figure 4: Change of layer remaining ratio, model remaining ratio and test accuracy for Lenet-300-100 with $\alpha = 0 . 0 0 0 5$ .
+
+![](images/cc44288b6a9427a21a49cac2a556f7f939a2cbd9ee0846387d9c3f3827d168cc.jpg)  
+Figure 5: VGG-16 trained with initial learning rate 0.1 and $\alpha = 5 \times 1 0 ^ { - 6 }$ .
+
+![](images/c246b41f6c4afabe5b70793f11cc4b0fa272caece27311436307d38925309ce0.jpg)  
+Figure 6: VGG-16 trained with initial learning rate 0.01 and $\alpha = 5 \times 1 0 ^ { - 6 }$ .
+
+Dynamic adjustment regarding learning rate decay. To achieve better performance, it is a common practice to decay the learning rate several times during the training process of deep neural networks. Usually, the test accuracy will decrease immediately just after the learning rate decay and then tend toward flatness. A similar phenomenon is observed for VGG-16 on CIFAR-10 trained by DST as present in Figure 5(b), where the learning rate decay from 0.1 to 0.01 at 80 epoch.
+
+Like the layer 3 of Lenet-300-100, the second fully connected layer (FC 2) of VGG-16 is the output layer, hence its remaining ratio is expected to be relatively high. But a surprising observation is that the remaining ratio of FC 2 is quite low at around 0.1 for the first 80 epochs and increases almost immediately just after the 80 epoch as present in Figure 5(a). We suppose that this is caused by the decay of the learning rate from 0.1 to 0.01 at 80 epoch. Before the learning rate decay, the layers preceding the output layer fail to extract enough useful features for classification due to the relatively coarse-grained parameter adjustment incurred by high learning rate. This means that the corresponding parameters that take those useless features as input can be pruned, which leads to the low remaining ratio of the output layer. The decayed learning rate enables a finegrained parameter update that makes the neural network model converge to the good local minima quickly (Kawaguchi, 2016), where most of the features extracted by the preceding layers turn to be helpful for the classification. This makes previously unimportant network connections in the output layer become important thus the remaining ratio of this layer gets an abrupt increase.
+
+There are two facts that support our assumptions for this phenomenon. The first fact is the sudden increase of the test accuracy from around $8 5 \%$ to over $92 \%$ just after the learning rate decay.
+
+Secondly, the remaining ratios of the preceding convolutional layers are almost unchanged after the remaining ratio of the output layer increases up to 1, which means that the remaining parameters in these layers are necessary to find the critical features. The abrupt change of the remaining ratio of the output layer indicates that our method can dynamically adjust the pruning schedule regarding the change of hyperparameters during the training process.
+
+Dynamic adjustment regarding different initial learning rate. To further investigate the effect of the learning rate, the VGG-16 model is trained by a different initial learning rate (0.01) with other hyperparameters unchanged. The corresponding training curves are presented in Figure 6. As shown in Figure 6(a), the remaining ratio of FC 2 increases up to 1 after around 40 epochs when the test accuracy reaches over $90 \%$ . This means that with the proper update of network parameters due to a smaller initial learning rate, the layers preceding the output layer (FC 2) tend to extract useful features before the learning rate decay. It can be observed in Figure 6(b) that the test accuracy only increases about $2 \%$ from $90 \%$ to $92 \%$ roughly after the learning rate decay at the 80 epoch. Meanwhile, one can see that our method adopts a different pruning schedule regarding different initial choices of training hyperparameters.
+
+Model performance under dynamic schedule. Figure 5(b) and Figure 6(b) show the model remaining ratio, test accuracy of sparse model (sparse accuracy) and test accuracy of dense counterparts (dense accuracy) after each epoch during the whole training process. For the sparse model trained with initial learning rate 0.1, the final model remaining percentage is $8 . 8 2 \%$ . The test accuracy of this sparse model is $9 3 . 9 3 \%$ , which is better than $9 3 . 7 5 \%$ of the dense counterparts. Similarly, for the sparse model trained with initial learning rate 0.01, the final model remaining percentage is $1 2 . 4 5 \%$ . The test accuracy of this sparse model is $9 2 . 7 4 \%$ , which is also better than $9 2 . 5 4 \%$ of the dense model.
+
+Considering the model performance during the whole training process, when trained with initial learning rate 0.01, the sparse accuracy is consistently higher than dense accuracy during the whole training process as present in Figure 6(b). Meanwhile, one can see from Figure 5(b) that the running average of sparse accuracy is also higher than that of dense accuracy during the whole training process when the initial learning rate is 0.1.
+
+# 5.3 INFORMATION REVEALED FROM CONSISTENT SPARSE PATTERN
+
+Many works have tried to design more compact models with mimic performance to overparameterized models (He et al., 2016; Howard et al., 2017; Zhang et al., 2018). Network architecture search has been viewed as the future paradigm of deep neural network design. However, it is extremely difficult to determine whether the designed layer consists of redundancy. Therefore, typical network architecture search methods rely on evolutionary algorithms (Liu et al., 2017) or reinforcement learning (Baker et al., 2016), which is extremely time-consuming and computationally expensive. Network pruning can actually be reviewed as a kind of architecture search process (Liu et al., 2018; Frankle & Carbin, 2018) thus the sparse structure revealed from network pruning may provide some guidance to the network architecture design. However, The layer-wise equal remaining ratio generated by the unified pruning strategy fails to indicate the different degrees of redundancy for each layer. And the global pruning algorithm is non-robust, which fails to offer consistent guidance.
+
+Here we demonstrate another interesting observation called consistent sparse pattern during dynamic sparse training that provides useful information about the redundancy of individual layers as the guidance for compact network architecture design. For the same architecture trained by our method with various $\alpha$ values, the relative relationship of sparsity among different layers keeps consistent. The sparse patterns of VGG-16 on CIFAR-10 are present in Figure 7 with three different $\alpha$ .
+
+In all configurations, the last four convolutional layers (Conv 10-13) and the first fully connected layers (FC 1) are highly sparse. Meanwhile, some layers (Conv 3-7, FC 2) keep a high amount of parameters after pruning. This consistent sparse pattern indicates that these heavily pruned layers consist of high redundancy and a large number of parameters can be reduced in these layers to get more compact models. This phenomenon also exists in other network architectures, which is present in detail in the appendix A.5. Therefore, with this consistent sparse pattern, after designing a new network architecture, our method can be applied to get useful information about the layer-wise redundancy in this new architecture.
+
+![](images/10f5ddda65068c3259a8f0526be4cbb8ea0e91f35ef9052dc978046618fa3dae.jpg)  
+Figure 7: The sparse pattern and percentage of parameter remaining for different choices of $\alpha$ on VGG-16
+
+# 6 CONCLUSION
+
+We propose Dynamic Sparse Training (DST) with trainable masked layers that enables direct training of sparse models with trainable pruning thresholds. DST can be easily applied to various types of neural network layers and architectures to get a highly sparse or better-performed model than dense counterparts. With the ability to reveal the consistent sparse pattern, our method can also provide useful guidance to the design of the more compact network.
+
+# REFERENCES
+
+Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. arXiv preprint arXiv:1611.02167, 2016.
+
+Guillaume Bellec, David Kappel, Wolfgang Maass, and Robert Legenstein. Deep rewiring: Training very sparse deep networks. arXiv preprint arXiv:1711.05136, 2017.
+
+Yoshua Bengio, Nicholas Leonard, and Aaron Courville. Estimating or propagating gradients ´ through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013.
+
+Tim Dettmers and Luke Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. arXiv preprint arXiv:1907.04840, 2019.
+
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. arXiv preprint arXiv:1803.03635, 2018.
+
+Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. In Advances In Neural Information Processing Systems, pp. 1379–1387, 2016.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Yang He, Guoliang Kang, Xuanyi Dong, Yanwei Fu, and Yi Yang. Soft filter pruning for accelerating deep convolutional neural networks. arXiv preprint arXiv:1808.06866, 2018.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.
+
+Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks. In Advances in neural information processing systems, pp. 4107–4115. 2016.
+
+Kenji Kawaguchi. Deep learning without poor local minima. In Advances in neural information processing systems, pp. 586–594, 2016.   
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems, pp. 598–605, 1990.   
+Yann LeCun, Leon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied ´ to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016.   
+Hanxiao Liu, Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, and Koray Kavukcuoglu. Hierarchical representations for efficient architecture search. arXiv preprint arXiv:1711.00436, 2017.   
+Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. arXiv preprint arXiv:1810.05270, 2018.   
+Decebal Constantin Mocanu, Elena Mocanu, Peter Stone, Phuong H Nguyen, Madeleine Gibescu, and Antonio Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature communications, 9(1):2383, 2018.   
+Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2498–2507. JMLR. org, 2017.   
+Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference. arXiv preprint arXiv:1611.06440, 2016.   
+Hesham Mostafa and Xin Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization. arXiv preprint arXiv:1902.05967, 2019.   
+Sharan Narang, Erich Elsen, Gregory Diamos, and Shubho Sengupta. Exploring sparsity in recurrent neural networks. arXiv preprint arXiv:1704.05119, 2017.   
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision (ECCV), pp. 525–542. Springer, 2016.   
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   
+Zhe Xu and Ray C. C. Cheung. Accurate and compact convolutional neural networks with trained binarization. In British Machine Vision Conference (BMVC), 2019.   
+Ruichi Yu, Ang Li, Chun-Fu Chen, Jui-Hsin Lai, Vlad I Morariu, Xintong Han, Mingfei Gao, ChingYung Lin, and Larry S Davis. Nisp: Pruning networks using neuron importance score propagation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9194– 9203, 2018.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   
+Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 6848–6856, 2018.   
+Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016.
+
+# A APPENDIX
+
+# A.1 EXPERIMENTAL SETUP
+
+MNIST: LeNet-300-100 and LeNet-5-Caffe are trained using SGD with a momentum of 0.9 and the batch size of 64 with 20 training epochs. The learning rate is 0.01 without learning rate decay. Meanwhile, the default scaling factor $\alpha$ for sparse regularization term is 0.0005 for both network architectures. LSTM models are trained using Adam optimization scheme (Kingma & Ba, 2014) with default Adam hyperparameter setting for 20 epochs. The batch size is 100 and the default learning rate is 0.001. Meanwhile, the default scaling factor $\alpha$ for sparse regularization term is 0.001.
+
+CIFAR-10 Models on CIFAR-10 are trained using SGD with momentum 0.9 and batch size of 64 with 160 training epochs. The initial learning rate is 0.1 and decayed by 0.1 at 80 and 120 epoch. The default scaling factor $\alpha$ for sparse regularization term is $5 \times 1 0 ^ { - 6 }$ for all tested architectures.
+
+ImageNet. ResNet-50 models are trained using SGD with momentum 0.9 and batch size of 1024 with 90 training epochs. The default initial learning rate is 0.1 and decayed by 10 at 30, 60, 80 epochs.
+
+For all trainable masked layers, the trainable thresholds are initialized to zero. Additionally, we find that an extremely high scaling coefficient $\alpha$ will make the sparse regularization term dominates the training loss thus making the mask $M$ to be all zero in a certain layer, which may impede the training process. To prevent this, the pruning threshold $\pmb { t }$ will be reset to zero if more than $9 9 \%$ elements in the mask are zero in a certain layer despite the LSTM models. This mechanism makes the training process smoother and enables a wider range choice of $\alpha$ .
+
+# A.2 ANALYSIS OF DIFFERENT THRESHOLD CHOICES
+
+Beside a threshold vector, a threshold scalar $t$ or threshold matrix $\pmb { T } \in \mathbb { R } ^ { c _ { o } \times c _ { i } }$ can also be adopted for each trainable masked layer with parameter $W \in \mathbb { R } ^ { c _ { o } \times c _ { i } }$ .
+
+$$
+Q _ { i j } = \left\{ { \begin{array} { l l } { | W _ { i j } | - t , } & { { \mathrm { f o r ~ t h r e s h o l d ~ s c a l a r } } } \\ { | W _ { i j } | - T _ { i j } , } & { { \mathrm { f o r ~ t h r e s h o l d ~ m a t r i x } } } \end{array} } \right.
+$$
+
+All three choices of trainable thresholds are tested on various architectures. Considering the effects on network pruning, the matrix threshold has almost the same model remaining ratio compared with the vector threshold. The scalar threshold is less robust than the vector and matrix threshold. In terms of the storage overhead, the matrix threshold almost doubles the amount of parameter during the training process in each architecture. Meanwhile, the vector threshold only adds less than $1 \%$ additional network parameter.
+
+The extra trainable threshold will also bring additional computation. In both feed-forward and backpropagation phase, the additional computations are matrix-element-wise operations $( \mathcal { O } ( n ^ { 2 } ) )$ , which is apparently light-weighted compared to the original batched matrix multiplication $( \mathcal { O } ( n ^ { 3 } ) )$ . For practical deployment, only the masked parameter $W \odot M$ needs to be stored, thus no overhead will be introduced. Therefore, considering the balance between the overhead and the benefit incurred by these three choices, the vector threshold is chosen for trainable masked layers.
+
+# A.3 MORE DETAILS ABOUT THE TRAINABLE MASKED LAYER
+
+Feed forward process. Considering a single layer in deep neural network with input $_ { \textbf { \em x } }$ and dense parameter $W$ . The normal layer will conduct matrix-vector multiplication as $W x$ or convolution as $C o n v ( \pmb { W } , \pmb { x } )$ . In trainable masked layers, since a sparse mask $M$ is obtained for each layer. The sparse parameter $W \odot M$ will be adopted in the corresponding matrix-vector multiplication or convolution as $( W \odot M ) x$ and $C o n v ( \pmb { W } \odot \pmb { M } , \pmb { x } )$ .
+
+Back-propagation process. Referring to Figure 1, we denote $P = W \odot M$ and the gradient received by $_ { r }$ in back-propagation as $d \mathbf { } P$ . Considering the gradients from right to left:
+
+• The performance gradient is $d P \odot M$   
+• The gradient received by $M$ is $d P \odot W$   
+• The gradient received by $Q$ is $d P \odot W \odot H ( Q )$ , where $H ( Q )$ is the result of $H ( x )$ applied to $Q$ elementwisely.   
+• The structure gradient is $d P \odot W \odot H ( Q ) \odot s g n ( W )$ , where $s g n ( W )$ is the result of sign function applied to $W$ elementwisely.   
+$\bullet$ The gradient received by the vector threshold $\pmb { t }$ is $d t \in \mathbb { R } ^ { c _ { o } }$ . We denote $d \pmb { T } = - d \pmb { P } \odot \pmb { W } \odot \pmb { H } ( \pmb { Q } )$ , then $\bar { d \mathbf { T } } \in \mathbb { R } ^ { c _ { o } \times c _ { i } }$ . And we will have $\begin{array} { r } { d \pmb { t } _ { i } = \sum _ { j = 1 } ^ { c _ { i } } \pmb { T } _ { i j } } \end{array}$ for $1 \leq i \leq c _ { o }$ .   
+• The gradient received by the parameter $W$ is $d \pmb { W } = d \pmb { P } \odot \pmb { M } + d \pmb { P } \odot \pmb { W } \odot \pmb { H } ( \pmb { Q } ) \odot s g n ( \pmb { W } )$
+
+Since we add $\ell _ { 2 }$ regularization in the training process, all the elements in $W$ are distributed within $[ - 1 , 1 ]$ . Meanwhile, almost all the elements in the vector threshold are distributed within $[ 0 , 1 ]$ . The exceptions are the situation as shown in Figure 3(a) and Figure 4(a) where the last layer get no weight pruned (masked). Regarding the process of getting $Q$ , all the elements in $Q$ are within $[ - 1 , 1 ]$ . Therefore $H ( Q )$ is a dense matrix. Then $W$ , $H ( Q )$ and $s g n ( W )$ are all dense matrices and the pruned (masked) weights can receive the structure gradient $d \pmb { P } \odot \pmb { W } \odot \pmb { H } ( \pmb { Q } ) \odot s g n ( \pmb { W } )$
+
+# A.4 CHANGE OF REMAINING RATIO IN OTHER NETWORK ARCHITECTURES
+
+Here we present the change of remaining ratios during dynamic sparse training for the other tested architectures. Since WideResNet models only have one fully connected layer at the end as the output layer, the first five convolutional layers and the last fully connected layer are present. Figure 8 demonstrates the corresponding result for WideResNet-16-8. Figure 9 demonstrates the corresponding result for WideResNet-16-10. And Figure 10 demonstrates the corresponding result for WideResNet-28-8. The similar phenomenon can be observed in all these three network architectures for various $\alpha$ .
+
+# A.5 CONSISTENT SPARSE PATTERN IN OTHER NETWORK ARCHITECTURES
+
+Here we present the consistent sparse pattern for the other tested architectures. Figure 11 demonstrates the corresponding result for WideResNet-16-8. And Figure 12 demonstrates the corresponding result for WideResNet-16-10.
+
+![](images/bb7c94e0e231291b6d31d15359af27aa66a6711ea15116c488bc9ea0870db207.jpg)  
+Figure 8: WideResNet-16-8 trained by dynamic sparse training with $\alpha = 1 0 ^ { - 5 }$
+
+![](images/1298886cbe35f9f5e8bd746359f67911ce7d3e935e09e63fa4eacb6a069b4840.jpg)  
+Figure 9: WideResNet-16-10 trained by dynamic sparse training with $\alpha = 1 0 ^ { - 5 }$
+
+![](images/e515b67993a03631126f0414b14dec1192f1d7926b9aacdb123782958f69680f.jpg)  
+Figure 10: WideResNet-28-8 trained by dynamic sparse training with $\alpha = 1 0 ^ { - 5 }$
+
+![](images/50c70ae28b6d6e66b8741f86a16ba1da2e71a2f3e12c17b98e2f20fee506fb60.jpg)  
+Figure 11: The sparse pattern and percentage of parameter remaining for different choices of $\alpha$ on WRN-16-8
+
+![](images/e4d31fb0f04b9cfa5f9c696468ef07d2168fd0155d6b7edb8f6b6ccd35d7eba9.jpg)
+
+Figure 12: The sparse pattern and percentage of parameter remaining for different choices of $\alpha$ on WRN-16-10

parse/train/SJlbGJrtDB/SJlbGJrtDB_content_list.json

@@ -0,0 +1,1374 @@
+[
+    {
+        "type": "text",
+        "text": "DYNAMIC SPARSE TRAINING: FIND EFFICIENT SPARSE NETWORK FROM SCRATCH WITH TRAINABLE MASKED LAYERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Junjie $\\mathbf { L I U ^ { 1 } }$ , Zhe $\\mathbf { X U } ^ { 2 }$ , Runbin $\\mathbf { S H I ^ { 1 } }$ , Ray C.C. CHEUNG2 & Hayden K.H. SO1 1Department of Electrical and Electronic Engineering, The University of Hong Kong 2Department of Electrical Engineering, City University of Hong Kong {jjliu,rbshi,hso}@eee.hku.hk zhexu22-c@my.cityu.edu.hk, r.cheung@cityu.edu.hk ",
+        "bbox": [
+            181,
+            194,
+            740,
+            266
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            303,
+            544,
+            318
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present a novel network pruning algorithm called Dynamic Sparse Training that can jointly find the optimal network parameters and sparse network structure in a unified optimization process with trainable pruning thresholds. These thresholds can have fine-grained layer-wise adjustments dynamically via backpropagation. We demonstrate that our dynamic sparse training algorithm can easily train very sparse neural network models with little performance loss using the same number of training epochs as dense models. Dynamic Sparse Training achieves state of the art performance compared with other sparse training algorithms on various network architectures. Additionally, we have several surprising observations that provide strong evidence to the effectiveness and efficiency of our algorithm. These observations reveal the underlying problems of traditional three-stage pruning algorithms and present the potential guidance provided by our algorithm to the design of more compact network architectures. ",
+        "bbox": [
+            233,
+            333,
+            764,
+            512
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            336,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the impressive success that deep neural networks have achieved in a wide range of challenging tasks, the inference in deep neural networks is highly memory-intensive and computationintensive due to the over-parameterization of deep neural networks. Network pruning (LeCun et al. (1990); Han et al. (2015); Molchanov et al. (2017)) has been recognized as an effective approach to improving the inference efficiency in resource-limited scenarios. ",
+        "bbox": [
+            174,
+            568,
+            823,
+            637
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Traditional pruning methods consist of dense network training followed with pruning and fine-tuning iterations. To avoid the expensive pruning and fine-tuning iterations, many sparse training methods (Mocanu et al., 2018; Bellec et al., 2017; Mostafa & Wang, 2019; Dettmers & Zettlemoyer, 2019) have been proposed, where the network pruning is conducted during the training process. However, all these methods suffer from following three problems: ",
+        "bbox": [
+            174,
+            645,
+            825,
+            714
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Coarse-grained predefined pruning schedule. Most of the existing pruning methods use a predefined pruning schedule with many additional hyperparameters like pruning $a \\%$ parameter each time and then fine-tuning for $b$ epochs with totally $c$ pruning steps. It is non-trivial to determine these hyperparameters for network architectures with various degrees of complexity. Therefore, usually a fixed pruning schedule is adopted for all the network architectures, which means that a very simple network architecture like LeNet-300-100 will have the same pruning schedule as a far more complex network like ResNet-152. Besides, almost all the existing pruning methods conduct epoch-wise pruning, which means that the pruning is conducted between two epochs and no pruning operation happens inside each epoch. ",
+        "bbox": [
+            174,
+            722,
+            823,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Failure to properly recover the pruned weights. Almost all the existing pruning methods conduct ”hard” pruning that prunes weights by directly setting their values to 0. Many works (Guo et al., 2016; Mocanu et al., 2018; He et al., 2018) have argued that the importance of network weights are not fixed and will change dynamically during the pruning and training process. Previously unimportant weights may tend to be important. So the ability to recover the pruned weights is of high significance. However, directly setting the pruned weights to 0 results in the loss of historical parameter importance, which makes it difficult to determine: 1) whether and when each pruned weight should be recovered, 2) what values should be assigned to the recovered weights. Therefore, existing methods that claim to be able to recover the pruned weights simply choose a predefined portion of pruned weights to recover and these recover weights are randomly initialized or initialized to the same value. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Failure to properly determine layer-wise pruning rates. Modern neural network architectures usually contain dozens of layers with a various number of parameters. Therefore, the degree of parameter redundancy is very different among the layers. For simplicity, some methods prune the same percentage of parameters at each layer, which is not optimal. To obtain dynamic layer-wise pruning rates, a single global pruning threshold or layer-wise greedy algorithms are applied. Using a single global pruning threshold is exceedingly difficult to assess the local parameter importance of the individual layer since each layer has a significantly different amount of parameter and contribution to the model performance. This makes pruning algorithms based on a single global threshold inconsistent and non-robust. The problem of layer-by-layer greedy pruning methods is that the unimportant neurons in an early layer may have a significant influence on the responses in later layers, which may result in propagation and amplification of the reconstruction error (Yu et al., 2018). ",
+        "bbox": [
+            174,
+            194,
+            825,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel end-to-end sparse training algorithm that properly solves the above problems. With only one additional hyperparameter used to set the final model sparsity, our method can achieve dynamic fine-grained pruning and recovery during the whole training process. Meanwhile, the layerwise pruning rates will be adjusted automatically with respect to the change of parameter importance during the training and pruning process. Our method achieves state-of-the-art performance compared with other sparse training algorithms. The proposed algorithm has following promising properties: ",
+        "bbox": [
+            174,
+            354,
+            825,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Step-wise pruning and recovery. A training epoch usually will have tens of thousands of training steps, which is the feed-forward and back-propagation pass for a single mini-batch. Instead of pruning between two training epochs with a predefined pruning schedule, our method prunes and recovers the network parameter at each training step, which is far more fine-grained than existing methods. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            527
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Neuron-wise or filter-wise trainable thresholds. All the existing methods adopt a single pruning threshold for each layer or the whole architecture. Our method defines a threshold vector for each layer. Therefore, our method adopts neuron-wise pruning thresholds for fully connected and recurrent layer and filter-wise pruning thresholds for convolutional layer. Additionally, all these pruning thresholds are trainable and will be updated automatically via back-propagation. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            597
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Dynamic pruning schedule. The training process of deep neural network consists of many hyperparameters. The learning rate is perhaps the most important hyperparameter. Usually, the learning rate will decay during the training process. Our method can automatically adjust the layer-wise pruning rates under different learning rates to get the optimal sparse network structure. ",
+        "bbox": [
+            174,
+            598,
+            823,
+            652
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Consistent sparse pattern. Our algorithm can get a consistent layer-wise sparse pattern under different model sparsities, which indicates that our method can automatically determine the optimal layer-wise pruning rates given the target model sparsity. ",
+        "bbox": [
+            173,
+            654,
+            823,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            731,
+            341,
+            746
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Traditional Pruning Methods: LeCun et al. (1990) presented the early work about network pruning using second-order derivatives as the pruning criterion. The effective and popular training, pruning and fine-tuning pipeline was proposed by Han et al. (2015), which used the parameter magnitude as the pruning criterion. Narang et al. (2017) extended this pipeline to prune the recurrent neural networks with a complicated pruning strategy. Molchanov et al. (2016) introduced first-order Taylor term as the pruning criterion and conduct global pruning. Li et al. (2016) used $\\ell _ { 1 }$ regularization to force the unimportant parameters to zero. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sparse Neural Network Training: Recently, some works attempt to find the sparse network directly during the training process without the pruning and fine-tuning stage. Inspired by the growth and extinction of neural cells in biological neural networks, Mocanu et al. (2018) proposed a pruneregrowth procedure called Sparse Evolutionary Training (SET) that allows the pruned neurons and connections to revive randomly. However, the sparsity level needs to be set manually and the random recovery of network connections may provoke unexpected effects on the network. DEEP-R proposed by Bellec et al. (2017) used Bayesian sampling to decide the pruning and regrowth configuration, which is computationally expensive. Dynamic Sparse Reparameterization (Mostafa & Wang, 2019) used dynamic parameter reallocation to find the sparse structure. However, the pruning threshold can only get halved if the percentage of parameter pruned is too high or get doubled if that percentage is too low for a certain layer. This coarse-grained adjustment of the pruning threshold significantly limits the ability of Dynamic Sparse Reparameterization. Additionally, a predefined pruning ratio and fractional tolerance are required. Dynamic Network Surgery (Guo et al., 2016) proposed pruning and splicing procedure that can prune or recover network connections according to the parameter magnitude but it requires manually determined thresholds that are fixed during the sparse learning process. These layer-wise thresholds are extremely hard to manually set. Meanwhile, Fixing the thresholds makes it hard to adapt to the rapid change of parameter importance. Dettmers & Zettlemoyer (2019) proposed sparse momentum that used the exponentially smoothed gradients as the criterion for pruning and regrowth. A fixed percentage of parameters are pruned at each pruning step. The pruning ratio and momentum scaling rate need to be searched from a relatively high parameter space. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            104,
+            825,
+            339
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DYNAMIC SPARSE TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            361,
+            446,
+            377
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 NOTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            393,
+            287,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep neural network consists of a set of parameters $\\{ W _ { i } : 1 \\leq i \\leq C \\}$ , where $W _ { i }$ denotes the parameter matrix at layer $i$ and $C$ denotes the number of layers in this network. For each fully connected layer and recurrent layer, the corresponding parameter is $W _ { i } ~ \\in ~ \\mathbb { R } ^ { c _ { o } \\times c _ { i } }$ , where $c _ { o }$ is the output dimension and $c _ { i }$ is the input dimension. For each convolutional layer, there exists a convolution kernel $\\pmb { \\mathsf { K } } _ { i } \\in \\mathbb { R } ^ { c _ { o } \\times c _ { i } \\times w \\times h }$ , where $c _ { o }$ is the number of output channels, $c _ { i }$ is the number of input channels, $w$ and $h$ are the kernel sizes. Each filter in a convolution kernel $\\mathsf { \\pmb { K } } _ { i }$ can be flattened to a vector. Therefore, a corresponding parameter matrix $W _ { i } \\in \\mathbb { R } ^ { c _ { o } \\times z }$ can be derived from each convolution kernel $\\mathsf { K } _ { i } \\in \\mathbb { R } ^ { c _ { o } \\times \\bar { c _ { i } } \\times w \\times h }$ , where $z = c _ { i } \\times w \\times h$ . Actually, the pruning process is equivalent to finding a binary parameter mask $M _ { i }$ for each parameter matrix $W _ { i }$ . Thus, a set of binary parameter masks $\\{ M _ { i } : 1 \\le i \\le C \\}$ will be found by network pruning. Each element for these parameter masks $M _ { i }$ is either 1 or 0. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            573
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 THRESHOLD VECTOR AND DYNAMIC PARAMETER MASK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            604,
+            607
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pruning can be regarded as applying a binary mask $M$ to each parameter $W$ . This binary parameter mask $M$ preserves the information about the sparse structure. Given the parameter set $\\{ W _ { 1 } , W _ { 2 } , \\cdot \\cdot \\cdot , \\bar { W } _ { C } \\}$ , our method will dynamically find the corresponding parameter masks $\\{ M _ { 1 } , M _ { 2 } , \\cdots , M _ { C } \\}$ . To achieve this, for each parameter matrix $W \\in \\mathbb { R } ^ { c _ { o } \\times c _ { i } }$ , a trainable pruning threshold vector $\\pmb { t } \\in \\mathbb { R } ^ { c _ { o } }$ is defined. Then we utilize a unit step function $S ( x )$ as shown in Figure 2(a) to get the masks according to the magnitude of parameters and corresponding thresholds as present below. ",
+        "bbox": [
+            174,
+            618,
+            825,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ed2d3db10da1ace33dc9c91f8c5c9267a97a6bae5b8cdce50f2e3a7d18813cb.jpg",
+        "text": "$$\n\\begin{array} { c } { { Q _ { i j } = F ( W _ { i j } , t _ { i } ) = | W _ { i j } | - t _ { i } \\quad 1 \\leq i \\leq c _ { o } , 1 \\leq j \\leq c _ { i } } } \\\\ { { \\qquad M _ { i j } = S ( Q _ { i j } ) \\quad 1 \\leq i \\leq c _ { o } , 1 \\leq j \\leq c _ { i } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            736,
+            691,
+            781
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With the dynamic parameter mask $M$ , the corresponding element in mask $M _ { i j }$ will be set to 0 if $W _ { i j }$ needs to be pruned. This means that the weight $W _ { i j }$ is masked out by the 0 at $M _ { i j }$ to get a sparse parameter $W \\odot M$ . The value of underlying weight $W _ { i j }$ will not change, which preserves the historical information about the parameter importance. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For a fully connected layer or recurrent layer with parameter $W \\in \\mathbb { R } ^ { c _ { o } \\times c _ { i } }$ and threshold vector $\\pmb { t } ~ \\in \\mathbb { R } ^ { c _ { o } }$ , each weight $W _ { i j }$ will have a neuron-wise threshold $\\mathbf { \\Delta } _ { t _ { i } }$ , where $W _ { i j }$ is the $j$ th weight associated with the ith output neuron. Similarly, the thresholds are filter-wise for convolutional layer. Besides, a threshold matrix or a single scalar threshold can also be chosen. More details are present in Appendix A.2. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With the threshold vector and dynamic parameter mask, the trainable masked fully connected, convolutional and recurrent layer are introduced as shown in Figure 1, where $\\boldsymbol { X }$ is the input of current layer and $\\mathbf { Y }$ is the output. For fully connected and recurrent layers, instead of the dense parameter $W$ , the sparse product $W \\odot M$ will be used in the batched matrix multiplication, where $\\odot$ denote Hadamard product operator. For convolutional layers, each convolution kernel $\\pmb { \\ K } \\in \\mathbb { R } ^ { c _ { o } \\times c _ { i } \\times w \\times h }$ can be flatten to get $W \\in \\mathbb { R } ^ { c _ { o } \\times z }$ . Therefore, the sparse kernel can be obtained by a similar process as fully connected layers. This sparse kernel will be used for subsequent convolution operation. ",
+        "bbox": [
+            173,
+            130,
+            825,
+            228
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/1a30d3262a631b3117c1bdd1c859215c91da40701d3d06e3d4d10cd58b80a30f.jpg",
+        "image_caption": [
+            "Figure 1: Detailed structure of trainable masked layer "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            241,
+            818,
+            316
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/00542c352c49df5a1ceb9e149b18f26a83137a68ceb185bcf0327280a5c61f45.jpg",
+        "image_caption": [
+            "Figure 2: The unit step function $S ( x )$ and its derivative approximations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            376,
+            787,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to make the elements in threshold vector $\\pmb { t }$ trainable via back-propagation, the derivative of the binary step function $S ( x )$ is required. However, its original derivative is an impulse function whose value is zero almost everywhere and infinite at zero as shown in Figure 2(b). Thus the original derivative of the binary step function $S ( x )$ cannot be applied in back-propagation and parameter updating directly. Some previous works (Hubara et al. (2016); Rastegari et al. (2016); Zhou et al. (2016)) demonstrated that by providing a derivative estimation, it is possible to train networks containing such binarization function. A clip function called straight-through estimator (STE) (Bengio et al., 2013) was employed in these works and is illustrated in Figure 2(c). ",
+        "bbox": [
+            173,
+            511,
+            825,
+            625
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, Xu & Cheung (2019) discussed the derivative estimation in a balance of tight approximation and smooth back-propagation. We adopt this long-tailed higher-order estimator $H ( x )$ in our method. As shown in Figure 2(d), it has a wide active range between $[ - 1 , 1 ]$ with a non-zero gradient to avoid gradient vanishing during training. On the other hand, the gradient value near zero is a piecewise polynomial function giving tighter approximation than STE. The estimator is represented as ",
+        "bbox": [
+            174,
+            630,
+            825,
+            713
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6b12d46d99d6f672f1b04326bbbf01152ac27b2dbeeeca646ef867e3c1f20298.jpg",
+        "text": "$$\n\\frac { d } { d x } S ( x ) \\approx H ( x ) = \\left\\{ \\begin{array} { l l } { 2 - 4 | x | , } & { - 0 . 4 \\leq x \\leq 0 . 4 } \\\\ { 0 . 4 , } & { 0 . 4 < | x | \\leq 1 } \\\\ { 0 , } & { o t h e r w i s e } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            713,
+            668,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With this derivative estimator, the elements in the vector threshold $\\pmb { t }$ can be trained via backpropagation. Meanwhile, in trainable masked layers, the network parameter $W$ can receive two branches of gradient, namely the performance gradient for better model performance and the structure gradient for better sparse structure, which helps to properly update the network parameter under sparse network connectivity. The structure gradient enables the pruned (masked) weights to be updated via back-propagation. The details about the feed-forward and back-propagation of the trainable masked layer are present in Appendix A.3. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Therefore, the pruned (masked) weights, the unpruned (unmasked) weights and the elements in the threshold vector can all be updated via back-propagation at each training step. The proposed method will conduct fine-grained step-wise pruning and recovery automatically. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 SPARSE REGULARIZATION TERM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            441,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now that the thresholds of each layer are trainable, a higher percentage of pruned parameter is de  \nsired. To get the parameter masks $M$ with high sparsity, higher pruning thresholds are needed. To   \nachieve this, we add a sparse regularization term $L _ { s }$ to the training loss that penalizes the low thresh  \nold vtermwith sked layer with threshold . Thus, the sparse regulars is: $\\pmb { t } \\in \\mathbb { R } ^ { c _ { o } }$ , therm rresponding regularizationfor a deep neural network $\\begin{array} { r } { R = \\sum _ { i = 1 } ^ { c _ { o } } \\exp ( - t _ { i } ) } \\end{array}$ $L _ { s }$ $C$ ",
+        "bbox": [
+            174,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf2e1bb184620e2100c1610505a9fb3496677775130cf39790d04170989e21a1.jpg",
+        "text": "$$\nL _ { s } = \\sum _ { i = 1 } ^ { C } R _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            454,
+            212,
+            544,
+            256
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use $\\exp ( - x )$ as the regularization function since it is asymptotical to zero as $x$ increases. Consequently, it penalizes low thresholds without encouraging them to become extremely large. ",
+        "bbox": [
+            174,
+            260,
+            825,
+            287
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 DYNAMIC SPARSE TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            305,
+            413,
+            319
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The traditional fully connected, convolutional and recurrent layers can be replaced with the corresponding trainable masked layers in deep neural networks. Then we can train a sparse neural network directly with back-propagation algorithm given the training dataset $\\begin{array} { r l } { \\mathcal { D } } & { { } = } \\end{array}$ $\\{ ( { \\pmb x } _ { 1 } , { \\pmb y } _ { 1 } ) , ( { \\pmb x } _ { 2 } , { \\pmb y } _ { 2 } ) , \\cdot \\cdot \\cdot \\ , ( { \\pmb x } _ { N } , { \\pmb y } _ { N } ) \\}$ , the network parameter $W$ and the layer-wise threshold $\\pmb { t }$ as follows: ",
+        "bbox": [
+            174,
+            332,
+            821,
+            401
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5c440736ff44ceda45fcd24bcbcb962b38a4867e76da90abdc7abd1cdc194566.jpg",
+        "text": "$$\n\\mathcal { I } ( W , t ) = \\frac { 1 } { N } ( \\sum _ { i = 1 } ^ { N } \\mathcal { L } ( ( x _ { i } , y _ { i } ) ; W , t ) ) + \\alpha L _ { s }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            406,
+            653,
+            478
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } ( \\cdot )$ is the loss function, e.g. cross-entropy loss for classification and $\\alpha$ is the scaling coefficient for the sparse regularization term, which can control the percentage of parameter remaining. The sparse regularization term $L _ { s }$ tends to increase the threshold $\\pmb { t }$ for each layer thus getting higher model sparsity. However, higher sparsity tends to increase the loss function, which reversely tends to reduce the threshold and level of sparsity. Consequently, the training process of the thresholds can be regarded as a contest between the sparse regularization term and the loss function in the sense of game theory. Therefore, our method can dynamically find the sparse structure that properly balances the model sparsity and performance. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            618,
+            326,
+            633
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proposed method is evaluated on MNIST, CIFAR-10 and ImageNet with various modern network architectures including fully connected, convolutional and recurrent neural networks. To quantify the pruning performance, the layer remaining ratio is defined to be $k _ { l } = n / m$ , where $n$ is the number of elements equal to 1 in the mask $M$ and $m$ is the total number of elements in $M$ . The model remaining ratio $k _ { m }$ is the overall ratio of the non-zero elements in the parameter masks for all trainable masked layers. The model remaining percentage is defined as $k _ { m } \\times \\mathrm { 1 0 0 \\% }$ . For all trainable masked layers, the trainable thresholds are initialized to zero since it is assumed that originally the network is dense. The detailed experimental setup is present in Appendix A.1. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            761
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 PRUNING PERFORMANCE ON VARIOUS DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            779,
+            549,
+            792
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "MNIST. Table 1 presents the pruning results of proposed method for Lenet-300-100 (LeCun et al., 1998), Lenet-5-Caffe and LSTM (Hochreiter & Schmidhuber, 1997). Both LSTM models have two LSTM layers with hidden size 128 for LSTM-a and 256 for LSTM-b. Our method can prune almost $98 \\%$ parameter with little loss of performance on Lenet-300-100 and Lenet-5-Caffe. For the LSTM models adapted for the sequential MNIST classification, our method can find sparse models with better performance than dense baseline with over $9 9 \\%$ parameter pruned. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10. The pruning performance of our method on CIFAR-10 is tested on VGG (Simonyan & Zisserman, 2014) and WideResNet (Zagoruyko & Komodakis, 2016). We compare our method ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/4dc4244854205753fa38f3b6357eec4908fd774a4c2be4363037f49424bfb306.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: The pruning results on MNIST for various architectures "
+        ],
+        "table_body": "<table><tr><td>Architecture</td><td>Dense Baseline (%)</td><td>Model Remaining Percentage (%)</td><td>Sparse Accuracy (%)</td><td>Difference</td></tr><tr><td>Lenet-300-100</td><td>98.16 ± 0.06</td><td>2.48 ± 0.21</td><td>97.69±0.14</td><td>-0.47</td></tr><tr><td>Lenet-5-Caffe</td><td>99.18 ± 0.05</td><td>1.64 ± 0.13</td><td>99.11±0.07</td><td>-0.07</td></tr><tr><td>LSTM-a</td><td>98.64 ± 0.12</td><td>1.93 ± 0.03</td><td>98.70±0.06</td><td>+0.06</td></tr><tr><td>LSTM-b</td><td>98.87 ± 0.07</td><td>0.98 ± 0.04</td><td>98.89±0.11</td><td>+0.02</td></tr></table>",
+        "bbox": [
+            173,
+            102,
+            825,
+            193
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9dc0b6512aa6cba08c35657bd1521694571f8de84ff63e70e054c21b0c80259b.jpg",
+        "table_caption": [
+            "with other sparse learning algorithms on CIFAR-10 as presented in Table 2. The state-of-the-art algorithms, DSR (Mostafa & Wang, 2019) and Sparse momentum (Dettmers & Zettlemoyer, 2019), are selected for comparison. Dynamic Sparse Training (DST) outperforms them in almost all the settings as present in Table 2. ",
+            "Table 2: Comparison with other sparse training methods on CIFAR-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture</td><td>Method</td><td>Dense baseline</td><td>Model Remaining Percentage (%)</td><td>Sparse Accuracy</td><td>Difference</td></tr><tr><td rowspan=\"3\">VGG-16</td><td rowspan=\"2\">Sparse Momentum</td><td rowspan=\"2\">93.51 ± 0.05</td><td>10</td><td>93.36± 0.04</td><td>-0.15</td></tr><tr><td>5</td><td>93.00 ± 0.07</td><td>-0.51</td></tr><tr><td rowspan=\"2\">DST (Ours)</td><td rowspan=\"2\">93.75 ± 0.21</td><td>8.82 ± 0.34</td><td>93.93 ± 0.05</td><td>+0.18</td></tr><tr><td>3.76 ± 0.53</td><td>93.02 ± 0.37</td><td>-0.73</td></tr><tr><td rowspan=\"5\">WideResNet-16-8</td><td rowspan=\"2\">Sparse Momentum</td><td rowspan=\"2\">95.43 ± 0.02</td><td>10</td><td>94.87 ± 0.04</td><td>-0.56</td></tr><tr><td>5</td><td>94.38 ± 0.05</td><td>-1.05</td></tr><tr><td rowspan=\"2\">DSR</td><td rowspan=\"2\">95.21± 0.05</td><td>10</td><td>94.93 ± 0.04</td><td>-0.28</td></tr><tr><td>5</td><td>94.68 ± 0.05</td><td>-0.53</td></tr><tr><td rowspan=\"2\">DST (Ours)</td><td rowspan=\"2\">95.18 ± 0.06</td><td>9.86± 0.22</td><td>95.05 ± 0.08</td><td>-0.13</td></tr><tr><td>4.64 ± 0.15</td><td>94.73 ± 0.11</td><td>-0.45</td></tr></table>",
+        "bbox": [
+            173,
+            324,
+            825,
+            474
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/d79c792b92ce3622779b0eaebc7756a56266ec15578bb9024f11f96ec645757a.jpg",
+        "table_caption": [
+            "ImageNet. For ResNet-50 on ImageNet (ILSVRC2012), we present the performance and comparison with other methods in Table 3. Dynamic Sparse Training (DST) achieves better top-1 and top-5 accuracy with slightly higher model sparsity. The number of parameters for the dense ResNet-50 model is $2 5 . 5 6 \\mathrm { M }$ . ",
+            "Table 3: Comparison with other sparse training methods for ResNet-50 on ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Dense baseline Top-1 /Top-5 (%)</td><td>Model Remaining Percentage (%)</td><td>Sparse accuracy Top-1/Top-5(%)</td><td>Difference</td><td>Remaining number of parameters</td></tr><tr><td>Sparse Momentum</td><td>74.90 /92.40</td><td>20 10</td><td>73.80/91.80 72.30 /91.00</td><td>-1.10/-0.60 -2.60 / -1.40</td><td>5.12M 2.56M</td></tr><tr><td>DSR</td><td>74.90 / 92.40</td><td>20 10</td><td>73.30/92.40 71.60 / 90.50</td><td>-1.60/+0.00 -3.30 /-1.90</td><td>5.14M 2.56M</td></tr><tr><td>DST (Ours)</td><td>74.95 /92.60</td><td>19.24 9.87</td><td>74.02/92.49 72.78 /91.53</td><td>-0.73/-0.11 -2.17 / -1.07</td><td>5.08M 2.49M</td></tr></table>",
+        "bbox": [
+            173,
+            593,
+            823,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 PRUNING PERFORMANCE ON VARIOUS REMAINING RATIO ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            757,
+            611,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "By varying the scaling coefficient $\\alpha$ for sparse regularization term, we can control the model remaining ratios of sparse models generated by dynamic sparse training. The relationships between $\\alpha$ , model remaining ratio and sparse model accuracy of VGG, WideResNet-16-8 and WideResNet-28-8 on CIFAR-10 are presented in Figure 3. As demonstrated, the model remaining ratio keeps decreasing with increasing $\\alpha$ . With a moderate $\\alpha$ value, it is easy to obtain a sparse model with comparable or even higher accuracy than the dense counterpart. On the other side, if the $\\alpha$ value is too large that makes the model remaining percentage less than $5 \\%$ , there will be a noticeable accuracy drop. As demonstrated in Figure 3, the choice of $\\alpha$ ranges from $1 0 ^ { - 9 }$ to $1 0 ^ { - 4 }$ . Depending on the application scenarios, we can either get models with similar or better performance as dense counterparts by a relatively small $\\alpha$ or get a highly sparse model with little performance loss by a larger $\\alpha$ . ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c61539f18d580e8692dab1995bd784ceeeb3706bef4c1300337ea4e499c975c.jpg",
+        "image_caption": [
+            "Figure 3: Test accuracy of sparse model on CIFAR-10 and model remaining ratio for different $\\alpha$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            99,
+            825,
+            244
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            294,
+            310,
+            310
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 FINE-GRAINED STEP-WISE PRUNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            325,
+            465,
+            339
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 4(a) demonstrates the change of layer remaining ratios for Lenet-300-100 trained with DST at each training step during the first training epoch. And Figure 4(b) presents the change of layer remaining ratios during the whole training process (20 epochs). As present in these two figures, instead of decreasing by manually set fixed step size as in other pruning methods, our method makes the layer remaining ratios change smoothly and continuously at each training step. Meanwhile, as shown in Figure 4(a), the layer remaining ratios fluctuate dynamically within the first 100 training steps, which indicates that DST can achieve step-wise fine-grained pruning and recovery. ",
+        "bbox": [
+            173,
+            351,
+            825,
+            449
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Meanwhile, for multilayer neural networks, the parameters in different layers will have different relative importance. For example, Lenet-300-100 has three fully connected layers. Changing the parameter of the last layer (layer 3) can directly affect the model output. Thus, the parameter of layer 3 should be pruned more carefully. The input layer (layer 1) has the largest amount of parameters and takes the raw image as input. Since the images in MNIST dataset consist of many unchanged pixels (the background) that have no contribution to the classification process, it is expected that the parameters that take these invariant background pixels as input can be pruned safely. Therefore, the remaining ratio should be the highest for layer 3 and the lowest for layer 1 if a Lenet-300-100 model is pruned. To check the pruning effect of our method on these three layers, Lenet-300-100 model is sparsely trained by the default hyperparameters setting present in Appendix A.1. The pruning trends of these three layers during dynamic sparse training are present in Figure 4(b). During the whole sparse training process, the remaining ratios of layer 1 and layer 2 keep decreasing and the remaining ratio of layer 3 maintains to be 1 after the fluctuation during the first epoch. The remaining ratio of layer 1 is the lowest and decrease to less than $10 \\%$ quickly, which is consistent with the expectation. In the meantime, the test accuracy of the sparse model is almost the same as the test accuracy on the dense model in the whole training process. This indicates that our method can properly balance the model remaining ratio and the model performance by continuous fine-grained pruning throughout the entire sparse training procedure. A similar training tendency can be observed in other network architectures. The detailed results for other architectures are present in Appendix A.4. ",
+        "bbox": [
+            173,
+            455,
+            825,
+            719
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5f8e480c791c6d048d65e1561d679279ae15b6e7f7e8bbf609861e3f68b5c48d.jpg",
+        "image_caption": [
+            "Figure 4: Change of layer remaining ratio, model remaining ratio and test accuracy for Lenet-300-100 with $\\alpha = 0 . 0 0 0 5$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            737,
+            823,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/cc44288b6a9427a21a49cac2a556f7f939a2cbd9ee0846387d9c3f3827d168cc.jpg",
+        "image_caption": [
+            "Figure 5: VGG-16 trained with initial learning rate 0.1 and $\\alpha = 5 \\times 1 0 ^ { - 6 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            135,
+            825,
+            338
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c246b41f6c4afabe5b70793f11cc4b0fa272caece27311436307d38925309ce0.jpg",
+        "image_caption": [
+            "Figure 6: VGG-16 trained with initial learning rate 0.01 and $\\alpha = 5 \\times 1 0 ^ { - 6 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            385,
+            825,
+            589
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Dynamic adjustment regarding learning rate decay. To achieve better performance, it is a common practice to decay the learning rate several times during the training process of deep neural networks. Usually, the test accuracy will decrease immediately just after the learning rate decay and then tend toward flatness. A similar phenomenon is observed for VGG-16 on CIFAR-10 trained by DST as present in Figure 5(b), where the learning rate decay from 0.1 to 0.01 at 80 epoch. ",
+        "bbox": [
+            174,
+            631,
+            823,
+            702
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Like the layer 3 of Lenet-300-100, the second fully connected layer (FC 2) of VGG-16 is the output layer, hence its remaining ratio is expected to be relatively high. But a surprising observation is that the remaining ratio of FC 2 is quite low at around 0.1 for the first 80 epochs and increases almost immediately just after the 80 epoch as present in Figure 5(a). We suppose that this is caused by the decay of the learning rate from 0.1 to 0.01 at 80 epoch. Before the learning rate decay, the layers preceding the output layer fail to extract enough useful features for classification due to the relatively coarse-grained parameter adjustment incurred by high learning rate. This means that the corresponding parameters that take those useless features as input can be pruned, which leads to the low remaining ratio of the output layer. The decayed learning rate enables a finegrained parameter update that makes the neural network model converge to the good local minima quickly (Kawaguchi, 2016), where most of the features extracted by the preceding layers turn to be helpful for the classification. This makes previously unimportant network connections in the output layer become important thus the remaining ratio of this layer gets an abrupt increase. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "There are two facts that support our assumptions for this phenomenon. The first fact is the sudden increase of the test accuracy from around $8 5 \\%$ to over $92 \\%$ just after the learning rate decay. ",
+        "bbox": [
+            174,
+            896,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Secondly, the remaining ratios of the preceding convolutional layers are almost unchanged after the remaining ratio of the output layer increases up to 1, which means that the remaining parameters in these layers are necessary to find the critical features. The abrupt change of the remaining ratio of the output layer indicates that our method can dynamically adjust the pruning schedule regarding the change of hyperparameters during the training process. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dynamic adjustment regarding different initial learning rate. To further investigate the effect of the learning rate, the VGG-16 model is trained by a different initial learning rate (0.01) with other hyperparameters unchanged. The corresponding training curves are presented in Figure 6. As shown in Figure 6(a), the remaining ratio of FC 2 increases up to 1 after around 40 epochs when the test accuracy reaches over $90 \\%$ . This means that with the proper update of network parameters due to a smaller initial learning rate, the layers preceding the output layer (FC 2) tend to extract useful features before the learning rate decay. It can be observed in Figure 6(b) that the test accuracy only increases about $2 \\%$ from $90 \\%$ to $92 \\%$ roughly after the learning rate decay at the 80 epoch. Meanwhile, one can see that our method adopts a different pruning schedule regarding different initial choices of training hyperparameters. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            319
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Model performance under dynamic schedule. Figure 5(b) and Figure 6(b) show the model remaining ratio, test accuracy of sparse model (sparse accuracy) and test accuracy of dense counterparts (dense accuracy) after each epoch during the whole training process. For the sparse model trained with initial learning rate 0.1, the final model remaining percentage is $8 . 8 2 \\%$ . The test accuracy of this sparse model is $9 3 . 9 3 \\%$ , which is better than $9 3 . 7 5 \\%$ of the dense counterparts. Similarly, for the sparse model trained with initial learning rate 0.01, the final model remaining percentage is $1 2 . 4 5 \\%$ . The test accuracy of this sparse model is $9 2 . 7 4 \\%$ , which is also better than $9 2 . 5 4 \\%$ of the dense model. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            438
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Considering the model performance during the whole training process, when trained with initial learning rate 0.01, the sparse accuracy is consistently higher than dense accuracy during the whole training process as present in Figure 6(b). Meanwhile, one can see from Figure 5(b) that the running average of sparse accuracy is also higher than that of dense accuracy during the whole training process when the initial learning rate is 0.1. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            513
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 INFORMATION REVEALED FROM CONSISTENT SPARSE PATTERN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            650,
+            549
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Many works have tried to design more compact models with mimic performance to overparameterized models (He et al., 2016; Howard et al., 2017; Zhang et al., 2018). Network architecture search has been viewed as the future paradigm of deep neural network design. However, it is extremely difficult to determine whether the designed layer consists of redundancy. Therefore, typical network architecture search methods rely on evolutionary algorithms (Liu et al., 2017) or reinforcement learning (Baker et al., 2016), which is extremely time-consuming and computationally expensive. Network pruning can actually be reviewed as a kind of architecture search process (Liu et al., 2018; Frankle & Carbin, 2018) thus the sparse structure revealed from network pruning may provide some guidance to the network architecture design. However, The layer-wise equal remaining ratio generated by the unified pruning strategy fails to indicate the different degrees of redundancy for each layer. And the global pruning algorithm is non-robust, which fails to offer consistent guidance. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            728
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Here we demonstrate another interesting observation called consistent sparse pattern during dynamic sparse training that provides useful information about the redundancy of individual layers as the guidance for compact network architecture design. For the same architecture trained by our method with various $\\alpha$ values, the relative relationship of sparsity among different layers keeps consistent. The sparse patterns of VGG-16 on CIFAR-10 are present in Figure 7 with three different $\\alpha$ . ",
+        "bbox": [
+            174,
+            736,
+            823,
+            805
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In all configurations, the last four convolutional layers (Conv 10-13) and the first fully connected layers (FC 1) are highly sparse. Meanwhile, some layers (Conv 3-7, FC 2) keep a high amount of parameters after pruning. This consistent sparse pattern indicates that these heavily pruned layers consist of high redundancy and a large number of parameters can be reduced in these layers to get more compact models. This phenomenon also exists in other network architectures, which is present in detail in the appendix A.5. Therefore, with this consistent sparse pattern, after designing a new network architecture, our method can be applied to get useful information about the layer-wise redundancy in this new architecture. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/10f5ddda65068c3259a8f0526be4cbb8ea0e91f35ef9052dc978046618fa3dae.jpg",
+        "image_caption": [
+            "Figure 7: The sparse pattern and percentage of parameter remaining for different choices of $\\alpha$ on VGG-16 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            101,
+            818,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            296,
+            318,
+            313
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We propose Dynamic Sparse Training (DST) with trainable masked layers that enables direct training of sparse models with trainable pruning thresholds. DST can be easily applied to various types of neural network layers and architectures to get a highly sparse or better-performed model than dense counterparts. With the ability to reveal the consistent sparse pattern, our method can also provide useful guidance to the design of the more compact network. ",
+        "bbox": [
+            174,
+            328,
+            825,
+            398
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            419,
+            285,
+            434
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. arXiv preprint arXiv:1611.02167, 2016. ",
+        "bbox": [
+            174,
+            443,
+            823,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Bellec, David Kappel, Wolfgang Maass, and Robert Legenstein. Deep rewiring: Training very sparse deep networks. arXiv preprint arXiv:1711.05136, 2017. ",
+        "bbox": [
+            176,
+            481,
+            820,
+            511
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Nicholas Leonard, and Aaron Courville. Estimating or propagating gradients ´ through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013. ",
+        "bbox": [
+            176,
+            520,
+            820,
+            549
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tim Dettmers and Luke Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. arXiv preprint arXiv:1907.04840, 2019. ",
+        "bbox": [
+            174,
+            559,
+            821,
+            588
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. arXiv preprint arXiv:1803.03635, 2018. ",
+        "bbox": [
+            173,
+            597,
+            821,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. In Advances In Neural Information Processing Systems, pp. 1379–1387, 2016. ",
+        "bbox": [
+            176,
+            635,
+            823,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015. ",
+        "bbox": [
+            174,
+            674,
+            823,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            712,
+            823,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yang He, Guoliang Kang, Xuanyi Dong, Yanwei Fu, and Yi Yang. Soft filter pruning for accelerating deep convolutional neural networks. arXiv preprint arXiv:1808.06866, 2018. ",
+        "bbox": [
+            171,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017. ",
+        "bbox": [
+            174,
+            842,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks. In Advances in neural information processing systems, pp. 4107–4115. 2016. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kenji Kawaguchi. Deep learning without poor local minima. In Advances in neural information processing systems, pp. 586–594, 2016.   \nDiederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \nYann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems, pp. 598–605, 1990.   \nYann LeCun, Leon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied ´ to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   \nHao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016.   \nHanxiao Liu, Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, and Koray Kavukcuoglu. Hierarchical representations for efficient architecture search. arXiv preprint arXiv:1711.00436, 2017.   \nZhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. arXiv preprint arXiv:1810.05270, 2018.   \nDecebal Constantin Mocanu, Elena Mocanu, Peter Stone, Phuong H Nguyen, Madeleine Gibescu, and Antonio Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature communications, 9(1):2383, 2018.   \nDmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2498–2507. JMLR. org, 2017.   \nPavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference. arXiv preprint arXiv:1611.06440, 2016.   \nHesham Mostafa and Xin Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization. arXiv preprint arXiv:1902.05967, 2019.   \nSharan Narang, Erich Elsen, Gregory Diamos, and Shubho Sengupta. Exploring sparsity in recurrent neural networks. arXiv preprint arXiv:1704.05119, 2017.   \nMohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision (ECCV), pp. 525–542. Springer, 2016.   \nKaren Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   \nZhe Xu and Ray C. C. Cheung. Accurate and compact convolutional neural networks with trained binarization. In British Machine Vision Conference (BMVC), 2019.   \nRuichi Yu, Ang Li, Chun-Fu Chen, Jui-Hsin Lai, Vlad I Morariu, Xintong Han, Mingfei Gao, ChingYung Lin, and Larry S Davis. Nisp: Pruning networks using neuron importance score propagation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9194– 9203, 2018.   \nSergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   \nXiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 6848–6856, 2018.   \nShuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016. ",
+        "bbox": [
+            169,
+            61,
+            826,
+            931
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            377,
+            150
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "MNIST: LeNet-300-100 and LeNet-5-Caffe are trained using SGD with a momentum of 0.9 and the batch size of 64 with 20 training epochs. The learning rate is 0.01 without learning rate decay. Meanwhile, the default scaling factor $\\alpha$ for sparse regularization term is 0.0005 for both network architectures. LSTM models are trained using Adam optimization scheme (Kingma & Ba, 2014) with default Adam hyperparameter setting for 20 epochs. The batch size is 100 and the default learning rate is 0.001. Meanwhile, the default scaling factor $\\alpha$ for sparse regularization term is 0.001. ",
+        "bbox": [
+            173,
+            162,
+            825,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10 Models on CIFAR-10 are trained using SGD with momentum 0.9 and batch size of 64 with 160 training epochs. The initial learning rate is 0.1 and decayed by 0.1 at 80 and 120 epoch. The default scaling factor $\\alpha$ for sparse regularization term is $5 \\times 1 0 ^ { - 6 }$ for all tested architectures. ",
+        "bbox": [
+            176,
+            267,
+            821,
+            309
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "ImageNet. ResNet-50 models are trained using SGD with momentum 0.9 and batch size of 1024 with 90 training epochs. The default initial learning rate is 0.1 and decayed by 10 at 30, 60, 80 epochs. ",
+        "bbox": [
+            174,
+            315,
+            823,
+            358
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For all trainable masked layers, the trainable thresholds are initialized to zero. Additionally, we find that an extremely high scaling coefficient $\\alpha$ will make the sparse regularization term dominates the training loss thus making the mask $M$ to be all zero in a certain layer, which may impede the training process. To prevent this, the pruning threshold $\\pmb { t }$ will be reset to zero if more than $9 9 \\%$ elements in the mask are zero in a certain layer despite the LSTM models. This mechanism makes the training process smoother and enables a wider range choice of $\\alpha$ . ",
+        "bbox": [
+            173,
+            364,
+            825,
+            449
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 ANALYSIS OF DIFFERENT THRESHOLD CHOICES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            469,
+            547,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Beside a threshold vector, a threshold scalar $t$ or threshold matrix $\\pmb { T } \\in \\mathbb { R } ^ { c _ { o } \\times c _ { i } }$ can also be adopted for each trainable masked layer with parameter $W \\in \\mathbb { R } ^ { c _ { o } \\times c _ { i } }$ . ",
+        "bbox": [
+            173,
+            496,
+            823,
+            525
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fef2179c761e6b8fc79456e78b4c1551a14ba59b523c0cbd85949411fbfb93e8.jpg",
+        "text": "$$\nQ _ { i j } = \\left\\{ { \\begin{array} { l l } { | W _ { i j } | - t , } & { { \\mathrm { f o r ~ t h r e s h o l d ~ s c a l a r } } } \\\\ { | W _ { i j } | - T _ { i j } , } & { { \\mathrm { f o r ~ t h r e s h o l d ~ m a t r i x } } } \\end{array} } \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            546,
+            647,
+            583
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "All three choices of trainable thresholds are tested on various architectures. Considering the effects on network pruning, the matrix threshold has almost the same model remaining ratio compared with the vector threshold. The scalar threshold is less robust than the vector and matrix threshold. In terms of the storage overhead, the matrix threshold almost doubles the amount of parameter during the training process in each architecture. Meanwhile, the vector threshold only adds less than $1 \\%$ additional network parameter. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            680
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The extra trainable threshold will also bring additional computation. In both feed-forward and backpropagation phase, the additional computations are matrix-element-wise operations $( \\mathcal { O } ( n ^ { 2 } ) )$ , which is apparently light-weighted compared to the original batched matrix multiplication $( \\mathcal { O } ( n ^ { 3 } ) )$ . For practical deployment, only the masked parameter $W \\odot M$ needs to be stored, thus no overhead will be introduced. Therefore, considering the balance between the overhead and the benefit incurred by these three choices, the vector threshold is chosen for trainable masked layers. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            771
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 MORE DETAILS ABOUT THE TRAINABLE MASKED LAYER ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            791,
+            607,
+            805
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Feed forward process. Considering a single layer in deep neural network with input $_ { \\textbf { \\em x } }$ and dense parameter $W$ . The normal layer will conduct matrix-vector multiplication as $W x$ or convolution as $C o n v ( \\pmb { W } , \\pmb { x } )$ . In trainable masked layers, since a sparse mask $M$ is obtained for each layer. The sparse parameter $W \\odot M$ will be adopted in the corresponding matrix-vector multiplication or convolution as $( W \\odot M ) x$ and $C o n v ( \\pmb { W } \\odot \\pmb { M } , \\pmb { x } )$ . ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Back-propagation process. Referring to Figure 1, we denote $P = W \\odot M$ and the gradient received by $_ { r }$ in back-propagation as $d \\mathbf { } P$ . Considering the gradients from right to left: ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• The performance gradient is $d P \\odot M$   \n• The gradient received by $M$ is $d P \\odot W$   \n• The gradient received by $Q$ is $d P \\odot W \\odot H ( Q )$ , where $H ( Q )$ is the result of $H ( x )$ applied to $Q$ elementwisely.   \n• The structure gradient is $d P \\odot W \\odot H ( Q ) \\odot s g n ( W )$ , where $s g n ( W )$ is the result of sign function applied to $W$ elementwisely.   \n$\\bullet$ The gradient received by the vector threshold $\\pmb { t }$ is $d t \\in \\mathbb { R } ^ { c _ { o } }$ . We denote $d \\pmb { T } = - d \\pmb { P } \\odot \\pmb { W } \\odot \\pmb { H } ( \\pmb { Q } )$ , then $\\bar { d \\mathbf { T } } \\in \\mathbb { R } ^ { c _ { o } \\times c _ { i } }$ . And we will have $\\begin{array} { r } { d \\pmb { t } _ { i } = \\sum _ { j = 1 } ^ { c _ { i } } \\pmb { T } _ { i j } } \\end{array}$ for $1 \\leq i \\leq c _ { o }$ .   \n• The gradient received by the parameter $W$ is $d \\pmb { W } = d \\pmb { P } \\odot \\pmb { M } + d \\pmb { P } \\odot \\pmb { W } \\odot \\pmb { H } ( \\pmb { Q } ) \\odot s g n ( \\pmb { W } )$ ",
+        "bbox": [
+            173,
+            103,
+            826,
+            233
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Since we add $\\ell _ { 2 }$ regularization in the training process, all the elements in $W$ are distributed within $[ - 1 , 1 ]$ . Meanwhile, almost all the elements in the vector threshold are distributed within $[ 0 , 1 ]$ . The exceptions are the situation as shown in Figure 3(a) and Figure 4(a) where the last layer get no weight pruned (masked). Regarding the process of getting $Q$ , all the elements in $Q$ are within $[ - 1 , 1 ]$ . Therefore $H ( Q )$ is a dense matrix. Then $W$ , $H ( Q )$ and $s g n ( W )$ are all dense matrices and the pruned (masked) weights can receive the structure gradient $d \\pmb { P } \\odot \\pmb { W } \\odot \\pmb { H } ( \\pmb { Q } ) \\odot s g n ( \\pmb { W } )$ ",
+        "bbox": [
+            173,
+            238,
+            825,
+            321
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.4 CHANGE OF REMAINING RATIO IN OTHER NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            369,
+            699,
+            383
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Here we present the change of remaining ratios during dynamic sparse training for the other tested architectures. Since WideResNet models only have one fully connected layer at the end as the output layer, the first five convolutional layers and the last fully connected layer are present. Figure 8 demonstrates the corresponding result for WideResNet-16-8. Figure 9 demonstrates the corresponding result for WideResNet-16-10. And Figure 10 demonstrates the corresponding result for WideResNet-28-8. The similar phenomenon can be observed in all these three network architectures for various $\\alpha$ . ",
+        "bbox": [
+            173,
+            406,
+            825,
+            505
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.5 CONSISTENT SPARSE PATTERN IN OTHER NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            553,
+            694,
+            565
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Here we present the consistent sparse pattern for the other tested architectures. Figure 11 demonstrates the corresponding result for WideResNet-16-8. And Figure 12 demonstrates the corresponding result for WideResNet-16-10. ",
+        "bbox": [
+            176,
+            589,
+            823,
+            632
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb7c94e0e231291b6d31d15359af27aa66a6711ea15116c488bc9ea0870db207.jpg",
+        "image_caption": [
+            "Figure 8: WideResNet-16-8 trained by dynamic sparse training with $\\alpha = 1 0 ^ { - 5 }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            674,
+            761,
+            861
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/1298886cbe35f9f5e8bd746359f67911ce7d3e935e09e63fa4eacb6a069b4840.jpg",
+        "image_caption": [
+            "Figure 9: WideResNet-16-10 trained by dynamic sparse training with $\\alpha = 1 0 ^ { - 5 }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            103,
+            761,
+            289
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/e515b67993a03631126f0414b14dec1192f1d7926b9aacdb123782958f69680f.jpg",
+        "image_caption": [
+            "Figure 10: WideResNet-28-8 trained by dynamic sparse training with $\\alpha = 1 0 ^ { - 5 }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            332,
+            761,
+            517
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/50c70ae28b6d6e66b8741f86a16ba1da2e71a2f3e12c17b98e2f20fee506fb60.jpg",
+        "image_caption": [
+            "Figure 11: The sparse pattern and percentage of parameter remaining for different choices of $\\alpha$ on WRN-16-8 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            556,
+            767,
+            689
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/e4d31fb0f04b9cfa5f9c696468ef07d2168fd0155d6b7edb8f6b6ccd35d7eba9.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            737,
+            767,
+            871
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 12: The sparse pattern and percentage of parameter remaining for different choices of $\\alpha$ on WRN-16-10 ",
+        "bbox": [
+            171,
+            881,
+            823,
+            895
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rJed6j0cKX/rJed6j0cKX.md

@@ -0,0 +1,431 @@
+# Analyzing Inverse Problems with Invertible Neural Networks
+
+Lynton Ardizzone1, Jakob Kruse $^ { 1 }$ , Sebastian Wirkert $^ 2$ , Daniel Rahner3, Eric W. Pellegrini $^ { 3 }$ , Ralf S. Klessen $^ { 3 }$ , Lena Maier-Hein $^ 2$ , Carsten Rother $^ { 1 }$ , Ullrich Köthe1 1Visual Learning Lab Heidelberg, $^ 2$ German Cancer Research Center (DKFZ), 3Zentrum für Astronomie der Universität Heidelberg (ZAH) 1lynton.ardizzone@iwr.uni-heidelberg.de, 2s.wirkert@dkfz-heidelberg.de, 3daniel.rahner@uni-heidelberg.de
+
+# Abstract
+
+For many applications, in particular in natural science, the task is to determine hidden system parameters from a set of measurements. Often, the forward process from parameter- to measurement-space is well-defined, whereas the inverse problem is ambiguous: multiple parameter sets can result in the same measurement. To fully characterize this ambiguity, the full posterior parameter distribution, conditioned on an observed measurement, has to be determined. We argue that a particular class of neural networks is well suited for this task – so-called Invertible Neural Networks (INNs). Unlike classical neural networks, which attempt to solve the ambiguous inverse problem directly, INNs focus on learning the forward process, using additional latent output variables to capture the information otherwise lost. Due to invertibility, a model of the corresponding inverse process is learned implicitly. Given a specific measurement and the distribution of the latent variables, the inverse pass of the INN provides the full posterior over parameter space. We prove theoretically and verify experimentally, on artificial data and real-world problems from medicine and astrophysics, that INNs are a powerful analysis tool to find multi-modalities in parameter space, uncover parameter correlations, and identify unrecoverable parameters.
+
+# 1 Introduction
+
+When analyzing complex physical systems, a common problem is that the system parameters of interest cannot be measured directly. For many of these systems, scientists have developed sophisticated theories on how measurable quantities y arise from the hidden parameters $\mathbf { x }$ We will call such mappings the forward process. However, the inverse process is required to infer the hidden states of a system from measurements. Unfortunately, the inverse is often both intractable and ill-posed, since crucial information is lost in the forward process.
+
+To fully assess the diversity of possible inverse solutions for a given measurement, an inverse solver should be able to estimate the complete posterior of the parameters, conditioned on an observation. This makes it possible to quantify uncertainty, reveal multi-modal distributions, and identify degenerate and unrecoverable parameters – all highly relevant for applications in natural science. In this paper, we ask if invertible neural networks (INNs) are a suitable model class for this task. INNs are characterized by three properties:
+
+(i) The mapping from inputs to outputs is bijective, i.e. its inverse exists, (ii) both forward and inverse mapping are efficiently computable, and (iii) both mappings have a tractable Jacobian, which allows explicit computation of posterior probabilities.
+
+Networks that are invertible by construction offer a unique opportunity: We can train them on the well-understood forward process $\mathbf x \to \mathbf y$ and get the inverse $\mathbf y \to \mathbf x$ for free by running them backwards at prediction time. To counteract the inherent information loss of the forward process, we introduce additional latent output variables $\mathbf { z }$ , which capture the information about $\mathbf { x }$ that is not contained in $\mathbf { y }$ . Thus, our INN learns to associate hidden parameter values $\mathbf { x }$ with unique pairs $\displaystyle [ \mathbf { y } , \mathbf { z } ]$ of measurements and latent variables. Forward training optimizes the mapping $[ { \bf y } , { \bf z } ] = f ( { \bf x } )$ and implicitly determines its inverse $\mathbf { x } = f ^ { - 1 } ( \mathbf { y } , \mathbf { z } ) = g ( \mathbf { y } , \mathbf { z } )$ . Additionally, we make sure that the density $p ( \mathbf { z } )$ of the latent variables is shaped as a Gaussian distribution. Thus, the INN represents the desired posterior $p ( \mathbf { x } | \mathbf { y } )$ by a deterministic function $\mathbf { x } = g ( \mathbf { y } , \mathbf { z } )$ that transforms (“pushes”) the known distribution $p ( \mathbf { z } )$ to $\mathbf { x }$ -space, conditional on $\mathbf { y }$ .
+
+![](images/cdd7bfb80080b967e26b65cefa9c788cb08794ed93214521264a321e9fc060dc.jpg)  
+Figure 1: Abstract comparison of standard approach (left) and ours (right). The standard direct approach requires a discriminative, supervised loss (SL) term between predicted and true $\mathbf { x }$ , causing problems when $\mathbf y \to \mathbf x$ is ambiguous. Our network uses a supervised loss only for the well-defined forward process $\mathbf x \to \mathbf y$ . Generated $\mathbf { x }$ are required to follow the prior $p ( \mathbf { x } )$ by an unsupervised loss (USL), while the latent variables $\mathbf { z }$ are made to follow a Gaussian distribution, also by an unsupervised loss. See details in Section 3.3.
+
+Compared to standard approaches (see Fig. 1, left), INNs circumvent a fundamental difficulty of learning inverse problems: Defining a sensible supervised loss for direct posterior learning is problematic since it requires prior knowledge about that posterior’s behavior, constituting a kind of hen-end-egg problem. If the loss does not match the possibly complicated (e.g. multimodal) shape of the posterior, learning will converge to incorrect or misleading solutions. Since the forward process is usually much simpler and better understood, forward training diminishes this difficulty. Specifically, we make the following contributions:
+
+• We show that the full posterior of an inverse problem can be estimated with invertible networks, both theoretically in the asymptotic limit of zero loss, and practically on synthetic and real-world data from astrophysics and medicine. • The architectural restrictions imposed by invertibility do not seem to have detrimental effects on our network’s representational power. While forward training is sufficient in the asymptotic limit, we find that a combination with unsupervised backward training improves results on finite training sets. • In our applications, our approach to learning the posterior compares favourably to approximate Bayesian computation (ABC) and conditional VAEs. This enables identifying unrecoverable parameters, parameter correlations and multimodalities.
+
+# 2 Related work
+
+Modeling the conditional posterior of an inverse process is a classical statistical task that can in principle be solved by Bayesian methods. Unfortunately, exact Bayesian treatment of real-world problems is usually intractable. The most common (but expensive) solution is to resort to sampling, typically by a variant of Markov Chain Monte Carlo (Robert and Casella, 2004; Gamerman and Lopes, 2006). If a model $\mathbf { y } = s ( \mathbf { x } )$ for the forward process is available, approximate Bayesian computation (ABC) is often preferred, which embeds the forward model in a rejection sampling scheme for the posterior $p ( \mathbf { x } | \mathbf { y } )$ (Sunnåker et al., 2013; Lintusaari et al., 2017; Wilkinson, 2013).
+
+Variational methods offer a more efficient alternative, approximating the posterior by an optimally chosen member of a tractable distribution family (Blei et al., 2017). Neural networks can be trained to predict accurate sufficient statistics for parametric posteriors (Papamakarios and Murray, 2016; Siddharth et al., 2017), or can be designed to learn a mean-field distribution for the network’s weights via dropout variational inference (Gal and Ghahramani, 2015; Kingma et al., 2015). Both ideas can be combined (Kendall and Gal, 2017) to differentiate between data-related and model-related uncertainty. However, the restriction to limited distribution families fails if the true distribution is too complex (e.g. when it requires multiple modes to represent ambiguous or degenerate solutions) and essentially counters the ability of neural networks to act as universal approximators. Conditional GANs (cGANs; Mirza and Osindero, 2014; Isola et al., 2017) overcome this restriction in principle, but often lack satisfactory diversity in practice (Zhu et al., 2017b). For our tasks, conditional variational autoencoders (cVAEs; Sohn et al., 2015) perform better than cGANs, and are also conceptually closer to our approach (see appendix Sec. 2), and hence serve as a baseline in our experiments.
+
+Generative modeling via learning of a non-linear transformation between the data distribution and a simple prior distribution (Deco and Brauer, 1995; Hyvärinen and Pajunen, 1999) has the potential to solve these problems. Today, this approach is often formulated as a normalizing flow (Tabak et al., 2010; Tabak and Turner, 2013), which gradually transforms a normal density into the desired data density and relies on bijectivity to ensure the mapping’s validity. These ideas were applied to neural networks by Deco and Brauer (1995); Rippel and Adams (2013); Rezende and Mohamed (2015) and refined by Tomczak and Welling (2016); Berg et al. (2018); Trippe and Turner (2018). Today, the most common realizations use auto-regressive flows, where the density is decomposed according to the Bayesian chain rule (Kingma et al., 2016; Huang et al., 2018; Germain et al., 2015; Papamakarios et al., 2017; Oord et al., 2016; Kolesnikov and Lampert, 2017; Salimans et al., 2017; Uria et al., 2016). These networks successfully learned unconditional generative distributions for artificial data and standard image sets (e.g. MNIST, CelebA, LSUN bedrooms), and some encouraging results for conditional modeling exist as well (Oord et al., 2016; Salimans et al., 2017; Papamakarios et al., 2017; Uria et al., 2016).
+
+These normalizing flows possess property (i) of an INN, and are usually designed to fulfill requirement (iii) as well. In other words, flow-based networks are invertible in principle, but the actual computation of their inverse is too costly to be practical, i.e. INN property (ii) is not fulfilled. This precludes the possibility of bi-directional or cyclic training, which has been shown to be very beneficial in generative adversarial nets and auto-encoders (Zhu et al., 2017a; Dumoulin et al., 2016; Donahue et al., 2017; Teng et al., 2018). In fact, optimization for cycle consistency forces such models to converge to invertible architectures, making fully invertible networks a natural choice. True INNs can be built using coupling layers, as introduced in the NICE (Dinh et al., 2014) and RealNVP (Dinh et al., 2016) architectures. Despite their simple design and training, these networks were rarely studied: Gomez et al. (2017) used a NICE-like design as a memory-efficient alternative to residual networks, Jacobsen et al. (2018) demonstrated that the lack of information reduction from input to representation does not cause overfitting, and Schirrmeister et al. (2018) trained such a network as an adverserial autoencoder. Danihelka et al. (2017) showed that minimization of an adversarial loss is superior to maximum likelihood training in RealNVPs, whereas the Flow-GAN of Grover et al. (2017) performs even better using bidirectional training, a combination of maximum likelihood and adverserial loss. The Glow architecture by Kingma and Dhariwal (2018) incorporates invertible 1x1 convolutions into RealNVPs to achieve impressive image manipulations. This line of research inspired us to extend RealNVPs for the task of computing posteriors in real-world inverse problems from natural and life sciences.
+
+# 3 Methods
+
+# 3.1 Problem specification
+
+We consider a common scenario in natural and life sciences: Researchers are interested in a set of variables $\mathbf { x } \in \mathbb { R } ^ { D }$ describing some phenomenon of interest, but only variables $\mathbf { y } \in \mathbb { R } ^ { M }$ can actually be observed, for which the theory of the respective research field provides a model $\mathbf { y } = s ( \mathbf { x } )$ for the forward process. Since the transformation from $\mathbf { x }$ to $\mathbf { y }$ incurs an information loss, the intrinsic dimension $m$ of $\mathbf { y }$ is in general smaller than $D$ , even if the nominal dimensions satisfy $M > D$ . Hence we want to express the inverse model as a conditional probability $p ( \mathbf { x } | \mathbf { y } )$ , but its mathematical derivation from the forward model is intractable in the applications we are going to address.
+
+We aim at approximating $p ( \mathbf { x } | \mathbf { y } )$ by a tractable model $q ( \mathbf { x } | \mathbf { y } )$ , taking advantage of the possibility to create an arbitrary amount of training data $\{ ( \mathbf { x } _ { i } , \mathbf { y } _ { i } ) \} _ { i = 1 } ^ { N }$ from the known forward model $s ( \mathbf { x } )$ and a suitable prior $p ( \mathbf { x } )$ . While this would allow for training of a standard regression model, we want to approximate the full posterior probability. To this end, we introduce a latent random variable $\mathbf { z } \in \mathbb { R } ^ { K }$ drawn from a multi-variate standard normal distribution and reparametrize $q ( \mathbf { x } | \mathbf { y } )$ in terms of a deterministic function $g$ of $\mathbf { y }$ and $\mathbf { z }$ , represented by a neural network with parameters $\theta$ :
+
+$$
+\mathbf { x } = g ( \mathbf { y } , \mathbf { z } ; \theta ) \mathrm { w i t h } \mathbf { z } \sim p ( \mathbf { z } ) = N ( \mathbf { z } ; 0 , I _ { K } ) .
+$$
+
+Note that we distinguish between hidden parameters $\mathbf { x }$ representing unobservable real-world properties and latent variables $\mathbf { z }$ carrying information intrinsic to our model. Choosing a Gaussian prior for $\mathbf { z }$ poses no additional limitation, as proven by the theory of non-linear independent component analysis (Hyvärinen and Pajunen, 1999).
+
+In contrast to standard methodology, we propose to learn the model $g ( \mathbf { y } , \mathbf { z } ; \theta )$ of the inverse process jointly with a model $f ( \mathbf { x } ; \theta )$ approximating the known forward process $s ( \mathbf { x } )$ :
+
+$$
+[ \mathbf { y } , \mathbf { z } ] = f ( \mathbf { x } ; \theta ) = [ f _ { \mathbf { y } } ( \mathbf { x } ; \theta ) , f _ { \mathbf { z } } ( \mathbf { x } ; \theta ) ] = g ^ { - 1 } ( \mathbf { x } ; \theta ) \mathrm { w i t h } f _ { \mathbf { y } } ( \mathbf { x } ; \theta ) \approx s ( \mathbf { x } ) .
+$$
+
+Functions $f$ and $g$ share the same parameters $\theta$ and are implemented by a single invertible neural network. Our experiments show that joint $b i$ -directional training of $f$ and $g$ avoids many complications arising in e.g. cVAEs or Bayesian neural networks, which have to learn the forward process implicitly.
+
+The relation $f = g ^ { - 1 }$ is enforced by the invertible network architecture, provided that the nominal and intrinsic dimensions of both sides match. When $m \leq M$ denotes the intrinsic dimension of $\mathbf { y }$ , the latent variable $\mathbf { z }$ must have dimension $K = D - m$ , assuming that the intrinsic dimension of $\mathbf { x }$ equals its nominal dimension $D$ . If the resulting nominal output dimension $M + K$ exceeds $D$ , we augment the input with a vector $\mathbf { x } _ { 0 } \in \mathbb { R } ^ { M + K - L }$ of zeros and replace $\mathbf { x }$ with the concatenation $\left[ \mathbf { x } , \mathbf { x } _ { 0 } \right]$ everywhere. Combining these definitions, our network expresses $q ( \mathbf { x } | \mathbf { y } )$ as
+
+$$
+q \big ( \mathbf { x } = g ( \mathbf { y } , \mathbf { z } ; \theta ) | \mathbf { y } \big ) = p ( \mathbf { z } ) \left| J _ { \mathbf { x } } \right| ^ { - 1 } , \qquad J _ { \mathbf { x } } = \operatorname* { d e t } \left( \left. \frac { \partial g ( \mathbf { y } , \mathbf { z } ; \theta ) } { \partial [ \mathbf { y } , \mathbf { z } ] } \right| _ { \mathbf { y } , f _ { \mathbf { z } } ( \mathbf { x } ) } \right)
+$$
+
+with Jacobian determinant $J _ { \mathbf { x } }$ . When using coupling layers, according to Dinh et al. (2016), computation of $J _ { \mathbf { x } }$ is simple, as each transformation has a triangular Jacobian matrix.
+
+# 3.2 Invertible architecture
+
+To create a fully invertible neural network, we follow the architecture proposed by Dinh et al. (2016): The basic unit of this network is a reversible block consisting of two complementary affine coupling layers. Hereby, the block’s input vector $\mathbf { u }$ is split into two halves, $\mathbf { u } _ { 1 }$ and $\mathbf { u } _ { 2 }$ , which are transformed by an affine function with coefficients $\exp ( s _ { i } )$ and $t _ { i }$ ( $i \in \{ 1 , 2 \}$ ), using element-wise multiplication ( $\odot$ ) and addition:
+
+$$
+\mathbf { v } _ { 1 } = \mathbf { u } _ { 1 } \odot \exp ( s _ { 2 } ( \mathbf { u } _ { 2 } ) ) + t _ { 2 } ( \mathbf { u } _ { 2 } ) , \qquad \mathbf { v } _ { 2 } = \mathbf { u } _ { 2 } \odot \exp ( s _ { 1 } ( \mathbf { v } _ { 1 } ) ) + t _ { 1 } ( \mathbf { v } _ { 1 } ) .
+$$
+
+Given the output $\mathbf { v } = [ \mathbf { v } _ { 1 } , \mathbf { v } _ { 2 } ]$ , these expressions are trivially invertible:
+
+$$
+\mathbf { u } _ { 2 } = \bigl ( \mathbf { v } _ { 2 } - t _ { 1 } ( \mathbf { v } _ { 1 } ) \bigr ) \odot \exp ( - s _ { 1 } ( \mathbf { v } _ { 1 } ) ) , \qquad \mathbf { u } _ { 1 } = \bigl ( \mathbf { v } _ { 1 } - t _ { 2 } ( \mathbf { u } _ { 2 } ) \bigr ) \odot \exp ( - s _ { 2 } ( \mathbf { u } _ { 2 } ) ) .
+$$
+
+Importantly, the mappings $s _ { i }$ and $t _ { i }$ can be arbitrarily complicated functions of $\mathbf { v } _ { 1 }$ and $\mathbf { u } _ { 2 }$ and need not themselves be invertible. In our implementation, they are realized by a succession of several fully connected layers with leaky ReLU activations.
+
+A deep invertible network is composed of a sequence of these reversible blocks. To increase model capacity, we apply a few simple extensions to this basic architecture. Firstly, if the dimension $D$ is small, but a complex transformation has to be learned, we find it advantageous to pad both the in- and output of the network with an equal number of zeros. This does not change the intrinsic dimensions of in- and output, but enables the network’s interior layers to embed the data into a larger representation space in a more flexible manner. Secondly, we insert permutation layers between reversible blocks, which shuffle the elements of the subsequent layer’s input in a randomized, but fixed, way. This causes the splits $\mathbf { u } = [ \mathbf { u } _ { 1 } , \mathbf { u } _ { 2 } ]$ to vary between layers and enhances interaction among the individual variables. Kingma and Dhariwal (2018) use a similar architecture with learned permutations.
+
+# 3.3 Bi-directional training
+
+Invertible networks offer the opportunity to simultaneously optimize for losses on both the inand output domains (Grover et al., 2017), which allows for more effective training. Hereby, we perform forward and backward iterations in an alternating fashion, accumulating gradients from both directions before performing a parameter update. For the forward iteration, we penalize deviations between simulation outcomes $\mathbf { y } _ { i } = s ( \mathbf { x } _ { i } )$ and network predictions $f _ { \mathbf { y } } ( \mathbf { x } _ { i } )$ with a loss $\mathcal { L } _ { \mathbf { y } } \left( \mathbf { y } _ { i } , f _ { \mathbf { y } } ( \mathbf { x } _ { i } ) \right)$ . Depending on the problem, ${ \mathcal { L } } _ { \mathbf { y } }$ can be any supervised loss, e.g. squared loss for regression or cross-entropy for classification.
+
+The loss for latent variables penalizes the mismatch between the joint distribution of network outputs $q ( \mathbf { y } = f _ { \mathbf { y } } ( \mathbf { x } ) , \mathbf { z } = f _ { \mathbf { z } } ( \mathbf { x } ) ) = p ( \mathbf { x } ) / \vert J _ { \mathbf { y z } } \vert$ and the product of marginal distributions of simulation outcomes $p \big ( \mathbf { y } = s ( \mathbf { x } ) \big ) = p ( \mathbf { x } ) / | J _ { s } |$ and latents $p ( \mathbf { z } )$ as $\mathcal { L } _ { \mathbf { z } } \big ( q ( \mathbf { y } , \mathbf { z } ) , p ( \mathbf { y } ) p ( \mathbf { z } ) \big )$ .
+
+We block the gradients of $\mathcal { L } _ { \mathbf { z } }$ with respect to $\mathbf { y }$ to ensure the resulting updates only affect the predictions of $\mathbf { z }$ and do not worsen the predictions of $\mathbf { y }$ . Thus, $\mathcal { L } _ { \mathbf { z } }$ enforces two things: firstly, the generated $\mathbf { z }$ must follow the desired normal distribution $p ( \mathbf { z } )$ ; secondly, $\mathbf { y }$ and $\mathbf { z }$ must be independent upon convergence (i.e. $p ( \mathbf { z } \mid \mathbf { y } ) = p ( \mathbf { z } )$ ), and not encode the same information twice. As $\mathcal { L } _ { \mathbf { z } }$ is implemented by Maximum Mean Discrepancy $D$ (Sec. 3.4), which only requires samples from the distributions to be compared, the Jacobian determinants $J _ { \mathbf { y } \mathbf { z } }$ and $J _ { s }$ do not have to be known explicitly. In appendix Sec. 1, we prove the following theorem:
+
+Theorem: If an INN $f ( \mathbf { x } ) = [ \mathbf { y } , \mathbf { z } ]$ is trained as proposed, and both the supervised loss $\mathcal { L } _ { \mathbf { y } } { = } \mathbb { E } [ ( \mathbf { y } { - } f _ { \mathbf { y } } ( \mathbf { x } ) ) ^ { 2 } ]$ and the unsupervised loss $\mathcal { L } _ { \mathbf { z } } = D \big ( q ( \mathbf { y } , \mathbf { z } ) , p ( \mathbf { y } ) p ( \mathbf { z } ) \big )$ reach zero, sampling according to Eq. 1 with $g = f ^ { - 1 }$ returns the true posterior $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ for any measurement $\mathbf { y } ^ { * }$ .
+
+Although $\mathcal { L } _ { \mathbf { y } }$ and $\mathcal { L } _ { \mathbf { z } }$ are sufficient asymptotically, a small amount of residual dependency between $\mathbf { y }$ and $\mathbf { z }$ remains after a finite amount of training. This causes $q ( \mathbf { x } | \mathbf { y } )$ to deviate from the true posterior $p ( \mathbf { x } | \mathbf { y } )$ . To speed up convergence, we also define a loss $\mathcal { L } _ { \mathbf { x } }$ on the input side, implemented again by MMD. It matches the distribution of backward predictions $q ( \mathbf { x } ) = p \big ( \mathbf { y } = f _ { \mathbf { y } } ( \mathbf { x } ) \big ) p \big ( \mathbf { z } = f _ { \mathbf { z } } ( \mathbf { x } ) \big ) / | J _ { \mathbf { x } } |$ against the prior data distribution $p ( \mathbf { x } )$ through $\mathcal { L } _ { \mathbf { x } } ( p ( \mathbf { x } ) , q ( \mathbf { x } ) )$ . In the appendix, Sec. 1, we prove that $\mathcal { L } _ { \mathbf { x } }$ is guaranteed to be zero when the forward losses $\mathcal { L } _ { \mathbf { y } }$ and $\mathcal { L } _ { \mathbf { z } }$ have converged to zero. Thus, incorporating $\mathcal { L } _ { \mathbf { x } }$ does not alter the optimum, but improves convergence in practice.
+
+Finally, if we use padding on either network side, loss terms are needed to ensure no information is encoded in the additional dimensions. We $a$ ) use a squared loss to keep those values close to zero and $b$ ) in an additional inverse training pass, overwrite the padding dimensions with noise of the same amplitude and minimize a reconstruction loss, which forces these dimensions to be ignored.
+
+# 3.4 Maximum mean discrepancy
+
+Maximum Mean Discrepancy (MMD) is a kernel-based method for comparison of two probability distributions that are only accessible through samples (Gretton et al., 2012). While a trainable discriminator loss is often preferred for this task in high-dimensional problems, especially in GAN-based image generation, MMD also works well, is easier to use and much cheaper, and leads to more stable training (Tolstikhin et al., 2017). The method requires a kernel function as a design parameter, and we found that kernels with heavier tails than Gaussian are needed to get meaningful gradients for outliers. We achieved best results with the Inverse Multiquadratic $k ( \mathbf { x } , \mathbf { x } ^ { \prime } ) = 1 / ( 1 + \| ( \mathbf { x } - \mathbf { x } ^ { \prime } ) / h \| _ { 2 } ^ { 2 } )$ , reconfirming the suggestion from Tolstikhin et al. (2017). Since the magnitude of the MMD depends on the kernel choice, the relative weights of the losses $\mathcal { L } _ { \mathbf { x } }$ , $\mathcal { L } _ { \mathbf { y } }$ , $\mathcal { L } _ { \mathbf { z } }$ are adjusted as hyperparameters, such that their effect is about equal.
+
+![](images/59edd85d3cf6fedb59f25a9459db4f341df50ed4d3ade36f57aa75f8b32da116.jpg)  
+Figure 2: Viability of INN for a basic inverse problem. The task is to produce the correct (multi-modal) distribution of 2D points $\mathbf { x }$ , given only the color label $\mathbf { y } ^ { * }$ . When trained with all loss terms from Sec. 3.3, the INN output matches ground truth almost exactly (2nd image). The ablations (3rd and 4th image) show that we need $\mathcal { L } _ { \mathbf { y } }$ and $\mathcal { L } _ { \mathbf { z } }$ to learn the conditioning correctly, whereas $\mathcal { L } _ { \mathbf { x } }$ helps us remain faithful to the prior.
+
+# 4 Experiments
+
+We first demonstrate the capabilities of INNs on two well-behaved synthetic problems and then show results for two real-world applications from the fields of medicine and astrophysics. Additional details on the datasets and network architectures are provided in the appendix.
+
+# 4.1 Artificial data
+
+Gaussian mixture model: To test basic viability of INNs for inverse problems, we train them on a standard 8-component Gaussian mixture model $p ( \mathbf { x } )$ . The forward process is very simple: The first four mixture components (clockwise) are assigned label $\mathbf { y } = \mathbf { r e d }$ , the next two get label $\mathbf { y } = \mathbf { b } \mathbf { l } \mathbf { u } \mathbf { e }$ , and the final two are labeled $\mathbf { y } = \mathbf { g r e e n }$ and y = purple (Fig. 2). The true inverse posteriors $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ consist of the mixture components corresponding to the given one-hot-encoded label $\mathbf { y } ^ { * }$ . We train the INN to directly regress one-hot vectors $\mathbf { y }$ using a squared loss $\mathcal { L } _ { \mathbf { y } }$ , so that we can provide plain one-hot vectors $\mathbf { y } ^ { * }$ to the inverse network when sampling $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ . We observe the following: (i) The INN learns very accurate approximations of the posteriors and does not suffer from mode collapse. (ii) The coupling block architecture does not reduce the network’s representational power – results are similar to standard networks of comparable size (see appendix Sec. 2). (iii) Bidirectional training works best, whereas forward training alone (using only $\mathcal { L } _ { \mathbf { y } }$ and $\mathcal { L } _ { \mathbf { z } }$ ) captures the conditional relationships properly, but places too much mass in unpopulated regions of $\mathbf { x }$ -space. Conversely, pure inverse training (just $\mathcal { L } _ { \mathbf { x } }$ ) learns the correct $\mathbf { x }$ -distribution, but loses all conditioning information.
+
+Inverse kinematics: For a task with a more complex and continuous forward process, we simulate a simple inverse kinematics problem in 2D space: An articulated arm moves vertically along a rail and rotates at three joints. These four degrees of freedom constitute the parameters $\mathbf { x }$ . Their priors are given by a normal distribution, which favors a pose with $1 8 0 ^ { \circ }$ angles and centered origin. The forward process is to calculate the coordinates of the end point y, given a configuration $\mathbf { x }$ . The inverse problem asks for the posterior distribution over all possible inputs $\mathbf { x }$ that place the arm’s end point at a given y position. An example for a fixed $\mathbf { y } ^ { * }$ is shown in Fig. 3, where we compare our INN to a conditional VAE (see appendix Fig. 7 for conceptual comparison of architectures). Adding Inverse Autoregressive Flow (IAF, Kingma et al., 2016) does not improve cVAE performance in this case (see appendix, Table 2). The $\mathbf { y } ^ { * }$ chosen in Fig. 3 is a hard example, as it is unlikely under the prior $p ( \mathbf { x } )$ (Fig. 3, right) and has a strongly bi-modal posterior $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ .
+
+In this case, due to the computationally cheap forward process, we can use approximate Bayesian computation (ABC, see appendix Sec. 7) to sample from the ground truth posterior. Compared to ground truth, we find that both INN and cVAE recover the two symmetric modes well. However, the true end points of x-samples produced by the cVAE tend to miss the target $\mathbf { y } ^ { * }$ by a wider margin. This is because the forward process $\mathbf x \to \mathbf y$ is only learned implicitly during cVAE training. See appendix for quantitative analysis and details.
+
+![](images/895fa44410dfd315a244092b0a59d310fa92ddce073013ea530e5e0f26f1c198.jpg)  
+Figure 3: Distribution over articulated poses x, conditioned on the end point $\mathbf { y } ^ { * }$ . The desired end point $\mathbf { y } ^ { * }$ is marked by a gray cross. A dotted line on the left represents the rail the arm is based on, and the faint colored lines indicate sampled arm configurations $\mathbf { x }$ taken from the true (ABC) or learned (INN, cVAE) posterior $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ . The prior (right) is shown for reference. The actual end point of each sample may deviate slightly from the target $\mathbf { y } ^ { * }$ ; contour lines enclose the regions containing $9 7 \%$ of these end points. We emphasize the articulated arm with the highest estimated likelihood for illustrative purposes.
+
+# 4.2 Real-world applications
+
+After demonstrating the viability on synthetic data, we apply our method to two real world problems from medicine and astronomy. While we focus on the medical task in the following, the astronomy application is shown in Fig. 5.
+
+In medical science, the functional state of biological tissue is of interest for many applications. Tumors, for example, are expected to show changes in oxygen saturation $s o _ { 2 }$ (Hanahan and Weinberg, 2011). Such changes cannot be measured directly, but influence the reflectance of the tissue, which can be measured by multispectral cameras (Lu and Fei, 2014). Since ground truth data can not be obtained from living tissue, we create training data by simulating observed spectra y from a tissue model $\mathbf { x }$ involving $s o _ { 2 }$ , blood volume fraction $v _ { \mathrm { h b } }$ , scattering magnitude $a _ { \mathrm { m i e } }$ , anisotropy $g$ and tissue layer thickness $d$ (Wirkert et al., 2016). This model constitutes the forward process, and traditional methods to learn point estimates of the inverse (Wirkert et al., 2016; 2017; Claridge and Hidovic-Rowe, 2013) are already sufficiently reliable to be used in clinical trials. However, these methods can not adequately express uncertainty and ambiguity, which may be vital for an accurate diagnosis.
+
+Competitors. We train an INN for this problem, along with two ablations (as in Fig. 2), as well as a cVAE with and without IAF (Kingma et al., 2016) and a network using the method of Kendall and Gal (2017), with dropout sampling and additional aleatoric error terms for each parameter. The latter also provides a point-estimate baseline (classical NN) when used without dropout and error terms, which matches the current state-of-the-art results in Wirkert et al. (2017). Finally, we compare to ABC, approximating $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ with the 256 samples closest to $\mathbf { y } ^ { * }$ . Note that with enough samples ABC would produce the true posterior. We performed $5 0 0 0 0$ simulations to generate samples for ABC at test time, taking one week on a GPU, but still measure inconsistencies in the posteriors. The learning-based methods are trained within minutes, on a training set of 15 000 samples generated offline.
+
+Error measures. We are interested in both the accuracy (point estimates), and the shape of the posterior distributions. For point estimates $\hat { \bf x }$ , i.e. MAP estimates, we compute the deviation from ground-truth values $\mathbf { x } ^ { * }$ in terms of the RMSE over test set observations $\mathbf { y } ^ { * }$ , $\mathrm { R M S E } = \sqrt { \mathbb { E } _ { \mathbf { y } ^ { * } } [ \| \hat { \mathbf { x } } - \mathbf { x } ^ { * } \| ^ { 2 } ] }$ . The scores are reported both for the main parameter of interest $s o _ { 2 }$ , and the parameter subspace of $s o _ { 2 }$ , $v _ { \mathrm { h b } }$ , $a _ { \mathrm { m i e } }$ , which we found to be the only recoverable parameters. Furthermore, we check the re-simulation error: We apply the simulation $s ( \hat { { \bf x } } )$ to the point estimate, and compare the simulation outcome to the conditioning $\mathbf { y } ^ { * }$ . To evaluate the shape of the posteriors, we compute the calibration error for the sampling-based methods, based on the fraction of ground truth inliers $\alpha _ { \mathrm { i n l } }$ . for corresponding $\alpha$ -confidence-region of the marginal posteriors of $\mathbf { x }$ . The reported error is the median of $| \alpha _ { \mathrm { i n l . } } - \alpha |$ over all $\alpha$ . All values are computed over 5000 test-set observations $\mathbf { y } ^ { * }$ , or 1000 observations in the case of re-simulation error. Each posterior uses 4096 samples, or 256 for ABC; all MAP estimates are found using the mean-shift algorithm.
+
+Table 1: Quantitative results in medical application. We measure the accuracy of point/MAP estimates as detailed in Sec. 4.2. Best results within measurement error are bold, and we determine uncertainties ( $\pm$ ) by statistical bootstrapping. The parameter $s o _ { 2 }$ is the most relevant in this application, whereas error all means all recoverable parameters ( $s o _ { 2 }$ , $v _ { \mathrm { h b } }$ and $a _ { \mathrm { m i e } }$ ). Re-simulation error measures how well the MAP estimate $\hat { \bf x }$ is conditioned on the observation $\mathbf { y } ^ { * }$ . Calibration error is the most important, as it summarizes correctness of the posterior shape in one number; see appendix Fig. 11 for more calibration results.   
+
+<table><tr><td>Method</td><td>MAP error SO2</td><td>MAP error all</td><td>MAP re-simulation error</td><td>Calibration error</td></tr><tr><td>NN (+Dropout)</td><td>0.057 ± 0.003</td><td>0.56 ± 0.01</td><td>0.397 ± 0.008</td><td>1.91%</td></tr><tr><td>INN</td><td>0.041 ± 0.002</td><td>0.57 ± 0.02</td><td>0.327 ± 0.007</td><td>0.34%</td></tr><tr><td>INN,only Ly,Lz</td><td>0.066 ± 0.003</td><td>0.71 ± 0.02</td><td>0.506 ± 0.010</td><td>1.62%</td></tr><tr><td>INN,only Lx</td><td>0.861 ± 0.033</td><td>1.70 ± 0.02</td><td>2.281 ± 0.045</td><td>3.20%</td></tr><tr><td>cVAE</td><td>0.050 ± 0.002</td><td>0.74 ± 0.02</td><td>0.314 ± 0.007</td><td>2.19%</td></tr><tr><td>cVAE-IAF</td><td>0.050 ± 0.002</td><td>0.74 ± 0.03</td><td>0.313 ± 0.008</td><td>1.40%</td></tr><tr><td>ABC</td><td>0.036± 0.001</td><td>0.54 ± 0.02</td><td>0.284± 0.005</td><td>0.90%</td></tr><tr><td>Simulation noise</td><td></td><td></td><td>0.129 ±0.001</td><td></td></tr></table>
+
+![](images/fbcd223d6c0f9aecec36bbf338a10a6d9036676907b89f4eb5502a736cf43313.jpg)  
+Figure 4: Sampled posterior of 5 parameters for fixed $\mathbf { y } ^ { * }$ in medical application. For a fixed observation $\mathbf { y } ^ { * }$ , we compare the estimated posteriors $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ of different methods. The bottom row also includes the point estimate (dashed green line). Ground truth values $\mathbf { x } ^ { * }$ (dashed black line) and prior $p ( \mathbf { x } )$ over all data (gray area) are provided for reference.
+
+Quantitative results. Evaluation results for all methods are presented in Table 1. The INN matches or outperforms other methods in terms of point estimate error. Its accuracy deteriorates slightly when trained without $\mathcal { L } _ { \mathbf { x } }$ , and entirely when trained without the conditioning losses $\mathcal { L } _ { \mathbf { y } }$ and $\mathcal { L } _ { \mathbf { z } }$ , just as in Fig. 2. For our purpose, the calibration error is the most important metric, as it summarizes the correctness of the whole posterior distribution in one number (see appendix Fig. 11). Here, the INN has a big lead over cVAE(-IAF) and Dropout, and even over ABC due to the low ABC sample count.
+
+Qualitative results. Fig. 4 shows generated parameter distributions for one fixed measurement $\mathbf { y } ^ { * }$ , comparing the INN to cVAE-IAF, Dropout sampling and ABC. The three former methods use a sample count of 160 000 to produce smooth curves. Due to the sparse posteriors of 256 samples in the case of ABC, kernel density estimation was applied to its results, with a bandwidth of $\sigma = 0 . 1$ . The results produced by the INN provide relevant insights: First, we find that the posteriors for layer thickness $d$ and anisotropy $g$ match the shape of their priors, i.e. $\mathbf { y } ^ { * }$ holds no information about these parameters – they are unrecoverable. This finding is supported by the ABC results, whereas the other two methods misleadingly suggest a roughly Gaussian posterior. Second, we find that the sampled distributions for the blood volume fraction $v _ { \mathrm { h b } }$ and scattering amplitude $a _ { \mathrm { m i e } }$ are strongly correlated (rightmost plot). This phenomenon is not an analysis artifact, but has a sound physical explanation: As blood volume fraction increases, more light is absorbed inside the tissue. For the sensor to record the same intensities $\mathbf { y } ^ { * }$ as before, scattering must be increased accordingly. In Fig. 10 in the appendix, we show how the INN is applied to real multispectral images.
+
+![](images/a2f0a8a13f24361409547b9ce81eca1cc92462a69de23df90288deb476cfe0fa.jpg)  
+Figure 5: Astrophysics application. Properties $\mathbf { x }$ of star clusters in interstellar gas clouds are inferred from multispectral measurements $\mathbf { y }$ . We train an INN on simulated data, and show the sampled posterior of 5 parameters for one $\mathbf { y } ^ { * }$ (colors as in Fig. 4, second row). The peculiar shape of the prior is due to the dynamic nature of these simulations. We include this application as a real-world example for the INN’s ability to recover multiple posterior modes, and strong correlations in $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ , see details in appendix, Sec. 5.
+
+# 5 Conclusion
+
+We have shown that the full posterior of an inverse problem can be estimated with invertible networks, both theoretically and practically on problems from medicine and astrophysics. We share the excitement of the application experts to develop INNs as a generic tool, helping them to better interpret their data and models, and to improve experimental setups. As a side effect, our results confirm the findings of others that the restriction to coupling layers does not noticeably reduce the expressive power of the network.
+
+In summary, we see the following fundamental advantages of our INN-based method compared to alternative approaches: Firstly, one can learn the forward process and obtain the (more complicated) inverse process ‘for free’, as opposed to e.g. cGANs, which focus on the inverse and learn the forward process only implicitly. Secondly, the learned posteriors are not restricted to a particular parametric form, in contrast to classical variational methods. Lastly, in comparison to ABC and related Bayesian methods, the generation of the INN posteriors is computationally very cheap. In future work, we plan to systematically analyze the properties of different invertible architectures, as well as more flexible models utilizing cycle losses, in the context of representative inverse problem. We are also interested in how our method can be scaled up to higher dimensionalities, where MMD becomes less effective.
+
+# Acknowledgments
+
+LA received funding by the Federal Ministry of Education and Research of Germany, project ‘High Performance Deep Learning Framework’ (No 01IH17002). JK, CR and UK received financial support from the European Research Council (ERC) under the European Unions Horizon 2020 research and innovation program (grant agreement No 647769). SW and LMH received funding from the European Research Council (ERC) starting grant COMBIOSCOPY (637960). EWP, DR, and RSK acknowledge support by Collaborative Research Centre (SFB 881) ‘The Milky Way System’ (subprojects B1, B2 and B8), the Priority Program SPP 1573 ‘Physics of the Interstellar Medium’ (grant numbers KL 1358/18.1, KL 1358/19.2 and GL 668/2-1) and the European Research Council in the ERC Advanced Grant STARLIGHT (project no. 339177)
+
+# References
+
+Jack A. Baldwin, Mark M. Phillips, and Roberto Terlevich. Classification parameters for the emission-line spectra of extragalactic objects. PASP, 93:5–19, February 1981.
+
+Rianne van den Berg, Leonard Hasenclever, Jakub M Tomczak, and Max Welling. Sylvester normalizing flows for variational inference. arXiv:1803.05649, 2018.
+
+David M Blei, Alp Kucukelbir, and Jon D McAuliffe. Variational inference: A review for statisticians. Journal of the American Statistical Association, 112(518):859–877, 2017.
+
+Ela Claridge and Dzena Hidovic-Rowe. Model based inversion for deriving maps of histological parameters characteristic of cancer from ex-vivo multispectral images of the colon. IEEE Trans Med Imaging, November 2013.
+
+Ivo Danihelka, Balaji Lakshminarayanan, Benigno Uria, Daan Wierstra, and Peter Dayan. Comparison of maximum likelihood and GAN-based training of Real NVPs. arXiv:1705.05263, 2017.
+
+Gustavo Deco and Wilfried Brauer. Nonlinear higher-order statistical decorrelation by volume-conserving neural architectures. Neural Networks, 8(4):525–535, 1995.
+
+Laurent Dinh, David Krueger, and Yoshua Bengio. NICE: Non-linear independent components estimation. arXiv:1410.8516, 2014.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using Real NVP. arXiv:1605.08803, 2016.
+
+Chris Donahue, Akshay Balsubramani, Julian McAuley, and Zachary C Lipton. Semantically decomposing the latent spaces of generative adversarial networks. arXiv:1705.07904, 2017.
+
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Olivier Mastropietro, Alex Lamb, Martin Arjovsky, and Aaron Courville. Adversarially learned inference. arXiv:1606.00704, 2016.
+
+Yarin Gal and Zoubin Ghahramani. Bayesian convolutional neural networks with Bernoulli approximate variational inference. arXiv:1506.02158, 2015.
+
+Dani Gamerman and Hedibert F Lopes. Markov Chain Monte Carlo: Stochastic simulation for Bayesian inference. Chapman and Hall/CRC, 2006.
+
+Mathieu Germain, Karol Gregor, Iain Murray, and Hugo Larochelle. MADE: Masked autoencoder for distribution estimation. In International Conference on Machine Learning, pages 881–889, 2015.
+
+Aidan N Gomez, Mengye Ren, Raquel Urtasun, and Roger B Grosse. The reversible residual network: Backpropagation without storing activations. In Advances in Neural Information Processing Systems, pages 2211–2221, 2017.
+
+Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Schölkopf, and Alexander Smola. A kernel two-sample test. Journal of Machine Learning Research, 13(Mar):723–773, 2012.
+
+Aditya Grover, Manik Dhar, and Stefano Ermon. Flow-GAN: Combining maximum likelihood and adversarial learning in generative models. arXiv:1705.08868, 2017.
+
+Douglas Hanahan and Robert A. Weinberg. Hallmarks of cancer: The next generation. Cell, 144(5):646–674, March 2011. ISSN 00928674.
+
+Chin-Wei Huang, David Krueger, Alexandre Lacoste, and Aaron Courville. Neural autoregressive flows. arXiv:1804.00779, 2018.
+
+Aapo Hyvärinen and Petteri Pajunen. Nonlinear independent component analysis: Existence and uniqueness results. Neural Networks, 12(3):429–439, 1999.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In CVPR, pages 1125–1134, 2017.
+
+Jörn-Henrik Jacobsen, Arnold Smeulders, and Edouard Oyallon. i-RevNet: Deep invertible networks. arXiv:1802.07088, 2018.
+
+Alex Kendall and Yarin Gal. What uncertainties do we need in bayesian deep learning for computer vision? In Advances in Neural Information Processing Systems, pages 5580–5590, 2017.
+
+Lisa J. Kewley, Michael A. Dopita, Claus Leitherer, Romeel Davé, Tiantian Yuan, Mark Allen, Brent Groves, and Ralph Sutherland. Theoretical evolution of optical strong lines across cosmic time. The Astrophysical Journal, 774(2):100, 2013.
+
+Diederik P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. arXiv:1807.03039, 2018.
+
+Diederik P Kingma, Tim Salimans, and Max Welling. Variational dropout and the local reparameterization trick. In Advances in Neural Information Processing Systems, pages 2575–2583, 2015.
+
+Diederik P Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, and Max Welling. Improved variational inference with inverse autoregressive flow. In Advances in Neural Information Processing Systems, pages 4743–4751, 2016.
+
+Alexander Kolesnikov and Christoph H. Lampert. PixelCNN models with auxiliary variables for natural image modeling. In International Conference on Machine Learning, pages 1905–1914, 2017.
+
+Jarno Lintusaari, Michael U. Gutmann, Ritabrata Dutta, Samuel Kaski, and Jukka Corander. Fundamentals and recent developments in approximate bayesian computation. Systematic Biology, 66(1):e66–e82, 2017.
+
+Guolan Lu and Baowei Fei. Medical hyperspectral imaging: a review. Journal of Biomedical Optics, 19(1):10901, January 2014. ISSN 1560-2281.
+
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv:1411.1784, 2014.
+
+Aäron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu. Conditional image generation with PixelCNN decoders. In Advances in Neural Information Processing Systems, pages 4797–4805, 2016.
+
+George Papamakarios and Iain Murray. Fast $\varepsilon$ -free inference of simulation models with bayesian conditional density estimation. In Advances in Neural Information Processing Systems, pages 1028–1036, 2016.
+
+George Papamakarios, Iain Murray, and Theo Pavlakou. Masked autoregressive flow for density estimation. In Advances in Neural Information Processing Systems, pages 2335– 2344, 2017.
+
+Eric W. Pellegrini, Jack A. Baldwin, and Gary J. Ferland. Structure and feedback in 30 Doradus. II. Structure and chemical abundances. The Astrophysical Journal, 738(1):34, 2011.
+
+Daniel Rahner, Eric W. Pellegrini, Simon C. O. Glover, and Ralf S. Klessen. Winds and radiation in unison: A new semi-analytic feedback model for cloud dissolution. Monthly Notices of the Royal Astronomical Society, 470:4453–4472, 10 2017.
+
+Stefan Reissl, Robert Brauer, and Sebastian Wolf. Radiative transfer with polaris: I. analysis of magnetic fields through synthetic dust continuum polarization measurements. Astronomy & Astrophysics, 593, 04 2016.
+
+Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In International Conference on Machine Learning, pages 1530–1538, 2015.
+
+Oren Rippel and Ryan Prescott Adams. High-dimensional probability estimation with deep density models. arXiv:1302.5125, 2013.
+
+Christian Robert and George Casella. Monte Carlo Statistical Methods. Springer, 2004.
+
+Ralf S. Klessen and Simon C. O. Glover. Physical processes in the interstellar medium. Saas-Fee Advanced Course, 43:85, 2016.
+
+Tim Salimans, Andrej Karpathy, Xi Chen, and Diederik P Kingma. PixelCNN++: Improving the PixelCNN with discretized logistic mixture likelihood and other modifications. arXiv:1701.05517, 2017.
+
+R.T. Schirrmeister, P. Chrab¸aszcz, F. Hutter, and T. Ball. Training generative reversible networks. arXiv:1806.01610, 2018.
+
+N Siddharth, Brooks Paige, Jan-Willem Van de Meent, Alban Desmaison, and Philip HS Torr. Learning disentangled representations with semi-supervised deep generative models. In Advances in Neural Information Processing Systems, pages 5925–5935, 2017.
+
+Kihyuk Sohn, Honglak Lee, and Xinchen Yan. Learning structured output representation using deep conditional generative models. In Advances in Neural Information Processing Systems, pages 3483–3491, 2015.
+
+Mikael Sunnåker, Alberto Giovanni Busetto, Elina Numminen, Jukka Corander, Matthieu Foll, and Christophe Dessimoz. Approximate bayesian computation. PLoS computational biology, 9(1):e1002803, 2013.
+
+E. G. Tabak and Cristina V. Turner. A family of nonparametric density estimation algorithms. Communications on Pure and Applied Mathematics, 66(2):145–164, 2013. doi: 10.1002/ cpa.21423.
+
+Esteban G Tabak, Eric Vanden-Eijnden, et al. Density estimation by dual ascent of the log-likelihood. Communications in Mathematical Sciences, 8(1):217–233, 2010.
+
+Yunfei Teng, Anna Choromanska, and Mariusz Bojarski. Invertible autoencoder for domain adaptation. arXiv:1802.06869, 2018.
+
+Ilya Tolstikhin, Olivier Bousquet, Sylvain Gelly, and Bernhard Schoelkopf. Wasserstein auto-encoders. arXiv:1711.01558, 2017.
+
+Jakub M Tomczak and Max Welling. Improving variational auto-encoders using householder flow. arXiv:1611.09630, 2016.
+
+Brian L Trippe and Richard E Turner. Conditional density estimation with bayesian normalising flows. arXiv:1802.04908, 2018.
+
+Benigno Uria, Marc-Alexandre Côté, Karol Gregor, Iain Murray, and Hugo Larochelle. Neural autoregressive distribution estimation. Journal of Machine Learning Research, 17(205): 1–37, 2016.
+
+Richard David Wilkinson. Approximate bayesian computation (abc) gives exact results under the assumption of model error. Statistical applications in genetics and molecular biology, 12(2):129–141, 2013.
+
+Sebastian J Wirkert, Hannes Kenngott, Benjamin Mayer, Patrick Mietkowski, Martin Wagner, Peter Sauer, Neil T Clancy, Daniel S Elson, and Lena Maier-Hein. Robust near real-time estimation of physiological parameters from megapixel multispectral images with inverse monte carlo and random forest regression. International journal of computer assisted radiology and surgery, 11(6):909–917, 2016.
+
+Sebastian J. Wirkert, Anant S. Vemuri, Hannes G. Kenngott, Sara Moccia, Michael Götz, Benjamin F. B. Mayer, Klaus H. Maier-Hein, Daniel S. Elson, and Lena Maier-Hein. Physiological Parameter Estimation from Multispectral Images Unleashed. In Medical Image Computing and Computer-Assisted Intervention, Lecture Notes in Computer Science, pages 134–141. Springer, Cham, September 2017.
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In CVPR, pages 2223–2232, 2017a.
+
+Jun-Yan Zhu, Richard Zhang, Deepak Pathak, Trevor Darrell, Alexei A Efros, Oliver Wang, and Eli Shechtman. Toward multimodal image-to-image translation. In Advances in Neural Information Processing Systems, pages 465–476, 2017b.
+
+# Appendix
+
+# 1 Proof of correctness of generated posteriors
+
+Lemma: If some bijective function $f : x  z$ transforms a probability density $p _ { X } ( x )$ to $p _ { Z } ( z )$ , then the inverse function $f ^ { - 1 }$ transforms $p _ { Z } ( z )$ back to $p _ { X } ( x )$ .
+
+Proof: We denote the probability density obtained through the reverse transformation as $p _ { X } ^ { * } ( x )$ . Therefore, we have to show that $p _ { X } ^ { * } ( x ) = p _ { X } ( x )$ . For the forward direction, via the change-of-variables formula, we have
+
+$$
+p _ { Z } ( z ) = p _ { X } \Big ( x = f ^ { - 1 } ( z ) \Big ) \left| \operatorname* { d e t } [ \partial _ { z } ( f ^ { - 1 } ) ] \right|
+$$
+
+with the Jacobian $\partial _ { z } f ^ { - 1 } \equiv \partial f _ { i } ^ { - 1 } / \partial z _ { j }$ . For the reverse transformation, we have
+
+$$
+p _ { X } ^ { * } ( x ) = p _ { Z } { \Big ( } z = f ( x ) { \Big ) } \left. \operatorname* { d e t } [ \partial _ { x } f ] \right. .
+$$
+
+We can substitute $p _ { Z }$ from Eq. 6 and obtain
+
+$$
+\begin{array} { r l } & { p _ { X } ^ { * } ( x ) = p _ { X } \Big ( x = f ^ { - 1 } ( f ( x ) ) \Big ) \left| \operatorname* { d e t } \Big [ ( \partial _ { z } ( f ^ { - 1 } ) ) ( \partial _ { x } f ) \Big ] \right| } \\ & { \qquad = p _ { X } ( x ) \left| \operatorname* { d e t } \Big [ ( \partial _ { z } f ^ { - 1 } ) ( \partial _ { x } f ) \Big ] \right| } \\ & { \qquad = p _ { X } ( x ) \left| \operatorname* { d e t } [ I ] \right| = p _ { X } ( x ) . } \end{array}
+$$
+
+In Eq. 9, the Jacobians cancel out due to the inverse function theorem, i.e. the Jacobian $\partial _ { z } ( f ^ { - 1 } )$ is the matrix inverse of $\partial _ { x } f$ .
+
+Theorem: If an INN $f ( \mathbf { x } ) = [ \mathbf { y } , \mathbf { z } ]$ is trained as proposed, and both the supervised loss $\mathcal { L } _ { \mathbf { y } } { = } \mathbb { E } [ ( \mathbf { y } { - } f _ { \mathbf { y } } ( \mathbf { x } ) ) ^ { 2 } ]$ and the unsupervised loss $\mathcal { L } _ { \mathbf { z } } = D \big ( q ( \mathbf { y } , \mathbf { z } ) , p ( \mathbf { y } ) p ( \mathbf { z } ) \big )$ reach zero, sampling according to Eq. 1 with $g = f ^ { - 1 }$ returns the true posterior $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ for any measurement $\mathbf { y } ^ { * }$ .
+
+Proof: We denote the chosen latent distribution as $p _ { Z } ( \mathbf { z } )$ , the distribution of observations as $p _ { Y } ( \mathbf { y } )$ , and the joint distribution of network outputs as ${ \boldsymbol { q } } ( \mathbf { y } , \mathbf { z } )$ . As shown by Gretton et al. (2012), if the MMD loss converges to $0$ , the network outputs follow the prescribed distribution:
+
+$$
+\mathcal { L } _ { \mathbf { z } } = 0 \iff q ( \mathbf { y } , \mathbf { z } ) = p _ { Y } ( \mathbf { y } ) p _ { Z } ( \mathbf { z } )
+$$
+
+Suppose we take a posterior conditioned on a fixed $\mathbf { y } ^ { * }$ , i.e. $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ , and transform it using the forward pass of our perfectly converged INN. From this we obtain an output distribution ${ \boldsymbol { q } } ^ { * } ( \mathbf { y } , \mathbf { z } )$ . Because $\mathcal { L } _ { \mathbf { y } } = 0$ , we know that the output distribution of $\mathbf { y }$ (marginalized over $\mathbf { z }$ ) must be $q ^ { * } ( \mathbf { y } ) = \delta ( \mathbf { y } - \mathbf { y } ^ { * } )$ . Also, because of the independence between $\mathbf { z }$ and $\mathbf { y }$ in the output, the distribution of $\mathbf { z }$ -outputs is still $q ^ { * } ( \mathbf { z } ) = p _ { Z } ( \mathbf { z } )$ . So the joint distribution of outputs is
+
+$$
+q ^ { * } ( \mathbf { y } , \mathbf { z } ) = \delta ( \mathbf { y } - \mathbf { y } ^ { * } ) p _ { Z } ( \mathbf { z } )
+$$
+
+When we invert the network, and repeatedly input $\mathbf { y } ^ { * }$ while sampling $\mathbf { z } \sim p _ { Z } ( \mathbf { z } )$ , this is the same as sampling $[ \mathbf { y } , \mathbf { z } ]$ from the ${ \boldsymbol { q } } ^ { * } ( \mathbf { y } , \mathbf { z } )$ above. Using the Lemma from above, we know that the inverted network will output samples from $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ .
+
+Corollary: If the conditions of the theorem above are fulfilled, the unsupervised reverse loss $\mathcal { L } _ { \mathbf { x } } = D \big ( q ( \mathbf { x } ) , p _ { X } ( \mathbf { x } ) \big )$ between the marginalized outputs of the inverted network, $q ( \mathbf { x } )$ , and the prior data distribution, $p _ { X } ( \mathbf { x } )$ , will also be 0. This justifies using the loss on the prior to speed up convergence, without altering the final results.
+
+Proof: Due to the theorem, the estimated posteriors generated by the INN are correct, i.e. $q ( \mathbf { x } | \mathbf { y } ^ { * } ) = p ( \mathbf { x } | \mathbf { y } ^ { * } )$ . If they are marginalized over observations $\mathbf { y } ^ { * }$ from the training data, then $q ( \mathbf { x } )$ will be equal to $p _ { X } ( \mathbf { x } )$ by definition. As shown by Gretton et al. (2012), this is equivalent to $\mathcal { L } _ { \mathbf { x } } = 0$ .
+
+# 2 Artificial data – Gaussian mixture
+
+In Sec. 4.1, we demonstrate that the proposed INN can approximate the true posteriors very well and is not hindered by the required coupling block architecture. Here we show how some existing methods do on the same task, using neural networks of similar size as the INN.
+
+![](images/ffa34912624e9f4bbee68e99ce169d827a71ec3890550d6b27d4acb17aa000fc.jpg)  
+Figure 6: Results of several existing methods for the Gaussian mixture toy example.
+
+cGAN Training a conditional GAN of network size comparable to the INN (counting only the generator) and only two noise dimensions turned out to be challenging. Even with additional pre-training to avoid mode collapse, the individual modes belonging to one label are reduced to nearly one-dimensional structures.
+
+Larger cGAN In order to match the results of the INN, we trained a more complex cGAN with 2M parameters instead of the previous 10K, and a latent dimension of 128, instead of 2. To prevent mode collapse, we introduced an additional regularization: an extra loss term forces the variance of generator outputs to match the variance of the training data prior. With these changes, the cGAN can be seen to recover the posteriors reasonably well.
+
+Generator $^ +$ MMD Another option is to keep the cGAN generator the same size as our INN, but replace the discriminator with an MMD loss (cf. Sec. 3.4). This loss receives a concatenation of the generator output $\mathbf { x }$ and the label y it was supplied with, and compares these batch-wise with the concatenation of ground truth $\displaystyle ( \mathbf { x } , \mathbf { y } )$ -pairs. Note that in contrast to this, the corresponding MMD loss of the INN only receives $\mathbf { x }$ , and no information about $\mathbf { y }$ . For this small toy problem, we find that the hand-crafted MMD loss dramatically improves results compared to the smaller learned discriminator.
+
+cVAE We also compare to a conditional Variational Autoencoder of same total size as the INN. There is some similarity between the training setup of our method (Fig. 7, right) and that of cVAE (Fig. 7, left), as the forward and inverse pass of an INN can also be seen as an encoder-decoder pair. The main differences are that the cVAE learns the relationship $\mathbf x \to \mathbf y$ only indirectly, since there is no explicit loss for it, and that the INN requires no reconstruction loss, since it is bijective by construction.
+
+![](images/ae7d80f49a594d2c379f00e2cabcd5e3da80782d47af87e8a0c64fb1ec628371.jpg)  
+Figure 7: Abstraction of the cVAE-IAF training scheme compared to our INN from Fig. 1. For the standard cVAE, the IAF component is omitted.
+
+cVAE-IAF We adapt the cVAE to use Inverse Autoregressive Flow (Kingma et al., 2016) between the encoder and decoder. On the Gaussian mixture toy problem, the trained cVAE-IAF generates correct posteriors on par with our INN (see Fig. 6).
+
+Dropout sampling The method of dropout sampling with learned error terms is by construction not able to produce multi-modal outputs, and therefore fails on this task.
+
+# 2.1 Latent space analysis
+
+To analyze how the latent space of our INN is structured for this task, we choose a fixed label $\mathbf { y } ^ { * }$ and sample $\mathbf { z }$ from a dense grid. For each $\mathbf { z }$ , we compute x through our inverse network and colorize this point in latent (z) space according to the distance from the closest mode in x-space. We can see that our network learns to shape the latent space such that each mode receives the expected fraction of samples (Fig. 8).
+
+![](images/79d6cdece218340639023c568260d9647fc17931055a69946cc7cd80a04d9196.jpg)  
+Figure 8: Layout of INN latent space for one fixed label $\mathbf { y } ^ { * }$ , colored by mode closest to $\mathbf { x } = g ( \mathbf { y } ^ { * } , \mathbf { z } )$ . For each latent position $\mathbf { z }$ , the hue encodes which mode the corresponding $\mathbf { x }$ belongs to and the luminosity encodes how close $\mathbf { x }$ is to this mode. Note that colors used here do not relate to those in Fig. 2, and encode the position $\mathbf { x }$ instead of the label $\mathbf { y }$ . The first three columns correspond to labels green, blue and red Fig. 2. White circles mark areas that contain $5 0 \%$ and $9 0 \%$ of the probability mass of latent prior $p ( \mathbf { z } )$ .
+
+# 3 Artificial data – inverse kinematics
+
+A short video demonstrating the structure of our INN’s latent space can be found under https://gfycat.com/SoggyCleanHog, for a slightly different arm setup.
+
+The dataset is constucted using gaussian priors $x _ { i } \sim \mathcal { N } ( 0 , \sigma _ { i } )$ , with $\sigma _ { 1 } = 0 . 2 5$ and $\sigma _ { 2 } = \sigma _ { 3 } =$ $\sigma _ { 4 } = 0 . 5 \overset { \land } { = } 2 8 . 6 5 ^ { \circ }$ . The forward process is given by
+
+$$
+\begin{array} { r l } & { y _ { 1 } = x _ { 1 } + l _ { 1 } \sin ( x _ { 2 } ) + l _ { 2 } \sin ( x _ { 3 } - x _ { 2 } ) + l _ { 3 } \sin ( x _ { 4 } - x _ { 2 } - x _ { 3 } ) } \\ & { y _ { 2 } = l _ { 1 } \cos ( x _ { 2 } ) + l _ { 2 } \cos ( x _ { 3 } - x _ { 2 } ) + l _ { 3 } \cos ( x _ { 4 } - x _ { 2 } - x _ { 3 } ) } \end{array}
+$$
+
+with the arm lenghts $l _ { 1 } = 0 . 5$ , $l _ { 2 } = 0 . 5$ , $l _ { 3 } = 1 . 0$ .
+
+To judge the quality of posteriors, we quantify both the re-simulation error and the calibration error over the test set, as in Sec. 4.2 of the paper. Because of the cheap simulation, we average the re-simulation error over the whole posterior, and not only the MAP estimate. In Table 2, we find that the INN has a clear advantage in both metrics, confirming the observations from Fig. 3.
+
+Table 2: Quantitative evaluation of the inverse kinematics experiment   
+
+<table><tr><td>Method</td><td>Mean re-sim. err.</td><td>Median re-sim.err.</td><td>Calibration err.</td></tr><tr><td>cVAE</td><td>0.0368</td><td>0.0307</td><td>7.78%</td></tr><tr><td>cVAE-IAF</td><td>0.0368</td><td>0.0307</td><td>7.81%</td></tr><tr><td>INN</td><td>0.0139</td><td>0.0113</td><td>0.96%</td></tr></table>
+
+![](images/20a1e959ec7b3d9bee3614642b0e6e848317cfc681ca216c4350c7e0e93e8d81.jpg)  
+Figure 9: Posteriors generated for less challenging observations $\mathbf { y } ^ { * }$ than in Fig. 3.
+
+# 4 Multispectral measurements of biological tissue
+
+The following figure shows the results when the INN trained in Sec. 4.2 is applied pixel-wise to multispectral endoscopic footage. In addition to estimating the oxygenation $s o _ { 2 }$ , we measure the uncertainty in the form of the 68% confidence interval.
+
+![](images/1cda0bd0b62c43ab3bdcabb2fc0b8079128f4758caf691bff1033ab4314c0061.jpg)  
+Figure 10: INN applied to real footage to predict oxygenation $s _ { O _ { 2 } }$ and uncertainty. The clips (arrows) on the connecting tissue cause lower oxygenation (blue) in the small intestine. Uncertainty is low in crucial areas and high only at some edges and specularities.
+
+# 5 Star cluster spectral data
+
+Star clusters are born from a large reservoir of gas and dust that permeates the Galaxy, the interstellar medium (ISM). The densest parts of the ISM are called molecular clouds, and star formation occurs in regions that become unstable under their own weight. The process is governed by the complex interplay of competing physical agents such as gravity, turbulence, magnetic fields, and radiation; with stellar feedback playing a decisive regulatory role (S. Klessen and C. O. Glover, 2016). To characterize the impact of the energy and momentum input from young star clusters on the dynamical evolution of the ISM, astronomers frequently study emission lines from chemical elements such as hydrogen or oxygen. These lines are produced when gas is ionized by stellar radiation, and their relative intensities depend on the ionization potential of the chemical species, the spectrum of the ionizing radiation, the gas density as well as the 3D geometry of the cloud, and the absolute intensity of the radiation (Pellegrini et al., 2011). Key diagnostic tools are the so-called BPT diagrams (after Baldwin et al., 1981) emission of ionized hydrogen, $\mathrm { H } +$ , to normalize the recombination lines of O++ , O+ and S+ (see also Kewley et al., 2013). We investigate the dynamical feedback of young star clusters on their parental cloud using the WARPFIELD 1D model developed by Rahner et al. (2017). It follows the entire temporal evolution of the system until the cloud is destroyed, which could take several stellar populations to happen. At each timestep we employ radiative transfer calculations (Reissl et al., 2016) to generate synthetic emission line maps which we use to train the neural network. Similar to the medical application from Section 4.2, the mapping from simulated observations to underlying physical parameters (such as cloud and cluster mass, and total age of the system) is highly degenerate and ill-posed. As an intermediary step, we therefore train our forward model to predict the observable quantities $\mathbf { y }$ (emission line ratios) from composite simulation outputs $\mathbf { x }$ (such as ionizing luminosity and emission rate, cloud density, expansion velocity, and age of the youngest cluster in the system, which in the case of multiple stellar populations could be considerably smaller than the total age). Using the inverse of our trained model for a given set of observations $\mathbf { y } ^ { * }$ , we can obtain a distribution over the unobservable properties $\mathbf { x }$ of the system.
+
+Results for one specific y are shown in Fig. 5. Note that our network recovers a decidedly multimodal distribution of $\mathbf { x }$ that visibly deviates from the prior $p ( \mathbf { x } )$ . Note also the strong correlations in the system. For example, the measurements $\mathbf { y } ^ { * }$ investigated may correspond to a young cluster with large expansion velocity, or to an older system that expands slowly. Finding these ambiguities in $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ and identifying degeneracies in the underlying model are pivotal aspects of astrophysical research, and a method to effectively approximate full posterior distributions has the potential to lead to a major breakthrough in this field.
+
+# 6 Calibration curve for tissue parameter estimation
+
+In Sec. 4.2, we report the median calibration error for each method. The following figure plots the calibration error, $q _ { \mathrm { i n l i e r s } } - q$ , against the level of confidence $q$ . Negative values mean that a model is overconfident, while positive values say the opposite.
+
+![](images/c4c209adc9729c97e87314d996c54d608d230e5be824d31a9d9810980c726397.jpg)  
+Figure 11: Calibration curves for all four methods compared in Sec. 4.2.
+
+# 7 Approximate Bayesian computation (ABC)
+
+While there is a whole field of research concerned with ABC approaches and their efficiencyaccuracy tradeoffs, our use of the method here is limited to the essential principle of rejection sampling. When we require $N$ samples of $\mathbf { x }$ from the posterior $p ( \mathbf { x } | \mathbf { y } ^ { * } )$ conditioned on some $\mathbf { y } ^ { * }$ , there are two basic ways to obtain them:
+
+Threshold: We set an acceptance threshold $\epsilon$ , repeatedly draw $\mathbf { x }$ -samples from the prior, compute the corresponding y-values (via simulation) and keep those where $\mathrm { d i s t } ( \mathbf { y } , \mathbf { y } ^ { * } ) < \epsilon$ , until we have accepted $N$ samples. The smaller we want $\epsilon$ , the more simulations have to be run, which is why we use this approach only for the experiment in Sec. 4.1, where we can afford to run the forward process millions or even billions of times.
+
+Quantile: Alternatively, we choose what quantile $q$ of samples shall be accepted, and then run exactly $N / q$ simulations. All sampled pairs $\displaystyle ( \mathbf { x } , \mathbf { y } )$ are sorted by $\operatorname { d i s t } ( \mathbf { y } , \mathbf { y } ^ { * } )$ and the $N$ closest to $\mathbf { y } ^ { * }$ form the posterior. This allows for a more predictable runtime when the simulations are costly, as in the medical application in Sec. 4.2 where $q = 0 . 0 0 5$ .
+
+# 8 Details of datasets and network architectures
+
+Table 3 summarizes the datasets used throughout the paper. The architecture details are given in the following.
+
+Table 3: Dimensionalities and training set sizes for each experiment.   
+
+<table><tr><td>Experiment</td><td>training data</td><td>dim(x)</td><td>dim(y)</td><td>dim(z)</td><td>see also</td></tr><tr><td>Gaussian mixture</td><td>106</td><td>2</td><td>8</td><td>2</td><td></td></tr><tr><td>Inverse kinematics</td><td>106</td><td>4</td><td>2</td><td>2</td><td></td></tr><tr><td>Medical data</td><td>15 000</td><td>13</td><td>8</td><td>13</td><td>Wirkert et al. (2016)</td></tr><tr><td>Astronomy</td><td>8772</td><td>19</td><td>69</td><td>17</td><td>Pellegrini et al. (2011)</td></tr></table>
+
+# 8.1 Artificial data – Gaussian mixture
+
+INN: 3 invertible blocks, 3 fully connected layers per affine coefficient function with ReLU activation functions in the intermediate layers, zero padding to a nominal dimension of 16, Adam optimizer, decaying learning rate from $1 0 ^ { - 3 }$ to $1 0 ^ { - 5 }$ , batch size 200. The inverse multiquadratic kernel was used for MMD, with $h = 0 . 2$ in both x- and $\mathbf { z }$ -space.
+
+Dropout sampling: 6 fully connected layers with ReLU activations, Adam optimizer, learning rate decay from $1 0 ^ { - 3 }$ to $1 0 ^ { - 5 }$ , batch size 200, dropout probability $p = 0 . 2$ .
+
+cGAN: 6 fully connected layers for the generator and 8 for the discriminator, all with leaky ReLU activations. Adam was used for the generator, SGD for the discriminator, learning rates decaying from $2 \cdot 1 0 ^ { - 3 }$ to $2 \cdot 1 0 ^ { - 6 }$ , batch size 256. Initially 100 iterations training with $\begin{array} { r } { \mathcal { L } = \frac { 1 } { N } \sum _ { i } \| g ( z _ { i } , y _ { i } ) - x _ { i } \| _ { 2 } ^ { 2 } } \end{array}$ , to separate the differently labeled modes, followed by pure GAN training.
+
+Larger cGAN: 2 fully connected layers with 1024 neurons each for discriminator and generator, batch size 512, Adam optimizer with learning rate $8 \cdot 1 0 ^ { - 4 }$ for the generator, SGD with learning rate $1 . 2 \cdot 1 0 ^ { - 3 }$ and momentum 0.05 for the discriminator, $1 . 6 \cdot 1 0 ^ { - 3 }$ weight decay for both, 0.25 dropout probabiliy for the generator at training and test time. Equal weighting of discriminator loss and penalty of output variance ${ \mathcal { L } } = ( \operatorname { V a r } _ { i } [ g ( z _ { i } , y _ { i } ) ] - \operatorname { V a r } _ { i } [ x _ { i } ] ) ^ { 2 }$
+
+Generator with MMD: 8 fully connected layers with leaky ReLU activations, Adam optimizer, decaying learning rate from $1 0 ^ { - 3 }$ to $1 0 ^ { - 6 }$ , batch size 256. Inverse multiquadratic kernel, $h = 0 . 5$ .
+
+cVAE: 3 fully connected layers each for encoder and decoder, ReLU activations, learning rate $2 \cdot 1 0 ^ { - 2 }$ , decay to $2 . 5 \cdot 1 0 ^ { - 5 }$ , Adam optimizer, batch size 25, reconstruction loss weighted 50:1 versus KL divergence loss.
+
+8.2 Artificial data – inverse kinematics
+
+INN: 6 affine coupling blocks with 3 fully connected layers each and leaky ReLU activations. Adam optimizer, decaying learning rate from $1 0 ^ { - 2 }$ to $1 0 ^ { - 4 }$ , multiquadratic kernel with $h = 1 . 2$ .
+
+cVAE: 4 fully connected layers each for encoder and decoder, ReLU activations, learning rate $5 \cdot 1 0 ^ { - 3 }$ , decay to $1 . 6 \cdot 1 0 ^ { - 5 }$ , Adam optimizer, batch size 250, reconstruction loss weighted 15:1 versus KL divergence loss.
+
+# 8.3 Functional parameter estimation from multispectral tissue images
+
+INN: 3 invertible blocks, 4 fully connected layers per affine coefficient function with leaky ReLUs in the intermediate layers, zero padding to double the original width. Adam optimizer, learning rate decay from $2 \cdot 1 0 ^ { - 3 }$ to $2 \cdot 1 0 ^ { - 5 }$ , batch size 200. Inverse multiquadratic kernel with $h = 1$ , weighted MMD terms by observation distance with decaying $\gamma = 0 . 2$ to $0$ .
+
+Dropout sampling/point estimate: 8 fully connected layers, ReLU activations, Adam with decaying learning rate from $1 0 ^ { - 2 }$ to $1 0 ^ { - 5 }$ , batch size 100, dropout probability $p = 0 . 2$ cVAE: 4 fully connected layers each for encoder and decoder, ReLU activations, learning rate $1 0 ^ { - 3 }$ , decay to $3 . 2 \cdot 1 0 ^ { - 6 }$ , Adam optimizer, batch size 25, reconstruction loss weighted $1 0 ^ { 3 }$ :1 versus KL divergence loss.
+
+8.4 Impact of star clusters on the dynamical evolution of the galactic gas
+
+INN: 5 invertible blocks, 4 fully connected layers per affine coefficient function with leaky ReLUs in the intermediate layers, no additional zero padding. Adam optimizer with $2 \cdot 1 0 ^ { - 3 }$ $1 . 5 \cdot 1 0 ^ { - 6 }$ , batchnel for ize 500.-space:   
+$k ( \mathbf { z } , \mathbf { z } ^ { \prime } ) = \exp ( - \| ( \mathbf { z } - \mathbf { z } ^ { \prime } ) / h \| _ { 2 } )$ $h = 7 . 1$ $\mathbf { x }$ $k ( \mathbf { x } , \mathbf { x } ^ { \prime } ) = - \| \mathbf { x } - \mathbf { x } ^ { \prime } \| _ { 1 / 2 } ^ { 1 / 4 }$ the details correctly, whereas the peak of the inverse multiquadratic kernel was too broad for this purpose.